socket编程-- 基于TCP协议的网络程序

847阅读　0评论2012-01-17　378333581
分类：

下图是基于TCP协议的客户端/服务器程序的一般流程：

TCP协议通讯流程






服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。


数据传输的过程：

建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，服务器被动处理请求，一问一答的方式。因此，服务器从accept()返回后立刻调用read()，读socket就像读管道一样，如果没有数据到达就阻塞等待，这时客户端调用write()发送请求给服务器，服务器收到后从read()返回，对客户端的请求进行处理，在此期间客户端调用read()阻塞等待服务器的应答，服务器调用write()将处理结果发回给客户端，再次调用read()阻塞等待下一条请求，客户端收到后从read()返回，发送下一条请求，如此循环下去。

如果客户端没有更多的请求了，就调用close()关闭连接，就像写端关闭的管道一样，服务器的read()返回0，这样服务器就知道客户端关闭了连接，也调用close()关闭连接。注意，任何一方调用close()后，连接的两个传输方向都关闭，不能再发送数据了。如果一方调用shutdown()则连接处于半关闭状态，仍可接收对方发来的数据。

在学习socket API时要注意应用程序和TCP协议层是如何交互的： *应用程序调用某个socket函数时TCP协议层完成什么动作，比如调用connect()会发出SYN段 *应用程序如何知道TCP协议层的状态变化，比如从某个阻塞的socket函数返回就表明TCP协议收到了某些段，再比如read()返回0就表明收到了FIN段


最简单的TCP网络程序

下面通过最简单的客户端/服务器程序的实例来学习socket API。

server.c的作用是从客户端读字符，然后将每个字符转换为大写并回送给客户端。

  1. /* server.c */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/socket.h>
  7. #include <netinet/in.h>

  9. #define MAXLINE 80
  10. #define SERV_PORT 8000

  12. int main(void)
  13. {
  14.     struct sockaddr_in servaddr, cliaddr;
  15.     socklen_t cliaddr_len;
  16.     int listenfd, connfd;
  17.     char buf[MAXLINE];
  18.     char str[INET_ADDRSTRLEN];
  19.     int i, n;

  21.     listenfd = socket(AF_INET, SOCK_STREAM, 0);

  23.     bzero(&servaddr, sizeof(servaddr));
  24.     servaddr.sin_family = AF_INET;
  25.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  26.     servaddr.sin_port = htons(SERV_PORT);
  27.     
  28.     bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

  30.     listen(listenfd, 20);

  32.     printf("Accepting connections ...\n");
  33.     while (1) {
  34.         cliaddr_len = sizeof(cliaddr);
  35.         connfd = accept(listenfd,
  36.                 (struct sockaddr *)&cliaddr, &cliaddr_len);
  37.     
  38.         n = read(connfd, buf, MAXLINE);
  39.         printf("received from %s at PORT %d\n",
  40.          inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
  41.          ntohs(cliaddr.sin_port));
  42.     
  43.         for (i = 0; i < n; i++)
  44.             buf[i] = toupper(buf[i]);
  45.         write(connfd, buf, n);
  46.         close(connfd);
  47.     }
  48. }

  

下面介绍程序中用到的socket API，这些函数都在sys/socket.h中。

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

socket()打开一个网络通讯端口，如果成功的话，就像open()一样返回一个文件描述符，应用程序可以像读写文件一样用read/write在网络上收发数据，如果socket()调用出错则返回-1。对于IPv4，family参数指定为AF_INET。对于TCP协议，type参数指定为SOCK_STREAM，表示面向流的传输协议。如果是UDP协议，则type参数指定为SOCK_DGRAM，表示面向数据报的传输协议。protocol参数的介绍从略，指定为0即可。

int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind绑定一个固定的网络地址和端口号。bind()成功返回0，失败返回-1。

bind()的作用是将参数sockfd和myaddr绑定在一起，使sockfd这个用于网络通讯的文件描述符监听myaddr所描述的地址和端口号。前面讲过，struct sockaddr *是一个通用指针类型，myaddr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度各不相同，所以需要第三个参数addrlen指定结构体的长度。我们的程序中对myaddr参数是这样初始化的：

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

