[UNP]:TCP客户服务器_IO复用

1. select版本

  • 服务器端IO复用

    服务器端IO复用的基本思想就是使用一个数据结构来维护客户于套接字描述符的映射关系，每当有一个客户建立连接时，就通过accept()为其分配一个以连接文件描述符，在本地数据结构中添加一个映射条目，每当断开一个客户连接时，就回收该文件描述符，在本地的数据结构中移除该条目

    UNP中采用了一个数据client[]和一个集合rest来表示这样的映射关系, client[n]表示客户n对应的套接字描述符

    1

  • str_cli()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    #include	"unp.h"

    void
    str_cli(FILE *fp, int sockfd)
    {
    	int			maxfdp1, stdineof;
    	fd_set		rset;
    	char		buf[MAXLINE];
    	int		    n;

    	stdineof = 0;
    	FD_ZERO(&rset);
    	for ( ; ; ) {
    		if (stdineof == 0)
    			FD_SET(fileno(fp), &rset);
    		FD_SET(sockfd, &rset);
    		maxfdp1 = max(fileno(fp), sockfd) + 1;
    		Select(maxfdp1, &rset, NULL, NULL, NULL);             // 用户监听STDIN, sockfd两个描述符

    		if (FD_ISSET(sockfd, &rset)) {	     				  // Socket 描述符可读
    			if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
    				if (stdineof == 1)          		          // 表明用户主动关闭
    					return;		
    				else                                          // 异常关闭
    					err_quit("str_cli: server terminated prematurely");
    			}

    			Write(fileno(stdout), buf, n);                    // 回显在终端上
    		}

    		if (FD_ISSET(fileno(fp), &rset)) {                    // STDIN可读
    			if ( (n = Read(fileno(fp), buf, MAXLINE)) == 0) { // 读取到EOF
    				stdineof = 1;
    				Shutdown(sockfd, SHUT_WR);	                  // 发送FIN
    				FD_CLR(fileno(fp), &rset);
    				continue;
    			}

    			Writen(sockfd, buf, n);                           // 向服务端发送
    		}
    	}
    }

客户端

客户端主函数代码与迭代版本一样， 只是更改了str_cli()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include "unp.h"

int main(int argc, char **argv)
{
        int sockfd;
        struct sockaddr_in servaddr;
        
        if(argc != 2)
            err_quit("usage: tcpcli <IPaddress>");
        
        sockfd = Socket(AF_INET, SOCK_STREAM, 0);
        
        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(SERV_PORT);
        Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
        
        Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));
        
        str_cli(stdin, sockfd); /*do it all*/
        
        exit(0);    
}

服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/* include fig01 */
#include	"unp.h"

int
main(int argc, char **argv)
{
	int					i, maxi, maxfd, listenfd, connfd, sockfd;
	int					nready, client[FD_SETSIZE];
	ssize_t				n;
	fd_set				rset, allset;
	char				buf[MAXLINE];
	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, (SA *) &servaddr, sizeof(servaddr));

	Listen(listenfd, LISTENQ);

	maxfd = listenfd;			/* initialize */
	maxi = -1;					/* index into client[] array */
	for (i = 0; i < FD_SETSIZE; i++)
		client[i] = -1;			/* -1 indicates available entry */
	FD_ZERO(&allset);
	FD_SET(listenfd, &allset);
/* end fig01 */

/* include fig02 */
	for ( ; ; ) {
		rset = allset;		/* structure assignment */
		nready = Select(maxfd+1, &rset, NULL, NULL, NULL);

		if (FD_ISSET(listenfd, &rset)) {	/* new client connection */
			clilen = sizeof(cliaddr);
			connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
#ifdef	NOTDEF
			printf("new client: %s, port %dn",
					Inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL),
					ntohs(cliaddr.sin_port));
#endif

			for (i = 0; i < FD_SETSIZE; i++)
				if (client[i] < 0) {
					client[i] = connfd;	/* save descriptor */
					break;
				}
			if (i == FD_SETSIZE)
				err_quit("too many clients");

			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[] 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 */
					Close(sockfd);
					FD_CLR(sockfd, &allset);
					client[i] = -1;
				} else
					Writen(sockfd, buf, n);

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

2. poll版本

poll()版本则不需要维护复杂的数据结构，只需要分配一个pollfd数组即可

服务器端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/* include fig01 */
#include "unp.h"
#include <limits.h> /* for OPEN_MAX */

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[FOPEN_MAX];
  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, (SA *)&servaddr, sizeof(servaddr));

  Listen(listenfd, LISTENQ);

  client[0].fd = listenfd;
  client[0].events = POLLRDNORM;
  for (i = 1; i < FOPEN_MAX; i++)
    client[i].fd = -1; /* -1 indicates available entry */
  maxi = 0;            /* max index into client[] array */
                       /* end fig01 */

  /* include fig02 */
  for (;;) {
    nready = Poll(client, maxi + 1, INFTIM);

    if (client[0].revents & POLLRDNORM) { /* new client connection */
      clilen = sizeof(cliaddr);
      connfd = Accept(listenfd, (SA *)&cliaddr, &clilen);
#ifdef NOTDEF
      printf("new client: %sn", Sock_ntop((SA *)&cliaddr, clilen));
#endif

      for (i = 1; i < FOPEN_MAX; i++)
        if (client[i].fd < 0) {
          client[i].fd = connfd; /* save descriptor */
          break;
        }
      if (i == FOPEN_MAX)
        err_quit("too many clients");

      client[i].events = POLLRDNORM;
      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 & (POLLRDNORM | POLLERR)) {
        if ((n = read(sockfd, buf, MAXLINE)) < 0) {
          if (errno == ECONNRESET) {
            /*4connection reset by client */
#ifdef NOTDEF
            printf("client[%d] aborted connectionn", i);
#endif
            Close(sockfd);
            client[i].fd = -1;
          } else
            err_sys("read error");
        } else if (n == 0) {
          /*4connection closed by client */
#ifdef NOTDEF
          printf("client[%d] closed connectionn", i);
#endif
          Close(sockfd);
          client[i].fd = -1;
        } else
          Writen(sockfd, buf, n);

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

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！