Linux 套接字编程 - TCP连接基础

第五章的内容，实现一个echo服务器和对应的客户端，主要收获：

0. TCP socket编程主要基本步骤

1. SIGCHLD信号含义（子进程退出时向父进程发送，提醒父进程对其状态信息进行一个获取），waitpid 和 wait在使用上的差异，前者可以配置参数设定为非阻塞方式调用，更加灵活。

2. 信号处理函数与其过程（尤其是信号发生后不列队这个性质），相同的信号多次发生（间隔非常接近的话）可能仅会调用一次信号处理函数

3. 信号处理对慢系统（阻塞）调用如accept等的影响（如果信号处理设置时没有置SA_RESTART），accept被中断后直接返回EINTR，而不是一个合法的socket fd，所以对一些调用的错误值检测并不是杞人忧天

4. 僵尸进程，只要父进程调用了wait*函数获取了已死子进程的状态信息后，它就消失了。但如果父进程产生了超多子进程，而他们有很快的死掉，然后父进程也不调用wait*函数，那么会使得pid号不够用

服务端程序：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include <unistd.h>
 #include <signal.h>

 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>

 #define SOCKET_BACKLOG  100
 #define SERVER_PORT     1234
 #define BUF_SIZE        256

 void echo(int fd);

 void setup_signal_handler();

 int main() {
         /* setup SIGCHLD handler */
         setup_signal_handler();

         /* define socket address */
         struct sockaddr_in server = {};
         server.sin_family = AF_INET;
         server.sin_port = htons( SERVER_PORT );

         /* define socket file descriptor */
         int server_fd = socket(AF_INET, SOCK_STREAM, );

         /* bind socket file descriptor to the socket address */
         bind(server_fd, (struct sockaddr *)&server, sizeof(server));

         /* listen on this socket file descriptor */
         listen( server_fd, SOCKET_BACKLOG );

         /* define socket struct/file descriptor used to present remote peer(client) */
         struct sockaddr_in client = {};
         int client_fd;
         int client_sockaddr_len = ;

         /* application send buffer */
         char buffer[BUF_SIZE];

         while () {
                 printf("server ready to accept\n");
                 client_fd = accept(server_fd, (struct sockaddr *)&client, &client_sockaddr_len);
                 if (client_fd < ) {
                         /* if SA_RESTART is not set in setup_signal_handler and
                          * then when process is interrupted by SIGCHLD
                          * the accept() will return EINTR instead of a valid socket fd
                          */
                         printf("server accept error!\n");
                         continue;
                 }
                 if (fork() == ) {
                         close(server_fd);
                         printf("child process start pid(%d)\n", getpid());

                         echo(client_fd);

                         printf("child process exit  pid(%d)\n", getpid());
                         exit();
                 }
                 close(client_fd);
         }

         return ;
 }

 void echo(int fd) {
         int n;
         char buffer[BUF_SIZE];
         while ((n = read(fd, buffer, BUF_SIZE)) > ) {
                 write(fd, buffer, n);
         }
 }

 void signal_child_handler(int signo) {
         pid_t pid;
         int stat;

         /* pid = wait(&stat);
          * signal is not queued, many child process exits
          * may just cause one signal handle process
          * so we should use waitpid() in a row instead of a single wait()
          * to collect child process information
          */
         while ((pid = waitpid(-, &stat, WNOHANG)) > ) {
                 printf("child process pid(%d) terminated\n", pid);
         }
 }

 void setup_signal_handler() {
         struct sigaction act, old_act;

         act.sa_handler = signal_child_handler;
         sigemptyset(&act.sa_mask);
         act.sa_flags = ;
 #ifdef SA_RESTART
         act.sa_flags |= SA_RESTART;
         printf("SA_RESTART\n");
 #endif
         if (sigaction(SIGCHLD, &act, &old_act) < ) {
                 printf("setup SIGCHLD Failed.");
         }
 }

客户端程序：

#include <unistd.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define SERVER_PORT 1234
#define SERVER_IP "127.0.0.1"

#define BUF_SIZE 256

void send_echo(FILE* fp, int fd);

int main() {
        int sockfd = socket(AF_INET, SOCK_STREAM, );

        struct sockaddr_in server_addr = {};
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(SERVER_PORT);

        inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr);

        connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));

        send_echo(stdin, sockfd);

        return ;
}

void send_echo(FILE* fp, int fd) {
        char send_buf[BUF_SIZE] = {};
        char recv_buf[BUF_SIZE] = {};

        int readn = ;
        int writen = ;

        while(fgets(send_buf, BUF_SIZE, fp) != NULL) {
                if ((writen = write(fd, send_buf, strlen(send_buf) + )) < ) {
                        printf("1st write error\n");
                        break;
                } else {
                        printf("1st write ok\n");
                }

                sleep();

                if ((writen = write(fd, "(test)", strlen("(test)") + )) < ) {
                        printf("2nd write error\n");
                        break;
                } else {
                        printf("2nd write ok\n");
                }

                sleep();

                if ((readn = read(fd, recv_buf, BUF_SIZE)) < ) {
                        printf("read error\n");
                        break;
                } else if (readn == ) {
                        printf("read EOF\n");
                        break;
                }
                fputs(recv_buf, stdout);
        }
        printf("client exit\n");
}