/* Tests for opening/closing pseudo terminals - by D.C. van Moolenbroek */
/*
 * As of the introduction of Unix98 PTY support, this test set actually relies
 * on the ability to create Unix98 PTYs.  The system still supports old-style
 * PTYs but there is no way to force openpty(3) to use them.  However, part of
 * this test set can still be used to test old-style PTYs: first disable Unix98
 * PTYs, for example by unmounting PTYFS or temporarily removing /dev/ptmx, and
 * then run the a-f subtests from this test set as root.
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <termios.h>
#include <sys/wait.h>
#include <sys/syslimits.h>
#include <paths.h>
#include <dirent.h>
#include <grp.h>
#include <fcntl.h>
#include <util.h>

#define ITERATIONS 10

#define MIN_PTYS 4

#include "common.h"

static int sighups;		/* number of SIGHUP signals received */

/*
 * Signal handler for SIGHUP and SIGUSR1.
 */
static void
signal_handler(int sig)
{
	if (sig == SIGHUP)
		sighups++;
}

/*
 * Set the slave side of the pseudo terminal to raw mode.  This simplifies
 * testing communication.
 */
static void
make_raw(int slavefd)
{
	struct termios tios;

	if (tcgetattr(slavefd, &tios) < 0) e(0);

	cfmakeraw(&tios);

	if (tcsetattr(slavefd, TCSANOW, &tios) < 0) e(0);
}

/*
 * See if the given pseudo terminal can successfully perform basic
 * communication between master and slave.
 */
static void
test_comm(int masterfd, int slavefd)
{
	char c;

	make_raw(slavefd);

	c = 'A';
	if (write(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (read(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (c != 'A') e(0);

	c = 'B';
	if (write(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (read(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (c != 'B') e(0);

	c = 'C';
	if (write(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (read(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (c != 'C') e(0);

	c = 'D';
	if (write(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (read(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (c != 'D') e(0);
}

/*
 * Obtain a pseudo terminal.  The master end is opened and its file descriptor
 * stored in 'pfd'.  The slave path name is stored in 'tname'.  For old-style
 * PTYs, the function returns 1 and stores the master name in 'pname' if not
 * NULL.  For Unix98 PTYs, the function returns 0, in which case no master name
 * is available.  For old-style PTYs, the caller may close and reopen the
 * master.  In that case, we make the assumption that nobody snatches the pair
 * while we are running.  For Unix98 PTYs, the master must be kept open.
 */
static int
get_pty(int *pfd, char pname[PATH_MAX], char tname[PATH_MAX])
{
	char *name;
	int len, masterfd, slavefd;

	/*
	 * First try Unix98 PTY allocation, mainly to avoid opening the slave
	 * end immediately.  If this fails, try openpty(3) as well.
	 */
	if ((masterfd = posix_openpt(O_RDWR | O_NOCTTY)) != -1) {
		if (grantpt(masterfd) != -1 && unlockpt(masterfd) != -1 &&
		    (name = ptsname(masterfd)) != NULL) {
			*pfd = masterfd;
			strlcpy(tname, name, PATH_MAX);

			return 0;
		}
		if (close(masterfd) < 0) e(0);
	}

	if (openpty(&masterfd, &slavefd, tname, NULL, NULL) < 0) e(0);

	test_comm(masterfd, slavefd);

	*pfd = masterfd;

	if (close(slavefd) < 0) e(0);

	/*
	 * openpty(3) gives us only the slave name, but we also want the master
	 * name.
	 */
	len = strlen(_PATH_DEV);
	if (strncmp(tname, _PATH_DEV, len)) e(0);

	if (strncmp(&tname[len], "tty", 3))
		return 0; /* Unix98 after all?  Well okay, whatever.. */

	if (pname != NULL) {
		strlcpy(pname, tname, PATH_MAX);
		pname[len] = 'p';
	}

	return 1;
}

/*
 * Test various orders of opening and closing the master and slave sides of a
 * pseudo terminal, as well as opening/closing one side without ever opening
 * the other.  This test is meaningful mainly for old-style pseudoterminals.
 */
static void
test77a(void)
{
	struct sigaction act, oact;
	char pname[PATH_MAX], tname[PATH_MAX];
	int oldstyle, masterfd, slavefd;

	subtest = 1;

	/* We do not want to get SIGHUP signals in this test. */
	memset(&act, 0, sizeof(act));
	act.sa_handler = SIG_IGN;
	if (sigaction(SIGHUP, &act, &oact) < 0) e(0);

	/* Obtain a pseudo terminal. */
	oldstyle = get_pty(&masterfd, pname, tname);

	if (oldstyle) {
		/* Try closing the master. */
		if (close(masterfd) < 0) e(0);

		/* See if we can reopen the master. */
		if ((masterfd = open(pname, O_RDWR | O_NOCTTY)) < 0) e(0);
	}

	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	test_comm(masterfd, slavefd);

	/* In the meantime, test different closing orders. This is order A. */
	if (close(slavefd) < 0) e(0);
	if (close(masterfd) < 0) e(0);

	/* Now try opening the pair (or a new pair) again. */
	if (!oldstyle)
		oldstyle = get_pty(&masterfd, pname, tname);
	else
		if ((masterfd = open(pname, O_RDWR | O_NOCTTY)) < 0) e(0);

	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	test_comm(masterfd, slavefd);

	if (close(slavefd) < 0) e(0);

	/*
	 * Try reopening the slave after closing it.  It is not very important
	 * that this works, but the TTY driver should currently support it.
	 */
	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	test_comm(masterfd, slavefd);

	/* This is closing order B. This may or may not cause a SIGHUP. */
	if (close(masterfd) < 0) e(0);
	if (close(slavefd) < 0) e(0);

	/* Try the normal open procedure. */
	if (!oldstyle)
		oldstyle = get_pty(&masterfd, pname, tname);
	else
		if ((masterfd = open(pname, O_RDWR | O_NOCTTY)) < 0) e(0);

	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	test_comm(masterfd, slavefd);

	if (close(slavefd) < 0) e(0);
	if (close(masterfd) < 0) e(0);

	/*
	 * Try reopening and closing the slave, without opening the master.
	 * This should work on old-style PTYS, but not on Unix98 PTYs.
	 */
	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) >= 0) {
		if (!oldstyle) e(0);

		if (close(slavefd) < 0) e(0);
	} else
		if (oldstyle) e(0);

	/* Again, try the normal open procedure. */
	if (!oldstyle)
		oldstyle = get_pty(&masterfd, pname, tname);
	else
		if ((masterfd = open(pname, O_RDWR | O_NOCTTY)) < 0) e(0);

	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	test_comm(masterfd, slavefd);

	if (close(slavefd) < 0) e(0);
	if (close(masterfd) < 0) e(0);

	/*
	 * Finally, try opening the slave first.  This does not work with
	 * Unix98 PTYs.
	 */
	if (oldstyle) {
		if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);
		if ((masterfd = open(pname, O_RDWR | O_NOCTTY)) < 0) e(0);

		test_comm(masterfd, slavefd);

		if (close(slavefd) < 0) e(0);
		if (close(masterfd) < 0) e(0);
	}

	if (sigaction(SIGHUP, &oact, NULL) < 0) e(0);
}

/*
 * Test opening a single side multiple times.
 */
static void
test77b(void)
{
	char pname[PATH_MAX], tname[PATH_MAX];
	int oldstyle, masterfd, slavefd, extrafd;

	subtest = 2;

	/* Obtain a pseudo terminal. */
	oldstyle = get_pty(&masterfd, pname, tname);

	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	/*
	 * It must not be possible to open the master multiple times.  Doing so
	 * is possible only if we have a named master, i.e., an old-style PTY.
	 */
	test_comm(masterfd, slavefd);

	if (oldstyle) {
		if ((extrafd = open(pname, O_RDWR | O_NOCTTY)) >= 0) e(0);
		if (errno != EIO) e(0);
	}

	test_comm(masterfd, slavefd);

	if (close(slavefd) < 0) e(0);
	if (close(masterfd) < 0) e(0);

	/* The slave can be opened multiple times, though. */
	oldstyle = get_pty(&masterfd, pname, tname);

	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	test_comm(masterfd, slavefd);

	if ((extrafd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	test_comm(masterfd, extrafd);
	test_comm(masterfd, slavefd);

	if (close(slavefd) < 0) e(0);
	if (close(extrafd) < 0) e(0);
	if (close(masterfd) < 0) e(0);
}

/*
 * Test communication on half-open pseudo terminals.
 */
static void
test77c(void)
{
	struct sigaction act, oact;
	char pname[PATH_MAX], tname[PATH_MAX];
	int oldstyle, masterfd, slavefd;
	char c;

	subtest = 3;

	/* We do not want to get SIGHUP signals in this test. */
	memset(&act, 0, sizeof(act));
	act.sa_handler = SIG_IGN;
	if (sigaction(SIGHUP, &act, &oact) < 0) e(0);

	/* Obtain a pseudo terminal. */
	oldstyle = get_pty(&masterfd, pname, tname);

	/*
	 * For old-style pseudo terminals, we have just opened and closed the
	 * slave end, which alters the behavior we are testing below.  Close
	 * and reopen the master to start fresh.
	 */
	if (oldstyle) {
		if (close(masterfd) < 0) e(0);

		if ((masterfd = open(pname, O_RDWR | O_NOCTTY)) < 0) e(0);
	}

	/* Writes to the master should be buffered until there is a slave. */
	c = 'E';
	if (write(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);

	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	make_raw(slavefd);

	if (read(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);
	if (c != 'E') e(0);

	/* Discard the echo on the master. */
	if (tcflush(slavefd, TCOFLUSH) != 0) e(0);

	test_comm(masterfd, slavefd);

	if (close(slavefd) < 0) e(0);

	/* Writes to the master after the slave has been closed should fail. */
	if (write(masterfd, &c, sizeof(c)) >= 0) e(0);
	if (errno != EIO) e(0);

	if (oldstyle)
		if (close(masterfd) < 0) e(0);

	/*
	 * Writes to the slave should be buffered until there is a master.
	 * This applies to old-style PTYs only.
	 */
	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	if (oldstyle) {
		make_raw(slavefd);

		c = 'F';
		if (write(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);

		if ((masterfd = open(pname, O_RDWR | O_NOCTTY)) < 0) e(0);

		if (read(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);
		if (c != 'F') e(0);
	}

	test_comm(masterfd, slavefd);

	if (close(masterfd) < 0) e(0);

	if (write(slavefd, &c, sizeof(c)) >= 0) e(0);
	if (errno != EIO) e(0);

	/* Reads from the slave should return EOF if the master is gone. */
	if (read(slavefd, &c, sizeof(c)) != 0) e(0);

	if (close(slavefd) < 0) e(0);

	if (sigaction(SIGHUP, &oact, NULL) < 0) e(0);
}

/*
 * Wait for a child process to terminate.  Return 0 if the child exited without
 * errors, -1 otherwise.
 */
static int
waitchild(void)
{
	int status;

	if (wait(&status) <= 0) return -1;
	if (!WIFEXITED(status)) return -1;
	if (WEXITSTATUS(status) != 0) return -1;

	return 0;
}

/*
 * Test opening the slave side with and without the O_NOCTTY flag.
 */
static void
test77d(void)
{
	char pname[PATH_MAX], tname[PATH_MAX];
	int masterfd, slavefd;

	subtest = 4;

	/* Make ourselves process group leader if we aren't already. */
	(void)setsid();

	/* Obtain a pseudo terminal. */
	(void)get_pty(&masterfd, NULL, tname);

	/*
	 * Opening the slave with O_NOCTTY should not change its controlling
	 * terminal.
	 */
	switch (fork()) {
	case 0:
		if (close(masterfd) < 0) e(0);

		if (setsid() < 0) e(0);

		if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

		if (open("/dev/tty", O_RDWR) >= 0) e(0);
		if (errno != ENXIO) e(0);

		exit(errct);
	case -1:
		e(0);
	default:
		break;
	}

	if (waitchild() < 0) e(0);

	if (close(masterfd) < 0) e(0);

	(void)get_pty(&masterfd, pname, tname);

	/*
	 * Opening the slave without O_NOCTTY should change its controlling
	 * terminal, though.
	 */
	switch (fork()) {
	case 0:
		if (close(masterfd) < 0) e(0);

		if (setsid() < 0) e(0);

		if ((slavefd = open(tname, O_RDWR)) < 0) e(0);

		if (open("/dev/tty", O_RDWR) < 0) e(0);

		exit(errct);
	case -1:
		e(0);
	default:
		break;
	}

	if (waitchild() < 0) e(0);

	if (close(masterfd) < 0) e(0);
}

/*
 * Test receiving of SIGHUP on master hang-up.  All of the tests so far have
 * ignored SIGHUP, and probably would not have received one anyway, since the
 * process was not its own session leader.  Time to test this aspect.
 */
static void
test77e(void)
{
	struct sigaction act, hup_oact, usr_oact;
	sigset_t set, oset;
	char tname[PATH_MAX];
	int masterfd, slavefd;

	subtest = 5;

	memset(&act, 0, sizeof(act));
	act.sa_handler = signal_handler;
	if (sigaction(SIGHUP, &act, &hup_oact) < 0) e(0);

	memset(&act, 0, sizeof(act));
	act.sa_handler = signal_handler;
	if (sigaction(SIGUSR1, &act, &usr_oact) < 0) e(0);

	sigemptyset(&set);
	sigaddset(&set, SIGHUP);
	sigaddset(&set, SIGUSR1);
	if (sigprocmask(SIG_BLOCK, &set, &oset) < 0) e(0);

	sighups = 0;

	/* Make ourselves process group leader if we aren't already. */
	(void)setsid();

	/* Obtain a pseudo terminal. */
	(void)get_pty(&masterfd, NULL, tname);

	switch (fork()) {
	case 0:
		if (close(masterfd) < 0) e(0);

		/* Become session leader. */
		if (setsid() < 0) e(0);

		if ((slavefd = open(tname, O_RDWR)) < 0) e(0);

		/* Tell the parent we are ready. */
		kill(getppid(), SIGUSR1);

		/* We should now get a SIGHUP. */
		set = oset;
		if (sigsuspend(&set) >= 0) e(0);

		if (sighups != 1) e(0);

		exit(errct);
	case -1:
		e(0);
	default:
		break;
	}

	/* Wait for SIGUSR1 from the child. */
	set = oset;
	if (sigsuspend(&set) >= 0) e(0);

	/* Closing the master should now raise a SIGHUP signal in the child. */
	if (close(masterfd) < 0) e(0);

	if (waitchild() < 0) e(0);

	if (sigprocmask(SIG_SETMASK, &oset, NULL) < 0) e(0);

	if (sigaction(SIGHUP, &hup_oact, NULL) < 0) e(0);
	if (sigaction(SIGUSR1, &usr_oact, NULL) < 0) e(0);
}

/*
 * Test basic select functionality on /dev/tty.  While this test should not be
 * part of this test set, we already have all the infrastructure we need here.
 */
static void
test77f(void)
{
	struct sigaction act, oact;
	char c, tname[PATH_MAX];
	struct timeval tv;
	fd_set fd_set;
	int fd, maxfd, masterfd, slavefd;

	subtest = 6;

	/* We do not want to get SIGHUP signals in this test. */
	memset(&act, 0, sizeof(act));
	act.sa_handler = SIG_IGN;
	if (sigaction(SIGHUP, &act, &oact) < 0) e(0);

	/* Obtain a pseudo terminal. */
	(void)get_pty(&masterfd, NULL, tname);

	switch (fork()) {
	case 0:
		if (close(masterfd) < 0) e(0);

		if (setsid() < 0) e(0);

		if ((slavefd = open(tname, O_RDWR)) < 0) e(0);

		if ((fd = open("/dev/tty", O_RDWR)) < 0) e(0);

		make_raw(fd);

		/* Without slave input, /dev/tty is not ready for reading. */
		FD_ZERO(&fd_set);
		FD_SET(fd, &fd_set);
		tv.tv_sec = 0;
		tv.tv_usec = 0;

		if (select(fd + 1, &fd_set, NULL, NULL, &tv) != 0) e(0);
		if (FD_ISSET(fd, &fd_set)) e(0);

		FD_SET(fd, &fd_set);
		tv.tv_sec = 0;
		tv.tv_usec = 10000;

		if (select(fd + 1, &fd_set, NULL, NULL, &tv) != 0) e(0);
		if (FD_ISSET(fd, &fd_set)) e(0);

		/* It will be ready for writing, though. */
		FD_SET(fd, &fd_set);

		if (select(fd + 1, NULL, &fd_set, NULL, NULL) != 1) e(0);
		if (!FD_ISSET(fd, &fd_set)) e(0);

		/* Test mixing file descriptors to the same terminal. */
		FD_ZERO(&fd_set);
		FD_SET(fd, &fd_set);
		FD_SET(slavefd, &fd_set);
		tv.tv_sec = 0;
		tv.tv_usec = 10000;

		maxfd = fd > slavefd ? fd : slavefd;
		if (select(maxfd + 1, &fd_set, NULL, NULL, &tv) != 0) e(0);
		if (FD_ISSET(fd, &fd_set)) e(0);
		if (FD_ISSET(slavefd, &fd_set)) e(0);

		/* The delayed echo on the master must wake up our select. */
		c = 'A';
		if (write(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);

		FD_ZERO(&fd_set);
		FD_SET(fd, &fd_set);

		if (select(fd + 1, &fd_set, NULL, NULL, NULL) != 1) e(0);
		if (!FD_ISSET(fd, &fd_set)) e(0);

		/* Select must now still flag readiness for reading. */
		tv.tv_sec = 0;
		tv.tv_usec = 0;

		if (select(fd + 1, &fd_set, NULL, NULL, &tv) != 1) e(0);
		if (!FD_ISSET(fd, &fd_set)) e(0);

		/* That is, until we read the byte. */
		if (read(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);
		if (c != 'B') e(0);

		if (select(fd + 1, &fd_set, NULL, NULL, &tv) != 0) e(0);
		if (FD_ISSET(fd, &fd_set)) e(0);

		/* Ask the parent to close the master. */
		c = 'C';
		if (write(slavefd, &c, sizeof(c)) != sizeof(c)) e(0);

		FD_SET(fd, &fd_set);

		/* The closure must cause an EOF condition on the slave. */
		if (select(fd + 1, &fd_set, NULL, NULL, NULL) != 1) e(0);
		if (!FD_ISSET(fd, &fd_set)) e(0);

		if (select(fd + 1, &fd_set, NULL, NULL, NULL) != 1) e(0);
		if (!FD_ISSET(fd, &fd_set)) e(0);

		if (read(slavefd, &c, sizeof(c)) != 0) e(0);

		exit(errct);
	case -1:
		e(0);
	default:
		/* Wait for the child to write something to the slave. */
		FD_ZERO(&fd_set);
		FD_SET(masterfd, &fd_set);

		if (select(masterfd + 1, &fd_set, NULL, NULL, NULL) != 1)
			e(0);
		if (!FD_ISSET(masterfd, &fd_set)) e(0);

		if (read(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);
		if (c != 'A') e(0);

		/* Write a reply once the child is blocked in its select. */
		tv.tv_sec = 1;
		tv.tv_usec = 0;
		if (select(masterfd + 1, &fd_set, NULL, NULL, &tv) != 0)
			e(0);

		c = 'B';
		if (write(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);

		/* Wait for the child to request closing the master. */
		if (read(masterfd, &c, sizeof(c)) != sizeof(c)) e(0);
		if (c != 'C') e(0);

		/* Close the master once the child is blocked in its select. */
		sleep(1);

		close(masterfd);

		break;
	}

	if (waitchild() < 0) e(0);

	if (sigaction(SIGHUP, &oact, NULL) < 0) e(0);
}

/*
 * See if the directory contents of /dev/pts are as we expect.  We have to keep
 * in mind that other programs may have pseudo terminals open while we are
 * running, although we assume that those programs do not open or close PTYs
 * while we are running.
 */
static void
test_getdents(int nindex, int array[3], int present[3])
{
	struct group *group;
	DIR *dirp;
	struct dirent *dp;
	struct stat buf;
	char path[PATH_MAX], *endp;
	gid_t tty_gid;
	int i, n, seen_dot, seen_dotdot, seen_index[3], *seen;

	seen_dot = seen_dotdot = 0;
	for (i = 0; i < nindex; i++)
		seen_index[i] = 0;

	if ((group = getgrnam("tty")) == NULL) e(0);
	tty_gid = group->gr_gid;

	if ((dirp = opendir(_PATH_DEV_PTS)) == NULL) e(0);

	while ((dp = readdir(dirp)) != NULL) {
		snprintf(path, sizeof(path), _PATH_DEV_PTS "%s", dp->d_name);
		if (stat(path, &buf) < 0) e(0);

		if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
			seen =
			    (dp->d_name[1] == '.') ? &seen_dot : &seen_dotdot;
			if (*seen) e(0);
			*seen = 1;

			/* Check basic dirent and stat fields. */
			if (dp->d_type != DT_DIR) e(0);
			if (dp->d_name[1] == '\0' &&
			    buf.st_ino != dp->d_fileno) e(0);
			if (!S_ISDIR(buf.st_mode)) e(0);
			if (buf.st_nlink < 2) e(0);
		} else {
			/* The file name must be a number. */
			errno = 0;
			n = strtol(dp->d_name, &endp, 10);
			if (errno != 0) e(0);
			if (dp->d_name[0] == '\0' || *endp != '\0') e(0);
			if (n < 0) e(0);

			/* Check basic dirent and stat fields. */
			if (dp->d_type != DT_CHR) e(0);
			if (buf.st_ino != dp->d_fileno) e(0);
			if (!S_ISCHR(buf.st_mode)) e(0);
			if (buf.st_nlink != 1) e(0);
			if (buf.st_size != 0) e(0);
			if (buf.st_rdev == 0) e(0);

			/* Is this one of the PTYs we created? */
			for (i = 0; i < nindex; i++) {
				if (array[i] == n) {
					if (seen_index[i]) e(0);
					seen_index[i] = 1;

					break;
				}
			}

			/* If so, perform some extra tests. */
			if (i < nindex) {
				if ((buf.st_mode & ALLPERMS) != 0620) e(0);
				if (buf.st_uid != getuid()) e(0);
				if (buf.st_gid != tty_gid) e(0);
			}
		}
	}

	if (closedir(dirp) < 0) e(0);

	if (!seen_dot) e(0);
	if (!seen_dotdot) e(0);
	for (i = 0; i < nindex; i++)
		if (seen_index[i] != present[i]) e(0);
}

/*
 * Obtain a Unix98 PTY.  Return an open file descriptor for the master side,
 * and store the name of the slave side in 'tptr'.
 */
static int
get_unix98_pty(char ** tptr)
{
	int masterfd;

	if ((masterfd = posix_openpt(O_RDWR | O_NOCTTY)) < 0) e(0);

	if (grantpt(masterfd) < 0) e(0);

	/* This call is a no-op on MINIX3. */
	if (unlockpt(masterfd) < 0) e(0);

	if ((*tptr = ptsname(masterfd)) == NULL) e(0);

	return masterfd;
}

/*
 * Test for Unix98 PTY support and PTYFS.
 */
static void
test77g(void)
{
	char *tname;
	struct stat buf;
	size_t len;
	int i, masterfd, slavefd, fd[3], array[3], present[3];

	subtest = 7;

	/*
	 * Test basic operation, and verify that the slave node disappears
	 * after both sides of the pseudo terminal have been closed.  We check
	 * different combinations of open master and slave ends (with 'i'):
	 * 0) opening and closing the master only, 1) closing a slave before
	 * the master, and 2) closing the slave after the master.
	 */
	for (i = 0; i <= 2; i++) {
		masterfd = get_unix98_pty(&tname);

		if (access(tname, R_OK | W_OK) < 0) e(0);

		if (i > 0) {
			if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0)
				e(0);

			if (access(tname, R_OK | W_OK) < 0) e(0);

			if (i > 1) {
				if (close(masterfd) < 0) e(0);

				masterfd = slavefd; /* ugly but saving code */
			} else
				if (close(slavefd) < 0) e(0);
		}

		if (access(tname, R_OK | W_OK) < 0) e(0);

		if (close(masterfd) < 0) e(0);

		if (access(tname, R_OK | W_OK) == 0) e(0);
	}

	/*
	 * Test whether we can open multiple pseudo terminals.  We need to be
	 * able to open three PTYs.  Verify that they are properly listed in
	 * the /dev/pts directory contents, and have proper attributes set.
	 */
	test_getdents(0, NULL, NULL);

	for (i = 0; i < 3; i++) {
		fd[i] = get_unix98_pty(&tname);

		/* Figure out the slave index number. */
		len = strlen(_PATH_DEV_PTS);
		if (strncmp(tname, _PATH_DEV_PTS, strlen(_PATH_DEV_PTS))) e(0);
		array[i] = atoi(&tname[len]);
		present[i] = 1;
	}

	test_getdents(3, array, present);

	if (close(fd[0]) < 0) e(0);
	present[0] = 0;

	test_getdents(3, array, present);

	if (close(fd[2]) < 0) e(0);
	present[2] = 0;

	test_getdents(3, array, present);

	if (close(fd[1]) < 0) e(0);
	present[1] = 0;

	test_getdents(3, array, present);

	/*
	 * Test chmod(2) on a slave node, and multiple calls to grantpt(3).
	 * The first grantpt(3) call should create the slave node (we currently
	 * can not test this: the slave node may be created earlier as well,
	 * but we do not know its name), whereas subsequent grantpt(3) calls
	 * should reset its mode, uid, and gid.  Testing the latter two and
	 * chown(2) on the slave node requires root, so we skip that part.
	 *
	 * Finally, NetBSD revokes access to existing slave file descriptors
	 * upon a call to grantpt(3).  This is not a POSIX requirement, but
	 * NetBSD needs this for security reasons because it already creates
	 * the slave node when the master is opened (and it does not lock the
	 * slave until a call to unlockpt(3)).  MINIX3 does not implement
	 * revocation this way, because the slave node is created only upon the
	 * call to grantpt(3), thus leaving no insecure window for the slave
	 * side between posix_openpt(3) and grantpt(3).  While this behavior
	 * may be changed later, we test for the lack of revocation here now.
	 */
	masterfd = get_unix98_pty(&tname);

	if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

	if (stat(tname, &buf) != 0) e(0);
	if (buf.st_mode != (S_IFCHR | 0620)) e(0);

	if (chmod(tname, S_IFCHR | 0630) != 0) e(0);

	if (stat(tname, &buf) != 0) e(0);
	if (buf.st_mode != (S_IFCHR | 0630)) e(0);

	if (grantpt(masterfd) != 0) e(0);

	if (stat(tname, &buf) != 0) e(0);
	if (buf.st_mode != (S_IFCHR | 0620)) e(0);

	test_comm(masterfd, slavefd);

	if (close(slavefd) < 0) e(0);
	if (close(masterfd) < 0) e(0);

	test_getdents(0, NULL, NULL);
}

/*
 * Check that the given PTY index, which is in use for an old-style PTY, is not
 * allocated through Unix98 PTY allocation.  This test is not foolproof, but it
 * does the job well enough.
 */
static void
test_overlap(int m)
{
	char *tname;
	size_t len;
	int i, n, fd[MIN_PTYS];

	for (i = 0; i < MIN_PTYS; i++) {
		if ((fd[i] = posix_openpt(O_RDWR | O_NOCTTY)) < 0)
			break; /* out of PTYs */
		if (grantpt(fd[i]) < 0) e(0);
		if (unlockpt(fd[i]) < 0) e(0);
		if ((tname = ptsname(fd[i])) == NULL) e(0);

		len = strlen(_PATH_DEV_PTS);
		if (strncmp(tname, _PATH_DEV_PTS, strlen(_PATH_DEV_PTS))) e(0);
		n = atoi(&tname[len]);
		if (n < 0 || n > 9) e(0);

		if (m == n) e(0);
	}

	for (i--; i >= 0; i--)
		if (close(fd[i]) < 0) e(0);
}

/*
 * Test for mixing access to old-style and Unix98 PTYs.  Since the PTY service
 * internally shares the set of pseudo terminals between the two types, it has
 * to implement checks to prevent that a PTY opened as one type is also
 * accessed through the other type.  We test some of those checks here.
 */
static void
test77h(void)
{
	char *tname, ptest[PATH_MAX], ttest[PATH_MAX];
	struct sigaction act, oact;
	size_t len;
	int i, n, masterfd, slavefd;

	subtest = 8;

	/* We do not want to get SIGHUP signals in this test. */
	memset(&act, 0, sizeof(act));
	act.sa_handler = SIG_IGN;
	if (sigaction(SIGHUP, &act, &oact) < 0) e(0);

	/*
	 * Check that Unix98 PTYs cannot be accessed through old-style device
	 * nodes.  We check different combinations of open master and
	 * slave ends for the Unix98 side (with 'i'): 0) opening and closing
	 * the master only, 1) closing a slave before the master, and 2)
	 * closing the slave after the master.
	 *
	 * This test relies on the implementation aspect that /dev/ttypN and
	 * /dev/pts/N (with N in the range 0..9) map to the same PTY.  It also
	 * relies on lack of concurrent PTY allocation outside the test.
	 */
	for (i = 0; i <= 2; i++) {
		/* Open a Unix98 PTY and get the slave name. */
		masterfd = get_unix98_pty(&tname);

		/* Figure out the slave index number. */
		len = strlen(_PATH_DEV_PTS);
		if (strncmp(tname, _PATH_DEV_PTS, strlen(_PATH_DEV_PTS))) e(0);
		n = atoi(&tname[len]);
		if (n < 0 || n > 9) e(0);

		/* Use this index number to create old-style device names. */
		snprintf(ptest, sizeof(ptest), _PATH_DEV "ptyp%u", n);
		snprintf(ttest, sizeof(ttest), _PATH_DEV "ttyp%u", n);

		/*
		 * Now make sure that opening the old-style master and slave
		 * fails as long as either side of the Unix98 PTY is open.
		 */
		if (open(ptest, O_RDWR | O_NOCTTY) >= 0) e(0);
		if (errno != EACCES && errno != EIO) e(0);
		if (open(ttest, O_RDWR | O_NOCTTY) >= 0) e(0);
		if (errno != EACCES && errno != EIO) e(0);

		if (i > 0) {
			if ((slavefd = open(tname, O_RDWR | O_NOCTTY)) < 0)
				e(0);

			if (open(ptest, O_RDWR | O_NOCTTY) >= 0) e(0);
			if (errno != EACCES && errno != EIO) e(0);
			if (open(ttest, O_RDWR | O_NOCTTY) >= 0) e(0);
			if (errno != EACCES && errno != EIO) e(0);

			if (close(slavefd) < 0) e(0);

			if (i > 1) {
				if (open(ptest, O_RDWR | O_NOCTTY) >= 0) e(0);
				if (errno != EACCES && errno != EIO) e(0);
				if (open(ttest, O_RDWR | O_NOCTTY) >= 0) e(0);
				if (errno != EACCES && errno != EIO) e(0);

				if ((slavefd =
				    open(tname, O_RDWR | O_NOCTTY)) < 0) e(0);

				if (open(ptest, O_RDWR | O_NOCTTY) >= 0) e(0);
				if (errno != EACCES && errno != EIO) e(0);
				if (open(ttest, O_RDWR | O_NOCTTY) >= 0) e(0);
				if (errno != EACCES && errno != EIO) e(0);

				if (close(masterfd) < 0) e(0);

				masterfd = slavefd; /* ugly but saving code */
			}

			if (open(ptest, O_RDWR | O_NOCTTY) >= 0) e(0);
			if (errno != EACCES && errno != EIO) e(0);
			if (open(ttest, O_RDWR | O_NOCTTY) >= 0) e(0);
			if (errno != EACCES && errno != EIO) e(0);
		}

		if (close(masterfd) < 0) e(0);

		/*
		 * Once both Unix98 sides are closed, the pseudo terminal can
		 * be reused.  Thus, opening the old-style master should now
		 * succeed.  However, it is possible that we do not have
		 * permission to open the master at all.
		 */
		if ((masterfd = open(ptest, O_RDWR | O_NOCTTY)) < 0 &&
		    errno != EACCES) e(0);

		if (masterfd >= 0 && close(masterfd) < 0) e(0);
	}

	/*
	 * The reverse test, which would check that old-style PTYs cannot be
	 * accessed through Unix98 device nodes, is impossible to perform
	 * properly without root privileges, as we would have to create device
	 * nodes manually with mknod(2).  All we can do here is ensure that if
	 * an old-style PTY is opened, it will not also be allocated as a
	 * Unix98 PTY.  We do a rather basic check, but only if we can open an
	 * old-style master at all.  We check two closing orders (with 'i'):
	 * 0) the slave first, 1) the master first.  Here, we make the hard
	 * assumption that the system supports at least four pseudo terminals,
	 * of which at least one is currently free.
	 */
	for (i = 0; i <= 1; i++) {
		for (n = 0; n < MIN_PTYS; n++) {
			snprintf(ptest, sizeof(ptest), _PATH_DEV "ptyp%u", n);

			if ((masterfd = open(ptest, O_RDWR | O_NOCTTY)) >= 0)
				break;
		}

		if (n >= MIN_PTYS)
			break;

		test_overlap(n);

		snprintf(ttest, sizeof(ttest), _PATH_DEV "ttyp%u", n);

		/* We can do part of the test only if we can open the slave. */
		if ((slavefd = open(ttest, O_RDWR | O_NOCTTY)) >= 0) {
			test_overlap(n);

			if (i > 0) {
				if (close(masterfd) < 0) e(0);

				masterfd = slavefd; /* again, ugly */
			} else
				if (close(slavefd) < 0) e(0);

			test_overlap(n);
		}

		if (close(masterfd) < 0) e(0);
	}

	if (sigaction(SIGHUP, &oact, NULL) < 0) e(0);
}

int
main(int argc, char **argv)
{
	int i, m;

	start(77);

	if (argc == 2)
		m = atoi(argv[1]);
	else
		m = 0xFF;

	for (i = 0; i < ITERATIONS; i++) {
		if (m & 0x01) test77a();
		if (m & 0x02) test77b();
		if (m & 0x04) test77c();
		if (m & 0x08) test77d();
		if (m & 0x10) test77e();
		if (m & 0x20) test77f();
		if (m & 0x40) test77g();
		if (m & 0x80) test77h();
	}

	quit();
}