ms_err_t ms_net_set_impl(const char *name);

int ms_net_get_dns_server(ms_uint8_t numdns, ip_addr_t *dnsserver);

int ms_net_set_dns_server(ms_uint8_t numdns, const ip_addr_t *dnsserver);

int gethostname(char *name, size_t len);

int sethostname(const char *name, size_t len);

ms_uint32_t htonl(ms_uint32_t x);

ms_uint16_t htons(ms_uint16_t x);

ms_uint32_t ntohl(ms_uint32_t x);

ms_uint16_t ntohs(ms_uint16_t x);

ms_uint32_t inet_addr(const char *cp);

int inet_aton(const char *cp, in_addr_t *addr);

char *inet_ntoa(const in_addr_t *addr);

char *inet_ntoa_r(const in_addr_t *addr, char *buf, int buflen);

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

int  inet_pton(int af, const char *src, void *dst);

struct hostent *gethostbyname(const char *name);

int  gethostbyname_r(const char *name, struct hostent *ret, char *buf,
                       size_t buflen, struct hostent **result, int *h_errnop);

int  getaddrinfo(const char *nodename, const char *servname, 
                   const struct addrinfo *hints, struct addrinfo **res);

void freeaddrinfo(struct addrinfo *ai);

const char *gai_strerror(int error);

char *if_indextoname(unsigned int ifindex, char *ifname);

unsigned int if_nametoindex(const char *ifname);

int socket(int domain, int type, int protocol);

int accept(int s, struct sockaddr *addr, socklen_t *addrlen);

int bind(int s, const struct sockaddr *name, socklen_t namelen);

int shutdown(int s, int how);

int getpeername(int s, struct sockaddr *name, socklen_t *namelen);

int getsockname(int s, struct sockaddr *name, socklen_t *namelen);

int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);

int setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen);

int connect(int s, const struct sockaddr *name, socklen_t namelen);

int listen(int s, int backlog);

ssize_t recv(int s, void *mem, size_t len, int flags);

ssize_t recvfrom(int s, void *mem, size_t len, int flags,
                   struct sockaddr *from, socklen_t *fromlen);

ssize_t recvmsg(int s, struct msghdr *message, int flags);

struct msghdr {
    void          *msg_name;        // protocol address
    socklen_t      msg_namelen;     // size of protocol address
    struct iovec  *msg_iov;         // scatter/gather array
    int            msg_iovlen;      // elements in msg_iov
    void          *msg_control;     // ancillary data (cmsghdr struct)
    socklen_t      msg_controllen;  // length of ancillary data
    int            msg_flags;       // flags returned by recvmsg()
};

ssize_t send(int s, const void *dataptr, size_t size, int flags);

ssize_t sendto(int s, const void *dataptr, size_t size, int flags,
                 const struct sockaddr *to, socklen_t tolen);

ssize_t sendmsg(int s, const struct msghdr *message, int flags);

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>

#define __TCP_ECHO_PORT_SERVER          8101                            /* 服务器端口号                 */
#define __TCP_ECHO_BUFF_SIZE_SERVER     257                             /* 服务器接收缓冲区大小         */

static char             cRecvBuff[__TCP_ECHO_BUFF_SIZE_SERVER] = {0};   /* 接收缓冲区                   */

