tools/testing/selftests/net/af_unix/scm_rights.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright Amazon.com Inc. or its affiliates. */
#define _GNU_SOURCE
#include <sched.h>

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#include "../../kselftest_harness.h"

FIXTURE(scm_rights)
{
	int fd[32];
};

FIXTURE_VARIANT(scm_rights)
{
	char name[32];
	int type;
	int flags;
	bool test_listener;
};

FIXTURE_VARIANT_ADD(scm_rights, dgram)
{
	.name = "UNIX ",
	.type = SOCK_DGRAM,
	.flags = 0,
	.test_listener = false,
};

FIXTURE_VARIANT_ADD(scm_rights, stream)
{
	.name = "UNIX-STREAM ",
	.type = SOCK_STREAM,
	.flags = 0,
	.test_listener = false,
};

FIXTURE_VARIANT_ADD(scm_rights, stream_oob)
{
	.name = "UNIX-STREAM ",
	.type = SOCK_STREAM,
	.flags = MSG_OOB,
	.test_listener = false,
};

FIXTURE_VARIANT_ADD(scm_rights, stream_listener)
{
	.name = "UNIX-STREAM ",
	.type = SOCK_STREAM,
	.flags = 0,
	.test_listener = true,
};

FIXTURE_VARIANT_ADD(scm_rights, stream_listener_oob)
{
	.name = "UNIX-STREAM ",
	.type = SOCK_STREAM,
	.flags = MSG_OOB,
	.test_listener = true,
};

static int count_sockets(struct __test_metadata *_metadata,
			 const FIXTURE_VARIANT(scm_rights) *variant)
{
	int sockets = -1, len, ret;
	char *line = NULL;
	size_t unused;
	FILE *f;

	f = fopen("/proc/net/protocols", "r");
	ASSERT_NE(NULL, f);

	len = strlen(variant->name);

	while (getline(&line, &unused, f) != -1) {
		int unused2;

		if (strncmp(line, variant->name, len))
			continue;

		ret = sscanf(line + len, "%d %d", &unused2, &sockets);
		ASSERT_EQ(2, ret);

		break;
	}

	free(line);

	ret = fclose(f);
	ASSERT_EQ(0, ret);

	return sockets;
}

FIXTURE_SETUP(scm_rights)
{
	int ret;

	ret = unshare(CLONE_NEWNET);
	ASSERT_EQ(0, ret);

	ret = count_sockets(_metadata, variant);
	ASSERT_EQ(0, ret);
}

FIXTURE_TEARDOWN(scm_rights)
{
	int ret;

	sleep(1);

	ret = count_sockets(_metadata, variant);
	ASSERT_EQ(0, ret);
}

static void create_listeners(struct __test_metadata *_metadata,
			     FIXTURE_DATA(scm_rights) *self,
			     int n)
{
	struct sockaddr_un addr = {
		.sun_family = AF_UNIX,
	};
	socklen_t addrlen;
	int i, ret;

	for (i = 0; i < n * 2; i += 2) {
		self->fd[i] = socket(AF_UNIX, SOCK_STREAM, 0);
		ASSERT_LE(0, self->fd[i]);

		addrlen = sizeof(addr.sun_family);
		ret = bind(self->fd[i], (struct sockaddr *)&addr, addrlen);
		ASSERT_EQ(0, ret);

		ret = listen(self->fd[i], -1);
		ASSERT_EQ(0, ret);

		addrlen = sizeof(addr);
		ret = getsockname(self->fd[i], (struct sockaddr *)&addr, &addrlen);
		ASSERT_EQ(0, ret);

		self->fd[i + 1] = socket(AF_UNIX, SOCK_STREAM, 0);
		ASSERT_LE(0, self->fd[i + 1]);

		ret = connect(self->fd[i + 1], (struct sockaddr *)&addr, addrlen);
		ASSERT_EQ(0, ret);
	}
}

