《Linux高性能服务器编程》学习总结（十）——信号

第十章      信号

　　Linux中信号是由用户、系统或进程发送给目标进程的信息，用来通知进程某个状态的改变或系统异常，其产生条件如下：1）对于前台进程，用户可以通过输入特殊的终端字符来发送信号，比如Ctrl+C发送中断信号；2）系统异常；3）系统状态变化，如SIGALRM信号；4）运行kill命令或使用kill函数。服务器程序必须处理一些常见的信号，以避免异常终止。

　　我们来看一下kill函数：

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

　　在这个函数中，如果pid大于0则给pid为这个值的进程发送信号；如果pid等于0则发送给本进程组内的其他进程；如果pid等于-1则给除init进程外的所有进程，但发送者需要由给目标进程发送信号的权限；如果pid小于-1则向组id为-pid的进程组中的所有成员发送。后面的sig参数则是发送的信号种类，Linux中的信号族中有很多信号，这里就不一一说了。

　　而接受信号的函数则是signal函数，可以指定一个接收函数来处理接收到的信号，也可以使用SIG_DFL和SIG_IGN两种预定义的宏来处理，分别代表采用默认方式处理和忽略。还有一种更加健壮的信号处理系统调用sigaction，其参数中需要指定新的信号处理方式，是一个sigset_t类型的结构体，其中包括信号掩码、信号处理函数，信号集等参数。

　　信号掩码用来设置进程可以接收什么信号，当进程设置了信号掩码之后，若收到了被屏蔽的信号，则操作系统将该信号设置为进程的一个被挂起信号，如果取消被挂起信号的屏蔽就可以马上接收到这个信号。

　　信号是一种异步事件，其处理函数和主循环是两条不同的执行路线，而信号处理函数必须尽快执行，以确保信号不被屏蔽，原因是信号在处理期间系统不会触发该信号，为了避免某些竞态条件。一个解决办法就是把信号的主要处理逻辑放在主函数内，信号处理函数只负责将信号值传递给主循环，这样我们就可以用I/O复用来监听信号事件：

/*************************************************************************
    > File Name: 10-1.cpp
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Sat 10 Feb 2018 02:56:14 AM PST
 ************************************************************************/

#include"head.h"
using namespace std;

#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) {
    int save_errno = errno;
    int msg = 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 <= 2) {
        printf("usage: %s ip_address port_number
", 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(AF_INET, SOCK_STREAM, 0);
    assert(listenfd >= 0);

    ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
    if(ret == -1) {
        printf("errno is %d
", 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);

    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
");
            break;
        }
        for(int i = 0; i < number; i ++) {
            int sockfd = events[i].data.fd;
            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);
            }
            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 {
                    for(int i = 0; i < ret; i ++) {
                        switch(signals[i]) {
                            case SIGCHLD:
                            case SIGHUP: continue;
                            case SIGTERM:
                            case SIGINT: stop_server = true;
                        }
                    }                
                }
            }
            else {}
        }
    }
    printf("close fds
");
    close(listenfd);
    close(pipefd[1]);
    close(pipefd[0]);
    return 0;
}

　　上例演示了如何安全终止服务器的主循环。

　　在网络编程中，有三个重要的信号。SIGHUP对于网络后台服务器而言一般用于强制服务器重读配置文件；SIGPIPE的产生一般是当往一个读端关闭的管道或socket写数据会引发，而程序一旦接收到SIGPIPE信号就会结束进程，所以我们一般都会捕获或者忽略之；最后就是SIGURG信号，它是另外一种通知应用进程有带外数据的方法，我们来通过一个程序看一下如何处理：

/*************************************************************************
    > File Name: 10-3.cpp
    > Author: Torrance_ZHANG
    > Mail: 597156711@qq.com
    > Created Time: Sat 10 Feb 2018 03:45:14 AM PST
 ************************************************************************/

#include"head.h"
using namespace std;

#define BUF_SIZE 1024
static int connfd;

void sig_urg(int sig) {
    int save_errno = errno;
    char buffer[BUF_SIZE];
    memset(buffer, 0, sizeof(buffer));
    int ret = recv(connfd, buffer, BUF_SIZE, MSG_OOB);
    printf("got %d bytes of oob data '%s'
", ret, buffer);
    errno = save_errno;
}

void addsig(int sig, void (*sig_handler)(int)) {
    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 <= 2) {
        printf("usage: %s ip_address port_number
", 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(AF_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_address;
    socklen_t client_addrlength = sizeof(client_address);
    connfd = accept(sock, (struct sockaddr*)&client_address, &client_addrlength);

    if(connfd < 0) printf("errno is: %d
", errno);
    else {
        addsig(SIGURG, sig_urg);
        fcntl(connfd, F_SETOWN, getpid());

        char buffer[BUF_SIZE];
        while(1) {
            memset(buffer, 0, sizeof(buffer));
            ret = recv(connfd, buffer, BUF_SIZE, 0);
            if(ret <= 0) {
                break;
            }
            printf("got %d bytes of normal data '%s'
", ret, buffer);
        }
        close(connfd);
    }
    close(sock);
    return 0;
}

　　此程序在Ubuntu16.04下有问题，不能接收到带外数据，在网上找了其他利用SIGURG接收带外数据的程序都不能接收，具体原因尚不知，待日后解决。