网络通信第二步：多对一通信（多进程实现）

// TCP通信的客户端 同第一步
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main() {

    // 1.创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd == -1) {
        perror("socket");
        exit(-1);
    }

    // 2.连接服务器端
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    inet_pton(AF_INET, "192.168.109.128", &serveraddr.sin_addr.s_addr);
    serveraddr.sin_port = htons(9999);
    int ret = connect(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

    if (ret == -1) {
        perror("connect");
        exit(-1);
    }

    // 3. 通信
    char recvBuf[1024];
    int i = 0;
    while (1) {

        sprintf(recvBuf, "data : %d\n", i++); // 字符串格式化命令

        // 给服务器端发送数据
        write(fd, recvBuf, strlen(recvBuf) + 1);

        int len = read(fd, recvBuf, sizeof(recvBuf));
        if (len == -1) {
            perror("read");
            exit(-1);
        } else if (len > 0) {
            printf("recv server : %s\n", recvBuf);
        } else if (len == 0) {
            // 表示服务器端断开连接
            printf("server closed...");
            break;
        }

        sleep(1);
    }

    // 关闭连接
    close(fd);

    return 0;
}

#include <arpa/inet.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <wait.h>

// 回收子进程
void recycleChild(int arg) {
    while (1) {
        int ret = waitpid(-1, NULL, WNOHANG); // 回收指定进程号的子进程，-1回收所有的子进程，相当于wait()，WNOHANG 非阻塞（没有子进程结束，立即返回）
        if (ret == -1) {
            // 所有的子进程都回收了
            break;
        } else if (ret == 0) {
            // 还有子进程活着
            break;
        } else if (ret > 0) {
            // 被回收了
            printf("子进程 %d 被回收了\n", ret);
        }
    }
}

int main() {

    struct sigaction act;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    act.sa_handler = recycleChild;
    // 注册信号捕捉
    sigaction(SIGCHLD, &act, NULL); // 子进程终止时，向父进程发送SIGCHLD信号，父进程默认忽略，导致子进程变成一个僵尸进程。

    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    if (lfd == -1) {
        perror("socket");
        exit(-1);
    }

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (ret == -1) {
        perror("bind");
        exit(-1);
    }

    // 监听
    ret = listen(lfd, 128);
    if (ret == -1) {
        perror("listen");
        exit(-1);
    }

    // 不断循环等待客户端连接
    while (1) {

        struct sockaddr_in cliaddr;
        int len = sizeof(cliaddr);
        // 接受连接
        int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
        if (cfd == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("accept");
            exit(-1);
        }

        // 每一个连接进来，创建一个子进程跟客户端通信
        pid_t pid = fork();
        if (pid == 0) {
            // 子进程
            // 获取客户端的信息
            char cliIp[16];
            inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, cliIp, sizeof(cliIp));
            unsigned short cliPort = ntohs(cliaddr.sin_port);
            printf("client ip is : %s, prot is %d\n", cliIp, cliPort);

            // 接收客户端发来的数据
            char recvBuf[1024];
            while (1) {
                int len = read(cfd, &recvBuf, sizeof(recvBuf));

                if (len == -1) {
                    perror("read");
                    exit(-1);
                } else if (len > 0) {
                    printf("recv client : %s\n", recvBuf);
                } else if (len == 0) {
                    printf("client closed....\n");
                    break;
                }
                write(cfd, recvBuf, strlen(recvBuf) + 1);
            }
            close(cfd);
            exit(0); // 退出当前子进程
        }
    }
    close(lfd);
    return 0;
}

升级点：
可实现多个客户端同时连接服务器

需要解决的问题及解决方法：

1. 如何实现多进程：当监听socket收到信息时，创建子进程与客户端进行连接，通信结束后，子进程退出。
2. 如何避免子进程成为僵尸进程：子进程终止时，向父进程发送SIGCHLD信号，父进程默认忽略，导致子进程变成一个僵尸进程，修改信号处理方式，利用wait回收资源。

补充知识：
信号：异步机制（进程不知道信号什么时候到来），当信号发送到某个进程中时，操作系统会中断该进程的正常流程，并进入相应的信号处理函数执行操作，完成后再回到中断的地方继续执行。（再学习）