static void create_socketpairs(struct __test_metadata *_metadata,
			       FIXTURE_DATA(scm_rights) *self,
			       const FIXTURE_VARIANT(scm_rights) *variant,
			       int n)
{
	int i, ret;

	ASSERT_GE(sizeof(self->fd) / sizeof(int), n);

	for (i = 0; i < n * 2; i += 2) {
		ret = socketpair(AF_UNIX, variant->type, 0, self->fd + i);
		ASSERT_EQ(0, ret);
	}
}

static void __create_sockets(struct __test_metadata *_metadata,
			     FIXTURE_DATA(scm_rights) *self,
			     const FIXTURE_VARIANT(scm_rights) *variant,
			     int n)
{
	ASSERT_LE(n * 2, sizeof(self->fd) / sizeof(self->fd[0]));

	if (variant->test_listener)
		create_listeners(_metadata, self, n);
	else
		create_socketpairs(_metadata, self, variant, n);
}

static void __close_sockets(struct __test_metadata *_metadata,
			    FIXTURE_DATA(scm_rights) *self,
			    int n)
{
	int i, ret;

	ASSERT_GE(sizeof(self->fd) / sizeof(int), n);

	for (i = 0; i < n * 2; i++) {
		ret = close(self->fd[i]);
		ASSERT_EQ(0, ret);
	}
}

void __send_fd(struct __test_metadata *_metadata,
	       const FIXTURE_DATA(scm_rights) *self,
	       const FIXTURE_VARIANT(scm_rights) *variant,
	       int inflight, int receiver)
{
#define MSG "x"
#define MSGLEN 1
	struct {
		struct cmsghdr cmsghdr;
		int fd[2];
	} cmsg = {
		.cmsghdr = {
			.cmsg_len = CMSG_LEN(sizeof(cmsg.fd)),
			.cmsg_level = SOL_SOCKET,
			.cmsg_type = SCM_RIGHTS,
		},
		.fd = {
			self->fd[inflight * 2],
			self->fd[inflight * 2],
		},
	};
	struct iovec iov = {
		.iov_base = MSG,
		.iov_len = MSGLEN,
	};
	struct msghdr msg = {
		.msg_name = NULL,
		.msg_namelen = 0,
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_control = &cmsg,
		.msg_controllen = CMSG_SPACE(sizeof(cmsg.fd)),
	};
	int ret;

	ret = sendmsg(self->fd[receiver * 2 + 1], &msg, variant->flags);
	ASSERT_EQ(MSGLEN, ret);
}

#define create_sockets(n)					\
	__create_sockets(_metadata, self, variant, n)
#define close_sockets(n)					\
	__close_sockets(_metadata, self, n)
#define send_fd(inflight, receiver)				\
	__send_fd(_metadata, self, variant, inflight, receiver)

TEST_F(scm_rights, self_ref)
{
	create_sockets(2);

	send_fd(0, 0);

	send_fd(1, 1);

	close_sockets(2);
}

TEST_F(scm_rights, triangle)
{
	create_sockets(6);

	send_fd(0, 1);
	send_fd(1, 2);
	send_fd(2, 0);

	send_fd(3, 4);
	send_fd(4, 5);
	send_fd(5, 3);

	close_sockets(6);
}

TEST_F(scm_rights, cross_edge)
{
	create_sockets(8);

	send_fd(0, 1);
	send_fd(1, 2);
	send_fd(2, 0);
	send_fd(1, 3);
	send_fd(3, 2);

	send_fd(4, 5);
	send_fd(5, 6);
	send_fd(6, 4);
	send_fd(5, 7);
	send_fd(7, 6);

	close_sockets(8);
}

TEST_F(scm_rights, backtrack_from_scc)
{
	create_sockets(10);

	send_fd(0, 1);
	send_fd(0, 4);
	send_fd(1, 2);
	send_fd(2, 3);
	send_fd(3, 1);

	send_fd(5, 6);
	send_fd(5, 9);
	send_fd(6, 7);
	send_fd(7, 8);
	send_fd(8, 6);

	close_sockets(10);
}

TEST_HARNESS_MAIN