IO模型（阻塞，非阻塞，多路复用......)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */


/* 定义服务器初始化函数 */
int server_init(char *ip, short port)
{
    int ret;
    int listenfd;
    struct sockaddr_in srvaddr;

    /* 创建套接字文件 */
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd == -1) {
        perror("server_init->socket");
        return -1;
    }
    printf("listenfd = %d\n", listenfd);

    /* 绑定服务器的ip地址和端口号 */
    memset(&srvaddr, 0, sizeof(srvaddr));
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(port);
    if (ip == NULL)
        srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    else
        srvaddr.sin_addr.s_addr = inet_addr(ip);
    ret = bind(listenfd, (const struct sockaddr *)&srvaddr, sizeof(srvaddr));
    if (ret == -1) {
        perror("server_init->bind");
        return -1;
    }
    printf("bind success\n");

    /* 启动监听 */
    ret = listen(listenfd, 1024);
    if (ret == -1) {
        perror("server_init->listen");
        return -1;
    }

    return listenfd;
}

/* 定义服务器等待客户端的连接请求，建立连接 */
int server_wait_client_connect(int listenfd)
{
    int connfd;
    socklen_t addrlen;
    struct sockaddr_in cltaddr;

    //accept(listenfd, NULL, NULL);
    addrlen = sizeof(cltaddr);
    connfd = accept(listenfd, (struct sockaddr *)&cltaddr, &addrlen);
    if (connfd == -1) {
        perror("accept");
        return -1;
    }
    printf("IP : %s connet success connfd = %d\n", inet_ntoa(cltaddr.sin_addr), connfd);

    return connfd;
}

int main()
{
    int ret;
    int listenfd;
    int connfd;
    char buf[256];
    fd_set readfds;
    fd_set rdfds;
    int nfds;
    int fd;

    /* 1. 服务器的初始化 */
    listenfd = server_init("127.0.0.1", 8888);
    //listenfd = server_init(NULL, 8888);
    if (listenfd == -1)
        exit(EXIT_FAILURE);
    printf("server init success\n");

    /* 创建集合，清空集合 */
    FD_ZERO(&readfds);

    /* 将文件描述符listenfd添加到读事件集合readfds中 */
    FD_SET(listenfd, &readfds);
    nfds = listenfd + 1;

    while(1) {
        /* c， 调用select函数，检测是否有准备就绪的事件，如果没有事件准备就绪，函数一直阻塞。如果有事件准备就绪函数返回；*/
        rdfds = readfds;
        ret = select(nfds, &rdfds, NULL, NULL, NULL);
        if (ret == -1) {
            perror("select");
            return -1;
        }
        for (fd = 0; fd < nfds; fd++) {
            /* 找到准备就绪事件的文件描述符 */
            if (!FD_ISSET(fd, &rdfds))
                continue;
            /* 准备就绪事件，进行IO操作 */
            if (fd == listenfd) { /* 监听套接字 */
                /* 2. 服务器等待客户端的连接请求，建立连接 */
                connfd = server_wait_client_connect(listenfd);
                if (connfd == -1)
                    exit(EXIT_FAILURE);
                /* 连接成功，将文件描述符connfd添加到读事件集合readfds中 */
                FD_SET(connfd, &readfds);
                nfds = (connfd >= nfds ? connfd+1 : nfds);
                continue;
            } //if (fd == listenfd) end

            /* 通信套接字 */
            /* 3. 服务器处理客户端的数据请求，并处理数据，反馈处理结果 */
            memset(buf, 0, sizeof(buf));
            ret = read(fd, buf, sizeof(buf));
            if (ret == -1) {
                perror("server->read");
                return -1;
            } else if (ret == 0) {
                /* 客户端退出的时候，需要将套接字从集合中删除 */
                FD_CLR(fd, &readfds);
                close(fd);
                break;
            }
            printf("buf : %s\n", buf);

            ret = write(fd, buf, sizeof(buf));
            if (ret == -1) {
                perror("server->write");
                return -1;
            }

        } //for (fd = 0; fd < nfds; fd++) end
    } //while(1) end

    return 0;
}