首先将整个结构体清零，然后设置地址类型为AF_INET，网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP地址，端口号为SERV_PORT，我们定义为8000。

int listen(int sockfd, int backlog);

典型的服务器程序可以同时服务于多个客户端，当有客户端发起连接时，服务器调用的accept()返回并接受这个连接，如果有大量的客户端发起连接而服务器来不及处理，尚未accept的客户端就处于连接等待状态，listen()声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接待状态，如果接收到更多的连接请求就忽略。listen()成功返回0，失败返回-1。

int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

三方握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。cliaddr是一个传出参数，accept()返回时传出客户端的地址和端口号。addrlen参数是一个传入传出参数（value-result argument），传入的是调用者提供的缓冲区cliaddr的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。如果给cliaddr参数传NULL，表示不关心客户端的地址。

我们的服务器程序结构是这样的：

while (1) { cliaddr_len = sizeof(cliaddr); connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len); n = read(connfd, buf, MAXLINE); ... close(connfd); }

整个是一个while死循环，每次循环处理一个客户端连接。由于cliaddr_len是传入传出参数，每次调用accept()之前应该重新赋初值。accept()的参数listenfd是先前的监听文件描述符，而accept()的返回值是另外一个文件描述符connfd，之后与客户端之间就通过这个connfd通讯，最后关闭connfd断开连接，而不关闭listenfd，再次回到循环开头listenfd仍然用作accept的参数。accept()成功返回一个文件描述符，出错返回-1。

client.c的作用是从命令行参数中获得一个字符串发给服务器，然后接收服务器返回的字符串并打印。


  1. /* client.c */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/socket.h>
  7. #include <netinet/in.h>

  9. #define MAXLINE 80
  10. #define SERV_PORT 8000

  12. int main(int argc, char *argv[])
  13. {
  14.     struct sockaddr_in servaddr;
  15.     char buf[MAXLINE];
  16.     int sockfd, n;
  17.     char *str;
  18.     
  19.     if (argc != 2) {
  20.         fputs("usage: ./client message\n", stderr);
  21.         exit(1);
  22.     }
  23.     str = argv[1];
  24.     
  25.     sockfd = socket(AF_INET, SOCK_STREAM, 0);

  27.     bzero(&servaddr, sizeof(servaddr));
  28.     servaddr.sin_family = AF_INET;
  29.     inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
  30.     servaddr.sin_port = htons(SERV_PORT);
  31.     
  32.     connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

  34.     write(sockfd, str, strlen(str));

  36.     n = read(sockfd, buf, MAXLINE);
  37.     printf("Response from server:\n");
  38.     write(STDOUT_FILENO, buf, n);

  40.     close(sockfd);
  41.     return 0;
  42. }


由于客户端不需要固定的端口号，因此不必调用bind()，客户端的端口号由内核自动分配。注意，客户端不是不允许调用bind()，只是没有必要调用bind()固定一个端口号，服务器也不是必须调用bind()，但如果服务器不调用bind()，内核会自动给服务器分配监听端口，每次启动服务器时端口号都不一样，客户端要连接服务器就会遇到麻烦。

int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen);

客户端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。connect()成功返回0，出错返回-1。

先编译运行服务器:

$ ./server Accepting connections ...

然后在另一个终端里用netstat命令查看：

  1. $ netstat -apn|grep 8000
  2.  tcp 0 0 0.0.0.0:8000 0.0.0.0:* LISTEN 8148/server

可以看到server程序监听8000端口，IP地址还没确定下来。现在编译运行客户端：

  1. $ ./client abcd 
  2. Response from server: 
  3. ABCD

回到server所在的终端，看看server的输出：

  1. $ ./server 
  2. Accepting connections ... 
  3. received from 127.0.0.1 at PORT 59757

可见客户端的端口号是自动分配的。现在把客户端所连接的服务器IP改为其它主机的IP，试试两台主机的通讯。

