信号是由用户、系统、进程发送给目标进程的信息，以通知目标进程某个状态的改变或系统异常。Linux信号可由以下条件产生：

1. 对于前台进程，用户可通过输入特殊终端字符来给它发送信号，如输入Ctrl+C通常会给进程发送一个中断信号。
2. 系统异常。如浮点异常或非法内存段访问。
3. 系统状态变化。如alarm定时器到期将引起SIGALRM信号。
4. 运行kill命令或调用kill函数。

服务器程序必须处理（或至少忽略）一些常见信号，以免异常终止。

Linux 信号概述

发送信号 kill 函数

Linux下，一个进程给其他进程发送信号的API是kill函数：

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

把信号sig参数发送给目标进程。目标进程用pid参数指定，其可能的取值及含义见下表：

Linux定义的信号值都大于0，如果sig参数传为0，则kill函数不发送任何信号，此时可用来检测目标进程或进程组是否存在，因为检查工作总是在信号发送前执行，但这种检测方式不可靠，一方面是由于进程 PID的回绕，导致被检测的PID不是我们期望的进程的PID，另一方面，这种检测方法不是原子操作。

kill函数成功时返回0，失败则返回-1并设置errno，以下是几种可能的errno：

信号处理方式

信号处理函数的原型为：

#incldue <signal.h>
typedef void(* _sighandler_t) (int);

信号处理只带有一个整型参数，该参数用来指示信号类型。信号处理函数应该是可重入的，否则容易引发竞态条件，因此在信号处理函数中严禁调用不安全的函数。

除了用户自定义信号处理函数外，bits/signum.h头文件中还定义了信号的另外两种处理方式：

#include <bits/signum.h>
#define SIG_DFL ((_sighandler_t) 0)
#define SIG_IGN ((_sighandler_t) 1)

SIG_IGN表示忽略目标信号，SIG_DFL表示使用信号的默认处理方式。

信号的默认处理方式有以下几种：

• 结束进程（Term）
• 忽略信号（Ign）
• 结束进程并生成核心转储文件（Core）
• 暂停进程（Stop）
• 继续进程（Cont）。

可重入函数

可重入函数（Reentrant Function）是指一个可以被中断并在中断后能安全地被再次调用的函数，而不会出现任何不正确的行为或数据损坏。这种函数特别适用于多线程环境或者中断处理程序中，因为在这些场景下，函数可能会被并发地调用。

要实现可重入，函数必须满足以下条件：

1. 不使用静态或全局变量：函数内部不应依赖静态变量或全局变量，因为多个线程可能会同时修改这些变量，导致数据不一致或竞争条件。
2. 不调用非可重入函数：函数内部不应调用其他非可重入函数，否则会继承那些非可重入函数的特性。
3. 局部数据处理：函数只能使用局部变量来存储临时数据，因为局部变量在每次调用时都是独立的，不会与其他调用互相干扰。
4. 不依赖共享资源：函数应避免依赖共享资源（如文件、设备），或者在访问这些资源时应采取适当的同步措施（如使用信号量）。
5. 避免使用动态内存分配或释放：函数不应频繁地进行动态内存分配或释放，因为这些操作可能引发不可预见的行为，尤其是在嵌入式或实时系统中。

举个例子：

int sum(int a, int b) {
    return a + b;
}

这个简单的函数是可重入的，因为它只使用局部变量，不依赖全局状态，也不调用非可重入的函数。

Linux 信号

Linux的可用信号都定义在bits/signum.h头文件中，其中包括标准信号和POSIX实时信号，我们仅讨论标准信号，如下表所示。

我们主要关注几个信号SIGHUP,SIGPIPE,SIGURG,SIGALRM,SIGCHLD。

中断系统调用

如果程序在执行处于阻塞状态的系统调用时收到信号，且我们为该信号设置了信号处理函数，则默认情况下该系统调用会被中断，并将errno设置为EINTR。我们可使用sigaction函数为信号设置SA_RESTART标志以自动重启被该信号中断的系统调用。

信号函数

signal 系统调用

signal 系统调用用于为一个信号设置处理函数。

#include <signal.h>
_sighandler_t signal(int sig, _sighandler_t _handler);

参数

• sig：指定要捕获的信号类型。
• _handler：是 _sighandler_t 类型的函数指针，用于指定 sig 的处理函数。

返回值

