8.1 服务器开发 API 函数封装，select 优化服务器和客户端

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>

#include <fcntl.h>


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

#include "commsocket.h"

typedef struct _SckHandle
{
    int sockArray[100];
    int arrayNum;
    int sockfd;
    int contime;
    int sendtime;
    int revtime;

}SckHandle;

/**
 * readn - 读取固定字节数
 * @fd: 文件描述符
 * @buf: 接收缓冲区
 * @count: 要读取的字节数
 * 成功返回count，失败返回-1，读到EOF返回<count
 */
ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nread;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nread = read(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nread == 0)
            return count - nleft;

        bufp += nread;
        nleft -= nread;
    }

    return count;
}

/**
 * writen - 发送固定字节数
 * @fd: 文件描述符
 * @buf: 发送缓冲区
 * @count: 要读取的字节数
 * 成功返回count，失败返回-1
 */
ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nwritten == 0)
            continue;

        bufp += nwritten;
        nleft -= nwritten;
    }

    return count;
}

/**
 * recv_peek - 仅仅查看套接字缓冲区数据，但不移除数据
 * @sockfd: 套接字
 * @buf: 接收缓冲区
 * @len: 长度
 * 成功返回>=0，失败返回-1
 */
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while (1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
            continue;
        return ret;
    }
}


//函数声明
//客户端环境初始化
int sckCliet_init(void **handle, int contime, int sendtime, int revtime, int nConNum)
{
    int     ret = 0;
    if (handle == NULL ||contime<0 || sendtime<0 || revtime<0)
    {
        ret = Sck_ErrParam;
        printf("func sckCliet_init() err: %d, check  (handle == NULL ||contime<0 || sendtime<0 || revtime<0)
", ret);
        return ret;
    }
    
    SckHandle *tmp = (SckHandle *)malloc(sizeof(SckHandle));
    if (tmp == NULL)
    {
        ret = Sck_ErrMalloc;
        printf("func sckCliet_init() err: malloc %d
", ret);
        return ret;
    }
    
    tmp->contime = contime;
    tmp->sendtime = sendtime;
    tmp->revtime = revtime;
    tmp->arrayNum = nConNum;
        
        
    /*
    int sockfd;
    int i = 0;
    for (i=0; i<1; i++)
    {
        //链表的顺序
        sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sockfd < 0)
        {
            ret = errno;
            printf("func socket() err:  %d
", ret);
            return ret;
        }
        tmp->sockfd = sockfd;
    }
    */

    *handle = tmp; 
    return ret;
}

/**
 * activate_noblock - 设置I/O为非阻塞模式
 * @fd: 文件描符符
 */
int activate_nonblock(int fd)
{
    int ret = 0;
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1)
    {
        ret = flags;
        printf("func activate_nonblock() err:%d", ret);
        return ret;
    }
        

    flags |= O_NONBLOCK;
    ret = fcntl(fd, F_SETFL, flags);
    if (ret == -1)
    {
        printf("func activate_nonblock() err:%d", ret);
        return ret;
    }
    return ret;
}

/**
 * deactivate_nonblock - 设置I/O为阻塞模式
 * @fd: 文件描符符
 */
int deactivate_nonblock(int fd)
{
    int ret = 0;
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1)
    {
        ret = flags;
        printf("func deactivate_nonblock() err:%d", ret);
        return ret;
    }

    flags &= ~O_NONBLOCK;
    ret = fcntl(fd, F_SETFL, flags);
    if (ret == -1)
    {
        printf("func deactivate_nonblock() err:%d", ret);
        return ret;
    }
    return ret;
}



