Linux 套接字编程

第五章的内容，实现一个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 = {0};
        server.sin_family = AF_INET;
        server.sin_port = htons( SERVER_PORT );


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

        /* 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 = {0};
        int client_fd;
        int client_sockaddr_len = 0;

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

        while (1) {
                printf("server ready to accept
");
                client_fd = accept(server_fd, (struct sockaddr *)&client, &client_sockaddr_len);
                if (client_fd < 0) {
                        /* 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!
");
                        continue;
                }
                if (fork() == 0) {
                        close(server_fd);
                        printf("child process start pid(%d)
", getpid());

                        echo(client_fd);

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

        return 0;
}

void echo(int fd) {
        int n;
        char buffer[BUF_SIZE];
        while ((n = read(fd, buffer, BUF_SIZE)) > 0) {
                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(-1, &stat, WNOHANG)) > 0) {
                printf("child process pid(%d) terminated
", pid);
        }
}

void setup_signal_handler() {
        struct sigaction act, old_act;

        act.sa_handler = signal_child_handler;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
#ifdef SA_RESTART
        act.sa_flags |= SA_RESTART;
        printf("SA_RESTART
");
#endif
        if (sigaction(SIGCHLD, &act, &old_act) < 0) {
                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, 0);

        struct sockaddr_in server_addr = {0};
        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 0;
}

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

        int readn = 0;
        int writen = 0;

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

                sleep(1);

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

                sleep(1);

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