• signal函数成功时返回一个函数指针，该函数指针的类型为_sighandler_t。它是sig参数信号在前一次调用signal函数时传入的函数指针，或是sig信号的默认处理函数指针SIG_DEF（如果是第一次调用 signal）。
• signal系统调用出错时返回SIG_ERR，并设置errno。

sigaction 系统调用

设置信号处理函数的更健壮的接口是sigaction系统调用：

#include <signal.h>
int sigaction(int sig, const struct sigaction* act, struct sigaction* oact);

参数

• sig：指定要捕获的信号类型。
• act：指定新的信号处理方式。
• oact：输出信号先前的处理方式（如果不为 NULL）。
• sigaction结构体：描述了信号处理的细节。

struct sigaction{
#ifdef __USE_POSIX199309
	union{
		_sighandler_t sa_handler;
		void (*sa_sigaction) (int, siginfo_t*, void*);
	}
	_sigaction_handler;
#define sa_handler __sigaction_handler.sa_handler
#define sa_sigaction __sigaction_handler.sa_sigaction
#else
	_sighandler_t sa_handler; /* 指定信号处理函数 */
#endif
	_sigset sa_mask; /* 设置（增加）进程的信号掩码 */
	int sa_flags; /* 设置程序接收到信号时的行为 */
	void (*sa_restorer) (void); /* 已经过时 */
}

返回值

• sigaction函数成功返回0，失败返回-1并设置errno。

信号集

信号集函数

上一节在sigaction 系统调用提到，sigaction结构体中的sa_mask是信号集sigset_t（ _sigset_t 的同义词）类型，该类型指定一组信号。

#include <bits/sigset.h>
#define _SIGSET_NWORDS(1024 / (8 * sizeof(unsigned long int)))
typedef struct
{
	unsigned long int __val[_SIGSET_NWORDS];
} sigset_t

sigset_t实际是一个长整型(long int)数组，数组的每个元素的每个位表示一个信号，这种定义方式和文件描述符集fd_set类似 文件描述符。Linux提供了以下函数来设置、修改、删除、查询信号集：

#include <signal.h>
int sigemptyset(sigset_t *_set);	                /* 清空信号集 */
int sigfillset(sigset_t* _set);		                /* 在信号集中设置所有信号 */
int sigaddset(sigset_t* _set, int _signo);	        /* 将信号_signo添加到信号集中 */
int sigdelset(sigset_t* _set, int _signo);	        /* 将信号_signo从信号集中删除 */
int sigismember(_const sigset_t* _set, int _signo);	/* 测试_signo是否在信号集中 */

信号掩码

上一节在sigaction 系统调用提到，sigaction结构体中的sa_mask成员可以用于设置进程的信号掩码，下面这个函数也可以用于设置或查看进程的信号掩码：

#include <signal.h>
int sigprocmask(int _how, _const sigset_t* _set, sigset_t* _oset);

参数

• _set：指定新的信号掩码。
• _oset：输出原来的信号掩码（如果不为 NULL）。
• _how：如果_set参数不为NULL，则_how参数指定设置进程信号掩码的方式，其可选值为：

• 如果_set参数为NULL，则进程信号掩码不变，此时我们可用_oset参数来获取进程当前的信号掩码。

返回值

• sigprocmask函数成功时返回0，失败则返回-1并设置errno。

被挂起的信号

设置进程信号掩码后，被屏蔽的信号不能被进程接收，如果给进程发送一个被屏蔽的信号，则操作系统将该信号设置为进程的一个被挂起的信号，如果我们取消对被挂起信号的屏蔽，则它立即能被进程接收到。以下函数能获得进程当前被挂起的信号集：

#include <signal.h>
int sigpending(sigset_t* set);

参数

• set参数返回被挂起的信号集。进程即使多次接收到同一个被挂起的信号，sigpengding函数也只能返回一次（set参数的类型决定了它只能反映信号是否被挂起，不能反映被挂起的次数），并且，当我们再次使用sigprocmask函数使能该挂起的信号时，该信号的处理函数也只触发一次。

返回值

• sigpending函数成功时返回0，失败时返回-1并设置errno。

在多线程、多进程环境中，我们以线程、进程为单位来处理信号和信号掩码。并且我们不能设想新创建的线程、进程具有和父进程、主线程完全相同的信号特征。比如，fork函数产生的子进程继承父进程的信号掩码，但具有一个空的挂起信号集（信号掩码相同，但是挂起信号集不同）。

统一事件源

信号是一种异步事件：信号处理函数和程序的主循环是两条不同的执行路线，我们希望信号处理函数尽可能快地执行完毕，以确保该信号不被屏蔽太久（信号在处理期间，为了避免一些竞态条件，系统不会再触发它）。

