Question

我正在测试我的网络代码。这涉及通过IPv4环回地址（127.0.0.1）建立连接。不幸的是，程序经常（并非总是）在发送数据时出现EPIPE错误。

我正在使用Berkeley网络套接字和libevent。我通过以下方式创建了一个非阻塞套接字：

CBSocketReturn CBNewSocket(uint64_t * socketID,bool IPv6){
    *socketID = socket(IPv6 ? PF_INET6 : PF_INET, SOCK_STREAM, 0);
    if (*socketID == -1) {
        if (errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT) {
            return CB_SOCKET_NO_SUPPORT;
        }
        return CB_SOCKET_BAD;
    }
    // Stop SIGPIPE annoying us.
    if (CB_NOSIGPIPE) {
        int i = 1;
        setsockopt(*socketID, SOL_SOCKET, SO_NOSIGPIPE, &i, sizeof(i));
    }
    // Make socket non-blocking
    evutil_make_socket_nonblocking((evutil_socket_t)*socketID);
    return CB_SOCKET_OK;
}

我通过以下方式发起连接事件：

bool CBSocketDidConnectEvent(uint64_t * eventID,uint64_t loopID,uint64_t socketID,void (*onDidConnect)(void *,void *),void * node){
    CBEvent * event = malloc(sizeof(*event));
    event->loop = (CBEventLoop *)loopID;
    event->onEvent.ptr = onDidConnect;
    event->node = node;
    event->event = event_new(((CBEventLoop *)loopID)->base, (evutil_socket_t)socketID, EV_TIMEOUT|EV_WRITE, CBDidConnect, event);
    if (NOT event->event) {
        free(event);
        event = 0;
    }
    *eventID = (uint64_t)event;
    return event;
}
void CBDidConnect(evutil_socket_t socketID,short eventNum,void * arg){
    CBEvent * event = arg;
    if (eventNum & EV_TIMEOUT) {
        // Timeout for the connection
        event->loop->onTimeOut(event->loop->communicator,event->node,CB_TIMEOUT_CONNECT);
    }else{
        // Connection successful
        event->onEvent.ptr(event->loop->communicator,event->node);
    }
}

并通过以下方式添加：

bool CBSocketAddEvent(uint64_t eventID,uint16_t timeout){
    CBEvent * event = (CBEvent *)eventID;
    int res;
    if (timeout) {
        struct timeval time = {timeout,0};
        res = event_add(event->event, &time);
    }else
        res = event_add(event->event, NULL);
    return NOT res;
}

连接：

bool CBSocketConnect(uint64_t socketID,uint8_t * IP,bool IPv6,uint16_t port){
    // Create sockaddr_in6 information for a IPv6 address
    int res;
    if (IPv6) {
        struct sockaddr_in6 address;
        memset(&address, 0, sizeof(address)); // Clear structure.
        address.sin6_family = AF_INET6;
        memcpy(&address.sin6_addr, IP, 16); // Move IP address into place.
        address.sin6_port = htons(port); // Port number to network order
        res = connect((evutil_socket_t)socketID, (struct sockaddr *)&address, sizeof(address));
    }else{
        struct sockaddr_in address;
        memset(&address, 0, sizeof(address)); // Clear structure.
        address.sin_family = AF_INET;
        memcpy(&address.sin_addr, IP + 12, 4); // Move IP address into place. Last 4 bytes for IPv4.
        address.sin_port = htons(port); // Port number to network order
        res = connect((evutil_socket_t)socketID, (struct sockaddr *)&address, sizeof(address));
    }
    if (NOT res || errno == EINPROGRESS)
        return true;
    return false;
}

连接后，会发出canSend事件：

bool CBSocketCanSendEvent(uint64_t * eventID,uint64_t loopID,uint64_t socketID,void (*onCanSend)(void *,void *),void * node){
    CBEvent * event = malloc(sizeof(*event));
    event->loop = (CBEventLoop *)loopID;
    event->onEvent.ptr = onCanSend;
    event->node = node;
    event->event = event_new(((CBEventLoop *)loopID)->base, (evutil_socket_t)socketID, EV_TIMEOUT|EV_WRITE|EV_PERSIST, CBCanSend, event);
    if (NOT event->event) {
        free(event);
        event = 0;
    }
    *eventID = (uint64_t)event;
    return event;
}
void CBCanSend(evutil_socket_t socketID,short eventNum,void * arg){
    CBEvent * event = arg;
    if (eventNum & EV_TIMEOUT) {
        // Timeout when waiting to write.
        event->loop->onTimeOut(event->loop->communicator,event->node,CB_TIMEOUT_SEND);
    }else{
        // Can send
        event->onEvent.ptr(event->loop->communicator,event->node);
    }
}

但是经常发送会产生EPIPE错误：

int32_t CBSocketSend(uint64_t socketID,uint8_t * data,uint32_t len){
    ssize_t res = send((evutil_socket_t)socketID, data, len, CB_SEND_FLAGS);
    printf("SENT (%li): ",res);
    for (uint32_t x = 0; x < res; x++) {
        printf("%c",data[x]);
    }
    printf("\n");
    if (res >= 0)
        return (int32_t)res;
    if (errno == EAGAIN)
        return 0; // False event. Wait again.
    return CB_SOCKET_FAILURE; // Failure
}

