4.Linux网络编程-select和poll模型

目录：
1.补充知识
2.简易版回射服务器的实现
3.select模型实现
4.poll模型实现

1.补充知识

#显示进程的pid：
ps -eo pid,ppid,sid,tty,pgrp,comm | grep -E 'bash|PID|server'
#显示TCP的状态
netstat -an | grep "5000"
#跟踪进程接收的信号命令
strace -e trace=signal -p 1359

2.简易回射服务器的实现
简易版回射服务器：实现服务器和多个客户端的点对点反射，源代码下面；
说明：简易版服务器的问题在于当服务器的子进程退出时，由于客户端处于调用fget函数侦听键盘输入的阻塞状态，所以客户端会一直处于CLOSE_WAIT，服务端处于FIN_WAIT2状态（见重现步骤），
当我们在客户端敲入数据后，客户端会执行write函数将数据发送给服务端，但此时服务端的接收窗口已关闭，会发送RST消息告诉客户端已关闭，客户端收到RST消息应该关闭发送窗口，如果客户端继续发送数据给服务器，此时会触发SIGPIPE的信号，导致服务器异常退出。所以我们需要解决这两个问题；
解决问题的方法：1.I/O进行异步处理（select/poll/epoll）；2.对SIGPIPE信号进行处理；

重现步骤：
1.利用ps获取服务端进程id
root@epc:~# ps -eo pid,ppid,sid,tty,pgrp,comm | grep -E 'PID|server'
   PID   PPID    SID TT         PGRP COMMAND
  1999   1856   1856 pts/1      1999 server
  2003   1999   1856 pts/1      1999 server
2.执行kill 2003杀掉子进程
3.查看tcp状态
root@epc:~# netstat -an|grep 5000
tcp        0      0 0.0.0.0:5000            0.0.0.0:*               LISTEN     
tcp        0      0 127.0.0.1:5000          127.0.0.1:45196         FIN_WAIT2  
tcp        1      0 127.0.0.1:45196         127.0.0.1:5000          CLOSE_WAIT 
root@epc:~# 
4.客户端在键盘输入数据；

//客户端程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>

#define SERV_PORT 5000
#define MAXLINE  64

#define handle_error(msg) \
	do { perror(msg); exit(EXIT_FAILURE); } while(0)

#define handle_success(msg) \
	do { printf(msg); exit(EXIT_SUCCESS); } while(0)

/**
readline-读取一行数据，以'\n'为分界符；
返回值：-1表示返回错误，0表示收到FIN信号，>0表示数据的长度
说明：此函数实现了低性能的读取行数据的功能；
@ssize_t：返回读的长度 -1失败
@fd：文件描述符
@buf：待写数据首地址
@nByte：待写长度
 */
//ssize_t readline(int fd, void *buf, size_t nByte)
//{
//    ssize_t n, nread;
//    char c;
//    char* ptr = (char*)buf;
//    for (n = 1; n < nByte; n++){
//    again:
//        if ( (nread = read(fd, &c, 1)) == 1){
//            *ptr++ = c;
//            if (c == '\n')
//                break;  // newline is stored
//        } else if (nread == 0){
//            *ptr = 0;
//            return (n - 1); // EOF, n - 1 bytes
//        } else {
//            if (errno == EINTR)
//                    goto again;
//            return -1; /// error, errno set by read()
//        }
//    }
//    *ptr = 0;
//    return n;
//}


//readline-读取一行数据，以'\n'为分界符；
//返回值：-1表示返回错误，0表示收到FIN信号，>0表示数据的长度
//说明：此函数实现了高性能的读取行数据的功能；
//@ssize_t：返回读的长度 -1失败
//@fd：文件描述符
//@buf：待写数据首地址
//@nByte：待写长度
ssize_t readline(int fd, void *buf, size_t nBytes)
{
	char *buf_p = (char*)buf;
	size_t n;
	int nread;

	for(;;)
	{
		nread = recv(fd, buf_p, nBytes, MSG_PEEK);	//偷窥缓冲区数据，但不刷新；
		if (nread<0)
		{
			if (errno==EINTR)
				continue;
			return -1;
		}
		else if (nread == 0)
			return 0;
		else
			break;
	}

	for (n=1; n<=nread; n++)
	{
		if (buf_p[n-1] == '\n')
			break;
	}

	for(;;)
	{
		nread = read(fd, buf_p, n);
		if (nread<0)
		{
			if (errno==EINTR)
				continue;
			return -1;
		}
		else if (nread == 0)
			return 0;
		else
		{
			break;
		}
	}
	*(buf_p+nread) = 0;
	return nread;
}


void str_cli(FILE *fp, int sockfd)
{
    char sendline[MAXLINE], recvline[MAXLINE];
    while (fgets(sendline, MAXLINE, fp) != NULL){
        write(sockfd, sendline, strlen(sendline));
        if (readline(sockfd, recvline, MAXLINE) == 0)
        	handle_success("str_cli:server terminated prematurely");
        fputs(recvline, stdout);
    }
}

int main(int argc, char **argv)
{
    int sockfd;
    struct sockaddr_in servaddr;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
    str_cli(stdin, sockfd);  // do it all
    return 0;
}

//服务端程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <wait.h>

#define SERV_PORT 5000
#define MAXLINE  64

#define handle_error(msg) \
	do { perror(msg); exit(EXIT_FAILURE); } while(0)

#define handle_success(msg) \
	do { printf(msg); exit(EXIT_SUCCESS); } while(0)

/*
 * sig_chld：信号的处理函数，触发时用来处理僵尸进程
 * 作用：子进程退出后会发送SIGCHLD信号给父进程，系统默认行为是维持子进程保持僵死状态不退出；
 * @signo：捕获的信号；
*/
void sig_chld(int signo)
{
    pid_t pid;
    int stat;
    // 用waitpid不用wait因为可以通过WNOHANG选项告知waitpid在尚有未终止的子进程在运行时不要阻塞
    while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0)
        printf("child %d terminated\n", pid);// printf() isn't suitable for use here
    return;
}

void str_echo(int sockfd)
{
    int n;
    char buf[MAXLINE];
again:
    while ( (n = read(sockfd, buf, MAXLINE)))
        write(sockfd, buf, n);
    if (n < 0 && errno == EINTR)
        goto again;
    else if (n < 0)
        printf("str_echo: read error");
}

int main(int argc, char **argv)
{
    if (signal(SIGCHLD, sig_chld) == SIG_ERR){
    	handle_error("can't catch SIGCHLD");
    }
	signal(SIGPIPE, SIG_IGN);	//处理服务器子进程关闭后，客户端连续发送多次数据，产生SIGPIPE信号，导致服务器挂掉；
    int listenfd, connfd;
    pid_t childpid;
    socklen_t clilen;
    struct sockaddr_in cliaddr, servaddr;
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);
    bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
    listen(listenfd, 5);

    for ( ; ; ){
        clilen = sizeof(cliaddr);
        if ( (connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen)) < 0){
            if (errno == EINTR) // accept 在阻塞的时候被signal打断会返回EINTR错误存于errno
                continue; // back to for()
            else{
            	handle_error("accept error\n");
            }
        }

        if ((childpid = fork()) == 0){ // child
            close(listenfd); // close listening socket
            str_echo(connfd);// process the request
            exit(0);
        }
        close(connfd); // parent closes connected socket
    }
    return 0;
}

3.select模型实现
Select函数在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用Select写程序，他们只是习惯写诸如connect、 accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回）。可是使用Select就可以完成非阻塞（所谓非阻塞方式non-block，就是进程或线程执行此函数时不必非要等待事件的发生，一旦执行肯定返回，以返回值的不同来反映函数的执行情况，如果事件发生则与阻塞方式相同，若事件没有发生则返回一个代码来告知事件未发生，而进程或线程继续执行，所以效率较高）方式工作的程序，它能够监视我们需要监视的文件描述符的变化情况——读写或是异常。

#include <sys/select.h>
#include <sys/time.h>
 
int select(int maxfd, fd_set *readset, fd_set *writeset,
			fd_set *exceptset, const struct timeval *timeout);

@select函数：select能够监视我们需要监视的文件描述符的变化情况
@int：错误返回-1，超时返回0。当关注的事件返回时，返回大于0的值，该值是发生事件的文件描述符数
@maxfd：监视对象文件描述符数量。
@readset：将所有关注“是否存在待读取数据”的文件描述符注册到fd_set变量，并传递其地址值
@writeset： 将所有关注“是否可传输无阻塞数据”的文件描述符注册到fd_set变量，并传递其地址值
@exceptset：将所有关注“是否发生异常”的文件描述符注册到fd_set变量，并传递其地址值
@timeout：调用select后，为防止陷入无限阻塞状态，传递超时信息
	struct timeval {
		long tv_sec;
		long tv_usec;
	};

