xref: /openbsd-src/regress/sys/dev/wscons/sigio.c (revision 36b1b8b4dfaf3411193c17c2462937014292f2df)

/*	$OpenBSD: sigio.c,v 1.5 2020/01/08 16:27:40 visa Exp $	*/

/*
 * Copyright (c) 2018 Anton Lindqvist <anton@openbsd.org>
 *
 * 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/ioctl.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <dev/wscons/wsconsio.h>

#include <err.h>
#include <fcntl.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "util.h"

static int test_getown_fcntl(int);
static int test_getown_ioctl(int);
static int test_gpgrp(int);
static int test_setown_fcntl(int);
static int test_setown_ioctl(int);
static int test_sigio(int);
static int test_spgrp(int);

static int test_common_getown(int, int);
static int test_common_setown(int, int);

static void sigio(int);
static void syncrecv(int, int);
static void syncsend(int, int);

static volatile sig_atomic_t nsigio;

static int
test_getown_fcntl(int fd)
{
	return test_common_getown(fd, 1);
}

static int
test_getown_ioctl(int fd)
{
	return test_common_getown(fd, 0);
}

static int
test_gpgrp(int fd)
{
	int arg, pgrp;

	if (ioctl(fd, TIOCGPGRP, &pgrp) == -1)
		err(1, "ioctl: TIOCGPGRP");
	if (pgrp != 0)
		errx(1, "ioctl: TIOCGPGRP: expected 0, got %d", pgrp);

	arg = getpgrp();
	if (ioctl(fd, TIOCSPGRP, &arg) == -1)
		err(1, "ioctl: TIOCSPGRP");
	if (ioctl(fd, TIOCGPGRP, &pgrp) == -1)
		err(1, "ioctl: TIOCGPGRP");
	if (pgrp != getpgrp())
		errx(1, "ioctl: TIOCGPGRP: expected %d, got %d", getpgrp(), pgrp);

	return 0;
}

static int
test_setown_fcntl(int fd)
{
	return test_common_setown(fd, 1);
}

static int
test_setown_ioctl(int fd)
{
	return test_common_setown(fd, 0);
}

static int
test_sigio(int fd)
{
	struct wscons_event ev;
	int cfd[2], pfd[2];
	ssize_t n;
	pid_t pid;
	int arg, len, status;

	if (pipe(cfd) == -1)
		err(1, "pipe");
	if (pipe(pfd) == -1)
		err(1, "pipe");

	arg = getpid();
	if (ioctl(fd, FIOSETOWN, &arg) == -1)
		err(1, "ioctl: FIOSETOWN");

	/* Enable async IO. */
	arg = 1;
	if (ioctl(fd, FIOASYNC, &arg) == -1)
		err(1, "ioctl: FIOASYNC");

	pid = fork();
	if (pid == -1)
		err(1, "fork");
	if (pid == 0) {
		close(cfd[1]);
		close(pfd[0]);

		syncsend(pfd[1], 1);
		syncrecv(cfd[0], 2);

		memset(&ev, 0, sizeof(ev));
		if (ioctl(fd, WSMUXIO_INJECTEVENT, &ev) == -1)
			err(1, "ioctl: WSMUXIO_INJECTEVENT");

		close(cfd[0]);
		close(pfd[1]);
		_exit(0);
	}
	close(cfd[0]);
	close(pfd[1]);

	syncrecv(pfd[0], 1);

	if (signal(SIGIO, sigio) == SIG_ERR)
		err(1, "signal");

	syncsend(cfd[1], 2);

	if (waitpid(pid, &status, 0) == -1)
		err(1, "waitpid");
	if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
		errx(1, "child exited %d", WEXITSTATUS(status));
	if (WIFSIGNALED(status))
                errx(1, "child killed by signal %d", WTERMSIG(status));

	if (nsigio != 1)
                errx(1, "expected SIGIO to be received once, got %d", nsigio);

	len = sizeof(ev);
	n = read(fd, &ev, len);
	if (n == -1)
		err(1, "read");
	if (n != len)
		errx(1, "read: expected %d bytes, got %ld", len, n);

	/* Disable async IO. */
	arg = 0;
	if (ioctl(fd, FIOASYNC, &arg) == -1)
		err(1, "ioctl: FIOASYNC");

	return 0;
}

static int
test_spgrp(int fd)
{
	int arg;

	/* The process group must be able to receive SIGIO. */
	arg = getpgrp();
	if (ioctl(fd, TIOCSPGRP, &arg) == -1)
		errx(1, "ioctl: TIOCSPGRP");

	/* Bogus process groups must be rejected. */
	arg = -getpgrp();
	if (ioctl(fd, TIOCSPGRP, &arg) != -1)
		errx(1, "ioctl: TIOCSPGRP: %d accepted", arg);
	arg = 1000000;
	if (ioctl(fd, TIOCSPGRP, &arg) != -1)
		errx(1, "ioctl: TIOCSPGRP: %d accepted", arg);

	return 0;
}

static int
test_common_getown(int fd, int dofcntl)
{
	int arg, pgrp;

	if (dofcntl) {
		pgrp = fcntl(fd, F_GETOWN);
		if (pgrp == -1)
			err(1, "fcntl: F_GETOWN");
		if (pgrp != 0)
			errx(1, "fcntl: F_GETOWN: expected 0, got %d", pgrp);
	} else {
		if (ioctl(fd, FIOGETOWN, &pgrp) == -1)
			err(1, "ioctl: FIOGETOWN");
		if (pgrp != 0)
			errx(1, "ioctl: FIOGETOWN: expected 0, got %d", pgrp);
	}

	arg = -getpgrp();
	if (ioctl(fd, FIOSETOWN, &arg) == -1)
		err(1, "ioctl: FIOSETOWN");
	if (dofcntl) {
		pgrp = fcntl(fd, F_GETOWN);
		if (pgrp == -1)
			err(1, "fcntl: F_GETOWN");
		if (pgrp != -getpgrp())
			errx(1, "fcntl: F_GETOWN: expected %d, got %d",
			    -getpgrp(), pgrp);
	} else {
		if (ioctl(fd, FIOGETOWN, &pgrp) == -1)
			err(1, "ioctl: FIOGETOWN");
		if (pgrp != -getpgrp())
			errx(1, "ioctl: FIOGETOWN: expected %d, got %d",
			    -getpgrp(), pgrp);
	}

	return 0;
}

static int
test_common_setown(int fd, int dofcntl)
{
	int arg;

        /* The process must be able to receive SIGIO. */
	arg = getpid();
	if (dofcntl) {
		if (fcntl(fd, F_SETOWN, arg) == -1)
			errx(1, "fcntl: F_SETOWN: process rejected");
	} else {
		if (ioctl(fd, FIOSETOWN, &arg) == -1)
			errx(1, "ioctl: FIOSETOWN: process rejected");
	}

	/* The process group must be able to receive SIGIO. */
	arg = -getpgrp();
	if (dofcntl) {
		if (fcntl(fd, F_SETOWN, arg) == -1)
			errx(1, "fcntl: F_SETOWN: process group rejected");
	} else {
		if (ioctl(fd, FIOSETOWN, &arg) == -1)
			errx(1, "ioctl: FIOSETOWN: process group rejected");
	}

	/* A bogus process must be rejected. */
	arg = 1000000;
	if (dofcntl) {
		if (fcntl(fd, F_SETOWN, arg) != -1)
			errx(1, "fcntl: F_SETOWN: bogus process accepted");
	} else {
		if (ioctl(fd, FIOSETOWN, &arg) != -1)
			errx(1, "ioctl: FIOSETOWN: bogus process accepted");
	}

	/* A bogus process group must be rejected. */
	arg = -1000000;
	if (dofcntl) {
		if (fcntl(fd, F_SETOWN, arg) != -1)
			errx(1, "fcntl: F_SETOWN: bogus process group accepted");
	} else {
		if (ioctl(fd, FIOSETOWN, &arg) != -1)
			errx(1, "ioctl: FIOSETOWN: bogus process group accepted");
	}

	return 0;
}

static void
sigio(int signo)
{
	nsigio++;
}

static void
syncrecv(int fd, int id)
{
	int r;

	if (read(fd, &r, sizeof(r)) == -1)
		err(1, "%s: read", __func__);
	if (r != id)
		errx(1, "%s: expected %d, got %d", __func__, id, r);
}

static void
syncsend(int fd, int id)
{
	if (write(fd, &id, sizeof(id)) == -1)
		err(1, "%s: write", __func__);
}

int
main(int argc, char *argv[])
{
	struct test tests[] = {
		{ "getown-fcntl",	test_getown_fcntl },
		{ "getown-ioctl",	test_getown_ioctl },
		{ "gpgrp",		test_gpgrp },
		{ "setown-fcntl",	test_setown_fcntl },
		{ "setown-ioctl",	test_setown_ioctl },
		{ "sigio",		test_sigio },
		{ "spgrp",		test_spgrp },
		{ NULL,			NULL },
	};

	return dotest(argc, argv, tests);
}