Re: [PATCH] selftests/unix: Add test for ECONNRESET and EOF behaviour

Thanks for adding tests.

[PATCH] selftests/unix: Add test for ECONNRESET and EOF behaviour

nit: The common prefix is "selftest: af_unix:".


On Thu, Oct 23, 2025 at 9:59 AM Sunday Adelodun
[off-list ref] wrote:

Add selftests verifying the EOF and ECONNRESET behaviour of
UNIX domain sockets (SOCK_STREAM and SOCK_DGRAM). The tests document
Linux's semantics and clarify the long-standing differences with BSD.

Suggested-by: Kuniyuki Iwashima <kuniyu@google.com>
Signed-off-by: Sunday Adelodun <redacted>
---
 tools/testing/selftests/net/unix/Makefile     |   5 +
 .../selftests/net/unix/test_unix_connreset.c  | 147 ++++++++++++++++++
 2 files changed, 152 insertions(+)
 create mode 100644 tools/testing/selftests/net/unix/Makefile
 create mode 100644 tools/testing/selftests/net/unix/test_unix_connreset.c

The test for af_unix is placed under tools/testing/selftests/net/af_unix.

nit: s/UNIX/AF_UNIX/

+ *
+ * This test verifies that:
+ *  1. SOCK_STREAM sockets return EOF when peer closes normally.
+ *  2. SOCK_STREAM sockets return ECONNRESET if peer closes with unread data.
+ *  3. SOCK_DGRAM sockets do not return ECONNRESET when peer closes,
+ *     unlike BSD where this error is observed.
+ *
+ * These tests document the intended Linux behaviour, distinguishing it from BSD.

I'd not mention BSD as it could be outdated again.

+ *
+ */
+
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include "../../kselftest_harness.h"
+
+#define SOCK_PATH "/tmp/test_unix_connreset.sock"
+
+static void remove_socket_file(void)
+{
+       unlink(SOCK_PATH);
+}
+
+/* Test 1: peer closes normally */
+TEST(stream_eof)

I think most of the code can be shared by defining
FIXTURE_VARIANT().

e.g. variant->unread_data can consolidate Test 1&2.

+{
+       int server, client, child;
+       struct sockaddr_un addr = {0};
+       char buf[16] = {0};

IIRC, {0} only initialises the first entry and we had a problem
in kernel code, so simply use "= {};" everywhere.

+       ssize_t n;
+
+       server = socket(AF_UNIX, SOCK_STREAM, 0);

Try using variant->type for SOCK_STREAM,
SOCK_DGRAM, and SOCK_SEQPACKET.

See unix_connect.c, or you could reuse the fixtures
of err == 0 there.

+       ASSERT_GE(server, 0);

nit: The 1st arg is "expected", and the 2nd is "seen",
so ASSERT_NE(-1, server) (or ASSERT_LT(-1, server)).

Same for other places.

+
+       addr.sun_family = AF_UNIX;
+       strcpy(addr.sun_path, SOCK_PATH);
+       remove_socket_file();
+
+       ASSERT_EQ(bind(server, (struct sockaddr *)&addr, sizeof(addr)), 0);

I personally feel easy to read this style:

err = bind();
ASSERT_EQ(0, err);

+       ASSERT_EQ(listen(server, 1), 0);
+
+       client = socket(AF_UNIX, SOCK_STREAM, 0);
+       ASSERT_GE(client, 0);
+       ASSERT_EQ(connect(client, (struct sockaddr *)&addr, sizeof(addr)), 0);
+
+       child = accept(server, NULL, NULL);
+       ASSERT_GE(child, 0);
+
+       /* Peer closes normally */
+       close(child);
+
+       n = recv(client, buf, sizeof(buf), 0);
+       EXPECT_EQ(n, 0);
+       TH_LOG("recv=%zd errno=%d (%s)", n, errno, strerror(errno));

I printed errno just for visibility, and you can simply use
ASSERT here too like

if (n == -1)
    ASSERT_EQ(ECONNRESET, errno)

(I'm assuming Test 1 & 2 will share most code)

+
+       close(client);
+       close(server);
+       remove_socket_file();

This will not be executed if the program fails at ASSERT_XX(),
so move it to FIXTURE_TEARDOWN().

+}
+
+/* Test 2: peer closes with unread data */
+TEST(stream_reset_unread)
+{
+       int server, client, child;
+       struct sockaddr_un addr = {0};
+       char buf[16] = {0};
+       ssize_t n;
+
+       server = socket(AF_UNIX, SOCK_STREAM, 0);
+       ASSERT_GE(server, 0);
+
+       addr.sun_family = AF_UNIX;
+       strcpy(addr.sun_path, SOCK_PATH);
+       remove_socket_file();
+
+       ASSERT_EQ(bind(server, (struct sockaddr *)&addr, sizeof(addr)), 0);
+       ASSERT_EQ(listen(server, 1), 0);
+
+       client = socket(AF_UNIX, SOCK_STREAM, 0);
+       ASSERT_GE(client, 0);
+       ASSERT_EQ(connect(client, (struct sockaddr *)&addr, sizeof(addr)), 0);
+
+       child = accept(server, NULL, NULL);
+       ASSERT_GE(child, 0);
+
+       /* Send data that will remain unread by client */
+       send(client, "hello", 5, 0);
+       close(child);
+
+       n = recv(client, buf, sizeof(buf), 0);
+       EXPECT_LT(n, 0);
+       EXPECT_EQ(errno, ECONNRESET);
+       TH_LOG("recv=%zd errno=%d (%s)", n, errno, strerror(errno));
+
+       close(client);
+       close(server);
+       remove_socket_file();
+}
+
+/* Test 3: SOCK_DGRAM peer close */
+TEST(dgram_reset)
+{
+       int server, client;
+       int flags;
+       struct sockaddr_un addr = {0};
+       char buf[16] = {0};
+       ssize_t n;
+
+       server = socket(AF_UNIX, SOCK_DGRAM, 0);
+       ASSERT_GE(server, 0);
+
+       addr.sun_family = AF_UNIX;
+       strcpy(addr.sun_path, SOCK_PATH);
+       remove_socket_file();
+
+       ASSERT_EQ(bind(server, (struct sockaddr *)&addr, sizeof(addr)), 0);
+
+       client = socket(AF_UNIX, SOCK_DGRAM, 0);
+       ASSERT_GE(client, 0);
+       ASSERT_EQ(connect(client, (struct sockaddr *)&addr, sizeof(addr)), 0);
+
+       send(client, "hello", 5, 0);
+       close(server);
+
+       flags = fcntl(client, F_GETFL, 0);
+       fcntl(client, F_SETFL, flags | O_NONBLOCK);

You can save fcntl() with socket(..., ... | SOCK_NONBLOCK, ...).

+
+       n = recv(client, buf, sizeof(buf), 0);
+       TH_LOG("recv=%zd errno=%d (%s)", n, errno, strerror(errno));
+       /* Expect EAGAIN or EWOULDBLOCK because there is no datagram and peer is closed. */
+       EXPECT_LT(n, 0);
+       EXPECT_TRUE(errno == EAGAIN);
+
+       close(client);
+       remove_socket_file();
+}
+
+TEST_HARNESS_MAIN
+
--
2.43.0