FD_ZERO(fd_set *fdset)：清空fdset与所有文件句柄的联系。
FD_SET(int fd, fd_set *fdset)：建立文件句柄fd与fdset的联系。
FD_CLR(int fd, fd_set *fdset)：清除文件句柄fd与fdset的联系。
FD_ISSET(int fd, fdset *fdset)：检查fdset联系的文件句柄fd是否可读写，>0表示可读写。

struct fd_set一个存放文件描述符(file descriptor)，即文件句柄的聚合，实际上是一long类型的数组，
每一个数组元素都能与一打开的文件句柄（不管是Socket句柄,还是其他文件或命名管道或设备句柄）建立联系，建立联系的工作由程序员完成；

//服务端程序
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>

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

#define MAXLINE 1024
#define SERV_PORT 5000

//readn函数
//说明：此函数解决了粘包的数据处理；
//@ssize_t：-1表示返回错误，0表示收到FIN信号，>0表示数据的长度
//@fd：文件描述符
//@buf：待写数据首地址
//@nByte：待读长度
ssize_t readn(int fd, void *buf, size_t nByte)
{
	size_t nleft = nByte;
	ssize_t nread = 0;
	char * buf_p = (char*)buf;

	while (nleft > 0)
	{
		nread = read(fd, buf_p, nleft);
		if (nread<0 && errno==EINTR)
			continue;
		else if (nread == 0)
			return 0;
		else if (nread < 0)
			return -1;
		else
			return nread;
		nleft -= nread;
		buf_p += nread;
	}
	return nByte;
}

//writen函数
//说明：此函数解决了缓冲区数据发送溢出的处理；
//@ssize_t：-1表示返回错误，0表示收到FIN信号，>0表示数据的长度
//@fd：文件描述符
//@buf：待写数据首地址
//@nByte：待写长度
ssize_t writen(int fd, void *buf, size_t nBytes)
{
	size_t nleft = nBytes;
	char *buf_p = (char*)buf;
	int nwritten = 0;

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

	return nBytes;
}