它落在return CB_SOCKET_FAILURE;上，而errno设置为EPIPE。现在为什么会这样？如果设置了发送标志只是MSG_NOSIGNAL，因为SIGPIPE一直在用这个错误中断程序。我希望EPIPE导致CBSocketSend返回CB_SOCKET_FAILURE而不中断程序，但没有理由使用EPIPE发送失败，为什么要这样做？

上次我收到错误时，我注意到连接的线程仍然在connect（）调用上。是否存在使连接事件由连接的线程而不是连接线程处理的危险？

查看这些地方的网络代码：

https://github.com/MatthewLM/cbitcoin/blob/master/test/testCBNetworkCommunicator.c https://github.com/MatthewLM/cbitcoin/tree/master/src/structures/CBObject/CBNetworkCommunicator https://github.com/MatthewLM/cbitcoin/tree/master/dependencies/sockets

谢谢。

编辑：我再次运行它，并在connect（）完成后得到错误。

编辑2：似乎连接事件没有得到另一方的接受。

Answer 1

下面是一个简单的libevent玩具程序，它合成EINPROGRESS，然后等待EV_WRITE等待连接完成。基本上，该程序显示在您的应用程序中，您应首先尝试connect调用，如果失败并使用EINPROGRESS，则应在执行I / O之前等待完成。

这是libevent回调函数：

extern "C" void on_connect (int sock, short ev, void *arg) {
    assert(ev == EV_WRITE);
    std::cout << "got wrieable on: " << sock << '\n';
    int optval = -1;
    socklen_t optlen = sizeof(optval);
    getsockopt(sock, SOL_SOCKET, SO_ERROR, &optval, &optlen);
    assert(optval == 0);
    std::cout << "succesful asynchronous connect on: " << sock << '\n';
    event_loopbreak();
}

这些是玩具应用程序使用的一些辅助函数：

static void init_addr (struct sockaddr_in *addr, short port) {
    memset(addr, '\0', sizeof(*addr));
    addr->sin_family = AF_INET;
    addr->sin_port = htons(port);
    addr->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
}

static void setup_accept (int sock) {
    const int one = 1;
    struct sockaddr_in addr;
    init_addr(&addr, 9876);
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    bind(sock, (struct sockaddr *)&addr, sizeof(addr));
    listen(sock, 1);
}

static int complete_accept (int sock) {
    struct sockaddr_in addr;
    socklen_t addrlen = sizeof(addr);
    return accept(sock, (struct sockaddr *)&addr, &addrlen);
}

static int try_connect (int sock) {
    struct sockaddr_in addr;
    init_addr(&addr, 9876);
    return connect(sock, (struct sockaddr *)&addr, sizeof(addr));
}

main计划如下：

int main () {
    int accept_sock = socket(PF_INET, SOCK_STREAM, 0);
    setup_accept(accept_sock);
    int sock = socket(PF_INET, SOCK_STREAM, 0);
    fcntl(sock, F_SETFL, fcntl(sock, F_GETFL) | O_NONBLOCK);
    std::cout << "trying first connect on: " << sock << '\n';
    int r = try_connect(sock);
    assert(r < 0 && errno == EINPROGRESS);
    event_init();
    struct event ev_connect;
    event_set(&ev_connect, sock, EV_WRITE, on_connect, 0);
    event_add(&ev_connect, 0);
    int new_sock = complete_accept(accept_sock);
    event_dispatch();
    return 0;
}

Answer 2

我不是TCP / IP专家，但我确实注意到，即使MSG_NOSIGNAL设置为“面向流的套接字”，此文档仍然可以返回EPIPE。看起来您正在使用SOCK_STREAM创建套接字。另一端可能正在破坏连接。

在CBSocketConnect()中，看起来如果你得到EINPROGRESS，你就会返回true - 如果它成功连接你也会返回。您无法知道是否需要等待连接完成。根据{{3}}，您可以select()或poll()来完成连接。

以上是我根据@MatthewMitchell和@ user315052的要求转发我的意见。

修改： this我正在添加I的更详细说明，以及随后的一些讨论。

所以，首先尝试做connect()。然后，如果EINPROGRESS是错误结果，则从libevent注册写事件唤醒。进入EV_WRITE的回调函数后，请检查getsockopt()与级别为SO_ERROR的套接字选项SOL_SOCKET的{{1}}的连接状态。如果返回的选项值为0，则连接成功。否则，请将其视为errno号码。

按照this answer中的说明执行此建议后，您发现客户端遇到错误ECONNREFUSED。这解释了为什么您的写入失败了EPIPE。在调查您的服务器之后，您发现由于错误EADDRINUSE，服务器无法侦听绑定的地址。这可以通过在侦听套接字上设置SO_REUSEADDR选项来处理。

Answer 3

从您的进程唤醒以处理连接成功的那一刻起，直到它尝试写入套接字的那一刻，连接的状态仍然可以在操作系统的内核角度进行更改，而libevent不能对此有远见。

您正在描述的场景可以包含以下阶段，因为您要连接的服务器的行为方式与我将描述的方式相同。给定进程A（您的客户端）和进程B（连接的另一端）：

B运行，绑定服务器套接字，等待。
A奔跑，connect()，等待
B醒来，accept()
醒来处理连接的成功。
B关闭套接字（由于进程终止或显式close()）。
A尝试发送，获取errno == EPIPE。

这可以在环回上重现。

BTW，SO_NOSIGPIPE不是便携式套接字选项。如果您正在编写可移植的C库，最好使用signal() SIG_IGN忽略该信号。

断开管道（EPIPE）连接到环回地址

3 个答案: