1
2
3
4

#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);
pid_t getppid(void);

1
2
3

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);

1
2
3

#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);

1
2
3
4
5

#include <signal.h>
void (*signal(int sig, void (*func)(int)))(int);
// 或者
typedef void (*sig_t) (int);
sig_t signal(int sig, sig_t func);

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// server.c

#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

void handle_sigchld(int signo) {
    pid_t wpid = 0;
    int status = 0;
    int options = WNOHANG | WUNTRACED;

#ifdef WCONTINUED // Linux 2.6.10及以上版本
    options |= WCONTINUED;
#endif

    for (;;) {
        wpid = waitpid(-1, &status, options);
        if (wpid == 0) {
            continue;
        }
        if (wpid == -1) {
            if (errno == EINTR) { // 系统调用被信号中断，重新调用一次。
                continue;
            }
            if (errno != ECHILD) { // ECHILD表示已无子进程，这属于'正常'情况。
                perror("waitpid error");
            }
            break;
        }
        if (WIFEXITED(status)) {
            printf("[%d]子进程%d主动调用exit或者_exit退出（退出码为%d）\n", getpid(), wpid, WEXITSTATUS(status));
        } else if (WIFSIGNALED(status)) {
            printf("[%d]子进程%d接收到信号后退出（信号为%d）%s产生内核转储文件\n", getpid(), wpid, WTERMSIG(status), WCOREDUMP(status) ? "且已" : "但未");
        } else if (WIFSTOPPED(status)) {
            printf("[%d]子进程%d接收到信号后停止（信号为%d）\n", getpid(), wpid, WSTOPSIG(status));
        }
#ifdef WIFCONTINUED // Linux 2.6.10及以上版本
        else if (WIFCONTINUED(status)) {
            printf("[%d]子进程%d接收到 SIGCONT 信号后继续\n", getpid(), wpid);
        }
#endif
    }
}

// 父进程负责监听客户端连接，每个连接都通过fork一个子进程的方式进行服务。
int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s port\n", argv[0]);
        return EXIT_FAILURE;
    }

    int port = atoi(argv[1]);

    int lfd = socket(AF_INET, SOCK_STREAM, 0); // 监听文件描述符
    if (lfd == -1) {
        perror("socket error");
        return EXIT_FAILURE;
    }

    int reuseaddr = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr)); // 支持重复绑定

    struct sockaddr_in addr;
    bzero(&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    int ret = 0;
    if ((bind(lfd, (struct sockaddr *)&addr, sizeof(addr))) == -1) {
        perror("bind error");
        return EXIT_FAILURE;
    }

    if ((ret = listen(lfd, 128)) == -1) {
        perror("listen error");
        return EXIT_FAILURE;
    }

    printf("[%d]The server is running at %s:%d\n", getpid(), inet_ntoa(addr.sin_addr), port);

    signal(SIGCHLD, SIG_IGN); // 注册SIGCHLD信号回收子进程资源

    int cfd; // 连接文件描述符
    pid_t pid;
    for (;;) {
        cfd = accept(lfd, NULL, NULL);
        if (cfd == -1) {
            if (errno == EINTR) { // 注意：被信号所中断，这类错误不是真的"错误"。
                continue;
            }
            perror("accept error");
            return EXIT_FAILURE;
        }

        pid = fork();
        if (pid < 0) {
            perror("fork error");
            return EXIT_FAILURE;
        }
        if (pid > 0) {
            // 父进程
            close(cfd); // 父进程中用不到cfd，关闭（cfd的引用计数减一）。
        } else if (pid == 0) {
            // 子进程
            close(lfd); // 子进程中用不到lfd，关闭（lfd的引用计数减一）。

            // 循环读取客户端连接文件描述符将读取的内容转换成大写后返回给客户端
            printf("[%d]Start servicing connection %d\n", getpid(), cfd);
            char buf[32];
            ssize_t size = 0;
            for (;;) {
                memset(buf, 0x00, sizeof(buf));
                size = read(cfd, buf, sizeof(buf));
                if (size < 0) {
                    close(cfd); // cfd的引用计数减一
                    perror("read error");
                    _exit(EXIT_FAILURE); // 直接退出当前进程，避免子进程再次创建子进程。
                }
                if (size == 0) { // 客户端关闭连接（EOF）
                    close(cfd);  // cfd的引用计数减一
                    printf("[%d]Connection %d is closed\n", getpid(), cfd);
                    _exit(EXIT_SUCCESS); // 直接退出当前进程，避免子进程再次创建子进程。
                }
                printf("[%d]Read: %s", getpid(), buf);

                for (int i = 0; i < size; i++) {
                    buf[i] = toupper(buf[i]);
                }
                write(cfd, buf, strlen(buf));
                printf("[%d]Write: %s", getpid(), buf);
            }
        }
    }

    close(lfd); // lfd的引用计数减一
    printf("[%d]The server is shut down\n", getpid());
    return EXIT_SUCCESS;
}