sock-test.c

// SPDX-License-Identifier: GPL-2.0

#include <kunit/static_stub.h>
#include <kunit/test.h>

#include <linux/socket.h>
#include <linux/spinlock.h>

#include "utils.h"

static const u8 dev_default_lladdr[] = { 0x01, 0x02 };

/* helper for simple sock setup: single device, with dev_default_lladdr as its
 * hardware address, assigned with a local EID 8, and a route to EID 9
 */
static void __mctp_sock_test_init(struct kunit *test,
				  struct mctp_test_dev **devp,
				  struct mctp_test_route **rtp,
				  struct socket **sockp)
{
	struct mctp_test_route *rt;
	struct mctp_test_dev *dev;
	struct socket *sock;
	unsigned long flags;
	u8 *addrs;
	int rc;

	dev = mctp_test_create_dev_lladdr(sizeof(dev_default_lladdr),
					  dev_default_lladdr);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);

	addrs = kmalloc(1, GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, addrs);
	addrs[0] = 8;

	spin_lock_irqsave(&dev->mdev->addrs_lock, flags);
	dev->mdev->num_addrs = 1;
	swap(addrs, dev->mdev->addrs);
	spin_unlock_irqrestore(&dev->mdev->addrs_lock, flags);

	kfree(addrs);

	rt = mctp_test_create_route_direct(dev_net(dev->ndev), dev->mdev, 9, 0);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);

	rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
	KUNIT_ASSERT_EQ(test, rc, 0);

	*devp = dev;
	*rtp = rt;
	*sockp = sock;
}

static void __mctp_sock_test_fini(struct kunit *test,
				  struct mctp_test_dev *dev,
				  struct mctp_test_route *rt,
				  struct socket *sock)
{
	sock_release(sock);
	mctp_test_route_destroy(test, rt);
	mctp_test_destroy_dev(dev);
}

struct mctp_test_sock_local_output_config {
	struct mctp_test_dev *dev;
	size_t halen;
	u8 haddr[MAX_ADDR_LEN];
	bool invoked;
	int rc;
};

static int mctp_test_sock_local_output(struct sock *sk,
				       struct mctp_dst *dst,
				       struct sk_buff *skb,
				       mctp_eid_t daddr, u8 req_tag)
{
	struct kunit *test = kunit_get_current_test();
	struct mctp_test_sock_local_output_config *cfg = test->priv;

	KUNIT_EXPECT_PTR_EQ(test, dst->dev, cfg->dev->mdev);
	KUNIT_EXPECT_EQ(test, dst->halen, cfg->halen);
	KUNIT_EXPECT_MEMEQ(test, dst->haddr, cfg->haddr, dst->halen);

	cfg->invoked = true;

	kfree_skb(skb);

	return cfg->rc;
}

static void mctp_test_sock_sendmsg_extaddr(struct kunit *test)
{
	struct sockaddr_mctp_ext addr = {
		.smctp_base = {
			.smctp_family = AF_MCTP,
			.smctp_tag = MCTP_TAG_OWNER,
			.smctp_network = MCTP_NET_ANY,
		},
	};
	struct mctp_test_sock_local_output_config cfg = { 0 };
	u8 haddr[] = { 0xaa, 0x01 };
	u8 buf[4] = { 0, 1, 2, 3 };
	struct mctp_test_route *rt;
	struct msghdr msg = { 0 };
	struct mctp_test_dev *dev;
	struct mctp_sock *msk;
	struct socket *sock;
	ssize_t send_len;
	struct kvec vec = {
		.iov_base = buf,
		.iov_len = sizeof(buf),
	};

	__mctp_sock_test_init(test, &dev, &rt, &sock);

	/* Expect to see the dst configured up with the addressing data we
	 * provide in the struct sockaddr_mctp_ext
	 */
	cfg.dev = dev;
	cfg.halen = sizeof(haddr);
	memcpy(cfg.haddr, haddr, sizeof(haddr));

	test->priv = &cfg;

	kunit_activate_static_stub(test, mctp_local_output,
				   mctp_test_sock_local_output);

	/* enable and configure direct addressing */
	msk = container_of(sock->sk, struct mctp_sock, sk);
	msk->addr_ext = true;

	addr.smctp_ifindex = dev->ndev->ifindex;
	addr.smctp_halen = sizeof(haddr);
	memcpy(addr.smctp_haddr, haddr, sizeof(haddr));

	msg.msg_name = &addr;
	msg.msg_namelen = sizeof(addr);

	iov_iter_kvec(&msg.msg_iter, ITER_SOURCE, &vec, 1, sizeof(buf));
	send_len = mctp_sendmsg(sock, &msg, sizeof(buf));
	KUNIT_EXPECT_EQ(test, send_len, sizeof(buf));
	KUNIT_EXPECT_TRUE(test, cfg.invoked);

	__mctp_sock_test_fini(test, dev, rt, sock);
}

static void mctp_test_sock_recvmsg_extaddr(struct kunit *test)
{
	struct sockaddr_mctp_ext recv_addr = { 0 };
	u8 rcv_buf[1], rcv_data[] = { 0, 1 };
	u8 haddr[] = { 0xaa, 0x02 };
	struct mctp_test_route *rt;
	struct mctp_test_dev *dev;
	struct mctp_skb_cb *cb;
	struct mctp_sock *msk;
	struct sk_buff *skb;
	struct mctp_hdr hdr;
	struct socket *sock;
	struct msghdr msg;
	ssize_t recv_len;
	int rc;
	struct kvec vec = {
		.iov_base = rcv_buf,
		.iov_len = sizeof(rcv_buf),
	};

	__mctp_sock_test_init(test, &dev, &rt, &sock);

	/* enable extended addressing on recv */
	msk = container_of(sock->sk, struct mctp_sock, sk);
	msk->addr_ext = true;

	/* base incoming header, using a nul-EID dest */
	hdr.ver = 1;
	hdr.dest = 0;
	hdr.src = 9;
	hdr.flags_seq_tag = MCTP_HDR_FLAG_SOM | MCTP_HDR_FLAG_EOM |
			    MCTP_HDR_FLAG_TO;

	skb = mctp_test_create_skb_data(&hdr, &rcv_data);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);

	mctp_test_skb_set_dev(skb, dev);

	/* set incoming extended address data */
	cb = mctp_cb(skb);
	cb->halen = sizeof(haddr);
	cb->ifindex = dev->ndev->ifindex;
	memcpy(cb->haddr, haddr, sizeof(haddr));

	/* Deliver to socket. The route input path pulls the network header,
	 * leaving skb data at type byte onwards. recvmsg will consume the
	 * type for addr.smctp_type
	 */
	skb_pull(skb, sizeof(hdr));
	rc = sock_queue_rcv_skb(sock->sk, skb);
	KUNIT_ASSERT_EQ(test, rc, 0);

	msg.msg_name = &recv_addr;
	msg.msg_namelen = sizeof(recv_addr);
	iov_iter_kvec(&msg.msg_iter, ITER_DEST, &vec, 1, sizeof(rcv_buf));

	recv_len = mctp_recvmsg(sock, &msg, sizeof(rcv_buf),
				MSG_DONTWAIT | MSG_TRUNC);

	KUNIT_EXPECT_EQ(test, recv_len, sizeof(rcv_buf));

	/* expect our extended address to be populated from hdr and cb */
	KUNIT_EXPECT_EQ(test, msg.msg_namelen, sizeof(recv_addr));
	KUNIT_EXPECT_EQ(test, recv_addr.smctp_base.smctp_family, AF_MCTP);
	KUNIT_EXPECT_EQ(test, recv_addr.smctp_ifindex, dev->ndev->ifindex);
	KUNIT_EXPECT_EQ(test, recv_addr.smctp_halen, sizeof(haddr));
	KUNIT_EXPECT_MEMEQ(test, recv_addr.smctp_haddr, haddr, sizeof(haddr));

	__mctp_sock_test_fini(test, dev, rt, sock);
}

static const struct mctp_test_bind_setup bind_addrany_netdefault_type1 = {
	.bind_addr = MCTP_ADDR_ANY, .bind_net = MCTP_NET_ANY, .bind_type = 1,
};

static const struct mctp_test_bind_setup bind_addrany_net2_type1 = {
	.bind_addr = MCTP_ADDR_ANY, .bind_net = 2, .bind_type = 1,
};

/* 1 is default net */
static const struct mctp_test_bind_setup bind_addr8_net1_type1 = {
	.bind_addr = 8, .bind_net = 1, .bind_type = 1,
};

static const struct mctp_test_bind_setup bind_addrany_net1_type1 = {
	.bind_addr = MCTP_ADDR_ANY, .bind_net = 1, .bind_type = 1,
};

/* 2 is an arbitrary net */
static const struct mctp_test_bind_setup bind_addr8_net2_type1 = {
	.bind_addr = 8, .bind_net = 2, .bind_type = 1,
};

static const struct mctp_test_bind_setup bind_addr8_netdefault_type1 = {
	.bind_addr = 8, .bind_net = MCTP_NET_ANY, .bind_type = 1,
};

static const struct mctp_test_bind_setup bind_addrany_net2_type2 = {
	.bind_addr = MCTP_ADDR_ANY, .bind_net = 2, .bind_type = 2,
};

static const struct mctp_test_bind_setup bind_addrany_net2_type1_peer9 = {
	.bind_addr = MCTP_ADDR_ANY, .bind_net = 2, .bind_type = 1,
	.have_peer = true, .peer_addr = 9, .peer_net = 2,
};

struct mctp_bind_pair_test {
	const struct mctp_test_bind_setup *bind1;
	const struct mctp_test_bind_setup *bind2;
	int error;
};

/* Pairs of binds and whether they will conflict */
static const struct mctp_bind_pair_test mctp_bind_pair_tests[] = {
	/* Both ADDR_ANY, conflict */
	{ &bind_addrany_netdefault_type1, &bind_addrany_netdefault_type1,
	  EADDRINUSE },
	/* Same specific EID, conflict */
	{ &bind_addr8_netdefault_type1, &bind_addr8_netdefault_type1,
	  EADDRINUSE },
	/* ADDR_ANY vs specific EID, OK */
	{ &bind_addrany_netdefault_type1, &bind_addr8_netdefault_type1, 0 },
	/* ADDR_ANY different types, OK */
	{ &bind_addrany_net2_type2, &bind_addrany_net2_type1, 0 },
	/* ADDR_ANY different nets, OK */
	{ &bind_addrany_net2_type1, &bind_addrany_netdefault_type1, 0 },

	/* specific EID, NET_ANY (resolves to default)
	 *  vs specific EID, explicit default net 1, conflict
	 */
	{ &bind_addr8_netdefault_type1, &bind_addr8_net1_type1, EADDRINUSE },

	/* specific EID, net 1 vs specific EID, net 2, ok */
	{ &bind_addr8_net1_type1, &bind_addr8_net2_type1, 0 },

	/* ANY_ADDR, NET_ANY (doesn't resolve to default)
	 *  vs ADDR_ANY, explicit default net 1, OK
	 */
	{ &bind_addrany_netdefault_type1, &bind_addrany_net1_type1, 0 },

	/* specific remote peer doesn't conflict with any-peer bind */
	{ &bind_addrany_net2_type1_peer9, &bind_addrany_net2_type1, 0 },

	/* bind() NET_ANY is allowed with a connect() net */
	{ &bind_addrany_net2_type1_peer9, &bind_addrany_netdefault_type1, 0 },
};

static void mctp_bind_pair_desc(const struct mctp_bind_pair_test *t, char *desc)
{
	char peer1[25] = {0}, peer2[25] = {0};

	if (t->bind1->have_peer)
		snprintf(peer1, sizeof(peer1), ", peer %d net %d",
			 t->bind1->peer_addr, t->bind1->peer_net);
	if (t->bind2->have_peer)
		snprintf(peer2, sizeof(peer2), ", peer %d net %d",
			 t->bind2->peer_addr, t->bind2->peer_net);

	snprintf(desc, KUNIT_PARAM_DESC_SIZE,
		 "{bind(addr %d, type %d, net %d%s)} {bind(addr %d, type %d, net %d%s)} -> error %d",
		 t->bind1->bind_addr, t->bind1->bind_type,
		 t->bind1->bind_net, peer1,
		 t->bind2->bind_addr, t->bind2->bind_type,
		 t->bind2->bind_net, peer2, t->error);
}

KUNIT_ARRAY_PARAM(mctp_bind_pair, mctp_bind_pair_tests, mctp_bind_pair_desc);

static void mctp_test_bind_invalid(struct kunit *test)
{
	struct socket *sock;
	int rc;

	/* bind() fails if the bind() vs connect() networks mismatch. */
	const struct mctp_test_bind_setup bind_connect_net_mismatch = {
		.bind_addr = MCTP_ADDR_ANY, .bind_net = 1, .bind_type = 1,
		.have_peer = true, .peer_addr = 9, .peer_net = 2,
	};
	mctp_test_bind_run(test, &bind_connect_net_mismatch, &rc, &sock);
	KUNIT_EXPECT_EQ(test, -rc, EINVAL);
	sock_release(sock);
}

static int
mctp_test_bind_conflicts_inner(struct kunit *test,
			       const struct mctp_test_bind_setup *bind1,
			       const struct mctp_test_bind_setup *bind2)
{
	struct socket *sock1 = NULL, *sock2 = NULL, *sock3 = NULL;
	int bind_errno;

	/* Bind to first address, always succeeds */
	mctp_test_bind_run(test, bind1, &bind_errno, &sock1);
	KUNIT_EXPECT_EQ(test, bind_errno, 0);

	/* A second identical bind always fails */
	mctp_test_bind_run(test, bind1, &bind_errno, &sock2);
	KUNIT_EXPECT_EQ(test, -bind_errno, EADDRINUSE);

	/* A different bind, result is returned */
	mctp_test_bind_run(test, bind2, &bind_errno, &sock3);

	if (sock1)
		sock_release(sock1);
	if (sock2)
		sock_release(sock2);
	if (sock3)
		sock_release(sock3);

	return bind_errno;
}

static void mctp_test_bind_conflicts(struct kunit *test)
{
	const struct mctp_bind_pair_test *pair;
	int bind_errno;

	pair = test->param_value;

	bind_errno =
		mctp_test_bind_conflicts_inner(test, pair->bind1, pair->bind2);
	KUNIT_EXPECT_EQ(test, -bind_errno, pair->error);

	/* swapping the calls, the second bind should still fail */
	bind_errno =
		mctp_test_bind_conflicts_inner(test, pair->bind2, pair->bind1);
	KUNIT_EXPECT_EQ(test, -bind_errno, pair->error);
}

static void mctp_test_assumptions(struct kunit *test)
{
	/* check assumption of default net from bind_addr8_net1_type1 */
	KUNIT_ASSERT_EQ(test, mctp_default_net(&init_net), 1);
}

static struct kunit_case mctp_test_cases[] = {
	KUNIT_CASE(mctp_test_assumptions),
	KUNIT_CASE(mctp_test_sock_sendmsg_extaddr),
	KUNIT_CASE(mctp_test_sock_recvmsg_extaddr),
	KUNIT_CASE_PARAM(mctp_test_bind_conflicts, mctp_bind_pair_gen_params),
	KUNIT_CASE(mctp_test_bind_invalid),
	{}
};

static struct kunit_suite mctp_test_suite = {
	.name = "mctp-sock",
	.test_cases = mctp_test_cases,
};

kunit_test_suite(mctp_test_suite);