再做一个小实验，在客户端的connect()代码之后插一个while(1);死循环，使客户端和服务器都处于连接中的状态，用netstat命令查看：

  1. $ ./server &
  2. [1] 8343
  3. $ Accepting connections ...
  4. ./client abcd &
  5. [2] 8344
  6. $ netstat -apn|grep 8000
  7. tcp 0 0 0.0.0.0:8000 0.0.0.0:* LISTEN 8343/server
  8. tcp 0 0 127.0.0.1:44406 127.0.0.1:8000 ESTABLISHED8344/client
  9. tcp 0 0 127.0.0.1:8000 127.0.0.1:44406 ESTABLISHED8343/server

应用程序中的一个socket文件描述符对应一个socket pair，也就是源地址:源端口号和目的地址:目的端口号，也对应一个TCP连接。


表中 . client和server的socket状态

socket文件描述符源地址:源端口号目的地址:目的端口号状态
server.c中的listenfd0.0.0.0:80000.0.0.0:*LISTEN
server.c中的connfd127.0.0.1:8000127.0.0.1:44406ESTABLISHED
client.c中的sockfd127.0.0.1:44406127.0.0.1:8000ESTABLISHED

 

错误处理与读写控制

上面的例子不仅功能简单，而且简单到几乎没有什么错误处理，我们知道，系统调用不能保证每次都成功，必须进行出错处理，这样一方面可以保证程序逻辑正常，另一方面可以迅速得到故障信息。

为使错误处理的代码不影响主程序的可读性，我们把与socket相关的一些系统函数加上错误处理代码包装成新的函数，做成一个模块wrap.c：

  1. #include <stdlib.h>
  2. #include <errno.h>
  3. #include <sys/socket.h>

  5. void perr_exit(const char *s)
  6. {
  7.     perror(s);
  8.     exit(1);
  9. }

  11. int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
  12. {
  13.     int n;

  15. again:
  16.     if ( (n = accept(fd, sa, salenptr)) < 0) {
  17.         if ((errno == ECONNABORTED) || (errno == EINTR))
  18.             goto again;
  19.         else
  20.             perr_exit("accept error");
  21.     }
  22.     return n;
  23. }

  25. void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
  26. {
  27.     if (bind(fd, sa, salen) < 0)
  28.         perr_exit("bind error");
  29. }

  31. void Connect(int fd, const struct sockaddr *sa, socklen_t salen)
  32. {
  33.     if (connect(fd, sa, salen) < 0)
  34.         perr_exit("connect error");
  35. }

  37. void Listen(int fd, int backlog)
  38. {
  39.     if (listen(fd, backlog) < 0)
  40.         perr_exit("listen error");
  41. }

  43. int Socket(int family, int type, int protocol)
  44. {
  45.     int n;

  47.     if ( (n = socket(family, type, protocol)) < 0)
  48.         perr_exit("socket error");
  49.     return n;
  50. }

  52. ssize_t Read(int fd, void *ptr, size_t nbytes)
  53. {
  54.     ssize_t n;

  56. again:
  57.     if ( (n = read(fd, ptr, nbytes)) == -1) {
  58.         if (errno == EINTR)
  59.             goto again;
  60.         else
  61.             return -1;
  62.     }
  63.     return n;
  64. }

  66. ssize_t Write(int fd, const void *ptr, size_t nbytes)
  67. {
  68.     ssize_t n;

  70. again:
  71.     if ( (n = write(fd, ptr, nbytes)) == -1) {
  72.         if (errno == EINTR)
  73.             goto again;
  74.         else
  75.             return -1;
  76.     }
  77.     return n;
  78. }

  80. void Close(int fd)
  81. {
  82.     if (close(fd) == -1)
  83.         perr_exit("close error");
  84. }


慢系统调用accept、read和write被信号中断时应该重试。connect虽然也会阻塞，但是被信号中断时不能立刻重试。对于accept，如果errno是ECONNABORTED，也应该重试。详细解释见参考资料。

