Question

我编写了一个服务器，它接受辅助端口上的套接字连接，以便传输通常发送到stderr的调试信息。第二个端口 - 错误服务端口 - 仅用于一次建立一个连接，这很方便，因为它允许我使用stderr呼叫重定向dup2(2)。（见Can I redirect a parent process's stderr to a socket file descriptor on a forked process?）。

以下代码在各方面都近乎令人满意。当客户端登录到端口时，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信号。（因此，仅当程序捕获，阻止或忽略此信号时才会看到写返回值。）

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

1 个答案:

EPIPE