一种典型的解决方案是：把信号的主要处理逻辑放在进程的主循环中，当信号处理函数被触发时，它只是简单地通知主循环程序接收到信号，并把信号值传递给主循环，主循环再根据接收到的信号值执行目标信号对应的逻辑代码。

信号处理函数通常使用管道将信号通知主循环：信号处理函数往管道的写端写入信号值，主循环则从管道的读端读出该信号值，主循环中使用I/O复用系统调用来监听管道的读端文件描述符上的可读事件，这样，信号事件就能和其他I/O事件一样被处理，即统一事件源。

很多优秀的I/O框架库和后台服务器都统一处理信号和I/O事件，如Libevent I/O框架库和 xinetd 超级服务。以下代码给出了统一事件源的一个简单实现：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>
#include <libgen.h>

#define MAX_EVENT_NUMBER 1024

static int pipefd[2];

int setnonblocking(int fd) {
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd) {
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

// 信号处理函数
void sig_handler(int sig) {
    // 保留原来的errno，在函数最后恢复，保证函数的可重入性
    int save_errno = errno;
    int msg = sig;
    // 将信号写入管道，以通知主循环，此处代码是错误的，只发送了int的低地址1字节
    // 如果系统是大端字节序，则发送的永远是0，因此可以改成发送一个int，或将sig改为网络字节序，然后发送最后一个字节
    send(pipefd[1], (char *)&msg, 1, 0);
    errno = save_errno;
}

// 设置信号的处理函数
void addsig(int sig) {
    struct sigaction sa;
    memset(&sa, '\0', sizeof(sa));
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("usage: %s ip_address port_number\n", basename(argv[0]));
        return 1;
    }
    const char *ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int listenfd = socket(PF_INET, SOCK_STREAM, 0);
    assert(listenfd >= 0);

    ret = bind(listenfd, (struct sockaddr *)&address, sizeof(address));
    if (ret == -1) {
        printf("errno is %d\n", errno);
        return 1;
    }
    ret = listen(listenfd, 5);
    assert(ret != -1);

    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    addfd(epollfd, listenfd);

    // 使用socketpair创建管道，注册pipefd[0]上的可读事件
    ret = socketpair(PF_UNIX, SOCK_STREAM, 0, pipefd);
    assert(ret != -1);
    setnonblocking(pipefd[1]);
    addfd(epollfd, pipefd[0]);

    // 设置一些信号的处理函数
    addsig(SIGHUP);
    addsig(SIGCHLD);
    addsig(SIGTERM);
    addsig(SIGINT);
    bool stop_server = false;

    while (!stop_server) {
        int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if ((number < 0) && (errno != EINTR)) {
            printf("epoll failure\n");
            break;
        }

        for (int i = 0; i < number; ++i) {
            int sockfd = events[i].data.fd;
            // 如果就绪的文件描述符是listenfd，则处理新的连接
            if (sockfd == listenfd) {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(client_address);
                int connfd = accept(listenfd, (struct sockaddr *)&client_address, &client_addrlength);
                addfd(epollfd, connfd);
            // 如果就绪的文件描述符是pipefd[0]，则处理信号
            } else if ((sockfd == pipefd[0]) && (events[i].events & EPOLLIN)) {
                int sig;
                char signals[1024];
                ret = recv(pipefd[0], signals, sizeof(signals), 0);
                if (ret == -1) {
                    continue;
                } else if (ret == 0) {
                    continue;
                } else {
                    // 每个信号占1字节，所以按字节逐个接收信号，我们用SIGERTM信号为例说明如何安全终止服务器主循环
                    for (int i = 0; i < ret; ++i) {
                        switch (signals[i]) {
                            case SIGCHLD:
                            case SIGHUP: 
                                continue;
                            case SIGTERM:
                            case SIGINT:
                                stop_server = true;
                        }
                    }
                }
            }
        }
    }

    printf("close fds\n");
    close(listenfd);
    close(pipefd[1]);
    close(pipefd[0]);
    return 0;
}

上述函数中用到的部分 API 回顾如下：

• 操作内核事件表 epoll_ctl：
• 设置、修改、删除、查询信号集
• 使用 socketpair 创建管道
• 文件描述符的分散读(recv)和集中写(writev)
• TCP 数据发送函数 send

网络编程相关信号

SIGHUP