TCP协议是面向流的，read和write调用的返回值往往小于参数指定的字节数。对于read调用，如果接收缓冲区中有20字节，请求读100个字节，就会返回20。对于write调用，如果请求写100个字节，而发送缓冲区中只有20个字节的空闲位置，那么write会阻塞，直到把100个字节全部交给发送缓冲区才返回，但如果socket文件描述符有O_NONBLOCK标志，则write不阻塞，直接返回20。为避免这些情况干扰主程序的逻辑，确保读写我们所请求的字节数，我们实现了两个包装函数readn和writen，也放在wrap.c中：


  1. ssize_t Readn(int fd, void *vptr, size_t n)
  2. {
  3.     size_t nleft;
  4.     ssize_t nread;
  5.     char *ptr;

  7.     ptr = vptr;
  8.     nleft = n;
  9.     while (nleft > 0) {
  10.         if ( (nread = read(fd, ptr, nleft)) < 0) {
  11.             if (errno == EINTR)
  12.                 nread = 0;
  13.             else
  14.                 return -1;
  15.         } else if (nread == 0)
  16.             break;

  18.         nleft -= nread;
  19.         ptr += nread;
  20.     }
  21.     return n - nleft;
  22. }

  24. ssize_t Writen(int fd, const void *vptr, size_t n)
  25. {
  26.     size_t nleft;
  27.     ssize_t nwritten;
  28.     const char *ptr;

  30.     ptr = vptr;
  31.     nleft = n;
  32.     while (nleft > 0) {
  33.         if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
  34.             if (nwritten < 0 && errno == EINTR)
  35.                 nwritten = 0;
  36.             else
  37.                 return -1;
  38.         }

  40.         nleft -= nwritten;
  41.         ptr += nwritten;
  42.     }
  43.     return n;
  44. }



如果应用层协议的各字段长度固定，用readn来读是非常方便的。例如设计一种客户端上传文件的协议，规定前12字节表示文件名，超过12字节的文件名截断，不足12字节的文件名用'\0'补齐，从第13字节开始是文件内容，上传完所有文件内容后关闭连接，服务器可以先调用readn读12个字节，根据文件名创建文件，然后在一个循环中调用read读文件内容并存盘，循环结束的条件是read返回0。

字段长度固定的协议往往不够灵活，难以适应新的变化。比如，以前DOS的文件名是8字节主文件名加“.”加3字节扩展名，不超过12字节，但是现代操作系统的文件名可以长得多，12字节就不够用了。那么制定一个新版本的协议规定文件名字段为256字节怎么样？这样又造成很大的浪费，因为大多数文件名都很短，需要用大量的'\0'补齐256字节，而且新版本的协议和老版本的程序无法兼容，如果已经有很多人在用老版本的程序了，会造成遵循新协议的程序与老版本程序的互操作性（Interoperability）问题。如果新版本的协议要添加新的字段，比如规定前12字节是文件名，从13到16字节是文件类型说明，从第17字节开始才是文件内容，同样会造成和老版本的程序无法兼容的问题。

现在重新看看上一节的TFTP协议是如何避免上述问题的：TFTP协议的各字段是可变长的，以'\0'为分隔符，文件名可以任意长，再看blksize等几个选项字段，TFTP协议并没有规定从第m字节到第n字节是blksize的值，而是把选项的描述信息“blksize”与它的值“512”一起做成一个可变长的字段，这样，以后添加新的选项仍然可以和老版本的程序兼容（老版本的程序只要忽略不认识的选项就行了）。

