五十五、linux 编程——TCP 连接和关闭过程及服务器的并发处理

55.1 TCP 连接和关闭过程

55.1.1 介绍

　　建立连接的过程就是三次握手的过程：客户端发送 SYN 报文给服务器，服务器回复 SYN+ACK 报文，客户机再发送 ACK 报文。

　　关闭连接的过程：客户机先发送 FIN 报文，服务器回复 ACK 报文，服务器再发送 FIN 报文，客户机再发送响应报文 ACK。

55.1.2 自定义协议编程例子　

　　msg.h

 1 #ifndef __MSG_H__
 2 #define __MSG_H__
 3 
 4 #include <sys/types.h>
 5 
 6 typedef struct {
 7     /** 协议头部: 不传输任何数据，只包含发送端的一些信息 */
 8     char head[10];      ///< 协议头部
 9     char checknum;      ///< 校验码
10 
11     /**协议体部 */
12     char buff[512];     ///< 数据
13 }Msg;
14 
15 /** 发送一个基于自定义协议的 message，发送的数据存放在 buff 中 */
16 extern int write_msg(int sockfd, char *buff, ssize_t len);
17 
18 /** 读取一个基于自定义协议的 message, 读取的数据存放在 buff 中 */
19 extern int read_msg(int sockfd, char *buff, ssize_t len);
20 
21 #endif

　　msg.c

 1 #include "msg.h"
 2 #include <unistd.h>
 3 #include <string.h>
 4 #include <memory.h>
 5 #include <sys/types.h>
 6 
 7 
 8 /** 计算校验码 */
 9 static unsigned char msg_check(Msg *message)
10 {
11     unsigned char s = 0;
12     int i;
13     for(i = 0; i < sizeof(message->head); i++){
14         s += message->head[i];
15     }
16 
17     for(i = 0; i < sizeof(message->buff); i++){
18         s += message->buff[i];
19     }
20 
21     return s;
22 }
23 
24 
25 /** 发送一个基于自定义协议的 message，发送的数据存放在 buff 中 */
26 int write_msg(int sockfd, char *buff, ssize_t len)
27 {
28     Msg message;
29     memset(&message, 0, sizeof(message));
30     strcpy(message.head, "hello");
31     memcpy(message.buff, buff, len);
32     message.checknum = msg_check(&message);
33 
34     if(write(sockfd, &message, sizeof(message)) != sizeof(message)){
35         return -1;
36     }
37 
38     return 0;
39 }
40 
41 /** 读取一个基于自定义协议的 message, 读取的数据存放在 buff 中 */
42 int read_msg(int sockfd, char *buff, ssize_t len)
43 {
44     Msg message;
45     memset(&message, 0, sizeof(message));
46 
47     ssize_t size;
48     if((size = read(sockfd, &message, sizeof(message))) < 0){
49         return -1;
50     }
51     else if(size == 0){
52         return 0;
53     }
54 
55     /** 进行校验码验证，判断接收到的 message 是否完整 */
56     unsigned char s = msg_check(&message);
57     if((s == (unsigned char)message.checknum) && (!strcmp("hello", message.head))){
58         memcpy(buff, message.buff, len);
59         return sizeof(message);
60     }
61     return -1;
62 
63 }

　　编译成 .o 文件：gcc -o obj/msg.o -Iinclude -c src/msg.c

55.2 服务器的并发过程

55.2.1 介绍

　　一个服务器处理多个客户端的请求，就称为服务器的并发。

服务器端并发性处理
- 多进程模型
- 多线程模型
- I/O多路转换（select）

55.2.2 基于自定义协议的多进程模型编程

（1）服务器代码

