// SPDX-License-Identifier: GPL-2.0 OR MIT
#define _GNU_SOURCE
#include <error.h>
#include <limits.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <linux/socket.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <sys/un.h>
#include <sys/signal.h>
#include <sys/types.h>
#include <sys/wait.h>

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

#define clean_errno() (errno == 0 ? "None" : strerror(errno))
#define log_err(MSG, ...)                                                   \
	fprintf(stderr, "(%s:%d: errno: %s) " MSG "\n", __FILE__, __LINE__, \
		clean_errno(), ##__VA_ARGS__)

#ifndef SCM_PIDFD
#define SCM_PIDFD 0x04
#endif

#ifndef SCM_PIDFD_THREAD
#define SCM_PIDFD_THREAD 0x05
#endif

#ifndef SO_PASSPIDFD_THREAD
#define SO_PASSPIDFD_THREAD 86
#endif

#ifndef SO_PEERPIDFD_THREAD
#define SO_PEERPIDFD_THREAD 87
#endif

#define CHILD_EXIT_CODE_OK 123

static void child_die()
{
	exit(1);
}

static int safe_int(const char *numstr, int *converted)
{
	char *err = NULL;
	long sli;

	errno = 0;
	sli = strtol(numstr, &err, 0);
	if (errno == ERANGE && (sli == LONG_MAX || sli == LONG_MIN))
		return -ERANGE;

	if (errno != 0 && sli == 0)
		return -EINVAL;

	if (err == numstr || *err != '\0')
		return -EINVAL;

	if (sli > INT_MAX || sli < INT_MIN)
		return -ERANGE;

	*converted = (int)sli;
	return 0;
}

static int char_left_gc(const char *buffer, size_t len)
{
	size_t i;

	for (i = 0; i < len; i++) {
		if (buffer[i] == ' ' || buffer[i] == '\t')
			continue;

		return i;
	}

	return 0;
}

static int char_right_gc(const char *buffer, size_t len)
{
	int i;

	for (i = len - 1; i >= 0; i--) {
		if (buffer[i] == ' ' || buffer[i] == '\t' ||
		    buffer[i] == '\n' || buffer[i] == '\0')
			continue;

		return i + 1;
	}

	return 0;
}

static char *trim_whitespace_in_place(char *buffer)
{
	buffer += char_left_gc(buffer, strlen(buffer));
	buffer[char_right_gc(buffer, strlen(buffer))] = '\0';
	return buffer;
}

/* borrowed (with all helpers) from pidfd/pidfd_open_test.c */
static pid_t get_pid_from_fdinfo_file(int pidfd, const char *key, size_t keylen)
{
	int ret;
	char path[512];
	FILE *f;
	size_t n = 0;
	pid_t result = -1;
	char *line = NULL;

	snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", pidfd);

	f = fopen(path, "re");
	if (!f)
		return -1;

	while (getline(&line, &n, f) != -1) {
		char *numstr;

		if (strncmp(line, key, keylen))
			continue;

		numstr = trim_whitespace_in_place(line + 4);
		ret = safe_int(numstr, &result);
		if (ret < 0)
			goto out;

		break;
	}

out:
	free(line);
	fclose(f);
	return result;
}

struct cmsg_data {
	struct ucred *ucred;
	int *pidfd;
};

static int parse_cmsg(struct msghdr *msg, struct cmsg_data *res)
{
	struct cmsghdr *cmsg;

	if (msg->msg_flags & (MSG_TRUNC | MSG_CTRUNC)) {
		log_err("recvmsg: truncated");
		return 1;
	}

	for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL;
	     cmsg = CMSG_NXTHDR(msg, cmsg)) {
		if (cmsg->cmsg_level == SOL_SOCKET &&
		    cmsg->cmsg_type == SCM_PIDFD) {
			if (cmsg->cmsg_len < sizeof(*res->pidfd)) {
				log_err("CMSG parse: SCM_PIDFD wrong len");
				return 1;
			}

			res->pidfd = (void *)CMSG_DATA(cmsg);
		}

		if (cmsg->cmsg_level == SOL_SOCKET &&
		    cmsg->cmsg_type == SCM_CREDENTIALS) {
			if (cmsg->cmsg_len < sizeof(*res->ucred)) {
				log_err("CMSG parse: SCM_CREDENTIALS wrong len");
				return 1;
			}

			res->ucred = (void *)CMSG_DATA(cmsg);
		}
	}

	if (!res->pidfd) {
		log_err("CMSG parse: SCM_PIDFD not found");
		return 1;
	}

	if (!res->ucred) {
		log_err("CMSG parse: SCM_CREDENTIALS not found");
		return 1;
	}

	return 0;
}

