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

55.1 TCP 连接和关闭过程

55.1.1 介绍

　　

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

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

55.1.2  自定义协议编程例子　

　　msg.h

 #ifndef __MSG_H__
 #define __MSG_H__

 #include <sys/types.h>

 typedef struct {
     /** 协议头部: 不传输任何数据，只包含发送端的一些信息 */
     char head[];      ///< 协议头部
     char checknum;      ///< 校验码

     /**协议体部 */
     char buff[];     ///< 数据
 }Msg;

 /** 发送一个基于自定义协议的 message，发送的数据存放在 buff 中 */
 extern int write_msg(int sockfd, char *buff, ssize_t len);

 /** 读取一个基于自定义协议的 message, 读取的数据存放在 buff 中 */
 extern int read_msg(int sockfd, char *buff, ssize_t len);

 #endif

　　msg.c

 #include "msg.h"
 #include <unistd.h>
 #include <string.h>
 #include <memory.h>
 #include <sys/types.h>

 /** 计算校验码 */
 static unsigned char msg_check(Msg *message)
 {
     unsigned char s = ;
     int i;
     for(i = ; i < sizeof(message->head); i++){
         s += message->head[i];
     }

     for(i = ; i < sizeof(message->buff); i++){
         s += message->buff[i];
     }

     return s;
 }

 /** 发送一个基于自定义协议的 message，发送的数据存放在 buff 中 */
 int write_msg(int sockfd, char *buff, ssize_t len)
 {
     Msg message;
     memset(&message, , sizeof(message));
     strcpy(message.head, "hello");
     memcpy(message.buff, buff, len);
     message.checknum = msg_check(&message);

     if(write(sockfd, &message, sizeof(message)) != sizeof(message)){
         return -;
     }

     return ;
 }

 /** 读取一个基于自定义协议的 message, 读取的数据存放在 buff 中 */
 int read_msg(int sockfd, char *buff, ssize_t len)
 {
     Msg message;
     memset(&message, , sizeof(message));

     ssize_t size;
     if((size = read(sockfd, &message, sizeof(message))) < ){
         return -;
     }
     else if(size == ){
         return ;
     }

     /** 进行校验码验证，判断接收到的 message 是否完整 */
     unsigned char s = msg_check(&message);
     if((s == (unsigned char)message.checknum) && (!strcmp("hello", message.head))){
         memcpy(buff, message.buff, len);
         return sizeof(message);
     }
     return -;

 }