int main (int argc, char *argv[])
{
    int                 iRet        = -1;
    int                 sockFd      = -1;
    int                 sockFdNew   = -1;
    socklen_t           uiAddrLen   = sizeof(struct sockaddr_in);       /* 地址结构大小                 */
    register ssize_t    sstRecv     = 0;                                /* 接收到的数据长度             */
    struct sockaddr_in  sockaddrinLocal;                                /* 本地地址                     */
    struct sockaddr_in  sockaddrinRemote;                               /* 远端地址                     */

    fprintf(stdout, "TCP echo server start.\r\n");

    sockFd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockFd < 0) {
        fprintf(stderr, "TCP echo server socket error.\r\n");
        return  (-1);
    }

    /*
     * 初始化本地地址结构
     */
    memset(&sockaddrinLocal, 0, sizeof(sockaddrinLocal));
    sockaddrinLocal.sin_len         = sizeof(struct sockaddr_in);
    sockaddrinLocal.sin_family      = AF_INET;                          /* 地址族                       */
    sockaddrinLocal.sin_addr.s_addr = INADDR_ANY;
    sockaddrinLocal.sin_port        = htons(__TCP_ECHO_PORT_SERVER);    /* 绑定服务器端口               */
    iRet = bind(sockFd, (struct sockaddr *)&sockaddrinLocal, sizeof(sockaddrinLocal));
                                                                        /* 绑定本地地址与端口           */
    if (iRet < 0) {                                                     /* 绑定操作失败                 */
        close(sockFd);                                                  /* 关闭已经创建的 socket        */
        fprintf(stderr, "TCP echo server bind error.\r\n");
        return  (-1);                                                   /* 错误返回                     */
    }

    listen(sockFd, 2);

    sockFdNew = accept(sockFd, (struct sockaddr *)&sockaddrinRemote, &uiAddrLen);
    if (sockFdNew < 0) {
        close(sockFd);                                                  /* 关闭已经创建的 socket        */
        fprintf(stderr, "TCP echo server accept error.\r\n");
        return  (-1);                                                   /* 错误返回                     */
    }

    for (;;) {
        memset(&cRecvBuff[0], 0, __TCP_ECHO_BUFF_SIZE_SERVER);          /* 清空接收缓冲区               */

        sstRecv = read(sockFdNew, (void *)&cRecvBuff[0], __TCP_ECHO_BUFF_SIZE_SERVER);
                                                                        /* 从远端接收数据               */
        if (sstRecv <= 0) {                                             /* 接收数据失败                 */
            if ((errno != ETIMEDOUT) && (errno != EWOULDBLOCK)) {       /* 非超时与非阻塞               */
                 close(sockFdNew);                                      /* 关闭已经连接的 socket        */
                 fprintf(stderr, "TCP echo server recvfrom error.\r\n");
                 return  (-1);                                          /* 错误返回                     */
            }

            continue;                                                   /* 超时或非阻塞后重新运行       */
        }

        cRecvBuff[sstRecv] = 0;
        printf("I recv %s\r\n", cRecvBuff);
                                                                        /* 将回射数据发回远端           */
        write(sockFdNew, (const void *)&cRecvBuff[0], sstRecv);
    }

    return  (0);
}

#include <ms_rtos.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>

#define __UDP_ECHO_PORT_SERVER          8101                            /* 服务器端口号                 */
#define __UDP_ECHO_BUFF_SIZE_SERVER     257                             /* 服务器接收缓冲区大小         */
#define __UDP_ECHO_TIMEOUT_SERVER       5

static char             cRecvBuff[__UDP_ECHO_BUFF_SIZE_SERVER];         /* 接收缓冲区                   */

int main (int argc, char **argv)
{
    int                 iRet;
    int                 sockFd1;
    int                 sockFd2;
    int                 sockFd3;
    int                 maxFd;
    socklen_t           uiAddrLen;                                      /* 地址结构大小                 */
    register ssize_t    sstRecv;                                        /* 接收到的数据长度             */
    struct sockaddr_in  sockaddrinLocal;                                /* 本地地址                     */
    struct sockaddr_in  sockaddrinRemote;                               /* 远端地址                     */
    fd_set              rfds;
    struct timeval      tv;
    char                ipAddrString[sizeof("255.255.255.255")];

    /*
     * 创建 socket 1
     */
    sockFd1 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sockFd1 < 0) {
        fprintf(stderr, "UDP echo server socket error, line %d.\r\n", __LINE__);
        return  (-1);
    }

    /*
     * 设置网络接口 st0 的 mac 地址
     */
    {
        struct ifreq ifreq;

        bzero(&ifreq, sizeof(struct ifreq));

        strcpy(ifreq.ifr_name, "st0");

        ifreq.ifr_hwaddr.sa_data[0] = 0x11;
        ifreq.ifr_hwaddr.sa_data[1] = 0x22;
        ifreq.ifr_hwaddr.sa_data[2] = 0x33;
        ifreq.ifr_hwaddr.sa_data[3] = 0x44;
        ifreq.ifr_hwaddr.sa_data[4] = 0x55;
        ifreq.ifr_hwaddr.sa_data[5] = 0x66;
        ioctl(sockFd1, SIOCSIFHWADDR, &ifreq);

        /*
         * 获取网络接口 st0 的 mac 地址
         */
        ioctl(sockFd1, SIOCGIFHWADDR, &ifreq);
        ms_printf("MAC addr: %02x:%02x:%02x:%02x:%02x:%02x\n",
                  (ms_uint8_t)ifreq.ifr_hwaddr.sa_data[0],
                  (ms_uint8_t)ifreq.ifr_hwaddr.sa_data[1],
                  (ms_uint8_t)ifreq.ifr_hwaddr.sa_data[2],
                  (ms_uint8_t)ifreq.ifr_hwaddr.sa_data[3],
                  (ms_uint8_t)ifreq.ifr_hwaddr.sa_data[4],
                  (ms_uint8_t)ifreq.ifr_hwaddr.sa_data[5]);
    }

    /*
     * 设置网络接口 st0 的 ip 地址
     */
    {
        struct ifreq ifreq;
        struct sockaddr_in *psockaddrin;

        bzero(&ifreq, sizeof(struct ifreq));

        strcpy(ifreq.ifr_name, "st0");

        psockaddrin = (struct sockaddr_in *)&(ifreq.ifr_addr);
        psockaddrin->sin_len         = sizeof(struct sockaddr_in);
        psockaddrin->sin_family      = AF_INET;
        psockaddrin->sin_addr.s_addr = inet_addr("192.168.1.33");
        ioctl(sockFd1, SIOCSIFADDR, &ifreq);

        /*
         * 获取网络接口 st0 的 ip 地址
         */
        ioctl(sockFd1, SIOCGIFADDR, &ifreq);
        inet_ntoa_r(psockaddrin->sin_addr, ipAddrString, sizeof(ipAddrString));
        ms_printf("IP addr: %s\n", ipAddrString);
    }

    /*
     * 为 st0 增加一个 ip, 新增加的网络接口名为 mi0
     */
    {
        struct ifaliasreq ifalias;
        struct sockaddr_in *psockaddrin;

        bzero(&ifalias, sizeof(struct ifaliasreq));

        strcpy(ifalias.ifra_name, "st0");

        /*
         * 设置 ip
         */
        psockaddrin = (struct sockaddr_in *)&(ifalias.ifra_addr);
        psockaddrin->sin_len         = sizeof(struct sockaddr_in);
        psockaddrin->sin_family      = AF_INET;
        psockaddrin->sin_addr.s_addr = inet_addr("192.168.1.100");

        /*
         * 设置子网掩码
         */
        psockaddrin = (struct sockaddr_in *)&(ifalias.ifra_mask);
        psockaddrin->sin_len         = sizeof(struct sockaddr_in);
        psockaddrin->sin_family      = AF_INET;
        psockaddrin->sin_addr.s_addr = inet_addr("255.255.255.0");

        ioctl(sockFd1, SIOCAIFADDR, &ifalias);
    }

    /*
     * socket 1 绑定服务器端口
     */
    memset(&sockaddrinLocal, 0, sizeof(sockaddrinLocal));
    sockaddrinLocal.sin_len         = sizeof(struct sockaddr_in);
    sockaddrinLocal.sin_family      = AF_INET;                          /* 地址族                       */
    sockaddrinLocal.sin_addr.s_addr = inet_addr("192.168.1.33");        /* 绑定到 192.168.1.33          */
    sockaddrinLocal.sin_port        = htons(__UDP_ECHO_PORT_SERVER);    /* 绑定服务器端口               */
    iRet = bind(sockFd1, (struct sockaddr *)&sockaddrinLocal, sizeof(sockaddrinLocal));
    if (iRet < 0) {                                                     /* 绑定操作失败                 */
        fprintf(stderr, "UDP echo server bind error, line %d.\r\n", __LINE__);
        return  (-1);                                                   /* 错误返回                     */
    }

    /*
     * 创建 socket 2
     */
    sockFd2 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sockFd2 < 0) {
        fprintf(stderr, "UDP echo server socket error, line %d.\r\n", __LINE__);
        return  (-1);
    }

    /*
     * socket 2 绑定服务器端口
     */
    memset(&sockaddrinLocal, 0, sizeof(sockaddrinLocal));
    sockaddrinLocal.sin_len         = sizeof(struct sockaddr_in);
    sockaddrinLocal.sin_family      = AF_INET;                          /* 地址族                       */
    sockaddrinLocal.sin_addr.s_addr = inet_addr("192.168.1.100");       /* 绑定到 192.168.1.100         */
    sockaddrinLocal.sin_port        = htons(__UDP_ECHO_PORT_SERVER + 1);/* 绑定服务器端口               */
    iRet = bind(sockFd2, (struct sockaddr *)&sockaddrinLocal, sizeof(sockaddrinLocal));
    if (iRet < 0) {                                                     /* 绑定操作失败                 */
        fprintf(stderr, "UDP echo server bind error, line %d.\r\n", __LINE__);
        return  (-1);                                                   /* 错误返回                     */
    }

    /*
     * 创建 socket 3
     */
    sockFd3 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sockFd3 < 0) {
        fprintf(stderr, "UDP echo server socket error, line %d.\r\n", __LINE__);
        return  (-1);
    }

    /*
     * socket 3 绑定服务器端口
     */
    memset(&sockaddrinLocal, 0, sizeof(sockaddrinLocal));
    sockaddrinLocal.sin_len         = sizeof(struct sockaddr_in);
    sockaddrinLocal.sin_family      = AF_INET;                          /* 地址族                       */
    sockaddrinLocal.sin_addr.s_addr = INADDR_ANY;                       /* 绑定到任意 IP 地址           */
    sockaddrinLocal.sin_port        = htons(__UDP_ECHO_PORT_SERVER + 2);/* 绑定服务器端口               */
    iRet = bind(sockFd3, (struct sockaddr *)&sockaddrinLocal, sizeof(sockaddrinLocal));
    if (iRet < 0) {                                                     /* 绑定操作失败                 */
        fprintf(stderr, "UDP echo server bind error, line %d.\r\n", __LINE__);
        return  (-1);                                                   /* 错误返回                     */
    }

    /*
     * 计算最大的文件描述符
     */
    maxFd = MS_MAX(sockFd1, sockFd2);
    maxFd = MS_MAX(maxFd, sockFd3);

    while (1) {

        /*
         * 将文件描述符加入到可读文件描述符集
         */
        FD_ZERO(&rfds);
        FD_SET(sockFd1, &rfds);
        FD_SET(sockFd2, &rfds);
        FD_SET(sockFd3, &rfds);

        /*
         * 等待至少一个 socket 可读，并设置等待的超时时间
         */
        tv.tv_sec  = __UDP_ECHO_TIMEOUT_SERVER;
        tv.tv_usec = 0;

        iRet = select(maxFd + 1, &rfds, MS_NULL, MS_NULL, &tv);
        if (iRet < 0) {
            /*
             * 出错
             */
            fprintf(stderr, "UDP echo server select error.\r\n");

        } else if (iRet == 0) {
            /*
             * 超时
             */
            fprintf(stderr, "UDP echo server select timeout.\r\n");

        } else {
            /*
             * 至少一个 socket 可读
             */
            if (FD_ISSET(sockFd1, &rfds)) {
                /*
                 * 读 socket 1
                 */
                uiAddrLen = sizeof(sockaddrinRemote);
                sstRecv = recvfrom(sockFd1, cRecvBuff, sizeof(cRecvBuff), 0, (struct sockaddr *)&sockaddrinRemote, &uiAddrLen);
                if (sstRecv > 0) {
                    /*
                     * 打印远端 IP 和端口及接收到的数据
                     */
                    cRecvBuff[sstRecv] = 0;
                    inet_ntoa_r(sockaddrinRemote.sin_addr, ipAddrString, sizeof(ipAddrString));
                    printf("I recv %s from %s:%u\r\n", cRecvBuff, ipAddrString, ntohs(sockaddrinRemote.sin_port));

                    /*
                     * 回显
                     */
                    if (sendto(sockFd1, cRecvBuff, sstRecv, 0, (struct sockaddr *)&sockaddrinRemote, sizeof(sockaddrinRemote)) != sstRecv) {
                        fprintf(stderr, "UDP echo server send error, line %d, errno %d.\r\n", __LINE__, errno);
                    }
                } else {
                    fprintf(stderr, "UDP echo server read error, line %d.\r\n", __LINE__);
                }

            } else if (FD_ISSET(sockFd2, &rfds)) {
                /*
                 * 读 socket 2
                 */
                uiAddrLen = sizeof(sockaddrinRemote);
                sstRecv = recvfrom(sockFd2, cRecvBuff, sizeof(cRecvBuff), 0, (struct sockaddr *)&sockaddrinRemote, &uiAddrLen);
                if (sstRecv > 0) {
                    /*
                     * 打印远端 IP 和端口及接收到的数据
                     */
                    cRecvBuff[sstRecv] = 0;
                    inet_ntoa_r(sockaddrinRemote.sin_addr, ipAddrString, sizeof(ipAddrString));
                    printf("I recv %s from %s:%u\r\n", cRecvBuff, ipAddrString, ntohs(sockaddrinRemote.sin_port));

                    /*
                     * 回显
                     */
                    if (sendto(sockFd2, cRecvBuff, sstRecv, 0, (struct sockaddr *)&sockaddrinRemote, sizeof(sockaddrinRemote)) != sstRecv) {
                        fprintf(stderr, "UDP echo server send error, line %d, errno %d.\r\n", __LINE__, errno);
                    }
                } else {
                    fprintf(stderr, "UDP echo server read error, line %d.\r\n", __LINE__);
                }

            } else if (FD_ISSET(sockFd3, &rfds)) {
                /*
                 * 读 socket 3
                 */
                uiAddrLen = sizeof(sockaddrinRemote);
                sstRecv = recvfrom(sockFd3, cRecvBuff, sizeof(cRecvBuff), 0, (struct sockaddr *)&sockaddrinRemote, &uiAddrLen);
                if (sstRecv > 0) {
                    /*
                     * 打印远端 IP 和端口及接收到的数据
                     */
                    cRecvBuff[sstRecv] = 0;
                    inet_ntoa_r(sockaddrinRemote.sin_addr, ipAddrString, sizeof(ipAddrString));
                    printf("I recv %s from %s:%u\r\n", cRecvBuff, ipAddrString, ntohs(sockaddrinRemote.sin_port));

                    /*
                     * 回显
                     */
                    if (sendto(sockFd3, cRecvBuff, sstRecv, 0, (struct sockaddr *)&sockaddrinRemote, sizeof(sockaddrinRemote)) != sstRecv) {
                        fprintf(stderr, "UDP echo server send error, line %d, errno %d.\r\n", __LINE__, errno);
                    }
                } else {
                    fprintf(stderr, "UDP echo server read error, line %d.\r\n", __LINE__);
                }
            }
        }
    }

    close(sockFd1);
    close(sockFd2);
    close(sockFd3);

    return  (0);
}