static int cmsg_check(int fd)
{
	struct msghdr msg = { 0 };
	struct cmsg_data res;
	struct iovec iov;
	int data = 0;
	char control[CMSG_SPACE(sizeof(struct ucred)) +
		     CMSG_SPACE(sizeof(int))] = { 0 };
	pid_t parent_pid;
	int err;

	iov.iov_base = &data;
	iov.iov_len = sizeof(data);

	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = control;
	msg.msg_controllen = sizeof(control);

	err = recvmsg(fd, &msg, 0);
	if (err < 0) {
		log_err("recvmsg");
		return 1;
	}

	if (msg.msg_flags & (MSG_TRUNC | MSG_CTRUNC)) {
		log_err("recvmsg: truncated");
		return 1;
	}

	/* send(pfd, "x", sizeof(char), 0) */
	if (data != 'x') {
		log_err("recvmsg: data corruption");
		return 1;
	}

	if (parse_cmsg(&msg, &res)) {
		log_err("CMSG parse: parse_cmsg() failed");
		return 1;
	}

	/* pidfd from SCM_PIDFD should point to the parent process PID */
	parent_pid =
		get_pid_from_fdinfo_file(*res.pidfd, "Pid:", sizeof("Pid:") - 1);
	if (parent_pid != getppid()) {
		log_err("wrong SCM_PIDFD %d != %d", parent_pid, getppid());
		close(*res.pidfd);
		return 1;
	}

	close(*res.pidfd);
	return 0;
}

static int cmsg_check_dead(int fd, int expected_pid)
{
	int err;
	struct msghdr msg = { 0 };
	struct cmsg_data res;
	struct iovec iov;
	int data = 0;
	char control[CMSG_SPACE(sizeof(struct ucred)) +
		     CMSG_SPACE(sizeof(int))] = { 0 };
	struct pidfd_info info = {
		.mask = PIDFD_INFO_EXIT,
	};

	iov.iov_base = &data;
	iov.iov_len = sizeof(data);

	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = control;
	msg.msg_controllen = sizeof(control);

	err = recvmsg(fd, &msg, 0);
	if (err < 0) {
		log_err("recvmsg");
		return 1;
	}

	if (msg.msg_flags & (MSG_TRUNC | MSG_CTRUNC)) {
		log_err("recvmsg: truncated");
		return 1;
	}

	/* send(cfd, "y", sizeof(char), 0) */
	if (data != 'y') {
		log_err("recvmsg: data corruption");
		return 1;
	}

	if (parse_cmsg(&msg, &res)) {
		log_err("CMSG parse: parse_cmsg() failed");
		return 1;
	}

	/*
	 * pidfd from SCM_PIDFD should point to the client_pid.
	 * Let's read exit information and check if it's what
	 * we expect to see.
	 */
	if (ioctl(*res.pidfd, PIDFD_GET_INFO, &info)) {
		log_err("%s: ioctl(PIDFD_GET_INFO) failed", __func__);
		close(*res.pidfd);
		return 1;
	}

	if (!(info.mask & PIDFD_INFO_EXIT)) {
		log_err("%s: No exit information from ioctl(PIDFD_GET_INFO)", __func__);
		close(*res.pidfd);
		return 1;
	}

	err = WIFEXITED(info.exit_code) ? WEXITSTATUS(info.exit_code) : 1;
	if (err != CHILD_EXIT_CODE_OK) {
		log_err("%s: wrong exit_code %d != %d", __func__, err, CHILD_EXIT_CODE_OK);
		close(*res.pidfd);
		return 1;
	}

	close(*res.pidfd);
	return 0;
}

struct sock_addr {
	char sock_name[32];
	struct sockaddr_un listen_addr;
	socklen_t addrlen;
};

FIXTURE(scm_pidfd)
{
	int server;
	pid_t client_pid;
	int startup_pipe[2];
	struct sock_addr server_addr;
	struct sock_addr *client_addr;
};

FIXTURE_VARIANT(scm_pidfd)
{
	int type;
	bool abstract;
};

FIXTURE_VARIANT_ADD(scm_pidfd, stream_pathname)
{
	.type = SOCK_STREAM,
	.abstract = 0,
};

FIXTURE_VARIANT_ADD(scm_pidfd, stream_abstract)
{
	.type = SOCK_STREAM,
	.abstract = 1,
};

FIXTURE_VARIANT_ADD(scm_pidfd, dgram_pathname)
{
	.type = SOCK_DGRAM,
	.abstract = 0,
};

FIXTURE_VARIANT_ADD(scm_pidfd, dgram_abstract)
{
	.type = SOCK_DGRAM,
	.abstract = 1,
};

FIXTURE_SETUP(scm_pidfd)
{
	self->client_addr = mmap(NULL, sizeof(*self->client_addr), PROT_READ | PROT_WRITE,
				 MAP_SHARED | MAP_ANONYMOUS, -1, 0);
	ASSERT_NE(MAP_FAILED, self->client_addr);
}

FIXTURE_TEARDOWN(scm_pidfd)
{
	close(self->server);

	kill(self->client_pid, SIGKILL);
	waitpid(self->client_pid, NULL, 0);

	if (!variant->abstract) {
		unlink(self->server_addr.sock_name);
		unlink(self->client_addr->sock_name);
	}
}

static void fill_sockaddr(struct sock_addr *addr, bool abstract)
{
	char *sun_path_buf = (char *)&addr->listen_addr.sun_path;

	addr->listen_addr.sun_family = AF_UNIX;
	addr->addrlen = offsetof(struct sockaddr_un, sun_path);
	snprintf(addr->sock_name, sizeof(addr->sock_name), "scm_pidfd_%d", getpid());
	addr->addrlen += strlen(addr->sock_name);
	if (abstract) {
		*sun_path_buf = '\0';
		addr->addrlen++;
		sun_path_buf++;
	} else {
		unlink(addr->sock_name);
	}
	memcpy(sun_path_buf, addr->sock_name, strlen(addr->sock_name));
}

static int sk_enable_cred_pass(int sk)
{
	int on = 0;

	on = 1;
	if (setsockopt(sk, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
		log_err("Failed to set SO_PASSCRED");
		return 1;
	}

	if (setsockopt(sk, SOL_SOCKET, SO_PASSPIDFD, &on, sizeof(on))) {
		log_err("Failed to set SO_PASSPIDFD");
		return 1;
	}

	return 0;
}

static void client(FIXTURE_DATA(scm_pidfd) *self,
		   const FIXTURE_VARIANT(scm_pidfd) *variant)
{
	int cfd;
	socklen_t len;
	struct ucred peer_cred;
	int peer_pidfd;
	pid_t peer_pid;

	cfd = socket(AF_UNIX, variant->type, 0);
	if (cfd < 0) {
		log_err("socket");
		child_die();
	}

	if (variant->type == SOCK_DGRAM) {
		fill_sockaddr(self->client_addr, variant->abstract);

		if (bind(cfd, (struct sockaddr *)&self->client_addr->listen_addr, self->client_addr->addrlen)) {
			log_err("bind");
			child_die();
		}
	}

	if (connect(cfd, (struct sockaddr *)&self->server_addr.listen_addr,
		    self->server_addr.addrlen) != 0) {
		log_err("connect");
		child_die();
	}

	if (sk_enable_cred_pass(cfd)) {
		log_err("sk_enable_cred_pass() failed");
		child_die();
	}

	close(self->startup_pipe[1]);

	if (cmsg_check(cfd)) {
		log_err("cmsg_check failed");
		child_die();
	}

	/* send something to the parent so it can receive SCM_PIDFD too and validate it */
	if (send(cfd, "y", sizeof(char), 0) == -1) {
		log_err("Failed to send(cfd, \"y\", sizeof(char), 0)");
		child_die();
	}

	/* skip further for SOCK_DGRAM as it's not applicable */
	if (variant->type == SOCK_DGRAM)
		return;

	len = sizeof(peer_cred);
	if (getsockopt(cfd, SOL_SOCKET, SO_PEERCRED, &peer_cred, &len)) {
		log_err("Failed to get SO_PEERCRED");
		child_die();
	}

	len = sizeof(peer_pidfd);
	if (getsockopt(cfd, SOL_SOCKET, SO_PEERPIDFD, &peer_pidfd, &len)) {
		log_err("Failed to get SO_PEERPIDFD");
		child_die();
	}

	/* pid from SO_PEERCRED should point to the parent process PID */
	if (peer_cred.pid != getppid()) {
		log_err("peer_cred.pid != getppid(): %d != %d", peer_cred.pid, getppid());
		child_die();
	}

	peer_pid = get_pid_from_fdinfo_file(peer_pidfd,
					    "Pid:", sizeof("Pid:") - 1);
	if (peer_pid != peer_cred.pid) {
		log_err("peer_pid != peer_cred.pid: %d != %d", peer_pid, peer_cred.pid);
		child_die();
	}
}

TEST_F(scm_pidfd, test)
{
	int err;
	int pfd;
	int child_status = 0;

	self->server = socket(AF_UNIX, variant->type, 0);
	ASSERT_NE(-1, self->server);

	fill_sockaddr(&self->server_addr, variant->abstract);

	err = bind(self->server, (struct sockaddr *)&self->server_addr.listen_addr, self->server_addr.addrlen);
	ASSERT_EQ(0, err);

	if (variant->type == SOCK_STREAM) {
		err = listen(self->server, 1);
		ASSERT_EQ(0, err);
	}

	err = pipe(self->startup_pipe);
	ASSERT_NE(-1, err);

	self->client_pid = fork();
	ASSERT_NE(-1, self->client_pid);
	if (self->client_pid == 0) {
		close(self->server);
		close(self->startup_pipe[0]);
		client(self, variant);

		/*
		 * It's a bit unusual, but in case of success we return non-zero
		 * exit code (CHILD_EXIT_CODE_OK) and then we expect to read it
		 * from ioctl(PIDFD_GET_INFO) in cmsg_check_dead().
		 */
		exit(CHILD_EXIT_CODE_OK);
	}
	close(self->startup_pipe[1]);

	if (variant->type == SOCK_STREAM) {
		pfd = accept(self->server, NULL, NULL);
		ASSERT_NE(-1, pfd);
	} else {
		pfd = self->server;
	}

	/* wait until the child arrives at checkpoint */
	read(self->startup_pipe[0], &err, sizeof(int));
	close(self->startup_pipe[0]);

	if (variant->type == SOCK_DGRAM) {
		err = sendto(pfd, "x", sizeof(char), 0, (struct sockaddr *)&self->client_addr->listen_addr, self->client_addr->addrlen);
		ASSERT_NE(-1, err);
	} else {
		err = send(pfd, "x", sizeof(char), 0);
		ASSERT_NE(-1, err);
	}

	waitpid(self->client_pid, &child_status, 0);
	/* see comment before exit(CHILD_EXIT_CODE_OK) */
	ASSERT_EQ(CHILD_EXIT_CODE_OK, WIFEXITED(child_status) ? WEXITSTATUS(child_status) : 1);

	err = sk_enable_cred_pass(pfd);
	ASSERT_EQ(0, err);

	err = cmsg_check_dead(pfd, self->client_pid);
	ASSERT_EQ(0, err);

	close(pfd);
}

struct thread_ids {
	pid_t pid;
	pid_t tid;
};

#define MAX_WRITERS 2

/* Used by writers to signal they've written, so we can sequence multiple writers */
static int seq_pipe[2];

static void *send_ids_thread(void *arg)
{
	int fd = *(int *)arg;
	struct thread_ids ids = {
		.pid = getpid(),
		.tid = gettid(),
	};
	char sync;

	if (send(fd, &ids, sizeof(ids), 0) != sizeof(ids))
		return (void *)1;

	/* let the client start the next writer, so the queue order is known */
	if (write(seq_pipe[1], "1", 1) != 1)
		return (void *)1;

	/* stay alive until the receiver has looked at our pidfd */
	if (read(fd, &sync, 1) != 1)
		return (void *)1;

	return NULL;
}

static void *send_ids_creds_thread(void *arg)
{
	int fd = *(int *)arg;
	struct thread_ids ids = {
		.pid = getpid(),
		.tid = gettid(),
	};
	struct ucred ucred = {
		.pid = getpid(),
		.uid = getuid(),
		.gid = getgid(),
	};
	char control[CMSG_SPACE(sizeof(ucred))] = { 0 };
	struct iovec iov;
	struct msghdr msg = { 0 };
	struct cmsghdr *cmsg;
	char sync;

	iov.iov_base = &ids;
	iov.iov_len = sizeof(ids);

	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = control;
	msg.msg_controllen = sizeof(control);

	cmsg = CMSG_FIRSTHDR(&msg);
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_CREDENTIALS;
	cmsg->cmsg_len = CMSG_LEN(sizeof(ucred));
	memcpy(CMSG_DATA(cmsg), &ucred, sizeof(ucred));

	if (sendmsg(fd, &msg, 0) != sizeof(ids))
		return (void *)1;

	/* signal we've written our info */
	if (write(seq_pipe[1], "1", 1) != 1)
		return (void *)1;

	/* stay alive until the receiver has looked at our pidfd */
	if (read(fd, &sync, 1) != 1)
		return (void *)1;

	return NULL;
}

/*
 * Runs @nwriters copies of @sender, each in its own non-leader thread, one
 * at a time so the queue order is known, then tells the parent on @ackfd
 * that everything is queued.
 */
static void thread_client(int fd, int syncfd, int ackfd,
			  void *(*sender)(void *), int nwriters)
{
	pthread_t writers[MAX_WRITERS];
	void *ret;
	char sync;
	int i;

	/* wait until the receiver enabled the options it wants */
	if (read(syncfd, &sync, 1) != 1)
		child_die();

	for (i = 0; i < nwriters; i++) {
		if (pthread_create(&writers[i], NULL, sender, &fd))
			child_die();

		if (read(seq_pipe[0], &sync, 1) != 1)
			child_die();
	}

	if (write(ackfd, "1", 1) != 1)
		child_die();

	for (i = 0; i < nwriters; i++)
		if (pthread_join(writers[i], &ret) || ret)
			child_die();

	exit(0);
}

struct pidfd_msg {
	ssize_t len;
	struct thread_ids ids;
	struct pidfd_info tgid_info;
	struct pidfd_info thread_info;
	int tgid_flags;
	int thread_flags;
	bool have_tgid;
	bool have_thread;
};

static int get_pidfd_info(int pidfd, struct pidfd_info *info)
{
	info->mask = PIDFD_INFO_PID;
	if (ioctl(pidfd, PIDFD_GET_INFO, info)) {
		log_err("ioctl(PIDFD_GET_INFO)");
		return -1;
	}

	return 0;
}

/* One recvmsg(), reporting how many bytes came back and what the pidfd
 * cmsgs that came with them say.
 */
static int read_pidfd_msg(int fd, struct pidfd_msg *out)
{
	char control[CMSG_SPACE(sizeof(int)) * 2] = { 0 };
	int tgid_pidfd = -1, thread_pidfd = -1;
	struct thread_ids buf[2] = { 0 };
	struct msghdr msg = { 0 };
	struct cmsghdr *cmsg;
	struct iovec iov;

	iov.iov_base = buf;
	iov.iov_len = sizeof(buf);
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = control;
	msg.msg_controllen = sizeof(control);

	out->len = recvmsg(fd, &msg, 0);
	if (out->len < 0) {
		log_err("recvmsg");
		return -1;
	}

	if (msg.msg_flags & MSG_CTRUNC) {
		log_err("recvmsg: control truncated");
		return -1;
	}

	out->ids = buf[0];

	for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
	     cmsg = CMSG_NXTHDR(&msg, cmsg)) {
		if (cmsg->cmsg_level != SOL_SOCKET)
			continue;

		if (cmsg->cmsg_type == SCM_PIDFD)
			memcpy(&tgid_pidfd, CMSG_DATA(cmsg), sizeof(tgid_pidfd));
		else if (cmsg->cmsg_type == SCM_PIDFD_THREAD)
			memcpy(&thread_pidfd, CMSG_DATA(cmsg), sizeof(thread_pidfd));
	}

	out->have_tgid = tgid_pidfd >= 0;
	out->have_thread = thread_pidfd >= 0;

	if (out->have_tgid) {
		if (get_pidfd_info(tgid_pidfd, &out->tgid_info))
			return -1;
		out->tgid_flags = fcntl(tgid_pidfd, F_GETFL);
		close(tgid_pidfd);
	}

	if (out->have_thread) {
		if (get_pidfd_info(thread_pidfd, &out->thread_info))
			return -1;
		out->thread_flags = fcntl(thread_pidfd, F_GETFL);
		close(thread_pidfd);
	}

	return 0;
}

/*
 * Runs @nwriters threads of one child process against a SOCK_STREAM pair,
 * all of them queued before the parent reads. SO_PASSPIDFD is set when
 * @want_tgid is given, SO_PASSPIDFD_THREAD when @want_thread is. @nread
 * reads are returned in @out.
 */
static int pidfd_flow(void *(*sender)(void *), int nwriters, bool want_tgid,
		      bool want_thread, struct pidfd_msg *out, int nread)
{
	int child_status = 0;
	int syncpipe[2];
	int ackpipe[2];
	int sk[2];
	int on = 1;
	char sync;
	pid_t child;
	int i;

	if (nwriters > MAX_WRITERS)
		return -1;

	if (socketpair(AF_UNIX, SOCK_STREAM, 0, sk))
		return -1;
	if (pipe(syncpipe) || pipe(ackpipe) || pipe(seq_pipe))
		return -1;

	child = fork();
	if (child < 0)
		return -1;

	if (child == 0) {
		close(sk[0]);
		close(syncpipe[1]);
		close(ackpipe[0]);
		thread_client(sk[1], syncpipe[0], ackpipe[1], sender, nwriters);
	}
	close(sk[1]);
	close(syncpipe[0]);
	close(ackpipe[1]);
	close(seq_pipe[0]);
	close(seq_pipe[1]);

	if (want_tgid &&
	    setsockopt(sk[0], SOL_SOCKET, SO_PASSPIDFD, &on, sizeof(on))) {
		log_err("Failed to set SO_PASSPIDFD");
		return -1;
	}

	if (want_thread &&
	    setsockopt(sk[0], SOL_SOCKET, SO_PASSPIDFD_THREAD, &on, sizeof(on))) {
		log_err("Failed to set SO_PASSPIDFD_THREAD");
		return -1;
	}

	/* let the child know the options are set, it can write now */
	if (write(syncpipe[1], "1", 1) != 1)
		return -1;
	close(syncpipe[1]);

	/* wait until every writer has queued its message */
	if (read(ackpipe[0], &sync, 1) != 1)
		return -1;
	close(ackpipe[0]);

	for (i = 0; i < nread; i++)
		if (read_pidfd_msg(sk[0], &out[i]))
			return -1;

	/* release the writers */
	for (i = 0; i < nwriters; i++)
		if (write(sk[0], "x", 1) != 1)
			return -1;
	close(sk[0]);

	waitpid(child, &child_status, 0);
	if (!WIFEXITED(child_status) || WEXITSTATUS(child_status))
		return -1;

	return 0;
}

static int sockopt_set(int fd, int optname, int val)
{
	return setsockopt(fd, SOL_SOCKET, optname, &val, sizeof(val));
}

static int sockopt_get(int fd, int optname)
{
	socklen_t len = sizeof(int);
	int val = -1;

	if (getsockopt(fd, SOL_SOCKET, optname, &val, &len))
		return -1;

	return val;
}

TEST(scm_pidfd_setsockopt_values)
{
	int sk[2];

	ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, sk));

	/* Verify that the options are truly set independently */
	ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSPIDFD_THREAD, 1));
	ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSPIDFD_THREAD));
	ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSPIDFD));

	ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSPIDFD, 1));
	ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSPIDFD));
	ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSPIDFD_THREAD));

	/* Verify that the options are truly cleared independently */
	ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSPIDFD, 0));
	ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSPIDFD));
	ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSPIDFD_THREAD));

	ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSPIDFD_THREAD, 0));
	ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSPIDFD_THREAD));
	ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSPIDFD));

	close(sk[0]);
	close(sk[1]);
}

/* A receiver that only asked about the process cannot tell the two
 * threads apart, so their writes are glued into one read.
 */
TEST(scm_pidfd_stream_glues_threads)
{
	struct pidfd_msg msg[1] = { 0 };

	ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, true, false, msg, 1));
	EXPECT_EQ(sizeof(struct thread_ids) * 2, msg[0].len);

	EXPECT_TRUE(msg[0].have_tgid);
	EXPECT_FALSE(msg[0].have_thread);
	EXPECT_EQ(msg[0].ids.pid, msg[0].tgid_info.pid);
	EXPECT_EQ(msg[0].ids.pid, msg[0].tgid_info.tgid);
}

/* A receiver asking for both thread and process pidfd should get a unique
 * msg for each thread writing
 */
TEST(scm_pidfd_thread_stream_splits_on_threads)
{
	struct pidfd_msg msg[2] = { 0 };
	int i;

	ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, true, true, msg, 2));

	for (i = 0; i < 2; i++) {
		EXPECT_EQ(sizeof(struct thread_ids), msg[i].len);
		EXPECT_TRUE(msg[i].have_tgid);
		EXPECT_TRUE(msg[i].have_thread);

		/* Make sure the info makes sense for the pidfd type */
		EXPECT_EQ(msg[i].ids.pid, msg[i].tgid_info.pid);
		EXPECT_EQ(msg[i].ids.pid, msg[i].tgid_info.tgid);
		EXPECT_EQ(msg[i].ids.tid, msg[i].thread_info.pid);
		EXPECT_EQ(msg[i].ids.pid, msg[i].thread_info.tgid);
		EXPECT_NE(msg[i].ids.pid, msg[i].ids.tid);
	}

	/* Make sure we really got unique threads per message */
	EXPECT_NE(msg[0].ids.tid, msg[1].ids.tid);
	EXPECT_EQ(msg[0].ids.pid, msg[1].ids.pid);
	EXPECT_EQ(msg[0].tgid_info.pid, msg[1].tgid_info.pid);
	EXPECT_NE(msg[0].thread_info.pid, msg[1].thread_info.pid);
}

/* Sends from the thread-group leader */
static int leader_flow(bool want_thread, struct pidfd_msg *out)
{
	struct thread_ids ids = {
		.pid = getpid(),
		.tid = gettid(),
	};
	int sk[2];
	int on = 1;
	int ret;

	if (socketpair(AF_UNIX, SOCK_STREAM, 0, sk))
		return -1;

	if (setsockopt(sk[0], SOL_SOCKET, SO_PASSPIDFD, &on, sizeof(on))) {
		log_err("Failed to set SO_PASSPIDFD");
		return -1;
	}

	if (want_thread &&
	    setsockopt(sk[0], SOL_SOCKET, SO_PASSPIDFD_THREAD, &on, sizeof(on))) {
		log_err("Failed to set SO_PASSPIDFD_THREAD");
		return -1;
	}

	if (send(sk[1], &ids, sizeof(ids), 0) != sizeof(ids)) {
		log_err("send");
		return -1;
	}

	ret = read_pidfd_msg(sk[0], out);

	close(sk[0]);
	close(sk[1]);

	return ret;
}

TEST(scm_pidfd_leader_sender)
{
	struct pidfd_msg msg = { 0 };

	ASSERT_EQ(getpid(), gettid());

	ASSERT_EQ(0, leader_flow(false, &msg));
	ASSERT_TRUE(msg.have_tgid);
	EXPECT_FALSE(msg.have_thread);

	EXPECT_EQ(getpid(), msg.tgid_info.pid);
	EXPECT_EQ(getpid(), msg.tgid_info.tgid);
	EXPECT_FALSE(msg.tgid_flags & O_EXCL);
}

TEST(scm_pidfd_thread_leader_sender)
{
	struct pidfd_msg msg = { 0 };

	ASSERT_EQ(getpid(), gettid());

	ASSERT_EQ(0, leader_flow(true, &msg));
	ASSERT_TRUE(msg.have_tgid);
	ASSERT_TRUE(msg.have_thread);

	EXPECT_EQ(getpid(), msg.tgid_info.pid);
	EXPECT_EQ(getpid(), msg.tgid_info.tgid);
	EXPECT_EQ(getpid(), msg.thread_info.pid);
	EXPECT_EQ(getpid(), msg.thread_info.tgid);

	EXPECT_FALSE(msg.tgid_flags & O_EXCL);
	EXPECT_TRUE(msg.thread_flags & O_EXCL);
}

TEST(scm_pidfd_thread_and_group)
{
	struct pidfd_msg msg = { 0 };

	ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, true, true, &msg, 1));
	ASSERT_NE(msg.ids.pid, msg.ids.tid);
	ASSERT_TRUE(msg.have_tgid);
	ASSERT_TRUE(msg.have_thread);

	EXPECT_EQ(msg.ids.pid, msg.tgid_info.pid);
	EXPECT_EQ(msg.ids.pid, msg.tgid_info.tgid);

	EXPECT_EQ(msg.ids.tid, msg.thread_info.pid);
	EXPECT_EQ(msg.ids.pid, msg.thread_info.tgid);
}

TEST(scm_pidfd_thread)
{
	struct pidfd_msg msg = { 0 };

	ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, false, true, &msg, 1));
	ASSERT_NE(msg.ids.pid, msg.ids.tid);
	ASSERT_TRUE(msg.have_thread);
	EXPECT_FALSE(msg.have_tgid);
	EXPECT_EQ(msg.ids.tid, msg.thread_info.pid);
	EXPECT_EQ(msg.ids.pid, msg.thread_info.tgid);
}

TEST(scm_pidfd_thread_group)
{
	struct pidfd_msg msg = { 0 };

	ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, true, false, &msg, 1));
	ASSERT_NE(msg.ids.pid, msg.ids.tid);
	ASSERT_TRUE(msg.have_tgid);
	EXPECT_FALSE(msg.have_thread);
	EXPECT_EQ(msg.ids.pid, msg.tgid_info.pid);
	EXPECT_EQ(msg.ids.pid, msg.tgid_info.tgid);
}

TEST(scm_pidfd_thread_creds)
{
	struct pidfd_msg msg = { 0 };

	ASSERT_EQ(0, pidfd_flow(send_ids_creds_thread, 1, true, true, &msg, 1));
	ASSERT_NE(msg.ids.pid, msg.ids.tid);
	ASSERT_TRUE(msg.have_tgid);
	ASSERT_TRUE(msg.have_thread);
	EXPECT_EQ(msg.ids.pid, msg.tgid_info.pid);
	EXPECT_EQ(msg.ids.pid, msg.tgid_info.tgid);
	EXPECT_EQ(msg.ids.tid, msg.thread_info.pid);
	EXPECT_EQ(msg.ids.pid, msg.thread_info.tgid);
}

static void *peer_connect_thread(void *arg)
{
	struct sock_addr *sa = arg;
	struct thread_ids ids = {
		.pid = getpid(),
		.tid = gettid(),
	};
	int fd;
	char sync;

	fd = socket(AF_UNIX, SOCK_STREAM, 0);
	if (fd < 0)
		return (void *)1;

	if (connect(fd, (struct sockaddr *)&sa->listen_addr, sa->addrlen))
		return (void *)1;

	if (send(fd, &ids, sizeof(ids), 0) != sizeof(ids))
		return (void *)1;

	/* stay alive until the server has looked at our pidfd */
	if (read(fd, &sync, 1) != 1)
		return (void *)1;

	close(fd);
	return NULL;
}

static int peer_pidfd_info(int fd, int optname, struct pidfd_info *info)
{
	int pidfd;
	socklen_t len = sizeof(pidfd);

	if (getsockopt(fd, SOL_SOCKET, optname, &pidfd, &len)) {
		log_err("getsockopt(SO_PEERPIDFD*)");
		return -1;
	}

	info->mask = PIDFD_INFO_PID;
	if (ioctl(pidfd, PIDFD_GET_INFO, info)) {
		log_err("ioctl(PIDFD_GET_INFO)");
		close(pidfd);
		return -1;
	}

	close(pidfd);
	return 0;
}

/* SO_PEERPIDFD_THREAD returns a pidfd for the peer's connecting thread. */
TEST(so_peerpidfd_thread)
{
	struct sock_addr sa;
	struct thread_ids ids;
	struct pidfd_info info;
	pthread_t thread;
	void *tret;
	int server, cfd;

	server = socket(AF_UNIX, SOCK_STREAM, 0);
	ASSERT_LE(0, server);

	fill_sockaddr(&sa, true);
	ASSERT_EQ(0, bind(server, (struct sockaddr *)&sa.listen_addr, sa.addrlen));
	ASSERT_EQ(0, listen(server, 1));

	ASSERT_EQ(0, pthread_create(&thread, NULL, peer_connect_thread, &sa));

	cfd = accept(server, NULL, NULL);
	ASSERT_LE(0, cfd);

	ASSERT_EQ(sizeof(ids), recv(cfd, &ids, sizeof(ids), MSG_WAITALL));
	ASSERT_NE(ids.pid, ids.tid);

	/* SO_PEERPIDFD refers to the peer's thread-group. */
	ASSERT_EQ(0, peer_pidfd_info(cfd, SO_PEERPIDFD, &info));
	EXPECT_EQ(ids.pid, info.pid);
	EXPECT_EQ(ids.pid, info.tgid);

	/* SO_PEERPIDFD_THREAD refers to the connecting thread. */
	ASSERT_EQ(0, peer_pidfd_info(cfd, SO_PEERPIDFD_THREAD, &info));
	EXPECT_EQ(ids.tid, info.pid);
	EXPECT_EQ(ids.pid, info.tgid);

	/* release the connecting thread */
	ASSERT_EQ(1, write(cfd, "x", 1));
	ASSERT_EQ(0, pthread_join(thread, &tret));
	ASSERT_EQ(NULL, tret);

	close(cfd);
	close(server);
}

TEST_HARNESS_MAIN