　　echo_tcp_server.c

  1 #include <netdb.h>
  2 #include <netinet/in.h>
  3 #include <sys/socket.h>
  4 #include <sys/wait.h>
  5 #include <unistd.h>
  6 #include <string.h>
  7 #include <stdio.h>
  8 #include <stdlib.h>
  9 #include <memory.h>
 10 #include <signal.h>
 11 #include <time.h>
 12 #include <arpa/inet.h>
 13 #include <errno.h>
 14 #include "msg.h"
 15 
 16 
 17 int sockfd;
 18 
 19 void sig_handler(int signo)
 20 {
 21     if(signo == SIGINT){
 22         printf("server close
");
 23         /** 步骤6: 关闭 socket */
 24         close(sockfd);
 25         exit(1);
 26     }
 27 
 28     if(signo == SIGINT){
 29         printf("child process deaded...
");
 30         wait(0);
 31     }
 32 }
 33 
 34 /** 输出连接上来的客户端相关信息 */
 35 void out_addr(struct sockaddr_in *clientaddr)
 36 {
 37     /** 将端口从网络字节序转换成主机字节序 */
 38     int port = ntohs(clientaddr->sin_port);
 39     char ip[16];
 40     memset(ip, 0, sizeof(ip));
 41     /** 将 ip 地址从网络字节序转换成点分十进制 */
 42     inet_ntop(AF_INET, &clientaddr->sin_addr.s_addr, ip, sizeof(ip));
 43     printf("client: %s(%d) connected
", ip, port);
 44 }
 45 
 46 void do_service(int fd)
 47 {
 48     /** 和客户端进行读写操作(双向通信) */
 49     char buff[512];
 50     while(1){
 51         memset(buff, 0, sizeof(buff));
 52         printf("start read and write....
");
 53         ssize_t size;
 54         if((size = read_msg(fd, buff, sizeof(buff))) < 0){
 55             perror("protocal error");
 56             break;
 57         }
 58         else if(size == 0){
 59             break;
 60         }
 61         else {
 62             printf("%s
", buff);
 63             if(write_msg(fd, buff, sizeof(buff)) < 0){
 64                 if(errno == EPIPE){
 65                     break;
 66                 }
 67                 perror("protocal error");
 68             }
 69         }
 70     }
 71 }
 72 
 73 int main(int argc, char *argv[])
 74 {
 75     if(argc < 2){
 76         printf("usage: %s #port
", argv[0]);
 77         exit(1);
 78     }
 79 
 80     if(signal(SIGINT, sig_handler) == SIG_ERR){
 81         perror("signal sigint error");
 82         exit(1);
 83     }
 84 
 85     if(signal(SIGCHLD, sig_handler) == SIG_ERR){
 86         perror("signal sigchld error");
 87         exit(1);
 88     }
 89 
 90     /** 步骤1: 创建 socket(套接字) 
 91      *  注: socket 创建在内核中，是一个结构体.
 92      *  AF_INET: IPV4
 93      *  SOCK_STREAM: tcp 协议
 94      *  AF_INET6: IPV6
 95      */
 96     sockfd = socket(AF_INET, SOCK_STREAM, 0);
 97     if(sockfd < 0){
 98         perror("socket error");
 99         exit(1);
100     }
101 
102     /** 
103      * 步骤2: 调用 bind 函数将 socket 和地址(包括 ip、port)进行绑定
104      */
105     struct sockaddr_in  serveraddr;
106     memset(&serveraddr, 0, sizeof(struct sockaddr_in));
107     /** 往地址中填入 ip、port、internet 地址族类型 */
108     serveraddr.sin_family = AF_INET;    ///< IPV4
109     serveraddr.sin_port = htons(atoi(argv[1])); ///< 填入端口
110     serveraddr.sin_addr.s_addr = INADDR_ANY; ///< 填入 IP 地址
111     if(bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in))){
112         perror("bind error");
113         exit(1);
114     }
115 
116     /**
117      *  步骤3: 调用 listen 函数启动监听(指定 port 监听)
118      *         通知系统去接受来自客户端的连接请求
119      *         (将接受到的客户端连接请求放置到对应的队列中)
120      *  第二个参数: 指定队列的长度
121      */
122     if(listen(sockfd, 10) < 0){
123         perror("listen error");
124         exit(1);
125     }
126 
127     /**
128      *  步骤4: 调用 accept 函数从队列中获得一个客户端的请求连接, 并返回新的
129      *         socket 描述符
130      *  注意:  若没有客户端连接，调用此函数后会足则, 直到获得一个客户端的连接
131      */
132     struct sockaddr_in clientaddr;
133     socklen_t clientaddr_len = sizeof(clientaddr);
134     while(1){
135         int fd = accept(sockfd, (struct sockaddr *)&clientaddr, &clientaddr_len);
136         if(fd < 0){
137             perror("accept error");
138             continue;
139         }
140 
141         /**
142          *  步骤5: 启动子进程去调用 IO 函数(read/write)和连接的客户端进行双向的通信
143          */
144         pid_t pid = fork();
145         if(pid < 0){
146             continue;
147         }
148         else if(pid == 0){
149             /** 子进程 */
150             out_addr(&clientaddr);
151             do_service(fd);
152             /** 步骤6: 关闭 socket */
153             close(fd);
154             break;
155         }
156         else{
157             /** 父进程 */
158             /** 步骤6: 关闭 socket */
159             close(fd);
160         }
161     }
162 
163     return 0;
164 }

　　gcc -o bin/echo_tcp_server -Iinclude obj/msg.o src/echo_tcp_server.c

（2）客户端代码

　　echo_tcp_client.c

 1 #include <sys/types.h>
 2 #include <stdlib.h>
 3 #include <stdio.h>
 4 #include <memory.h>
 5 #include <unistd.h>
 6 #include <sys/socket.h>
 7 #include <netdb.h>
 8 #include <signal.h>
 9 #include <string.h>
10 #include <time.h>
11 #include <arpa/inet.h>
12 #include "msg.h"
13 
14 
15 int main(int argc, char *argv[])
16 {
17     if(argc < 3){
18         printf("usage: %s ip port
", argv[0]);
19         exit(1);
20     }
21 
22     /** 步骤1: 创建 socket */
23     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
24     if(sockfd < 0){
25         perror("socket error");
26         exit(1);
27     }
28 
29     /** 往 serveraddr 中填入 ip、port 和地址族类型(ipv4) */
30     struct sockaddr_in serveraddr;
31     memset(&serveraddr, 0, sizeof(struct sockaddr_in));
32     serveraddr.sin_family = AF_INET;
33     serveraddr.sin_port = htons(atoi(argv[2]));
34     /** 将 ip 地址转换成网络字节序后填入 serveraddr 中  */
35     inet_pton(AF_INET, argv[1], &serveraddr.sin_addr.s_addr);
36 
37     /**
38      *  步骤2: 客户端调用 connect 函数连接到服务器端
39      */
40     if(connect(sockfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in)) < 0){
41         perror("connect error");
42         exit(1);
43     }
44 
45     /** 步骤3: 调用 IO 函数(read/write)和服务器端进行双向通信 */
46     char buff[512];
47     ssize_t size;
48     char *prompt = "==>";
49     while(1){
50         memset(buff, 0, sizeof(buff));
51         write(STDOUT_FILENO, prompt, 3);
52         size = read(STDIN_FILENO, buff, sizeof(buff));
53         if(size < 0) continue;
54         buff[size - 1] = '';
55 
56         if(write_msg(sockfd, buff, sizeof(buff)) < 0){
57             perror("write msg error");
58             continue;
59         }
60         else {
61             if(read_msg(sockfd, buff, sizeof(buff)) < 0){
62                 perror("read msg error");
63                 continue;
64             }
65             else {
66                 printf("%s
", buff);
67             }
68         }
69     }
70 
71     /** 步骤4: 关闭 socket */
72     close(sockfd);
73 
74     return 0;
75 }

　　gcc -o bin/echo_tcp_client -Iinclude obj/msg.o src/echo_tcp_client.c

（3）测试

　　开启两个终端进行测试，一个运行服务器，一个运行客户端：

55.2.3 基于自定义协议的多线程模型编程

　　echo_tcp_server_th.c

  1 #include <netdb.h>
  2 #include <netinet/in.h>
  3 #include <sys/socket.h>
  4 #include <sys/wait.h>
  5 #include <unistd.h>
  6 #include <string.h>
  7 #include <stdio.h>
  8 #include <stdlib.h>
  9 #include <memory.h>
 10 #include <signal.h>
 11 #include <time.h>
 12 #include <arpa/inet.h>
 13 #include <errno.h>
 14 #include "msg.h"
 15 #include <pthread.h>
 16 
 17 
 18 int sockfd;
 19 
 20 void sig_handler(int signo)
 21 {
 22     if(signo == SIGINT){
 23         printf("server close
");
 24         /** 步骤6: 关闭 socket */
 25         close(sockfd);
 26         exit(1);
 27     }
 28 }
 29 
 30 void do_service(int fd)
 31 {
 32     /** 和客户端进行读写操作(双向通信) */
 33     char buff[512];
 34     while(1){
 35         memset(buff, 0, sizeof(buff));
 36         ssize_t size;
 37         if((size = read_msg(fd, buff, sizeof(buff))) < 0){
 38             perror("protocal error");
 39             break;
 40         }
 41         else if(size == 0){
 42             break;
 43         }
 44         else {
 45             printf("%s
", buff);
 46             if(write_msg(fd, buff, sizeof(buff)) < 0){
 47                 if(errno == EPIPE){
 48                     break;
 49                 }
 50                 perror("protocal error");
 51             }
 52         }
 53     }
 54 }
 55 
 56 
 57 void out_fd(int fd)
 58 {
 59     struct sockaddr_in   addr;
 60     socklen_t len = sizeof(addr);
 61     /** 从 fd 中获得连接的客户端相关信息并放置到 sockaddr_in 当中 */
 62     if(getpeername(fd, (struct sockaddr *)&addr, &len) < 0){
 63         perror("getpeername error");
 64         return;
 65     }
 66 
 67     char ip[16];
 68     memset(ip, 0, sizeof(ip));
 69     int port = ntohs(addr.sin_port);
 70     inet_ntop(AF_INET, &addr.sin_addr.s_addr, ip, sizeof(ip));
 71     printf("%16s(%5d) closed!
", ip, port);
 72 }
 73 
 74 void *th_fn(void *arg)
 75 {
 76     int fd = (int)arg;
 77 
 78     do_service(fd);
 79     out_fd(fd);
 80     close(fd);
 81     return (void *)0;
 82 }
 83 
 84 int main(int argc, char *argv[])
 85 {
 86     if(argc < 2){
 87         printf("usage: %s #port
", argv[0]);
 88         exit(1);
 89     }
 90 
 91     if(signal(SIGINT, sig_handler) == SIG_ERR){
 92         perror("signal sigint error");
 93         exit(1);
 94     }
 95 
 96 
 97     /** 步骤1: 创建 socket(套接字) 
 98      *  注: socket 创建在内核中，是一个结构体.
 99      *  AF_INET: IPV4
100      *  SOCK_STREAM: tcp 协议
101      *  AF_INET6: IPV6
102      */
103     sockfd = socket(AF_INET, SOCK_STREAM, 0);
104     if(sockfd < 0){
105         perror("socket error");
106         exit(1);
107     }
108 
109     /** 
110      * 步骤2: 调用 bind 函数将 socket 和地址(包括 ip、port)进行绑定
111      */
112     struct sockaddr_in  serveraddr;
113     memset(&serveraddr, 0, sizeof(struct sockaddr_in));
114     /** 往地址中填入 ip、port、internet 地址族类型 */
115     serveraddr.sin_family = AF_INET;    ///< IPV4
116     serveraddr.sin_port = htons(atoi(argv[1])); ///< 填入端口
117     serveraddr.sin_addr.s_addr = INADDR_ANY; ///< 填入 IP 地址
118     if(bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in))){
119         perror("bind error");
120         exit(1);
121     }
122 
123     /**
124      *  步骤3: 调用 listen 函数启动监听(指定 port 监听)
125      *         通知系统去接受来自客户端的连接请求
126      *         (将接受到的客户端连接请求放置到对应的队列中)
127      *  第二个参数: 指定队列的长度
128      */
129     if(listen(sockfd, 10) < 0){
130         perror("listen error");
131         exit(1);
132     }
133 
134     /**
135      *  步骤4: 调用 accept 函数从队列中获得一个客户端的请求连接, 并返回新的
136      *         socket 描述符
137      *  注意:  若没有客户端连接，调用此函数后会足则, 直到获得一个客户端的连接
138      */
139 
140     /** 设置线程的分离属性 */
141     pthread_attr_t attr;
142     pthread_attr_init(&attr);
143     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
144 
145     while(1){
146         /** 主控线程负责调用 accept 去获得客户端的连接 */
147         int fd = accept(sockfd, NULL, NULL);
148         if(fd < 0){
149             perror("accept error");
150             continue;
151         }
152 
153         /**
154          *  步骤5: 启动子线程去调用 IO 函数(read/write)和连接的客户端进行双向的通信
155          */
156         pthread_t th;
157         int err;
158         /** 以分离状态启动子线程 */
159         if((err = pthread_create(&th, &attr, th_fn, (void *)fd)) != 0){
160             perror("pthread create error");
161         }
162 
163         pthread_attr_destroy(&attr);
164 
165     }
166 
167     return 0;
168 }

　　客户端程序用上面的客户端程序即可。