c - EPIPE block 服务器

Question

我用C写了一个运行在Linux上的单线程异步服务器:套接字是非阻塞的，至于轮询，我使用的是epoll。基准测试显示服务器运行良好，根据 Valgrind 的说法，没有内存泄漏或其他问题。

唯一的问题是当一个write()命令被中断时(因为客户端关闭了连接)，服务器会遇到一个EPIPE。我通过使用参数 -b 运行基准测试实用程序“siege”来人为地进行中断。它连续执行大量请求，所有请求都完美运行。现在我按下 CTRL-C 并重新启动“围攻”。有时我很幸运，服务器无法发送完整的响应，因为客户端的 fd 无效。正如预期的那样，errno 被设置为 EPIPE。我处理这种情况，在 fd 上执行 close() 然后释放与连接相关的内存。现在的问题是服务器阻塞并且不再正确回答。这是 strace 输出:

epoll_wait(4, {{EPOLLIN, {u32=0, u64=0}}}, 128, -1) = 1
accept(3, {sa_family=AF_INET, sin_port=htons(55328), sin_addr=inet_addr("127.0.0.1")}, [16]) = 5
fcntl64(5, F_GETFL)                     = 0x2 (flags O_RDWR)
fcntl64(5, F_SETFL, O_RDWR|O_NONBLOCK)  = 0
epoll_ctl(4, EPOLL_CTL_ADD, 5, {EPOLLIN|EPOLLERR|EPOLLHUP|EPOLLET, {u32=144039912, u64=144039912}}) = 0
epoll_wait(4, {{EPOLLIN, {u32=144039912, u64=144039912}}}, 128, -1) = 1
read(5, "GET /user/register HTTP/1.1\r\nHos"..., 4096) = 161
send(5, "HTTP/1.1 200 OK\r\nContent-Type: t"..., 106, MSG_NOSIGNAL) = 106 <<<<
send(5, "00001000\r\n", 10, MSG_NOSIGNAL) = -1 EPIPE (Broken pipe)        <<<< Why did the previous send() work?
close(5)                                = 0
epoll_wait(4, {{EPOLLIN, {u32=0, u64=0}}}, 128, -1) = 1
accept(3, {sa_family=AF_INET, sin_port=htons(55329), sin_addr=inet_addr("127.0.0.1")}, [16]) = 5
...

(如果您想知道，我从日志中删除了 printf())

如您所见，客户端建立了一个新连接，该连接随后被接受。然后，它被添加到 EPOLL 队列中。 epoll_wait() 表示客户端发送了数据 (EPOLLIN)。解析请求并组成响应。发送 header 工作正常，但当涉及正文时，write() 会导致 EPIPE。这不是“围攻”中的错误，因为它会阻止任何传入连接，无论来自哪个客户端。

#include "Connection.h"

static ExceptionManager *exc;

void Connection0(ExceptionManager *e) {
    exc = e;
}

void Connection_Init(Connection *this) {
    Socket_Init(&this->server);
    Socket_SetReusableFlag(&this->server);
    Socket_SetCloexecFlag(&this->server, true);
    Socket_SetBlockingFlag(&this->server, true);
    Socket_ListenTCP(&this->server, 8080, SOMAXCONN);

    // Add the server socket to epoll
    Poll_Init(&this->poll, SOMAXCONN, (void *) &Connection_OnEvent, this);
    Poll_AddEvent(&this->poll, NULL, this->server.fd, EPOLLIN | EPOLLET | EPOLLHUP | EPOLLERR);

    this->activeConn = 0;
}

void Connection_Destroy(Connection *this) {
    Poll_Destroy(&this->poll);
    Socket_Destroy(&this->server);
}

void Connection_Process(Connection *this) {
    Poll_Process(&this->poll, -1);
}

void Connection_AcceptClient(Connection *this) {
    Client *client;

    SocketConnection conn = Socket_Accept(&this->server);
    SocketConnection_SetBlockingFlag(&conn, true);

    client = New(Client);

    client->req = NULL;

    client->conn = New(SocketConnection);
    client->conn->remote = conn.remote;
    client->conn->fd = conn.fd;

    this->activeConn++;

    Poll_AddEvent(&this->poll, client, conn.fd, EPOLLIN | EPOLLET | EPOLLHUP | EPOLLERR);
}

void Connection_DestroyClient(Connection *this, Client *client) {
    // Poll_DeleteEvent(&this->poll, client->conn->fd);
    SocketConnection_Close(client->conn);

    if (client->req != NULL) {
        Request_Destroy(client->req);
        Memory_Free(client->req);
    }

    if (client->conn != NULL) {
        Memory_Free(client->conn);
    }

    Memory_Free(client);

    this->activeConn--;
}

void Connection_OnEvent(Connection *this, int events, Client *client) {
    /* error or connection hung up */
    if (client != NULL && (events & (EPOLLHUP | EPOLLERR))) {
        String_Print(String("EPOLLHUP | EPOLLERR received\n"));
        Connection_DestroyClient(this, client);
        return;
    }

    /* incoming connection */
    if (client == NULL && (events & EPOLLIN)) {
        if (this->activeConn > SOMAXCONN - 1) { /* TODO */
            String_Print(String("Too many connections...\n"));
            return;
        }

        Connection_AcceptClient(this);
        return;
    }

    /* receiving data from client */
    if (client != NULL && (events & EPOLLIN)) {
        if (client->req == NULL) {
            client->req = New(Request);
            Request_Init(client->req, client->conn);
        }

        bool keepOpen = false;

        try (exc) {
            keepOpen = Request_Parse(client->req);
        } catch(&SocketConnection_PipeException, e) {
            printf("Caught PipeException on fd=%d\n", client->conn->fd); fflush(stdout);
        } catch(&SocketConnection_ConnectionResetException, e) {
            printf("Caught ConnectionResetException on fd=%d\n", client->conn->fd); fflush(stdout);
        } finally {
            if (!keepOpen) {
                printf("Will close...\n"); fflush(stdout);
                Connection_DestroyClient(this, client);
            }
        } tryEnd;
    }
}

Answer 1

使用sigaction()将 SIGPIPE 的操作设置为 SIG_IGN。然后你只会得到-1的返回码，errno设置为EPIPE，没有信号。

在 Linux 上，另一种方法是使用 send()使用 MSG_NOSIGNAL 标志，而不是 write()。这允许您抑制该写入的信号，而不影响任何其他信号。 BSD 系统上的替代方案是 SO_NOSIGPIPE 套接字选项，它会抑制对该套接字上的所有写入的 SIGPIPE。

内核 TCP 实现可以随时从对等方接收 TCP RST。该点之后套接字上的下一次写入将导致 EPIPE 错误，如果未被抑制，则将导致 SIGPIPE 信号。因此，即使连续两次写入，第一次也可能成功，而下一次可能因 EPIPE 和 SIGPIPE 而失败。

更新:虽然它不是已发布代码的一部分，但我在您的 strace 输出中看到您正在调用 fcntl64(5, F_SETFL, O_RDONLY|O_NONBLOCK)。由于 O_RDONLY 为 0，您的代码可能只是将标志设置为 O_NONBLOCK。它应该获取当前标志，然后将其设置为 OldFlags | O_NONBLOCK 为了设置非阻塞模式。将套接字设置为只读模式似乎很可能在写入时引起问题。或者可能是您不小心使用了 F_GETFD 而不是 F_GETFL 来获取旧标志。