c - ループバックアドレスへの接続でのパイプの破損 (EPIPE)

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 に設定されます。これはなぜでしょう？SIGPIPE がこのエラーでプログラムを中断し続けたため、送信フラグが設定されている場合、MSG_NOSIGNAL になります。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() が終了した後にエラーが発生しました。

EDIT 2:接続イベントは、反対側からの受け入れなしで提供されているようです。

score 1 · Accepted Answer

以下は、を合成し、を待って接続が完了するのを待つ簡単なlibeventおもちゃのプログラムです。基本的に、このプログラムは、アプリケーションで最初に呼び出しを試行する必要があることを示しています。呼び出しが失敗した場合は、I/O を実行する前に完了を待つ必要があります。EINPROGRESSEV_WRITEconnectEINPROGRESS

これは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;
}

score 0 · Accepted Answer

接続の成功を処理するためにプロセスがウェイクアップした瞬間から、ソケットへの書き込みを試みる瞬間まで、接続の状態はオペレーティングシステムのカーネルの観点で変化する可能性があり、libevent は予測できません。それ。

説明しているシナリオは、接続先のサーバーがこれから説明する方法で動作する場合、次の段階で構成できます。プロセス A (クライアント) とプロセス B (接続の反対側) の場合:

B が実行され、サーバーソケットがバインドされ、待機します。
A が走る、connect()、待つ
B 目覚める、するaccept()
A は、接続の成功を処理するためにウェイクアップします。
B はソケットを閉じます (プロセスの終了または明示的のいずれかによるclose())。
A は送信を試み、を取得しerrno == EPIPEます。

これは、ループバックで再現できます。

ところで、SO_NOSIGPIPEポータブルソケットオプションではありません。移植可能な C ライブラリを作成している場合は、 with を使用signal()してシグナルを無視することをお勧めしますSIG_IGN。

c - ループバック アドレスへの接続でのパイプの破損 (EPIPE)

3 に答える 3

Related

Reference

c - ループバックアドレスへの接続でのパイプの破損 (EPIPE)