xref: /openbsd/regress/sys/kern/pledge/sendrecvfd/sendrecvfd.c (revision 6f5256c2)

/*	$OpenBSD: sendrecvfd.c,v 1.1 2017/02/22 11:30:00 tb Exp $ */
/*
 * Copyright (c) 2017 Sebastien Marie <semarie@online.fr>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/wait.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

enum testtype {
	nopledge,
	sendfd,
	recvfd,
	nosendfd,
	norecvfd,
};

static void do_receiver(enum testtype type, int sock);
static void do_sender(enum testtype type, int sock, int fd);
__dead static void usage();


static void
do_receiver(enum testtype type, int sock)
{
	struct msghdr msg;
	struct cmsghdr *cmsg;
	union {
		struct cmsghdr hdr;
		unsigned char buf[CMSG_SPACE(sizeof(int))];
	} cmsgbuf;

	/* pledge */
	switch(type) {
	case recvfd:
		if (pledge("stdio recvfd", NULL) == -1)
			err(EXIT_FAILURE, "receiver: pledge");
		break;

	case norecvfd:
		if (pledge("stdio", NULL) == -1)
			err(EXIT_FAILURE, "receiver: pledge");
		break;

	default:
		/* no pledge */
		break;
	}

	memset(&msg, 0, sizeof(msg));
	msg.msg_control = &cmsgbuf.buf;
	msg.msg_controllen = sizeof(cmsgbuf.buf);

	if (recvmsg(sock, &msg, 0) == -1)
		err(EXIT_FAILURE, "receiver: recvmsg");

	if ((msg.msg_flags & MSG_TRUNC) || (msg.msg_flags & MSG_CTRUNC))
		errx(EXIT_FAILURE, "receiver: control message truncated");

	for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
	    cmsg = CMSG_NXTHDR(&msg, cmsg)) {
		if (cmsg->cmsg_len == CMSG_LEN(sizeof(int)) &&
		    cmsg->cmsg_level == SOL_SOCKET &&
		    cmsg->cmsg_type == SCM_RIGHTS) {

			int fd = *(int *)CMSG_DATA(cmsg);
			struct stat sb;

			/* test received fd */
			if (fstat(fd, &sb) == -1)
				err(EXIT_FAILURE, "receiver: fstat");
		}
	}
}

static void
do_sender(enum testtype type, int sock, int fd)
{
	struct msghdr msg;
	struct cmsghdr *cmsg;
	union {
		struct cmsghdr hdr;
		unsigned char buf[CMSG_SPACE(sizeof(int))];
	} cmsgbuf;

	/* pledge */
	switch (type) {
	case sendfd:
		if (pledge("stdio sendfd", NULL) == -1)
			err(EXIT_FAILURE, "sender: pledge");
		break;

	case nosendfd:
		if (pledge("stdio", NULL) == -1)
			err(EXIT_FAILURE, "sender: pledge");
		break;

	default:
		/* no pledge */
		break;
	}

	memset(&msg, 0, sizeof(msg));
	msg.msg_control = &cmsgbuf.buf;
	msg.msg_controllen = sizeof(cmsgbuf.buf);

	cmsg = CMSG_FIRSTHDR(&msg);
	cmsg->cmsg_len = CMSG_LEN(sizeof(int));
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;
	*(int *)CMSG_DATA(cmsg) = fd;

	if (sendmsg(sock, &msg, 0) == -1)
		err(EXIT_FAILURE, "sender: sendmsg");
}

__dead static void
usage()
{
	printf("usage: %s testtype vnodetype\n", getprogname());
	printf("  testtype  = nopledge sendfd recvfd nosendfd norecvfd\n");
	printf("  vnodetype = VREG VDIR VBLK VCHAR VLNK VSOCK VFIFO\n");
	exit(EXIT_FAILURE);
}