因此，常见的应用层协议都是带有可变长字段的，字段之间的分隔符用换行的比用'\0'的更常见，例如本节后面要介绍的HTTP协议。可变长字段的协议用readn来读就很不方便了，为此我们实现一个类似于fgets的readline函数，也放在wrap.c中：

  1. static ssize_t my_read(int fd, char *ptr)
  2. {
  3.     static int read_cnt;
  4.     static char *read_ptr;
  5.     static char read_buf[100];

  7.     if (read_cnt <= 0) {
  8.     again:
  9.         if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
  10.             if (errno == EINTR)
  11.                 goto again;
  12.             return -1;
  13.         } else if (read_cnt == 0)
  14.             return 0;
  15.         read_ptr = read_buf;
  16.     }
  17.     read_cnt--;
  18.     *ptr = *read_ptr++;
  19.     return 1;
  20. }

  22. ssize_t Readline(int fd, void *vptr, size_t maxlen)
  23. {
  24.     ssize_t n, rc;
  25.     char c, *ptr;

  27.     ptr = vptr;
  28.     for (n = 1; n < maxlen; n++) {
  29.         if ( (rc = my_read(fd, &c)) == 1) {
  30.             *ptr++ = c;
  31.             if (c == '\n')
  32.                 break;
  33.         } else if (rc == 0) {
  34.             *ptr = 0;
  35.             return n - 1;
  36.         } else
  37.             return -1;
  38.     }
  39.     *ptr = 0;
  40.     return n;
  41. }


2.3. 把client改为交互式输入




目前实现的client每次运行只能从命令行读取一个字符串发给服务器，再从服务器收回来，现在我们把它改成交互式的，不断从终端接受用户输入并和server交互。

client.c

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <unistd.h>
  4. #include <netinet/in.h>
  5. #include "wrap.h"

  7. #define MAXLINE 80
  8. #define SERV_PORT 8000

  10. int main(int argc, char *argv[])
  11. {
  12.     struct sockaddr_in servaddr;
  13.     char buf[MAXLINE];
  14.     int sockfd, n;
  15.     
  16.     sockfd = Socket(AF_INET, SOCK_STREAM, 0);

  18.     bzero(&servaddr, sizeof(servaddr));
  19.     servaddr.sin_family = AF_INET;
  20.     inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
  21.     servaddr.sin_port = htons(SERV_PORT);
  22.     
  23.     Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

  25.     while (fgets(buf, MAXLINE, stdin) != NULL) {
  26.         Write(sockfd, buf, strlen(buf));
  27.         n = Read(sockfd, buf, MAXLINE);
  28.         if (n == 0)
  29.             printf("the other side has been closed.\n");
  30.         else
  31.             Write(STDOUT_FILENO, buf, n);
  32.     }

  34.     Close(sockfd);
  35.     return 0;
  36. }

这时server仍在运行，但是client的运行结果并不正确。原因是什么呢？仔细查看server.c可以发现，server对每个请求只处理一次，应答后就关闭连接，client不能继续使用这个连接发送数据。但是client下次循环时又调用write发数据给server，write调用只负责把数据交给TCP发送缓冲区就可以成功返回了，所以不会出错，而server收到数据后应答一个RST段，client收到RST段后无法立刻通知应用层，只把这个状态保存在TCP协议层。client下次循环又调用write发数据给server，由于TCP协议层已经处于RST状态了，因此不会将数据发出，而是发一个SIGPIPE信号给应用层，SIGPIPE信号的缺省处理动作是终止程序，所以看到上面的现象。

为了避免client异常退出，上面的代码应该在判断对方关闭了连接后break出循环，而不是继续write。另外，有时候代码中需要连续多次调用write，可能还来不及调用read得知对方已关闭了连接就被SIGPIPE信号终止掉了，这就需要在初始化时调用sigaction处理SIGPIPE信号，如果SIGPIPE信号没有导致进程异常退出，write返回-1并且errno为EPIPE。