int main(int argc, char **argv)
{
	int i, maxi, maxfd, listenfd, connfd, sockfd;
	int nready, client[FD_SETSIZE];
	ssize_t n;

	char buf[MAXLINE];
	socklen_t clilen;
	struct sockaddr_in cliaddr, servaddr;

	//1.创建套接字
    if ((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
    	ERR_EXIT("socket error"); //调用上边的宏

	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	//2.设置套接字属性
    int on = 1;
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
    	ERR_EXIT("setsockopt error");

    //3.绑定
    if (bind(listenfd, (struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)
    	ERR_EXIT("bind error");

    //4.监听
    if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前
    	ERR_EXIT("listen error");

	maxfd = listenfd; // initialize
	maxi = -1;  // index into client[] array
	for (i = 0; i < FD_SETSIZE; ++i)
		client[i] = -1; // -1 indicates available entry

	fd_set rset, allset;
	FD_ZERO(&allset);
	FD_SET(listenfd, &allset);
	while(true)
	{
		rset = allset; //rset被select调用后值会改变
		nready = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nready < 0) {
            if (errno == EINTR)
                continue;
            ERR_EXIT("select error");
        }

		if (FD_ISSET(listenfd, &rset)) { // new client connection
			clilen = sizeof(cliaddr);
			connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);

			for (i = 0; i < FD_SETSIZE; ++i)
			{
				if (client[i] < 0) {
					client[i] = connfd; // save descriptor
					break;
				}
			}
			if (i == FD_SETSIZE)
			{
				ERR_EXIT("too many clients");
				exit(EXIT_FAILURE);
			}
			FD_SET(connfd, &allset); // add new descriptor to set
			if (connfd > maxfd)
				maxfd = connfd; // for select

			if (i > maxi)
				maxi = i; // max index in client[i] array

			if (--nready <= 0)
				continue; // no more readable descriptors
		}
		for (i = 0; i <= maxi; ++i) { // check all clients for data
			if ( (sockfd = client[i]) < 0)
				continue;
			if (FD_ISSET(sockfd, &rset))
			{
				if ( (n = read(sockfd, buf, MAXLINE)) == 0)
				{
					// connection closed by client
					//shutdown(sockfd, SHUT_WR);	//关闭可写，但还可以接收客户端数据，避免服务器异常；
					close(sockfd);
					FD_CLR(sockfd, &allset);
					client[i] = -1;
				}
				else if (n < 0)
					ERR_EXIT("read error");
				else
					writen(sockfd, buf, n);

				if (--nready <= 0)
					break; // no more readable descriptors
			}
		}
	}

    return 0;
}

//客户端程序
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>


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

#define MAXLINE 1024
#define SERV_PORT 5000

int main(void)
{
    int sock;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        //  listenfd = socket(AF_INET, SOCK_STREAM, 0)
        ERR_EXIT("socket error");


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

    if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("connect error");
    struct sockaddr_in localaddr;
    char cli_ip[20];
    socklen_t local_len = sizeof(localaddr);
    memset(&localaddr, 0, sizeof(localaddr));
    if( getsockname(sock,(struct sockaddr *)&localaddr,&local_len) != 0 )
        ERR_EXIT("getsockname error");
    inet_ntop(AF_INET, &localaddr.sin_addr, cli_ip, sizeof(cli_ip));
    printf("host %s:%d\n", cli_ip, ntohs(localaddr.sin_port));

    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 (true)
    {
        FD_SET(fd_stdin, &rset);
        FD_SET(sock, &rset);
        nready = select(maxfd + 1, &rset, NULL, NULL, NULL); //select返回表示检测到可读事件
        if (nready < 0) {
            if (errno == EINTR)
                continue;
            ERR_EXIT("select error");
        }

        if (FD_ISSET(sock, &rset))
        {
            int ret = read(sock, recvbuf, sizeof(recvbuf));
            if (ret == -1)
                ERR_EXIT("read error");
            else if (ret  == 0)   //服务器关闭
            {
                printf("server close\n");
                break;
            }

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

        if (FD_ISSET(fd_stdin, &rset))
        {
            if (fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
                break;

            write(sock, sendbuf, strlen(sendbuf));
            memset(sendbuf, 0, sizeof(sendbuf));
        }
    }

    close(sock);
    return 0;
}

4.poll模型实现

select() 和 poll() 系统调用的本质一样，poll() 的机制与 select() 类似，与 select() 在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理。

#include <poll.h>
int poll(struct pollfd * fdarray, unsigned long nfds, int timeout);
参数解释： 
（1）fdarray：指向一个结构体数组的第0个元素的指针，每个数组元素都是一个struct pollfd结构，用于指定测试某个给定的fd的条件 ;
（2）nfds：表示fds结构体数组的长度 ;
（3）timeout：表示poll函数的超时时间，单位是毫秒 ;
函数功能： 
监视并等待多个文件描述符的属性变化 
函数返回值： 
（1）返回值小于0，表示出错 
（2）返回值等于0，表示poll函数等待超时 
（3）返回值大于0，表示poll由于监听的文件描述符就绪返回，并且返回结果就是就绪的文件描述符的个数。

在该函数的第一个参数中，我们知道存放文件描述符的数组中每一个元素都是一个struct pollfd结构，那么pollfd结构到底是什么样的呢？我们来一起了解一下：
struct poolfd{
	int fd;
	short events;
	short revents;
}
成员变量说明： 
（1）fd：每一个 pollfd 结构体指定了一个被监视的文件描述符，可以传递多个结构体，指示 poll() 监视多个文件描述符。 
（2）events：表示要告诉操作系统需要监测fd的事件（输入、输出、错误），每一个事件有多个取值 
（3）revents：revents 域是文件描述符的操作结果事件，内核在调用返回时设置这个域。events 域中请求的任何事件都可能在 revents 域中返回。
 事件的常用值有以下几种：
 可读：
	POLLIN:                有普通数据或者优先数据可读
	POLLRDNORM:    有普通数据可读
	POLLRDBAND:    有优先数据可读
	POLLPRI:              有紧急数据可读
可写：
	POLLOUT:            有普通数据可写
	POLLWRNORM:   有普通数据可
	POLLWRBAND:    有紧急数据可写
异常：
	POLLERR:            有错误发生
	POLLHUP:            有描述符挂起事件发生
	POLLNVAL:          描述符非法

//利用poll实现回射服务器
#include <limits.h> // for OPEN_MAX
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <poll.h>
#include <unistd.h>

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

#define MAXLINE 1024
#define SERV_PORT 5000
#define OPEN_MAX 1024
#define INFTIM -1

//writen函数
//说明：此函数解决了缓冲区数据发送溢出的处理；
//@ssize_t：-1表示返回错误，0表示收到FIN信号，>0表示数据的长度
//@fd：文件描述符
//@buf：待写数据首地址
//@nByte：待写长度
ssize_t writen(int fd, void *buf, size_t nBytes)
{
	size_t nleft = nBytes;
	char *buf_p = (char*)buf;
	int nwritten = 0;

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

	return nBytes;
}

int main(int argc, char **argv)
{
	int i, maxi, listenfd, connfd, sockfd;
	int nready;

	ssize_t n;
	char buf[MAXLINE];
	socklen_t clilen;
	struct pollfd client[OPEN_MAX];
	struct sockaddr_in cliaddr, servaddr;

	//1.创建套接字
	if ((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
		ERR_EXIT("socket error"); //调用上边的宏

	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	//2.设置套接字属性
	int on = 1;
	if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
		ERR_EXIT("setsockopt error");

	//3.绑定
	if (bind(listenfd, (struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)
		ERR_EXIT("bind error");

	//4.监听
	if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前
		ERR_EXIT("listen error");

	client[0].fd = listenfd;
	client[0].events = POLLIN;
	for (i = 1; i < OPE_MAX; ++i)
		client[i].fd = -1;  // indicates available entry
	maxi = 0;  // max index into client[] array
	while (true)
	{
		nready = poll(client, maxi + 1, INFTIM);
		if(nready < 0)
		{
			perror("poll error");
            break;
		}
		else if(nready == 0)
		{
			continue;
		}

		if (client[0].revents & POLLIN)
		{ // new client connection
			clilen = sizeof(cliaddr);
			connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);
			printf("new client\n");
			for (i = 1; i < OPEN_MAX; ++i)
			{
				if (client[i].fd < 0)
				{
					client[i].fd = connfd; // save descriptor
					break;
				}
			}
			if (OPEN_MAX == i)
			{
				ERR_EXIT("too many clients");
			}
			client[i].events = POLLIN;
			if (i > maxi)
				maxi = i;  // max index in client[] array

			if (--nready <= 0)
				continue; // no more readable descriptors
		}

		for (i = 1; i <= maxi; ++i)
		{ // check all clients for data
			if ( (sockfd = client[i].fd) < 0)
				continue;
			if (client[i].revents & (POLLIN | POLLERR))
			{
				if ( (n = read(sockfd, buf, MAXLINE)) >= 0)
				{
					if (errno == ECONNRESET)
					{
						// connection reset by client
						close(sockfd);
						client[i].fd = -1;
					}
					else if (0 == n)
					{
						// connection closed by client
						close(sockfd);
						client[i].fd = -1;
					} else
						writen(sockfd, buf, n);
					if (--nready <= 0)
						break; // no more readable descriptors
				}
				else
				{
					ERR_EXIT("read error");
				}
			}
		}
	}
	return 0;
}

//客户端
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<poll.h>


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

#define MAXLINE 1024
#define SERV_PORT 5000

int main(void)
{
    int sock;
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        //  listenfd = socket(AF_INET, SOCK_STREAM, 0)
        ERR_EXIT("socket error");


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

    if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("connect error");
    struct sockaddr_in localaddr;
    char cli_ip[20];
    socklen_t local_len = sizeof(localaddr);
    memset(&localaddr, 0, sizeof(localaddr));
    if( getsockname(sock,(struct sockaddr *)&localaddr,&local_len) != 0 )
        ERR_EXIT("getsockname error");
    inet_ntop(AF_INET, &localaddr.sin_addr, cli_ip, sizeof(cli_ip));
    printf("host %s:%d\n", cli_ip, ntohs(localaddr.sin_port));

    struct pollfd p_fds[2];
    int fd_stdin = fileno(stdin);
	p_fds[0].fd = STDIN_FILENO;
	p_fds[0].events = POLLIN;
	p_fds[0].revents = 0;
	p_fds[1].fd = sock;
	p_fds[1].events = POLLIN;
	p_fds[1].revents = 0;

    int nready;
    int maxfd;
    if (fd_stdin > sock)
        maxfd = fd_stdin;
    else
        maxfd = sock;
    char sendbuf[1024] = {0};
    char recvbuf[1024] = {0};

    while (true)
    {
		nready = poll(p_fds, 2, -1);
        if(nready < 0)
            ERR_EXIT("poll");
        else if(nready == 0)
        {
            printf("timeout\n");
            continue;
        }
        else
        {
        	if ((p_fds[1].revents&POLLIN) == POLLIN && p_fds[1].fd == sock)
			{
				int ret = read(sock, recvbuf, sizeof(recvbuf));
				if (ret == -1)
					ERR_EXIT("read error");
				else if (ret  == 0 || errno == ECONNRESET)   //服务器关闭
				{
					p_fds[1].fd = -1;
					break;
				}

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

			if ((p_fds[0].revents&POLLIN) == POLLIN && p_fds[0].fd == STDIN_FILENO)
			{
				if (fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
					break;
				write(sock, sendbuf, strlen(sendbuf));
				memset(sendbuf, 0, sizeof(sendbuf));
			}
        }
    }

    close(sock);
    return 0;
}