/**
 * connect_timeout - connect
 * @fd: 套接字
 * @addr: 要连接的对方地址
 * @wait_seconds: 等待超时秒数，如果为0表示正常模式
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
static int connect_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
{
    int ret;
    socklen_t addrlen = sizeof(struct sockaddr_in);

    if (wait_seconds > 0)
        activate_nonblock(fd);

    ret = connect(fd, (struct sockaddr*)addr, addrlen);
    if (ret < 0 && errno == EINPROGRESS)
    {
        //printf("11111111111111111111
");
        fd_set connect_fdset;
        struct timeval timeout;
        FD_ZERO(&connect_fdset);
        FD_SET(fd, &connect_fdset);
        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        do
        {
            // 一但连接建立，则套接字就可写  所以connect_fdset放在了写集合中
            ret = select(fd + 1, NULL, &connect_fdset, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);
        if (ret == 0)
        {
            ret = -1;
            errno = ETIMEDOUT;
        }
        else if (ret < 0)
            return -1;
        else if (ret == 1)
        {
            //printf("22222222222222222
");
            /* ret返回为1（表示套接字可写），可能有两种情况，一种是连接建立成功，一种是套接字产生错误，*/
            /* 此时错误信息不会保存至errno变量中，因此，需要调用getsockopt来获取。 */
            int err;
            socklen_t socklen = sizeof(err);
            int sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);
            if (sockoptret == -1)
            {
                return -1;
            }
            if (err == 0)
            {
                //printf("3333333333333
");
                ret = 0;
            }
            else
            {
                //printf("4444444444444444:%d
", err);
                errno = err;
                ret = -1;
            }
        }
    }
    if (wait_seconds > 0)
    {
        deactivate_nonblock(fd);
    }
    return ret;
}