另外，我们需要修改server，使它可以多次处理同一客户端的请求。

 server.cc

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <netinet/in.h>
  4. #include "wrap.h"

  6. #define MAXLINE 80
  7. #define SERV_PORT 8000

  9. int main(void)
  10. {
  11.     struct sockaddr_in servaddr, cliaddr;
  12.     socklen_t cliaddr_len;
  13.     int listenfd, connfd;
  14.     char buf[MAXLINE];
  15.     char str[INET_ADDRSTRLEN];
  16.     int i, n;

  18.     listenfd = Socket(AF_INET, SOCK_STREAM, 0);

  20.     bzero(&servaddr, sizeof(servaddr));
  21.     servaddr.sin_family = AF_INET;
  22.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  23.     servaddr.sin_port = htons(SERV_PORT);
  24.     
  25.     Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

  27.     Listen(listenfd, 20);

  29.     printf("Accepting connections ...\n");
  30.     while (1) {
  31.         cliaddr_len = sizeof(cliaddr);
  32.         connfd = Accept(listenfd,
  33.                 (struct sockaddr *)&cliaddr, &cliaddr_len);
  34.         while (1) {
  35.             n = Read(connfd, buf, MAXLINE);
  36.             if (n == 0) {
  37.                 printf("the other side has been closed.\n");
  38.                 break;
  39.             }
  40.             printf("received from %s at PORT %d\n",
  41.              inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
  42.              ntohs(cliaddr.sin_port));
  43.     
  44.             for (i = 0; i < n; i++)
  45.                 buf[i] = toupper(buf[i]);
  46.             Write(connfd, buf, n);
  47.         }
  48.         Close(connfd);
  49.     }
  50. }


经过上面的修改后，客户端和服务器可以进行多次交互了。我们知道，服务器通常是要同时服务多个客户端的，运行上面的server和client之后，再开一个终端运行client试试，新的client能得到服务吗？想想为什么。


2.4. 使用fork并发处理多个client的请求

怎么解决这个问题？网络服务器通常用fork来同时服务多个客户端，父进程专门负责监听端口，每次accept一个新的客户端连接就fork出一个子进程专门服务这个客户端。但是子进程退出时会产生僵尸进程，父进程要注意处理SIGCHLD信号和调用wait清理僵尸进程。

以下给出代码框架，完整的代码请读者自己完成。

  1. listenfd = socket(...);
  2. bind(listenfd, ...);
  3. listen(listenfd, ...);
  4. while (1) {
  5.     connfd = accept(listenfd, ...);
  6.     n = fork();
  7.     if (n == -1) {
  8.         perror("call to fork");
  9.         exit(1);
  10.     } else if (n == 0) {
  11.         close(listenfd);
  12.         while (1) {
  13.             read(connfd, ...);
  14.             ...
  15.             write(connfd, ...);
  16.         }
  17.         close(connfd);
  18.         exit(0);
  19.     } else
  20.         close(connfd);
  21. }





2.5. setsockopt


现在做一个测试，首先启动server，然后启动client，然后用Ctrl-C使server终止，这时马上再运行server，结果是：

$ ./server bind error: Address already in use

这是因为，虽然server的应用程序终止了，但TCP协议层的连接并没有完全断开，因此不能再次监听同样的server端口。我们用netstat命令查看一下：

$ netstat -apn |grep 8000 tcp 1 0 127.0.0.1:33498 127.0.0.1:8000 CLOSE_WAIT 10830/client tcp 0 0 127.0.0.1:8000 127.0.0.1:33498 FIN_WAIT2 -

server终止时，socket描述符会自动关闭并发FIN段给client，client收到FIN后处于CLOSE_WAIT状态，但是client并没有终止，也没有关闭socket描述符，因此不会发FIN给server，因此server的TCP连接处于FIN_WAIT2状态。

现在用Ctrl-C把client也终止掉，再观察现象：

$ netstat -apn |grep 8000 tcp 0 0 127.0.0.1:8000 127.0.0.1:44685 TIME_WAIT - $ ./server bind error: Address already in use

client终止时自动关闭socket描述符，server的TCP连接收到client发的FIN段后处于TIME_WAIT状态。TCP协议规定，主动关闭连接的一方要处于TIME_WAIT状态，等待两个MSL（maximum segment lifetime）的时间后才能回到CLOSED状态，因为我们先Ctrl-C终止了server，所以server是主动关闭连接的一方，在TIME_WAIT期间仍然不能再次监听同样的server端口。MSL在RFC1122中规定为两分钟，但是各操作系统的实现不同，在Linux上一般经过半分钟后就可以再次启动server了。至于为什么要规定TIME_WAIT的时间请读者参考UNP 2.7节。

