计算机网络套接字编程实验-TCP多进程并发服务器程序与单进程客户端程序（简单回声）

1．实验系列

·Linux NAP-Linux网络应用编程系列

2．实验目的

·理解多进程（Multiprocess）相关基本概念，理解父子进程之间的关系与差异，熟练掌握基于fork（）的多进程编程模式；

·理解僵尸进程产生原理，能基于｜sigaction（）或signal（），使用waitpid（）规避僵尸进程产生；

·理解Linux 文件系统的组织方式，掌握文件描述符的基本概念，理解主进程 fork（）进程后，子进程对于主进程fork（）前创建的文件描述符的继承关系；

·在「TCP单进程循环服务器与单进程客户端」的基础上，进一步实践巩固：a.单进程循环服务器套接字编程基本模式；

b.服务器对于客户端正常结束的识别处理；c.客户端基于命令行指令的退出实现方式；

d.服务器基于SIGINT 信号的退出实现方式（僵速系统调用退出问题）；

同时，还要进一步理解并掌握TCP多进程并发服务器套接字编程模式与技能，包括：a.多进程并发服务器套接字编程核心系统调用模式：

b.多进程并发服务器规避产生僵尸进程的基本模式（包括 SIGCHLD 处理等）；c.简单应用层协议及其PDU的设计、构建与解析处理；

d.文件的读写应用

3．实验内容

·编写TCP多进程循环服务器程序与单进程客户端程序，实现以下主体功能：。客户端启动连接服务器之后，进入命令行交互模式。

操作人员在命令行窗口输入一行字符并回车后，客户端进程立刻从命令行（本质即 stdin）读取数据，并将该行信息发送给服务器。

·服务器收到该行信息后，会将该信息原封不动的返回给客户端，即所谓消息回声（Message Echo）。。客户端收到服务器返回的消息回声后，将其打印输出至屏幕（本质即 stdout）。

·客户端在从命令行收到 EXIT 指令后退出。

·若服务器启动时设定 Established Queue的长度，即listen（）第二个参数backlog为2，则最多可 以有2个客户编同时连上服务器并开展交互，此时，再启动另一个客户端连接服务器，观察体验是什么现象，并尝试分析现象背后的底层逻辑。

·本实验不考核以下内容：SIGPIPE 信号处理、基于多次读取的PDU完整获取、PDU 完整设计、多进程客户端.

·本实验不涉及复杂业务，仅要求进行PDU筒单设计（增加了头部要求，但不涉及长度字段），实现简单消息回声服务，以帮助学生理解并构建多进程并发服务器程序的基本框架。

·【重要假设】

·当网络与主机环境均比较理想时，可以支持客户端与服务器实现对于PDU的一次性收发」，即仅通过 read（）／write（）的一次调用，即可实现PDU（本实验中即消息／消息回声）的「完整收发」.

·本实验中，数据传输量很小（将明确限定一行数据的上限），且测评时客户端与服务器进程均在同一容器内工作，故而不会出现一次收发不能处理「单—PDU」的场景。

服务器端代码：