　　编译成 .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

 #include <netdb.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <memory.h>
 #include <signal.h>
 #include <time.h>
 #include <arpa/inet.h>
 #include <errno.h>
 #include "msg.h"

 int sockfd;

 void sig_handler(int signo)
 {
     if(signo == SIGINT){
         printf("server close\n");
         /** 步骤6: 关闭 socket */
         close(sockfd);
         exit();
     }

     if(signo == SIGINT){
         printf("child process deaded...\n");
         wait();
     }
 }

 /** 输出连接上来的客户端相关信息 */
 void out_addr(struct sockaddr_in *clientaddr)
 {
     /** 将端口从网络字节序转换成主机字节序 */
     int port = ntohs(clientaddr->sin_port);
     char ip[];
     memset(ip, , sizeof(ip));
     /** 将 ip 地址从网络字节序转换成点分十进制 */
     inet_ntop(AF_INET, &clientaddr->sin_addr.s_addr, ip, sizeof(ip));
     printf("client: %s(%d) connected\n", ip, port);
 }

 void do_service(int fd)
 {
     /** 和客户端进行读写操作(双向通信) */
     char buff[];
     while(){
         memset(buff, , sizeof(buff));
         printf("start read and write....\n");
         ssize_t size;
         if((size = read_msg(fd, buff, sizeof(buff))) < ){
             perror("protocal error");
             break;
         }
         else if(size == ){
             break;
         }
         else {
             printf("%s\n", buff);
             if(write_msg(fd, buff, sizeof(buff)) < ){
                 if(errno == EPIPE){
                     break;
                 }
                 perror("protocal error");
             }
         }
     }
 }

 int main(int argc, char *argv[])
 {
     if(argc < ){
         printf("usage: %s #port\n", argv[]);
         exit();
     }

     if(signal(SIGINT, sig_handler) == SIG_ERR){
         perror("signal sigint error");
         exit();
     }

     if(signal(SIGCHLD, sig_handler) == SIG_ERR){
         perror("signal sigchld error");
         exit();
     }

     /** 步骤1: 创建 socket(套接字)
      *  注: socket 创建在内核中，是一个结构体.
      *  AF_INET: IPV4
      *  SOCK_STREAM: tcp 协议
      *  AF_INET6: IPV6
      */
     sockfd = socket(AF_INET, SOCK_STREAM, );
     if(sockfd < ){
         perror("socket error");
         exit();
     }

     /**
      * 步骤2: 调用 bind 函数将 socket 和地址(包括 ip、port)进行绑定
      */
     struct sockaddr_in  serveraddr;
     memset(&serveraddr, , sizeof(struct sockaddr_in));
     /** 往地址中填入 ip、port、internet 地址族类型 */
     serveraddr.sin_family = AF_INET;    ///< IPV4
     serveraddr.sin_port = htons(atoi(argv[1])); ///< 填入端口
     serveraddr.sin_addr.s_addr = INADDR_ANY; ///< 填入 IP 地址
     if(bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in))){
         perror("bind error");
         exit();
     }

     /**
      *  步骤3: 调用 listen 函数启动监听(指定 port 监听)
      *         通知系统去接受来自客户端的连接请求
      *         (将接受到的客户端连接请求放置到对应的队列中)
      *  第二个参数: 指定队列的长度
      */
     if(listen(sockfd, ) < ){
         perror("listen error");
         exit();
     }

     /**
      *  步骤4: 调用 accept 函数从队列中获得一个客户端的请求连接, 并返回新的
      *         socket 描述符
      *  注意:  若没有客户端连接，调用此函数后会足则, 直到获得一个客户端的连接
      */
     struct sockaddr_in clientaddr;
     socklen_t clientaddr_len = sizeof(clientaddr);
     while(){
         int fd = accept(sockfd, (struct sockaddr *)&clientaddr, &clientaddr_len);
         if(fd < ){
             perror("accept error");
             continue;
         }

         /**
          *  步骤5: 启动子进程去调用 IO 函数(read/write)和连接的客户端进行双向的通信
          */
         pid_t pid = fork();
         if(pid < ){
             continue;
         }
         else if(pid == ){
             /** 子进程 */
             out_addr(&clientaddr);
             do_service(fd);
             /** 步骤6: 关闭 socket */
             close(fd);
             break;
         }
         else{
             /** 父进程 */
             /** 步骤6: 关闭 socket */
             close(fd);
         }
     }

     return ;
 }

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

（2）客户端代码

　　echo_tcp_client.c

 #include <sys/types.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <memory.h>
 #include <unistd.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <signal.h>
 #include <string.h>
 #include <time.h>
 #include <arpa/inet.h>
 #include "msg.h"

 int main(int argc, char *argv[])
 {
     if(argc < ){
         printf("usage: %s ip port\n", argv[]);
         exit();
     }

     /** 步骤1: 创建 socket */
     int sockfd = socket(AF_INET, SOCK_STREAM, );
     if(sockfd < ){
         perror("socket error");
         exit();
     }

     /** 往 serveraddr 中填入 ip、port 和地址族类型(ipv4) */
     struct sockaddr_in serveraddr;
     memset(&serveraddr, , sizeof(struct sockaddr_in));
     serveraddr.sin_family = AF_INET;
     serveraddr.sin_port = htons(atoi(argv[]));
     /** 将 ip 地址转换成网络字节序后填入 serveraddr 中  */
     inet_pton(AF_INET, argv[], &serveraddr.sin_addr.s_addr);

     /**
      *  步骤2: 客户端调用 connect 函数连接到服务器端
      */
     if(connect(sockfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in)) < ){
         perror("connect error");
         exit();
     }

     /** 步骤3: 调用 IO 函数(read/write)和服务器端进行双向通信 */
     char buff[];
     ssize_t size;
     char *prompt = "==>";
     while(){
         memset(buff, , sizeof(buff));
         write(STDOUT_FILENO, prompt, );
         size = read(STDIN_FILENO, buff, sizeof(buff));
         if(size < ) continue;
         buff[size - ] = '\0';

         if(write_msg(sockfd, buff, sizeof(buff)) < ){
             perror("write msg error");
             continue;
         }
         else {
             if(read_msg(sockfd, buff, sizeof(buff)) < ){
                 perror("read msg error");
                 continue;
             }
             else {
                 printf("%s\n", buff);
             }
         }
     }

     /** 步骤4: 关闭 socket */
     close(sockfd);

     return ;
 }

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