//
int sckCliet_getconn(void *handle, char *ip, int port, int *connfd)
{
    
    int ret = 0;
    SckHandle  *tmp = NULL;
    if (handle == NULL || ip==NULL || connfd==NULL || port<0 || port>65537)
    {
        ret = Sck_ErrParam;
        printf("func sckCliet_getconn() err: %d, check  (handle == NULL || ip==NULL || connfd==NULL || port<0 || port>65537) 
", ret);
        return ret;
    }
    
    //
    int sockfd;
    sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockfd < 0)
    {
        ret = errno;
        printf("func socket() err:  %d
", ret);
        return ret;
    }
    
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port);
    servaddr.sin_addr.s_addr = inet_addr(ip);
    
    tmp = (SckHandle* )handle;

    /*
    ret = connect(sockfd, (struct sockaddr*) (&servaddr), sizeof(servaddr));
    if (ret < 0)
    {
        ret = errno;
        printf("func connect() err:  %d
", ret);
        return ret;
    }
    */
    
    ret = connect_timeout(sockfd, (struct sockaddr_in*) (&servaddr), (unsigned int )tmp->contime);
    if (ret < 0)
    {
        if (ret==-1 && errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            return ret;
        }
        else
        {
            printf("func connect_timeout() err:  %d
", ret);
        }
    }
    
    *connfd = sockfd;
   
       return ret;
    
}



/**
 * write_timeout - 写超时检测函数，不含写操作
 * @fd: 文件描述符
 * @wait_seconds: 等待超时秒数，如果为0表示不检测超时
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
int write_timeout(int fd, unsigned int wait_seconds)
{
    int ret = 0;
    if (wait_seconds > 0)
    {
        fd_set write_fdset;
        struct timeval timeout;

        FD_ZERO(&write_fdset);
        FD_SET(fd, &write_fdset);

        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        do
        {
            ret = select(fd + 1, NULL, &write_fdset, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);

        if (ret == 0)
        {
            ret = -1;
            errno = ETIMEDOUT;
        }
        else if (ret == 1)
            ret = 0;
    }

    return ret;
}


//客户端发送报文
int sckClient_send(void *handle, int  connfd,  unsigned char *data, int datalen)
{
    int     ret = 0;
    
    SckHandle  *tmp = NULL;
    tmp = (SckHandle *)handle;
    ret = write_timeout(connfd, tmp->sendtime);
    if (ret == 0)
    {
        int writed = 0;
        unsigned char *netdata = ( unsigned char *)malloc(datalen + 4);
        if ( netdata == NULL)
        {
            ret = Sck_ErrMalloc;
            printf("func sckClient_send() mlloc Err:%d
 ", ret);
            return ret;
        }
        int netlen = htonl(datalen);
        memcpy(netdata, &netlen, 4);
        memcpy(netdata+4, data, datalen);
        
        writed = writen(connfd, netdata, datalen + 4);
        if (writed < (datalen + 4) )
        {
            if (netdata != NULL) 
            {
                free(netdata);
                netdata = NULL;
            }
            return writed;
        }
          
    }
    
    if (ret < 0)
    {
        //失败返回-1，超时返回-1并且errno = ETIMEDOUT
        if (ret == -1 && errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func sckClient_send() mlloc Err:%d
 ", ret);
            return ret;
        }
        return ret;
    }
    
    return ret;
}



/**
 * read_timeout - 读超时检测函数，不含读操作
 * @fd: 文件描述符
 * @wait_seconds: 等待超时秒数，如果为0表示不检测超时
 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
 */
int read_timeout(int fd, unsigned int wait_seconds)
{
    int ret = 0;
    if (wait_seconds > 0)
    {
        fd_set read_fdset;
        struct timeval timeout;

        FD_ZERO(&read_fdset);
        FD_SET(fd, &read_fdset);

        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        
        //select返回值三态
        //1 若timeout时间到（超时），没有检测到读事件 ret返回=0
        //2 若ret返回<0 &&  errno == EINTR 说明select的过程中被别的信号中断（可中断睡眠原理）
        //2-1 若返回-1，select出错
        //3 若ret返回值>0 表示有read事件发生，返回事件发生的个数
        
        do
        {
            ret = select(fd + 1, &read_fdset, NULL, NULL, &timeout);
        } while (ret < 0 && errno == EINTR); 

        if (ret == 0)
        {
            ret = -1;
            errno = ETIMEDOUT;
        }
        else if (ret == 1)
            ret = 0;
    }

    return ret;
}

//客户端端接受报文
int sckClient_rev(void *handle,  int  connfd, unsigned char *out, int *outlen)
{
    
    int        ret = 0;
    SckHandle *tmpHandle = (SckHandle *)handle;
    
    if (handle==NULL || out==NULL)
    {
        ret = Sck_ErrParam;
        printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
        return ret;
    }
    
    ret =  read_timeout(connfd, tmpHandle->revtime ); //bugs modify bombing
    if (ret != 0)
    {
        if (ret==-1 || errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
            return ret;
        }
        else
        {
            printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
            return ret;
        }    
    }
    
    int netdatalen = 0;
    ret = readn(connfd, &netdatalen,  4); //读包头 4个字节
    if (ret == -1)
    {
        printf("func readn() err:%d 
", ret);
        return ret;
    }
    else if (ret < 4)
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d 
", ret);
        return ret;
    }
    
    int n;
    n = ntohl(netdatalen);
    ret = readn(connfd, out, n); //根据长度读数据
    if (ret == -1)
    {
        printf("func readn() err:%d 
", ret);
        return ret;
    }
    else if (ret < n)
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d 
", ret);
        return ret;
    }
    
    *outlen = n;
    
    return 0;
}

// 客户端环境释放 
int sckClient_destroy(void *handle)
{
    if (handle != NULL)
    {
        free(handle);
    }
    return 0;
}

int sckCliet_closeconn(int connfd)
{
    if (connfd >=0 )
    {
        close(connfd);
    }
    return 0;
}



/////////////////////////////////////////////////////////////////////////////////////
//函数声明
//服务器端初始化
int sckServer_init(int port, int *listenfd)
{
    int     ret = 0;
    int mylistenfd;
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    
        
    mylistenfd = socket(PF_INET, SOCK_STREAM, 0);
    if (mylistenfd < 0)
    {
        ret = errno ;
        printf("func socket() err:%d 
", ret);
        return ret;
    }
        

    int on = 1;
    ret = setsockopt(mylistenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );
    if (ret < 0)
    {
        ret = errno ;
        printf("func setsockopt() err:%d 
", ret);
        return ret;
    }
    

    ret = bind(mylistenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
    if (ret < 0)
    {
        ret = errno ;
        printf("func bind() err:%d 
", ret);
        return ret;
    }
        
    ret = listen(mylistenfd, SOMAXCONN);
    if (ret < 0)
    {
        ret = errno ;
        printf("func listen() err:%d 
", ret);
        return ret;
    }
        
    *listenfd = mylistenfd;

    return 0;
}

/**
 * accept_timeout - 带超时的accept
 * @fd: 套接字
 * @addr: 输出参数，返回对方地址
 * @wait_seconds: 等待超时秒数，如果为0表示正常模式
 * 成功（未超时）返回已连接套接字，超时返回-1并且errno = ETIMEDOUT
 */
int accept_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
{
    int ret;
    socklen_t addrlen = sizeof(struct sockaddr_in);

    if (wait_seconds > 0)
    {
        fd_set accept_fdset;
        struct timeval timeout;
        FD_ZERO(&accept_fdset);
        FD_SET(fd, &accept_fdset);
        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        do
        {
            ret = select(fd + 1, &accept_fdset, NULL, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);
        if (ret == -1)
            return -1;
        else if (ret == 0)
        {
            errno = ETIMEDOUT;
            return -1;
        }
    }

    //一但检测出 有select事件发生，表示对等方完成了三次握手，客户端有新连接建立
    //此时再调用accept将不会堵塞
    if (addr != NULL)
        ret = accept(fd, (struct sockaddr*)addr, &addrlen); //返回已连接套接字
    else
        ret = accept(fd, NULL, NULL);
        if (ret == -1)
        {
            ret = errno;
            printf("func accept() err:%d 
", ret);
            return ret;
        }
    

    return ret;
}

int sckServer_accept(int listenfd, int *connfd,  int timeout)
{
    int    ret = 0;
    
    ret = accept_timeout(listenfd, NULL, (unsigned int) timeout);
    if (ret < 0)
    {
        if (ret == -1 && errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func accept_timeout() timeout err:%d 
", ret);
            return ret;
        }
        else
        {
            ret = errno;
            printf("func accept_timeout() err:%d 
", ret);
            return ret;
        }
    }
    
    *connfd = ret;
    return 0;
}
//服务器端发送报文
int sckServer_send(int connfd,  unsigned char *data, int datalen, int timeout)
{
    int     ret = 0;
    
    ret = write_timeout(connfd, timeout);
    if (ret == 0)
    {
        int writed = 0;
        unsigned char *netdata = ( unsigned char *)malloc(datalen + 4);
        if ( netdata == NULL)
        {
            ret = Sck_ErrMalloc;
            printf("func sckServer_send() mlloc Err:%d
 ", ret);
            return ret;
        }
        int netlen = htonl(datalen);
        memcpy(netdata, &netlen, 4);
        memcpy(netdata+4, data, datalen);
        
        writed = writen(connfd, netdata, datalen + 4);
        if (writed < (datalen + 4) )
        {
            if (netdata != NULL) 
            {
                free(netdata);
                netdata = NULL;
            }
            return writed;
        }
          
    }
    
    if (ret < 0)
    {
        //失败返回-1，超时返回-1并且errno = ETIMEDOUT
        if (ret == -1 && errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func sckServer_send() mlloc Err:%d
 ", ret);
            return ret;
        }
        return ret;
    }
    
    return ret;
}
//服务器端端接受报文
int sckServer_rev(int  connfd, unsigned char *out, int *outlen,  int timeout)
{
        
    int        ret = 0;
    
    if (out==NULL || outlen==NULL)
    {
        ret = Sck_ErrParam;
        printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
        return ret;
    }
    
    ret =  read_timeout(connfd, timeout); //bugs modify bombing
    if (ret != 0)
    {
        if (ret==-1 || errno == ETIMEDOUT)
        {
            ret = Sck_ErrTimeOut;
            printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
            return ret;
        }
        else
        {
            printf("func sckClient_rev() timeout , err:%d 
", Sck_ErrTimeOut);
            return ret;
        }    
    }
    
    int netdatalen = 0;
    ret = readn(connfd, &netdatalen,  4); //读包头 4个字节
    if (ret == -1)
    {
        printf("func readn() err:%d 
", ret);
        return ret;
    }
    else if (ret < 4)
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d 
", ret);
        return ret;
    }
    
    int n;
    n = ntohl(netdatalen);
    ret = readn(connfd, out, n); //根据长度读数据
    if (ret == -1)
    {
        printf("func readn() err:%d 
", ret);
        return ret;
    }
    else if (ret < n)
    {
        ret = Sck_ErrPeerClosed;
        printf("func readn() err peer closed:%d 
", ret);
        return ret;
    }
    
    *outlen = n;
    
    return 0;
}

//服务器端环境释放 
int sckServer_destroy(void *handle)
{
    return 0;
}

 select优化服务器：

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>

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

#define ERR_EXIT(m) 
        do 
        { 
                perror(m); 
                exit(EXIT_FAILURE); 
        } while(0)

ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nread;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nread = read(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nread == 0)
            return count - nleft;

        bufp += nread;
        nleft -= nread;
    }

    return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nwritten;
    char *bufp = (char*)buf;

    while (nleft > 0)
    {
        if ((nwritten = write(fd, bufp, nleft)) < 0)
        {
            if (errno == EINTR)
                continue;
            return -1;
        }
        else if (nwritten == 0)
            continue;

        bufp += nwritten;
        nleft -= nwritten;
    }

    return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while (1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK);
        if (ret == -1 && errno == EINTR)
            continue;
        return ret;
    }
}

ssize_t readline(int sockfd, void *buf, size_t maxline)
{
    int ret;
    int nread;
    char *bufp = buf;
    int nleft = maxline;
    while (1)
    {
        ret = recv_peek(sockfd, bufp, nleft);
        if (ret < 0)
            return ret;
        else if (ret == 0)
            return ret;

        nread = ret;
        int i;
        for (i=0; i<nread; i++)
        {
            if (bufp[i] == '
')
            {
                ret = readn(sockfd, bufp, i+1);
                if (ret != i+1)
                    exit(EXIT_FAILURE);

                return ret;
            }
        }

        if (nread > nleft)
            exit(EXIT_FAILURE);

        nleft -= nread;
        ret = readn(sockfd, bufp, nread);
        if (ret != nread)
            exit(EXIT_FAILURE);

        bufp += nread;
    }

    return -1;
}

void echo_srv(int conn)
{
    char recvbuf[1024];
        while (1)
        {
                memset(recvbuf, 0, sizeof(recvbuf));
                int ret = readline(conn, recvbuf, 1024);
        if (ret == -1)
            ERR_EXIT("readline");
        if (ret == 0)
        {
            printf("client close
");
            break;
        }
        
                fputs(recvbuf, stdout);
                writen(conn, recvbuf, strlen(recvbuf));
        }
}

void handle_sigchld(int sig)
{
/*    wait(NULL);*/
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ;
}

void handle_sigpipe(int sig)
{
    printf("recv a sig=%d
", sig);
}

int main(void)
{
    /*signal(SIGPIPE, SIG_IGN);*/
    signal(SIGPIPE, handle_sigpipe);
/*    signal(SIGCHLD, SIG_IGN);*/
    signal(SIGCHLD, handle_sigchld);
    int listenfd;
    if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
/*    if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)*/
        ERR_EXIT("socket");

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    /*servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");*/
    /*inet_aton("127.0.0.1", &servaddr.sin_addr);*/

    int on = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt");

    if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("bind");
    if (listen(listenfd, SOMAXCONN) < 0)
        ERR_EXIT("listen");

    struct sockaddr_in peeraddr;
    socklen_t peerlen;    
    int conn;

/*
    pid_t pid;
    while (1)
    {
        if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
            ERR_EXIT("accept");

        printf("ip=%s port=%d
", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));

        pid = fork();
        if (pid == -1)
            ERR_EXIT("fork");
        if (pid == 0)
        {
            close(listenfd);
            echo_srv(conn);
            exit(EXIT_SUCCESS);
        }
        else
            close(conn);
    }
*/

    int i;
    int client[FD_SETSIZE]; //支持的最大客户端连接数 数组
    int maxi = 0; //最大的不空闲的位置

    printf("FD_SETSIZE:%d 
", FD_SETSIZE);
    for (i=0; i<FD_SETSIZE; i++)
        client[i] = -1;

    int nready;
    int maxfd = listenfd;
    fd_set         rset;
    fd_set         allset;
    
    FD_ZERO(&rset);
    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);
    printf("FD_SETSIZE:%d 
", FD_SETSIZE);
    while (1)
    {
        rset = allset;
        //listenfd 可读，表示有客户端连接进来了，可以建立一个新的连接
        nready = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nready == -1)
        {
            if (errno == EINTR)
                continue;
            
            ERR_EXIT("select");
        }
        if (nready == 0)
            continue;

        if (FD_ISSET(listenfd, &rset)) //若侦听套接口产生可读事件 说明3次握手已完成，有客户端已经连接建立
        {
            peerlen = sizeof(peeraddr);
            conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen); //处理accept
            if (conn == -1)
                ERR_EXIT("accept");

            for (i=0; i<FD_SETSIZE; i++)
            {
                if (client[i] < 0)
                {
                    client[i] = conn;
                    if (i > maxi)
                        maxi = i;
                    break;
                }
            }

            if (i == FD_SETSIZE)
            {
                fprintf(stderr, "too many clients
");
                exit(EXIT_FAILURE);
            }
            printf("ip=%s port=%d
", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
            
            FD_SET(conn, &allset); //把新的连接 放入集合中
            if (conn > maxfd)  //同时按照条件，更新maxfd  //维护最大描述符
                maxfd = conn;

            if (--nready <= 0)
                continue;

        }

        for (i=0; i<=maxi; i++) //检测已连接的调节字conn是否可读
        {
            conn = client[i];
            if (conn == -1)
                continue;

            if (FD_ISSET(conn, &rset)) //当前连接是否可读
            {
                char recvbuf[1024] = {0};
                int ret = readline(conn, recvbuf, 1024);
                if (ret == -1)
                        ERR_EXIT("readline");
                if (ret == 0)
                {
                    printf("client close
");
                    FD_CLR(conn, &allset); //若对方已退出 从集合中清除
                    client[i] = -1; //保存连接的数组 也置成-1 //也可进一步控制 若i是把maxfd，需要把maxifd变成第二大maxifd
                    close(conn);
                }

                fputs(recvbuf, stdout);
                //sleep(4);
                writen(conn, recvbuf, strlen(recvbuf));

                if (--nready <= 0)
                    break;    
            }
        }
    }    
    return 0;
}

select优化客户端：

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>

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

#define ERR_EXIT(m) 
        do 
        { 
                perror(m); 
                exit(EXIT_FAILURE); 
        } while(0)

ssize_t readn(int fd, void *buf, size_t count)
{
        size_t nleft = count;
        ssize_t nread;
        char *bufp = (char*)buf;

        while (nleft > 0)
        {
                if ((nread = read(fd, bufp, nleft)) < 0)
                {
                        if (errno == EINTR)
                                continue;
                        return -1;
                }
                else if (nread == 0)
                        return count - nleft;

                bufp += nread;
                nleft -= nread;
        }

        return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
        size_t nleft = count;
        ssize_t nwritten;
        char *bufp = (char*)buf;

        while (nleft > 0)
        {
                if ((nwritten = write(fd, bufp, nleft)) < 0)
                {
                        if (errno == EINTR)
                                continue;
                        return -1;
                }
                else if (nwritten == 0)
                        continue;

                bufp += nwritten;
                nleft -= nwritten;
        }

        return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
        while (1)
        {
                int ret = recv(sockfd, buf, len, MSG_PEEK);
                if (ret == -1 && errno == EINTR)
                        continue;
                return ret;
        }
}


ssize_t readline(int sockfd, void *buf, size_t maxline)
{
        int ret;
        int nread;
        char *bufp = buf;
        int nleft = maxline;
        while (1)
        {
                ret = recv_peek(sockfd, bufp, nleft);
                if (ret < 0)
                        return ret;
                else if (ret == 0)
                        return ret;

                nread = ret;
                int i;
                for (i=0; i<nread; i++)
                {
                        if (bufp[i] == '
')
                        {
                                ret = readn(sockfd, bufp, i+1);
                                if (ret != i+1)
                                        exit(EXIT_FAILURE);

                                return ret;
                        }
                }

                if (nread > nleft)
                        exit(EXIT_FAILURE);

                nleft -= nread;
                ret = readn(sockfd, bufp, nread);
                if (ret != nread)
                        exit(EXIT_FAILURE);

                bufp += nread;
        }

        return -1;
}

void echo_cli(int sock)
{
/*
    char sendbuf[1024] = {0};
        char recvbuf[1024] = {0};
        while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
        {
                writen(sock, sendbuf, strlen(sendbuf));

                int ret = readline(sock, recvbuf, sizeof(recvbuf));
                if (ret == -1)
                        ERR_EXIT("readline");
                else if (ret == 0)
                {
                        printf("client close
");
                        break;
                }

                fputs(recvbuf, stdout);
                memset(sendbuf, 0, sizeof(sendbuf));
                memset(recvbuf, 0, sizeof(recvbuf));
        }

        close(sock);
*/
    fd_set     rset;
    FD_ZERO(&rset);

    int     nready;
    int     maxfd;
    int         fd_stdin = fileno(stdin);
    
    if (fd_stdin > sock)
        maxfd = fd_stdin;
    else
        maxfd = sock;

    char sendbuf[1024] = {0};
    char recvbuf[1024] = {0};

    while (1)
    {
        FD_SET(fd_stdin, &rset);
        FD_SET(sock, &rset);
        nready = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nready == -1)
            ERR_EXIT("select");

        if (nready == 0)
            continue;

        if (FD_ISSET(sock, &rset))
        {
            int ret = readline(sock, recvbuf, sizeof(recvbuf));
            if (ret == -1)
                    ERR_EXIT("readline");
            else if (ret == 0)
            {
                printf("server close
");
                break;
            }

               fputs(recvbuf, stdout);
            memset(recvbuf, 0, sizeof(recvbuf));
        }
        if (FD_ISSET(fd_stdin, &rset))
        {
            if (fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
                break;
            writen(sock, sendbuf, strlen(sendbuf));
            memset(sendbuf, 0, sizeof(sendbuf));
        }
    }

    close(sock);
}

void handle_sigpipe(int sig)
{
    printf("recv a sig=%d
", sig);
}

int main(void)
{
/*
    signal(SIGPIPE, handle_sigpipe);
*/
    signal(SIGPIPE, SIG_IGN);
    int sock;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        ERR_EXIT("socket");

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(5188);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("connect");

    struct sockaddr_in localaddr;
    socklen_t addrlen = sizeof(localaddr);
    if (getsockname(sock, (struct sockaddr*)&localaddr, &addrlen) < 0)
        ERR_EXIT("getsockname");

    printf("ip=%s port=%d
", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));


    echo_cli(sock);

    return 0;
}