当挂起进程的控制终端时（关闭终端），SIGHUP信号将被触发。对于没有控制终端的网络后台程序而言，它们通常利用SIGHUP信号来强制服务器重读配置文件。一个典型的例子是 xinetd 超级服务程序。

xinetd 程序在接收到SIGHUP信号后将调用hard_reconfig函数（见xinetd 源码），它循环读取/etc/xinetd.d目录下的每个子配置文件，并检测其变化。如果某个正在运行的子服务的配置文件被修改以停止服务，则 xinetd 主进程将给该子进程发送SIGTERM信号以结束它。如果某个子服务的配置文件被修改以开启服务，则 xinetd 将创建新socket并将其绑定到该服务对应的端口上。

SIGPIPE

默认情况下，往一个读端关闭的管道或已关闭的socket连接中写数据将引发SIGPIPE信号，我们需要在代码中捕获并处理该信号，或者至少忽略它，因为程序接收到 SIGPIPE 信号的默认行为是结束进程，而我们绝对不希望因为错误的写操作而导致程序退出。引起SIGPIPE信号的写操作将设置errno为EPIPE。

在 TCP 数据读写 小节中提到的 recv 和 send 调用，函数传入的参数中的 flags 参数为数据收发提供了额外的控制。（具体见《Linux 高性能服务器编程》P82）

其中， send函数的MSG_NOSIGNAL标志可以用来禁止写操作触发SIGPIPE信号。此时，我们应使用send函数反馈的errno值来判断管道的读端或socket连接的读端是否已经关闭。

此外，我们也可利用I/O复用系统调用来检测管道读端和socket 连接的读端是否已经关闭。

以poll函数为例，当管道的读端关闭时，写端文件描述符上的POLLHUP事件将被触发；

当socket连接被对方关闭时，socket上的POLLRDHUP事件将被触发。见poll 系统调用

SIGURG

在Linux环境下，内核通知应用程序带外数据到达主要有两种方法：

• I/O复用技术，select等系统调用在接收到带外数据时将返回，并向应用程序报告socket上的异常事件（见处理带外数据）；
• 使用SIGURG信号。

TCP 带外数据总结

至此，我们讨论完了 TCP 带外数据相关的所有知识。总结梳理一下：

• 《Linux 高性能服务器编程》第 3 章 3.8 节 （P50）：带外数据
• 《Linux 高性能服务器编程》第 5 章 5.8.1 小节 （P81）：TCP 数据读写 提到的 recv 和 send 调用，函数传入的参数中的 flags 参数为数据收发提供了额外的控制，其中 MSG_OOB标志的含义即为发送或接收紧急数据。实战 2：使用 MSG_OOB 选项发送带外数据的代码描述了这一过程。
• 《Linux 高性能服务器编程》第 9 章 9.1.3 小节 （P148）：处理带外数据，socket上接收到普通数据和带外数据都将使select函数返回，但 socket 处于不同的就绪状态：前者处于可读状态，后者处于异常状态。对于异常事件，采用带MSG_OOB标志的recv函数读取带外数据。实战 1：select 调用同时接收普通数据和带外数据的代码描述了这一过程。

// 异常事件，采用带MSG_OOB标志的recv函数读取带外数据
else if (FD_ISSET(connfd, &exception_fds)) {
    ret = recv(connfd, buf, sizeof(buf) - 1, MSG_OOB);
    if (ret <= 0) {
        break;
    }
    printf("get %d bytes of oob data: %s\n", ret, buf);
}

• 《Linux 高性能服务器编程》第 10 章 10.5.3 小节 （P190）：在Linux环境下，内核通知应用程序带外数据到达主要有两种方法：

• • I/O复用技术，select等系统调用在接收到带外数据时将返回，并向应用程序报告socket上的异常事件。
  • 使用SIGURG信号。

在应用程序检测到带外数据到达以后，还需要进一步判断带外数据在数据流中的具体位置，才能够读取带外数据。《Linux 高性能服务器编程》第 15 章 5.9 小节 （P87）带外标记介绍的 sockatmark调用可以判断 sockfd 是否处于带外标记，即下一个被读取到的数据是否是带外数据。如果是，sockatmark返回1，此时我们就可以利用带MSG_OOB标志的recv调用来接收带外数据。如果不是，则sockatmark返回0。

实战 4：使用 SIGURG 信号检测带外数据是否到达

其他完整代码见实战 2：使用 MSG_OOB 选项发送带外数据 使用 SIGURG 信号处理带外数据的代码如下所示：

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <fcntl.h>
#include <libgen.h>