int
main(int argc, char *argv[])
{
	enum testtype type;
	int fd;
	int sv[2], status;
	pid_t child;

	/*
	 * parse arguments
	 */

	if (argc != 3)
		usage();

	if (strcmp(argv[1], "nopledge") == 0 ) {
		/* test sendfd/recvfd without pledge */
		type = nopledge;

	} else if (strcmp(argv[1], "sendfd") == 0) {
		/* test sendfd process with "stdio sendfd" */
		type = sendfd;

	} else if (strcmp(argv[1], "recvfd") == 0) {
		/* test recvfd process with "stdio recvfd" */
		type = recvfd;

	} else if (strcmp(argv[1], "nosendfd") == 0) {
		/* test sendfd process with "stdio" (without "sendfd") */
		type = nosendfd;

	} else if (strcmp(argv[1], "norecvfd") == 0) {
		/* test recvfd process with "stdio" (without "recvfd") */
		type = norecvfd;

	} else
		usage();

	/* open a file descriptor according to vnodetype requested */
	if (strcmp(argv[2], "VREG") == 0) {
		if ((fd = open("/etc/passwd", O_RDONLY)) == -1)
			err(EXIT_FAILURE, "open: VREG: /etc/passwd");

	} else if (strcmp(argv[2], "VDIR") == 0) {
		if ((fd = open("/dev", O_RDONLY)) == -1)
			err(EXIT_FAILURE, "open: VDIR: /dev");

	} else if (strcmp(argv[2], "VBLK") == 0) {
		if ((fd = open("/dev/vnd0c", O_RDONLY)) == -1)
		    err(EXIT_FAILURE, "open: VBLK: /dev/vnd0c");

	} else if (strcmp(argv[2], "VCHR") == 0) {
		if ((fd = open("/dev/null", O_RDONLY)) == -1)
			err(EXIT_FAILURE, "open: VCHR: /dev/null");

	} else if (strcmp(argv[2], "VLNK") == 0) {
		if ((fd = open("/etc/termcap", O_RDONLY)) == -1)
			err(EXIT_FAILURE, "open: VCHR: /etc/termcap");

	} else if (strcmp(argv[2], "VSOCK") == 0) {
		/* create socket */
		if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
			err(EXIT_FAILURE, "socket: VSOCK");

	} else if (strcmp(argv[2], "VFIFO") == 0) {
		/* unlink possibly existing file (from previous run) */
		unlink("fifo");

		/* create a new named fifo */
		if (mkfifo("fifo", 0600) == -1)
			err(EXIT_FAILURE, "mkfifo: VFIFO");

		/* open it */
		if ((fd = open("fifo", O_RDONLY|O_NONBLOCK)) == -1)
			err(EXIT_FAILURE, "open: VFIFO: fifo");

		/* unlink the file now */
		unlink("fifo");
	} else
		usage();


	/*
	 * do test
	 */

	/* communication socket */
	if (socketpair(AF_LOCAL, SOCK_STREAM, PF_UNSPEC, sv) == -1)
		err(EXIT_FAILURE, "socketpair");

	/* create two procs and pass fd from one to another */
	switch (child = fork()) {
	case -1:	/* error */
		err(EXIT_FAILURE, "fork");

	case 0:		/* child: receiver */
		close(fd);
		close(sv[0]);

		do_receiver(type, sv[1]);
		_exit(EXIT_SUCCESS);

	default:	/* parent: sender */
		close(sv[1]);

		do_sender(type, sv[0], fd);

		/* wait for child */
		while (waitpid(child, &status, 0) < 0) {
			if (errno == EAGAIN)
				continue;

			err(EXIT_FAILURE, "waitpid");
		}

		if (! WIFEXITED(status)) {
			if (WIFSIGNALED(status))
				errx(EXIT_FAILURE,
				    "child (receiver): WTERMSIG(): %d",
				    WTERMSIG(status));

			errx(EXIT_FAILURE, "child (receiver): !WIFEXITED");
		}

		if (WEXITSTATUS(status) != 0)
			errx(EXIT_FAILURE, "child(receiver): WEXITSTATUS(): %d",
			    WEXITSTATUS(status));

		exit(EXIT_SUCCESS);
	}
}