#include         
#include      //exit()函数相关
#include      //C 和 C++ 程序设计语言中提供对 POSIX 操作系统 API 的访问功能的头文件
#include   //Unix/Linux系统的基本系统数据类型的头文件,含有size_t,time_t,pid_t等类型
#include  //套接字基本函数相关
#include  //IP地址和端口相关定义，比如struct sockaddr_in等
#include   //inet_pton()等函数相关
#include     //bzero()函数相关
#include 
#include 
#include  //SIGCHLD信号使用
#include 
#define BACKLOG    5      //listen函数参数
#define MAXDATASIZE    140
char p[MAXDATASIZE + 100];
void handle_sigint(int sig);
void srv_biz(int connfd,char* veri_code);
void sig_chld(int signo);
void sig_pipe(int signo);
char buf[MAXDATASIZE];
int sigint_flag = 0; // 标记服务器进程是否受到signal信号
int main(int argc, char *argv[]) {
    if (argc != 4){                 //如果命令行用法不对，则提醒并退出
        printf("usage: %s     \n",argv[0]);
        exit(0);
    }
    int    listenfd, connectfd;        //分别是监听套接字和连接套接字
    struct sockaddr_in server, client; //存放服务器和客户端的地址信息（前者在bind时指定，后者在accept时得到）
    int    sin_size;                      // accept时使用，得到客户端地址大小信息
    pid_t pid;
    //安装使用SIGPIPE
    struct sigaction sigact_pipe;
    sigemptyset(&sigact_pipe.sa_mask);
    sigact_pipe.sa_handler = sig_pipe;//信号处理函数
    sigact_pipe.sa_flags = 0;
    sigact_pipe.sa_flags |= SA_RESTART;//设置受影响的慢系
    if (sigaction(SIGPIPE, &sigact_pipe, NULL) < 0){
        perror("cannot ignore SIGPIPE");
        return -1;
    }
    //安装SIGINT信号处理器
    struct sigaction sa;
    sa.sa_flags = 0;
    sa.sa_handler = handle_sigint;
    sigemptyset(&sa.sa_mask);
    if(sigaction(SIGINT, &sa, NULL) < 0){
        return -1;
    }
    //注册SIGCHLD的处理函数
    struct sigaction sigact_chld, old_sigact_chld;
    sigemptyset(&sigact_chld.sa_mask);
    sigact_chld.sa_handler = sig_chld;
    sigact_chld.sa_flags = 0;
    if (sigaction(SIGCHLD, &sigact_chld, &old_sigact_chld) < 0){
        return -1;
    }

    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  //建立监听套接字
    {
        //perror是系统函数，参见https://www.cnblogs.com/noxy/p/11188583.html
        perror("Create socket failed.");
        exit(-1);
    }

    int opt = SO_REUSEADDR;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); //将地址和端口设为可立即重用（后续再解释）

    //这4行是设置地址结构变量的标准做法，可直接套用
    bzero(&server, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    if(inet_pton(AF_INET, argv[1], &server.sin_addr) == 0)
    {
        perror("Server IP Address Error:\n");
        exit(1);
    }

    //把server里的地址信息绑定到监听套接字上
    if (bind(listenfd, (struct sockaddr *)&server, sizeof(struct sockaddr)) == -1) {
        perror("Bind error.");
        exit(-1);
    }

    if (listen(listenfd, BACKLOG) == -1) { //开始监听
        perror("listen error.");
        exit(-1);
    }
    sprintf(p,"[srv](%d)[srv_sa](%s:%s)[vcd](%s) Server has initialized!\n",getpid(),argv[1],argv[2],argv[3]);
    fputs(p, stdout);

    sin_size = sizeof(struct sockaddr_in);
    int sym = 0;
    while(!sigint_flag) {
        //接受客户端连接（从监听队列里取出）
        if ((connectfd = accept(listenfd, (struct sockaddr *)&client, (socklen_t *)&sin_size)) == -1) {
            if(errno == EINTR){
                continue;
            } else{
                perror("accept error.");
                exit(-1);
            }
        } 
        sprintf(p,"[srv] client[%s:%d] is accepted!\n",inet_ntoa(client.sin_addr),client.sin_port);
        fputs(p, stdout);
        if ((pid= fork()) > 0) { // 父进程
            close(connectfd);
            continue;
        } else if (pid == 0) { // 子进程
            close(listenfd);
            srv_biz(connectfd, argv[3]);
            close(connectfd);
            return 0;
        } else { // 出现错误
            perror("Create child process failed.");
            exit(1);
        }
        close(connectfd); //关闭连接套接字
    } 
    close(listenfd); //关闭监听套接字
}

void srv_biz(int connfd,char* veri_code){
    char tep[MAXDATASIZE + 3];
    short cid_net;
    while(1){
        int numbytes; // 从客户端接收字节数
        numbytes = read(connfd,&cid_net,2); // 读取2字节的客户端编号
        if(numbytes == 0){
            break;
        }
        if((numbytes = read(connfd,buf,MAXDATASIZE)) == -1) {
                perror("recv error.");
                exit(1);
        }
        if(numbytes == 0){
            break;
        }
        sprintf(p, "[chd](%d)[cid](%d)[ECH_RQT] %s", getpid(), (short)ntohs(cid_net), buf);
        fputs(p,stdout);
        bzero(p, sizeof(p));
        bzero(tep,sizeof(tep));

        short vcd_net = (short)htons((uint16_t)atoi(veri_code));
        memcpy(tep, &vcd_net,2);
        memcpy(tep + 2, buf, numbytes);
        write(connfd, tep, sizeof(tep));
    }
}

void handle_sigint(int sig){ // 定义SIGNAL信号处理器
    sprintf(p,"[srv] SIGINT is coming!\n");
    fputs(p, stdout);
    sigint_flag = 1;
}
void sig_chld(int signo){
    pid_t pid_chld;
    int stat;
    while((pid_chld = waitpid(-1, &stat, WNOHANG)) > 0){
        sprintf(p, "[srv](%d)[chd](%d) Child has terminated!\n",getppid(),pid_chld);
        fputs(p, stdout);
    }
}

void sig_pipe(int signo) {
    int sig_num = signo;
    pid_t pid = getpid();
    printf("[srv](%d) SIGPIPE is coming!\n", pid);
}

客户端代码：

#include         
#include      //exit()函数，atoi()函数
#include      //C 和 C++ 程序设计语言中提供对 POSIX 操作系统 API 的访问功能的头文件
#include   //Unix/Linux系统的基本系统数据类型的头文件,含有size_t,time_t,pid_t等类型
#include  //套接字基本函数
#include  //IP地址和端口相关定义，比如struct sockaddr_in等
#include   //inet_pton()等函数
#include      //bzero()函数
#include 
#include 
#include 
#include   
#include 
#define MAXDATASIZE    140
char p[MAXDATASIZE + 300];
void handle_sigint(int sig);
void cli_biz(int fd, char* cid);
void sig_chld(int signo);
int sigint_flag = 0; // 标记服务器进程是否受到signal信号
int main(int argc, char *argv[])
{
    
    int    clientfd;      //clientfd是客户端套接字
    struct sockaddr_in server_addr; //存放服务器端地址信息，connect()使用
    if (argc != 4){                 //如果命令行用法不对，则提醒并退出
        printf("usage: %s     \n",argv[0]);
        exit(0);
    }
    //安装使用SIGPIPE
    struct sigaction ssa;
    ssa.sa_handler = SIG_IGN;
    sigemptyset(&ssa.sa_mask);
    ssa.sa_flags = 0;
    if (sigaction(SIGPIPE, &ssa, NULL) < 0){
        perror("cannot ignore SIGPIPE");
        return -1;
    }
    //安装SIGINT信号处理器
    struct sigaction sa;
    sa.sa_flags = 0;
    sa.sa_handler = handle_sigint;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGINT, &sa, NULL);
    //注册SIGCHLD的处理函数
    struct sigaction sigact_chld, old_sigact_chld;
    sigemptyset(&sigact_chld.sa_mask);
    sigact_chld.sa_handler = sig_chld;
    sigact_chld.sa_flags = 0;
    sigaction(SIGCHLD, &sigact_chld, &old_sigact_chld);

    if ((clientfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("Create socket failed.");
        exit(1);
    }

    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    // argv[1] 为服务器IP字符串，需要用inet_pton转换为IP地址
    if(inet_pton(AF_INET, argv[1], &server_addr.sin_addr) == 0)
    {
        perror("Server IP Address Error:\n");
        exit(1);
    }
    // argv[2] 为服务器端口，需要用atoi及htons转换
    server_addr.sin_port = htons(atoi(argv[2]));
    if (connect(clientfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) {
        perror("connect failed.");
        exit(1);
    }
    sprintf(p,"[cli](%d)[srv_sa](%s:%s) Server is connected!\n",getpid(),argv[1],argv[2]);
    fputs(p,stdout);

    cli_biz(clientfd, argv[3]);

    close(clientfd);
    sprintf(p,"[cli] clientfd is closed!\n");
    fputs(p, stdout);
    sprintf(p,"[cli] clinetfd is to return!\n");
    fputs(p, stdout);
    return 0;
}

void handle_sigint(int sig){ // 定义SIGNAL信号处理器
    sprintf(p,"[srv] SIGINT is coming!\n");
    fputs(p, stdout);
    sigint_flag = 1;
}

void cli_biz(int clientfd, char* cid){
    char buf[MAXDATASIZE + 3];     //缓冲区，用于存放从服务器接收到的信息
    char msg[MAXDATASIZE];  // 从命令行中读取的消息
    short vcd_net;
    while(1){
        int numbytes; // numbytes是服务器端接收到的字节数
        int msg_len;
        fgets(msg,MAXDATASIZE,stdin);
        msg_len = strlen(msg);
        if(sigint_flag || strncmp(msg, "EXIT", 4) == 0){
            sprintf(p,"[cli](%d)[cid](%s)[ECH_RQT] %s",getpid(), cid, msg);
            fputs(p,stdout);
            bzero(p,sizeof(p));
            break;
        }
        if(msg_len > MAXDATASIZE - 2){
            printf("messge is too long!\n");
            exit(1);
        }
        msg[msg_len] = '\0';
        sprintf(p,"[cli](%d)[cid](%s)[ECH_RQT] %s",getpid(), cid, msg);
        fputs(p,stdout);
        bzero(p,sizeof(p));
        short cid_net = htons((uint16_t)atoi(cid));
        memcpy(buf,&cid_net,2);
        memcpy(buf + 2,msg, msg_len);
        write(clientfd, buf, sizeof(buf)); //发送原始数据和客户端编号到服务器端
        bzero(buf,sizeof(buf));
        read(clientfd, &vcd_net, 2); // 读取2字节的验证码
        if((numbytes = read(clientfd, buf, MAXDATASIZE)) == -1) {
            perror("recv error.");
            exit(1);
        }
        sprintf(p, "[cli](%d)[vcd](%d)[ECH_REP] %s",getpid(), (short)ntohs(vcd_net), buf);
        fputs(p,stdout);
        bzero(p, sizeof(p));
    }
}
void sig_chld(int signo){
    pid_t pid_chld;
    int stat;
    while((pid_chld = waitpid(-1, &stat, WNOHANG)) > 0){
        sprintf(p, "[srv](%d)[chd](%d) Child has terminated!\n",getppid(),pid_chld);
        fputs(p, stdout);
    }
}

注意事项：

关于学生客户端服务器在本地交互测试一切正常，但是上线测试即出现各种错误甚至超时的问题

·在线测试时采用以下模式进行交互：学生客户端＜＝＞标准服务器；标准客户端＜＝＞学生服务器。

·当学生自行编写的客户端、服务器在本地进行交互测试时表现正常，并不能充分说明编码符合题设。

【案例】学生客户端与服务器收发数据时均未进行 PDU字节序转换

学生客户端与服务器收发数据时均未进行PDU字节序转换，本地测试看起来一切正常，但究其根本，是因为学生客户端与服务器程序虽未遵循网络字节序规范，但相当于遵循了无需字节序转换的自定义协议规范，且客户端、服务器进程都运行在同一主机上，因此字节序问题并不会暴露。但标准客户端与标准服务器并不认可该协议，所以上线测试即表现出各种问题。