（3）测试

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

　　

　　

　　

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

　　

　　echo_tcp_server_th.c

 #include <netdb.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <memory.h>
 #include <signal.h>
 #include <time.h>
 #include <arpa/inet.h>
 #include <errno.h>
 #include "msg.h"
 #include <pthread.h>

 int sockfd;

 void sig_handler(int signo)
 {
     if(signo == SIGINT){
         printf("server close\n");
         /** 步骤6: 关闭 socket */
         close(sockfd);
         exit();
     }
 }

 void do_service(int fd)
 {
     /** 和客户端进行读写操作(双向通信) */
     char buff[];
     while(){
         memset(buff, , sizeof(buff));
         ssize_t size;
         if((size = read_msg(fd, buff, sizeof(buff))) < ){
             perror("protocal error");
             break;
         }
         else if(size == ){
             break;
         }
         else {
             printf("%s\n", buff);
             if(write_msg(fd, buff, sizeof(buff)) < ){
                 if(errno == EPIPE){
                     break;
                 }
                 perror("protocal error");
             }
         }
     }
 }

 void out_fd(int fd)
 {
     struct sockaddr_in   addr;
     socklen_t len = sizeof(addr);
     /** 从 fd 中获得连接的客户端相关信息并放置到 sockaddr_in 当中 */
     if(getpeername(fd, (struct sockaddr *)&addr, &len) < ){
         perror("getpeername error");
         return;
     }

     char ip[];
     memset(ip, , sizeof(ip));
     int port = ntohs(addr.sin_port);
     inet_ntop(AF_INET, &addr.sin_addr.s_addr, ip, sizeof(ip));
     printf("%16s(%5d) closed!\n", ip, port);
 }

 void *th_fn(void *arg)
 {
     int fd = (int)arg;

     do_service(fd);
     out_fd(fd);
     close(fd);
     return (void *);
 }

 int main(int argc, char *argv[])
 {
     if(argc < ){
         printf("usage: %s #port\n", argv[]);
         exit();
     }

     if(signal(SIGINT, sig_handler) == SIG_ERR){
         perror("signal sigint error");
         exit();
     }

     /** 步骤1: 创建 socket(套接字)
      *  注: socket 创建在内核中，是一个结构体.
      *  AF_INET: IPV4
      *  SOCK_STREAM: tcp 协议
      *  AF_INET6: IPV6
      */
     sockfd = socket(AF_INET, SOCK_STREAM, );
     if(sockfd < ){
         perror("socket error");
         exit();
     }

     /**
      * 步骤2: 调用 bind 函数将 socket 和地址(包括 ip、port)进行绑定
      */
     struct sockaddr_in  serveraddr;
     memset(&serveraddr, , sizeof(struct sockaddr_in));
     /** 往地址中填入 ip、port、internet 地址族类型 */
     serveraddr.sin_family = AF_INET;    ///< IPV4
     serveraddr.sin_port = htons(atoi(argv[1])); ///< 填入端口
     serveraddr.sin_addr.s_addr = INADDR_ANY; ///< 填入 IP 地址
     if(bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in))){
         perror("bind error");
         exit();
     }

     /**
      *  步骤3: 调用 listen 函数启动监听(指定 port 监听)
      *         通知系统去接受来自客户端的连接请求
      *         (将接受到的客户端连接请求放置到对应的队列中)
      *  第二个参数: 指定队列的长度
      */
     if(listen(sockfd, ) < ){
         perror("listen error");
         exit();
     }

     /**
      *  步骤4: 调用 accept 函数从队列中获得一个客户端的请求连接, 并返回新的
      *         socket 描述符
      *  注意:  若没有客户端连接，调用此函数后会足则, 直到获得一个客户端的连接
      */

     /** 设置线程的分离属性 */
     pthread_attr_t attr;
     pthread_attr_init(&attr);
     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

     while(){
         /** 主控线程负责调用 accept 去获得客户端的连接 */
         int fd = accept(sockfd, NULL, NULL);
         if(fd < ){
             perror("accept error");
             continue;
         }

         /**
          *  步骤5: 启动子线程去调用 IO 函数(read/write)和连接的客户端进行双向的通信
          */
         pthread_t th;
         int err;
         /** 以分离状态启动子线程 */
         if((err = pthread_create(&th, &attr, th_fn, (void *)fd)) != ){
             perror("pthread create error");
         }

         pthread_attr_destroy(&attr);

     }

     return ;
 }

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