Bug in TCP keep-alive with unix socket

[MouhK]

• Version: 1.48.0 (same on previous versions)
• Platform: Linux 6.1.0-18-amd64 - Debian 6.1.76-1 (2024-02-01) x86_64 GNU/Linux

I have a client server setup, the server is on a distant machine.
The client sends every 2sec a message to the server.
When I disconnect all internet connection and have tcp keep-alive enabled, the timeout (ETIMEDOUT) is never triggered.
If the client stops sending messages every 2sec the timeout is triggered normally.
So it looks like calling uv_write reset the keep-alive timer, as if there was some activity that justifies the keep-alive to be reset.

NOTE: On windows there is no issue...

The following sample can be used to trigger the issue.
Stop the internet connection once the program has started

#include <uv.h>
#include <iostream>

static void on_close(uv_handle_t* handle);
static void on_connect(uv_connect_t* req, int status);
static void on_write(uv_write_t* req, int status);
static bool trigger_bug {false};

static uv_loop_t *loop;
static uv_tcp_t pSock;

static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
	*buf = uv_buf_init(new char[size], size);
}

void on_close(uv_handle_t* handle)
{
  std:: cout << "closed" << std::endl;
  uv_stop(loop);
}

void on_write(uv_write_t* req, int status)
{
    if (status) {
        std::cerr << "uv_write error " << status << std::endl;
        return;
    }
    std::cout << "write done" << std::endl;
    delete(req);
}

void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf)
{
    if (nread < 0) {
        std::cerr << "read error " << uv_strerror(nread) << " (" << uv_err_name(nread) << ")" << std::endl;
        uv_close((uv_handle_t*)tcp, on_close);
    }

    delete(buf->base);
}

void to_write(uv_stream_t* stream, char *data, int len2) {
    uv_buf_t buffer[] = {
        {.base = data, .len = len2}
    };
    uv_write_t *req = new uv_write_t;
    uv_write(req, stream, buffer, 1, on_write);
}

void on_connect(uv_connect_t* connection, int status)
{
    if (status < 0) {
        std::cerr << "failed to connect" << std::endl;
        return uv_stop(loop);
    }
    std::cout << "connected, let's setup keepalive" << std::endl;

    if (uv_tcp_keepalive(&pSock, 1, 2) < 0) {
        std::cerr << "Failed to setup keep-alive" << std::endl;
        return uv_stop(loop);
    }

    if (uv_tcp_nodelay(&pSock, 1) < 0) {
        std::cerr << "Failed to setup tcp no-delay" << std::endl;
        return uv_stop(loop);
    }

    uv_timer_t* timer = (uv_timer_t*)malloc(sizeof(uv_timer_t));
    if (uv_timer_init(loop, timer) < 0) {
        std::cerr << "uv_timer init failed" << std::endl;
        return uv_stop(loop);
    }

    uv_stream_t* stream = connection->handle;
    timer->data = stream;

    uv_read_start(stream, alloc_cb, on_read);

    auto connect_timer_cb = [](uv_timer_t* handle) -> void {
        if (!handle->data) {
            return;
        }

        if (!trigger_bug) {
            std::cout << "skip writting to socket to avoid bug" << std::endl;
            return;
        }
        std::cout << "writing to socket..." << std::endl;
        to_write(reinterpret_cast<uv_stream_t*>(handle->data), "hello", 5);
    };

    if (uv_timer_start(
             timer,
             connect_timer_cb,
             2000,
             2000) < 0) {
        std::cerr << "Failed to start timer" << std::endl;
        return;
    }

}

void startConn(char *host, int port) {
    uv_tcp_init(loop, &pSock);
    struct sockaddr_in dest;
    uv_ip4_addr(host, port, &dest);

    uv_connect_t *pConn = new uv_connect_t;
    uv_tcp_connect(pConn, &pSock, reinterpret_cast<const struct sockaddr*>(&dest), on_connect);
}

int main(int argc, char **argv) {
    loop = uv_default_loop();
    if (argc > 3) {
        trigger_bug = true;
        std::cout << "Triggering bug mode" << std::endl;
    } else {
        std::cout << "Not triggering bug mode" << std::endl;
    }

    startConn(argv[1], atoi(argv[2]));

    uv_run(loop, UV_RUN_DEFAULT);
}

Results:

$ ./tcp_client 45.79.112.203 4242 yes
Triggering bug mode
connected, let's setup keepalive
writing to socket...
write done
writing to socket...                <------------- Internet stoppped 
write done
writing to socket...
write done
writing to socket...
write done
[...]              <------------- Nothing happen for ever

VS

$ ./tcp_client 45.79.112.203 4242    
Not triggering bug mode
connected, let's setup keepalive
skip writting to socket to avoid bug
skip writting to socket to avoid bug      <--------------- Internet stoppped 
skip writting to socket to avoid bug
skip writting to socket to avoid bug
skip writting to socket to avoid bug
skip writting to socket to avoid bug
skip writting to socket to avoid bug
skip writting to socket to avoid bug
read error connection timed out (ETIMEDOUT)
closed.

[bnoordhuis]

Converted to a discussion. Not a bug, that's just how TCP works.

[MouhK]

Ok so there is a problem on Windows since this behavior does not happen.

What's the best practice in this situation ? uv_write does not complain when internet is off and the keep-alive is reset at each write...
Beside having something like a ping/pong I don't see

[bnoordhuis]

Ping/pong a.k.a. heartbeat is basically what you need.

[MouhK]

Ok thank you