#define BUF_SIZE 1024

static int connfd;

// SIGURG信号的处理函数
void sig_urg(int sig) {
    int save_errno = errno;
    char buffer[BUF_SIZE];
    memset(buffer, '\0', BUF_SIZE);
    
    int ret;
    while ((ret = recv(connfd, buffer, BUF_SIZE - 1, MSG_OOB)) < 0) {
        if (errno == EWOULDBLOCK) {
            continue; // 如果接收缓冲区满了,继续读取,直到接收到带外数据
        } else {
            break; // 处理其他错误情况
        }
    }
    if (ret > 0) {
        printf("got %d bytes of oob data '%s'\n", ret, buffer);
    }
    
    errno = save_errno;
}

void addsig(int sig, void (*sig_handler)(int)) {
    struct sigaction sa;
    memset(&sa, '\0', sizeof(sa)); // 使用 memset 函数将结构体 sa 的所有字节初始化为零。
    sa.sa_handler = sig_handler; // 将信号处理函数指针 sig_handler 赋值给 sa_handler 字段。这个字段指定了当信号 sig 发生时，操作系统应该调用哪个函数来处理这个信号。
    sa.sa_flags |= SA_RESTART; // 设置 sa_flags 字段，并启用 SA_RESTART 标志。SA_RESTART 标志表示，如果在处理信号时一个被阻塞的系统调用被中断，内核会自动重新启动这个系统调用，而不会返回 EINTR 错误。这在网络编程中很有用，因为它可以避免信号处理过程中某些系统调用（如 recv 或 accept）被意外中断。
    sigfillset(&sa.sa_mask); // 将 sa_mask 字段设置为阻塞所有信号。在信号处理函数运行期间，其他信号将被阻塞，防止信号处理函数被其他信号中断。
    assert(sigaction(sig, &sa, NULL) != -1); // 调用 sigaction 函数来注册信号处理程序，将信号 sig 与 sig_handler 函数绑定。如果 sigaction 调用失败，它将返回 -1，在这种情况下，assert 宏将终止程序并报告错误。sigaction 的第三个参数为 NULL，表示不需要保存之前的信号处理程序信息。
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("usage: %s ip_address port_number\n", basename(argv[0]));
        return 1;
    }
    const char *ip = argv[1];
    int port = atoi(argv[2]);

    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int sock = socket(PF_INET, SOCK_STREAM, 0);
    assert(sock >= 0);

    int ret = bind(sock, (struct sockaddr *)&address, sizeof(address));
    assert(ret != -1);

    ret = listen(sock, 5);
    assert(ret != -1);

    struct sockaddr_in client;
    socklen_t client_addrlength = sizeof(client);
    connfd = accept(sock, (struct sockaddr *)&client, &client_addrlength);
    if (connfd < 0) {
        printf("errno is: %d\n", errno);
    } else {
        // 将 SIGURG 信号与 sig_urg 处理函数关联起来。当 SIGURG 信号发生时，操作系统将调用 sig_urg 函数来处理这个信号。
        addsig(SIGURG, sig_urg);
        // 设置指定文件描述符 connfd 的所有者为当前进程，以便该文件描述符在收到 SIGURG 信号时，将信号发送给这个进程。
        fcntl(connfd, F_SETOWN, getpid());

        char buffer[BUF_SIZE];
        // 循环接收普通数据
        while (1) {
            memset(buffer, '\0', BUF_SIZE);
            ret = recv(connfd, buffer, BUF_SIZE - 1, 0);
            if (ret < 0) {
                // 如果 recv 或其他系统调用因信号中断而返回 -1，那么 errno 就会被设置为 EINTR，表示系统调用被信号中断。
                if(errno == EINTR) {
                    continue; // 如果recv因信号中断,则继续读取
                }
                break; // 处理其他错误
            } else if (ret == 0) {
                printf("Client disconnected.\n");
                break;
            }
            printf("get %d bytes of normal data '%s'\n", ret, buffer);
        }
        close(connfd);
    }
    close(sock);
    return 0;
}

编译：

g++ -o sigurg_server sigurg_server.cpp

运行：

./sigurg_server 127.0.0.1 12345 		// 服务器端
./client 127.0.0.1 12345				// 客户端

结果：

参考文章

1. Linux高性能服务器编程-游双——第十章信号_发送信号 游双-CSDN博客
2. Linux高性能服务器编程 学习笔记 第十章 信号-CSDN博客