信号处理 signal和signaction函数，signal是最原始的API，提供的接口比sigaction简单。而sigaction提供了signal不具备的功能，首选sigaction函数作为信号处理器。 signal的函数原型是：

``

include <signal.h>

void (signal(int sig, void (handler)(int)))(int);

 
而在头文件里看到的定义是：
```c
typedef void (*sighandler_t)(int);
sighandler_t signal(int sig, sighandler_t handler);

signal函数的返回值是个函数指针：void (*handler)(int) 信号处理的回调函数是类似这个形式

void handle(int sig)
{
// do you self..
}

发送信号

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

pid参数的解释：

1. 如果pid大于0，那么会发送信号给由pid指定的进程
2. 如果pid等于0，那么会发送信号给与调用进程同组的每个进程，包括调用进程自身
3. 如果pid小于-1，那么会向组id等于该pid的绝对值的进程组内所有下属进程发送信号。
4. 如果pid等于-1，那么信号的发送范围是：调用进程有权将信号发往每个目标进程，除去init和调用进程自身。

如果是特权进程发起这一调用，那么会发送信号给系统中的所有进程，除了init和自身进程以外。这个信号发送方式也称为广播信号。
如果没有进程与pid匹配，那么kill会调用失败，同时讲errno置于ESRCH kill系统调用若将参数sig指定为0，则无信号发送，kill只会去执行错误检查，查看是否可以向目标进程发送信号，也就是说，可以检查pid指定的进程是否存在。若调用失败，且errno为EPERM（进程存在，但无权向此进程发送信号）或调用成功，那就表示此进程存在。

检查进程的存在还可以通过以下4种方式：

1. 是用wait系统调用，这个仅适合监控调用者的子进程
2. 信号量与排他文件锁
3. 管道和fifo之类的ipc通道
4. /proc/PID接口，可以使用stat之类的系统调用检查。

---

发信号

#include <signal.h>
int raise(int sig);

这个系统调用相当于

kill(getpid(), sig);

在支持多线程的系统会将raise(sig)实现为:

pthread_kill(pthread_self(), sig);

killpg系统调用

#include <signal.h>
int killpg(pid_t pgrp, int sig);

killpg调用相当于kill(-pgrp, sig);

---

显示信号描述

#include <signal.h>
extern const char * const sys_siglist[];
extern const char * const sys_signame[];
 
#include <string.h>
char *strsignal(int sig);

像sys_siglist[SIGPIPE]是获取对SIGPIPE信号的描述.
strsignal函数对sig参数进行了边界检查，然后返回指针，指向对该信号的可打印描述字符串，或者是当信号编号无效时指向错误字符串。

#include <signal.h>
void psignal(int sig, const char* msg);

psignal函数为msg参数所给定的字符串，后面跟有一个冒号，随后是对应于sig的信号描述。
strsignal函数和psignal函数一样，对本地设置敏感（描述会使用本地语言）。
(psignal，strsignal，sys_siglist在susv3未列入标准，在svsv4列入了)

---

信号集

#include <signal.h>
// 初始化一个未包含任何成员的信号集
int sigemptyset(sigset_t *set);
 
// 初始化一个信号集，使其包含所有信号（包括所有实时信号）
int sigfillset(sigset_t *set);
 
// 向一个集合中添加单个信号
int sigaddset(sigset_t *set, int sig);
 
// 向一个集合中移除单个信号
int sigdelset(sigset_t *set, int sig);
 
// 测试信号sig是否是信号集set的成员
int sigismember(const sigset_t *set, int sig);
 
// 将left集和right集的交集置于dest集
int sigandset(sigset_t *dest, sigset_t *left, sigset_t *right);
// 将left集合right集的并集置于dest集
int sigorset(sigset_t *dest, sigset_t *left, sigset_t *right);
// 若set集内未包含信号的话返回1，否则返回0
int sigisemptyset(const sigset_t *set);

注：必须使用sigemptyset或sigfillset来初始化信号集。因为c语言不会对自动变量进行初始化。

信号掩码（阻塞信号传递）
内核会为每个进程维护一个信号掩码，即一组信号，并将阻塞其针对该进程的传递。如将遭阻塞的信号发送给某进程，那么对该信号的传递将延后，直至从进程信号掩码中移除该信号，从而解除阻塞为止。向信号掩码中添加一个信号，有以下几种方式：
1、使用sigaction()函数建立信号处理程序时，可以指定一组额外信号，当调用该处理程序时会将其阻塞
2、当调用信号处理器程序时，可将引发调用的信号自动添加到信号掩码中。是否发生这一情况，要视sigaction()函数在装载信号处理程序时所用的标志而定
3、使用sigprocmask()系统调用，随时可以显示向信号掩码中添加或移除信号。

---

介绍sigprocmask函数吧

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

使用sigprocmask既可以修改进程的信号掩码，也可以获取现有掩码，或2个功能都可以实现，how参数可取下面3种值：

1. SIG_BLOCK
   将set指向的信号集内的指定信号添加到信号掩码中。
2. SIG_UNBLOCK
   将set指向信号集中的信号从信号掩码中移除。即使要解除阻塞的信号当前并未处于阻塞状态，也不会返回错误
3. SIG_SETMASK
   将set指向的信号集赋给信号掩码

上述3种情况，若oldset参数不为空，则其指向一个sigset_t结构缓冲区，用于返回之前的信号掩码。
如果想获取信号且对其不作改动，那么可将set参数指定为空，这时将忽略how参数

处于等待状态的信号

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

如果某进程接受了一个该进程正在阻塞的信号，那么会将该信号添加到进程的等待信号集中。之后若解除了对该信号的锁定时，会将信号传递给此进程。
sigpending()系统调用为调用进程返回处于等待状态的信号集，并将其置于set指向的sigset_t结构中。随后可以使用sigismember()函数来检查set。返回值是0的话表示成功，返回-1的话，表示有错。

#include <string.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <time.h>
 
void printSigset(FILE* of, const char *prefix, const sigset_t *sigset)
{
    int sig, cnt;
    cnt = 0;
    for (sig = 1; sig < NSIG; sig++) {
        if (sigismember(sigset, sig)) {
            cnt++;
            fprintf(of, "%s%d (%s)\n", prefix, sig, strsignal(sig));
        }
    }
 
    if (cnt == 0)
        fprintf(of, "%s<empty signal set>\n", prefix);
}
 
int printSigMask(FILE* of, const char *msg)
{
    sigset_t currMask;
    if (msg != NULL)
        fprintf(of, "%s", msg);
 
    // 返回前一次设置的信号掩码
    if (sigprocmask(SIG_BLOCK, NULL, &currMask) == -1)
        return -1;
 
    printSigset(of, "\t\t", &currMask);
    return 0;
}
 
int printPendingSigs(FILE *of, const char *msg)
{
    sigset_t pendingSigs;
    if (msg != NULL)
        fprintf(of, "%s", msg);
 
    if (sigpending(&pendingSigs) == -1)
        return -1;
 
    printSigset(of, "\t\t", &pendingSigs);
    return 0;
}
 
int main(int argc, char const *argv[])
{
    sigset_t blockSet, prevMask;
    sigemptyset(&blockSet);
    sigaddset(&blockSet, SIGINT);
 
    if (sigprocmask(SIG_BLOCK, &blockSet, &prevMask) == -1) {
        perror("sigprocmask");
        return 1;
    }
 
    fprintf(stderr, "display pending sigset\n");
    printPendingSigs(stderr, "pending");
 
    fprintf(stderr, "display mask sigset\n");
    printSigMask(stderr, "mask");
 
    fprintf(stderr, "开始对SIGINT的信号进行阻塞，在接下来5秒内按ctl+c无法中断本进程\n");
    int i;
    for (i = 0; i < 5; i++) {
        //查看已被阻塞的信号
        printPendingSigs(stderr, "pending");
        sleep(1);
    }
 
    fprintf(stderr, "解除对SIGINT的信号阻塞，若刚过去的5秒你有按下ctl+c键，本进程会立即中断\n");
    // 恢复之前的信号掩码，不阻塞SIGINT信号
    if (sigprocmask(SIG_SETMASK, &prevMask, NULL) == -1) {
        perror("sigprocmask");
        return 1;
    }
 
    printSigMask(stderr, "mask");
 
    for (i = 0; i < 5; i++) {
        sleep(1);
    }
 
 
    sigset_t blockSet1;
    sigfillset(&blockSet1);
    fprintf(stderr, "阻塞除了SIGKILL和SIGSTOP信号的请求\n");
    fprintf(stderr, "SIGSTOP=%d\n", SIGSTOP);
    if (sigprocmask(SIG_BLOCK, &blockSet1, NULL) == -1) {
        perror("sigprocmask");
        return 1;
    }
 
    for (i = 0; i < 10; i++) {
        sleep(1);
    }
 
    fprintf(stderr, "解除阻塞所有信号的请求\n");
    if (sigprocmask(SIG_UNBLOCK, &blockSet1, NULL) == -1) {
        perror("sigprocmask");
        return 1;
    }
 
    for (i = 0; i < 10; i++)
        sleep(1);
 
    return 0;
}