在server的TCP连接没有完全断开之前不允许重新监听是不合理的，因为，TCP连接没有完全断开指的是connfd（127.0.0.1:8000）没有完全断开，而我们重新监听的是listenfd（0.0.0.0:8000），虽然是占用同一个端口，但IP地址不同，connfd对应的是与某个客户端通讯的一个具体的IP地址，而listenfd对应的是wildcard address。解决这个问题的方法是使用setsockopt()设置socket描述符的选项SO_REUSEADDR为1，表示允许创建端口号相同但IP地址不同的多个socket描述符。在server代码的socket()和bind()调用之间插入如下代码：

int opt = 1; setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

有关setsockopt可以设置的其它选项请参考UNP第7章。


2.6. 使用select


select是网络程序中很常用的一个系统调用，它可以同时监听多个阻塞的文件描述符（例如多个网络连接），哪个有数据到达就处理哪个，这样，不需要fork和多进程就可以实现并发服务的server。


  1. /* server.c */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <netinet/in.h>
  6. #include "wrap.h"

  8. #define MAXLINE 80
  9. #define SERV_PORT 8000

  11. int main(int argc, char **argv)
  12. {
  13.     int i, maxi, maxfd, listenfd, connfd, sockfd;
  14.     int nready, client[FD_SETSIZE];
  15.     ssize_t n;
  16.     fd_set rset, allset;
  17.     char buf[MAXLINE];
  18.     char str[INET_ADDRSTRLEN];
  19.     socklen_t cliaddr_len;
  20.     struct sockaddr_in cliaddr, servaddr;

  22.     listenfd = Socket(AF_INET, SOCK_STREAM, 0);

  24.     bzero(&servaddr, sizeof(servaddr));
  25.     servaddr.sin_family = AF_INET;
  26.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  27.     servaddr.sin_port = htons(SERV_PORT);

  29.     Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

  31.     Listen(listenfd, 20);

  33.     maxfd = listenfd; /* initialize */
  34.     maxi = -1; /* index into client[] array */
  35.     for (i = 0; i < FD_SETSIZE; i++)
  36.         client[i] = -1; /* -1 indicates available entry */
  37.     FD_ZERO(&allset);
  38.     FD_SET(listenfd, &allset);

  40.     for ( ; ; ) {
  41.         rset = allset; /* structure assignment */
  42.         nready = select(maxfd+1, &rset, NULL, NULL, NULL);
  43.         if (nready < 0)
  44.             perr_exit("select error");

  46.         if (FD_ISSET(listenfd, &rset)) { /* new client connection */
  47.             cliaddr_len = sizeof(cliaddr);
  48.             connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

  50.             printf("received from %s at PORT %d\n",
  51.              inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
  52.              ntohs(cliaddr.sin_port));

  54.             for (i = 0; i < FD_SETSIZE; i++)
  55.                 if (client[i] < 0) {
  56.                     client[i] = connfd; /* save descriptor */
  57.                     break;
  58.                 }
  59.             if (i == FD_SETSIZE) {
  60.                 fputs("too many clients\n", stderr);
  61.                 exit(1);
  62.             }

  64.             FD_SET(connfd, &allset); /* add new descriptor to set */
  65.             if (connfd > maxfd)
  66.                 maxfd = connfd; /* for select */
  67.             if (i > maxi)
  68.                 maxi = i; /* max index in client[] array */

  70.             if (--nready == 0)
  71.                 continue; /* no more readable descriptors */
  72.         }

  74.         for (i = 0; i <= maxi; i++) { /* check all clients for data */
  75.             if ( (sockfd = client[i]) < 0)
  76.                 continue;
  77.             if (FD_ISSET(sockfd, &rset)) {
  78.                 if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
  79.                     /* connection closed by client */
  80.                     Close(sockfd);
  81.                     FD_CLR(sockfd, &allset);
  82.                     client[i] = -1;
  83.                 } else {
  84.                     int j;
  85.                     for (j = 0; j < n; j++)
  86.                         buf[j] = toupper(buf[j]);
  87.                     Write(sockfd, buf, n);
  88.                 }

  90.                 if (--nready == 0)
  91.                     break; /* no more readable descriptors */
  92.             }
  93.         }
  94.     }
  95. }






