如何为关闭的套接字捕获信号(`SIGPIPE`)？

Question

我编写了一个服务器,它接受辅助端口上的套接字连接,以便传输通常发送的调试信息stderr.这个第二个端口 - 一个错误服务端口 - 一次只能有一个连接,这很方便,因为它允许我stderr使用一个dup2(2)调用重定向.(请参阅我是否可以将父进程的stderr重定向到分叉进程上的套接字文件描述符？).

以下代码在各方面都近乎令人满意.当客户端登录到端口时,stderr流将定向到套接字.当另一个客户端登录时,流再次被重定向,并且第一个客户端停止接收:完全令人满意.

在设计不足的情况下,当客户端关闭连接时,服务器崩溃,因为它正在尝试write()关闭的套接字.

我有一个正常的子进程的基本信号处理程序,但我不知道如何在错误套接字关闭时处理来自父进程的特定信号.

如何捕获ERR_PORT_NUM上的连接已关闭并让信号处理程序重新打开(或dup)stderr以/dev/null备下一个等待错误客户端的信号(在父级中)？

另外,当第二个连接时,我应该如何处理原始错误客户端连接？目前第一个客户是悬空.即使非正常关闭第一个连接也是可以接受的.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <errno.h>
#include <pwd.h>
#include <signal.h>
#include <netinet/in.h>
#include <sys/mman.h>

#define PORT_NUM 12345
#define ERR_PORT_NUM 54321

static void child_handler(int signum)
{
    switch (signum) {
        case SIGALRM:
            exit(EXIT_FAILURE);
            break;
        case SIGUSR1:
            exit(EXIT_SUCCESS);
            break;
        case SIGCHLD:
            exit(EXIT_FAILURE);
            break;
    }
}

static void daemonize(void)
{
    /* Trap signals that we expect to recieve */
    signal(SIGUSR1, child_handler);
    signal(SIGALRM, child_handler);

    signal(SIGCHLD, SIG_IGN);   /* A child process dies */
    signal(SIGTSTP, SIG_IGN);   /* Various TTY signals */
    signal(SIGTTOU, SIG_IGN);
    signal(SIGTTIN, SIG_IGN);
    signal(SIGHUP, SIG_IGN);    /* Ignore hangup signal */
    signal(SIGTERM, SIG_DFL);   /* Die on SIGTERM */

    freopen("/dev/null", "r", stdin);
    freopen("/dev/null", "w", stdout);
    freopen("/dev/null", "w", stderr);
}

static void server_work(void)
{
    int sockfd, err_sockfd;
    socklen_t clilen;
    struct sockaddr_in serv_addr, cli_addr, err_serv_addr, err_cli_addr;
    struct timeval tv = { 0 };
    int new_stderr;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    err_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0 || err_sockfd < 0)
        return;

    memset((char *) &serv_addr, '\0', sizeof(serv_addr));
    memset((char *) &err_serv_addr, '\0', sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(PORT_NUM);

    err_serv_addr.sin_family = AF_INET;
    err_serv_addr.sin_addr.s_addr = INADDR_ANY;
    err_serv_addr.sin_port = htons(ERR_PORT_NUM);

    if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr))
        < 0)
        return;
    if (bind
        (err_sockfd, (struct sockaddr *) &err_serv_addr,
         sizeof(err_serv_addr)) < 0)
        return;

    listen(sockfd, 5);
    listen(err_sockfd, 5);

    clilen = sizeof(cli_addr);

    while (1) {
        int maxfd;
        fd_set read_sockets_set;

        FD_ZERO(&read_sockets_set);
        FD_SET(sockfd, &read_sockets_set);
        FD_SET(err_sockfd, &read_sockets_set);

        maxfd = (err_sockfd > sockfd) ? err_sockfd : sockfd;

        if (select(maxfd + 1, &read_sockets_set, NULL, NULL, NULL) < 0) {
            break;
        }
        if (FD_ISSET(sockfd, &read_sockets_set)) {
            /* Typical process fork(2) and such ... not gremaine to the question. */
        }
        if (FD_ISSET(err_sockfd, &read_sockets_set)) {
            new_stderr =
                accept(err_sockfd, (struct sockaddr *) &err_cli_addr,
                       &clilen);
            dup2(new_stderr, STDERR_FILENO);
        }
    }
    close(sockfd);
    close(err_sockfd);
    return;
}

int main(int argc, char *argv[])
{
    daemonize();                /* greatly abbreviated for question */

    server_work();
    return 0;
}

Answer 1

你可以简单地忽略SIGPIPE.这是一个无用的,恼人的信号.

signal(SIGPIPE, SIG_IGN);

如果忽略它,那么程序将从失败的write()调用中接收EPIPE错误代码.这使您可以在代码中的合理位置处理I/O错误,而不是在某些全局信号处理程序中处理.

EPIPE

fd连接到读取端关闭的管道或插座.当发生这种情况时,写入过程也将收到SIGPIPE信号.(因此,仅当程序捕获,阻止或忽略此信号时才会看到写入返回值.)