超时接受TCP连接

Question

Is there a standard way of calling accept with a timeout?

I am setting the socket as a non-blocking, but it immediately returns with errno set to EAGAIN , I would like to wait for a period, if succeed return descriptor, if not, return -1. I am doing this, but I don;t feel good about it and I feel like there has to be a better way.

template <class Rep, class Period>
socket_handler_t wait_for_connection(const std::chrono::duration<Rep, Period> &timeout_duration)
{
        set_nonblocking();

        auto c_lambda = [](int fd) -> int {
            struct sockaddr_storage conn_addr_;
            int addrlen = sizeof(conn_addr_);
            return accept(fd, (struct sockaddr *)&conn_addr_, (socklen_t *)&addrlen);
        };

        auto wait_ms = std::chrono::duration_cast<std::chrono::milliseconds>(timeout_duration);
        wait_ms /= 10;

        socket_handler_t connfd = -1;
        auto count = 0U;

        while (count < 10)
        {
            count++;
            connfd = c_lambda(socket_handle);
            if (errno == EWOULDBLOCK || errno == EAGAIN)
            {
                std::puts(std::to_string(wait_ms.count()).c_str());
                std::this_thread::sleep_for(timeout_duration);
                continue;
            }
            else
            {
                break;
            }
        }

        set_blocking();

        return connfd;
}

Answer 1

Is there a standard way of calling accept with a timeout?

Depends on what you mean by "standard way". accept itself isn't even specified by the C++ standard, so there is certainly no way specified by C++. There is no accept function that would take a timeout argument in POSIX standard either, but a timeout can be implemented using standard POSIX functionality.

I would like to wait for a period

If you want accept to wait ie block , you need to set the socket to blocking mode.

To implement a timeout for accept (or any blocking system call), you can use a POSIX timer to send a signal that will interrupt the accept call. After accept returns, you need to check whether it succeeded, or was interrupted, or failed for other reason.

Example using a POSIX timer. Accept is simulated using sleep :

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

void die(const char*);

volatile sig_atomic_t timeout_reached;
const int timeout_signal = SIGRTMIN;

int main()
{
    int limit = 1;

    timer_t timer_id;
    sigevent sev{};
    sev.sigev_notify = SIGEV_SIGNAL;
    sev.sigev_signo = timeout_signal;
    if (timer_create(CLOCK_MONOTONIC, &sev, &timer_id))
        die("timer_create");

    timeout_reached = false;

    struct sigaction sa{};
    sa.sa_flags = SA_RESETHAND;
    sa.sa_handler = [](int) {
        timeout_reached = true;
    };
    if (sigaction(timeout_signal, &sa, nullptr))
        die("sigaction");

    itimerspec its {};
    its.it_value.tv_sec = limit;
    if (timer_settime(timer_id, 0, &its, nullptr))
        die("timer_settime");

    while(!timeout_reached) {
        std::cout << "start accepting" << std::endl;
        // blocking accept; we simulate it using sleep
        sleep(100000);
        // check here whether accept succeeded
    }
    std::cout << "timed out after " << limit << " seconds\n";
}

void die(const char* msg) {
    perror(msg);
    exit(EXIT_FAILURE);
}

Note that this example probably won't work without modification if you use threads.

---

An alternative approach, is to use a timer that uses a threaded callback, and within that callback connect to the socket to stop the blocking. A full example including the use of TCP:

#include <iostream>
#include <atomic>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

void die(const char*);

std::atomic<bool> timeout_reached;
constexpr int port = 50000;

int main()
{
    int limit = 1;

    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == -1)
        die("socket");

    sockaddr_in listen_addr{};
    listen_addr.sin_family = AF_INET;
    listen_addr.sin_port = htons(port);
    if(bind(sock, (sockaddr*)&listen_addr, sizeof listen_addr))
        die("bind");

    if(listen(sock, SOMAXCONN))
        die("listen");

    timer_t timer_id;
    sigevent sev{};
    sev.sigev_notify = SIGEV_THREAD;
    sev.sigev_notify_function = [](sigval) {
        timeout_reached = true;
        int client_sock = socket(AF_INET, SOCK_STREAM, 0);
        sockaddr_in client_addr;
        client_addr.sin_family = AF_INET;
        client_addr.sin_port = htons(port);
        if(inet_pton(AF_INET, "127.0.0.1", &client_addr.sin_addr) != 1)
            die("inet_pton");
        if(connect(client_sock, (sockaddr*)&client_addr, sizeof client_addr))
            die("connect");
        if(close(client_sock))
            die("close");
    };
    if (timer_create(CLOCK_MONOTONIC, &sev, &timer_id))
        die("timer_create");

    timeout_reached = false;

    itimerspec its {};
    its.it_value.tv_sec = limit;
    if(timer_settime(timer_id, 0, &its, nullptr))
        die("timer_settime");

    for(;;) {
        std::cout << "start accepting" << std::endl;
        sockaddr_storage addr;
        socklen_t addrlen = sizeof addr;
        int fd = accept(sock, (sockaddr*)&addr, &addrlen);
        if(fd != -1) {
            if (timeout_reached) {
                close(fd);
                break;
            }
            // read or whatever
            close(fd);
        } else {
            // handle EAGAIN etc
        }
    }
    std::cout << "timed out after " << limit << " seconds\n";
    if(close(sock))
        die("close");
}

void die(const char* msg) {
    perror(msg);
    exit(EXIT_FAILURE);
}

This approach may be easier to port to certain systems that don't support interruption of accept .