select 
  1. /*
  2.  * server.cc
  3.  *
  4.  * Created on: 2012-1-17
  5.  * Author: simondu
  6.  */
  7. #include "head.h"

  9. #define MAXLINE 80
  10. #define SERV_PORT 8000
  11. int main(void )
  12. {
  13.     int i, maxi, maxfd, listenfd, connfd, sockfd;
  14.     int nready, client[FD_SETSIZE];
  15.     ssize_t n;
  16.     fd_set rset, allset;
  17.     char buf[MAXLINE];
  18.     char str[INET_ADDRSTRLEN];
  19.     socklen_t cliaddr_len;
  20.     struct sockaddr_in    cliaddr, servaddr;

  22.     listenfd = socket(AF_INET, SOCK_STREAM, 0);

  24.     bzero(&servaddr, sizeof(servaddr));
  25.     servaddr.sin_family = AF_INET;
  26.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  27.     servaddr.sin_port = htons(SERV_PORT);

  29.     bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

  31.     listen(listenfd, 20);

  33.     maxfd = listenfd;        /* initialize */
  34.     maxi = -1;            /* index into client[] array */
  35.     for (i = 0; i < FD_SETSIZE; i++)
  36.         client[i] = -1;    /* -1 indicates available entry */
  37.     FD_ZERO(&allset);
  38.     FD_SET(listenfd, &allset);
  39.     printf("Starting ... \n");
  40.     for ( ; ; ) {
  41.         rset = allset;    /* structure assignment */
  42.         nready = select(maxfd+1, &rset, NULL, NULL, NULL);
  43.         if (nready < 0)
  44.         {
  45.             printf("select error");
  46.             exit(1);
  47.         }

  49.         if (FD_ISSET(listenfd, &rset)) { /* new client connection */
  50.             cliaddr_len = sizeof(cliaddr);
  51.             connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

  53.             printf("received from %s at PORT %d\n",
  54.              inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
  55.              ntohs(cliaddr.sin_port));

  57.             for (i = 0; i < FD_SETSIZE; i++)
  58.                 if (client[i] < 0) {
  59.                     client[i] = connfd; /* save descriptor */
  60.                     break;
  61.                 }

  63.             if (i == FD_SETSIZE) {
  64.                 fputs("too many clients\n", stderr);
  65.                 exit(1);
  66.             }

  68.             FD_SET(connfd, &allset);    /* add new descriptor to set */
  69.             if (connfd > maxfd)
  70.                 maxfd = connfd; /* for select */
  71.             if (i > maxi)
  72.                 maxi = i;    /* max index in client[] array */

  74.             if (--nready == 0)
  75.                 continue;    /* no more readable descriptors */
  76.         }

  78.         for (i = 0; i <= maxi; i++) {    /* check all clients for data */
  79.             if ( (sockfd = client[i]) < 0)
  80.             {
  81.                 printf("sockfd = client[i] = %d\n",sockfd);
  82.                 continue;
  83.             }
  84.             if (FD_ISSET(sockfd, &rset)) {
  85.                 if ( (n = read(sockfd, buf, MAXLINE)) == 0) {
  86.                     /* connection closed by client */
  87.                     close(sockfd);
  88.                     FD_CLR(sockfd, &allset);
  89.                     client[i] = -1;
  90.                 } else {
  91.                     int j;
  92.                     for (j = 0; j < n; j++)
  93.                         buf[j] = toupper(buf[j]);
  94.                     int rettest = write(sockfd, buf, n);
  95.                     printf("%d\n",rettest);
  96.                 }
  97.                 if (--nready == 0)
  98.                     break;    /* no more readable descriptors */
  99.             }
  100.         }
  101.     }

  103. }







test  \\\\









上一篇：为什么 12306 不需要排队系统
下一篇：Android 本机代码(Native Code)开发基础