/*	$OpenBSD: nanosleep.c,v 1.9 2024/02/29 21:47:02 bluhm Exp $	*/
/*
 *	Written by Artur Grabowski <art@openbsd.org> 2002 Public Domain.
 */
#include <sys/types.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <err.h>
#include <signal.h>

int invalid_time(void);
int trivial(void);
int with_signal(void);
int time_elapsed(void);
int time_elapsed_with_signal(void);

int short_time(void);

void sighandler(int);

int
main(int argc, char **argv)
{
	int ch, ret;

	ret = 0;

	while ((ch = getopt(argc, argv, "itseES")) != -1) {
		switch (ch) {
		case 'i':
			ret |= invalid_time();
			break;
		case 't':
			ret |= trivial();
			break;
		case 's':
			ret |= with_signal();
			break;
		case 'e':
			ret |= time_elapsed();
			break;
		case 'E':
			ret |= time_elapsed_with_signal();
			break;
		case 'S':
			ret |= short_time();
			break;
		default:
			fprintf(stderr, "Usage: nanosleep [-itseSE]\n");
			exit(1);
		}
	}

	return (ret);
}

void
sighandler(int signum)
{
}

int
trivial(void)
{
	struct timespec timeout, remainder;

	timeout.tv_sec = 0;
	timeout.tv_nsec = 30000000;
	remainder.tv_sec = 4711;	/* Just add to the confusion */
	remainder.tv_nsec = 4711;
	if (nanosleep(&timeout, &remainder) < 0) {
		warn("%s: nanosleep", __func__);
		return 1;
	}

	/*
	 * Just check that we don't get any leftover time if we sleep the
	 * amount of time we want to sleep.
	 * If we receive any signal, something is wrong anyway.
	 */
	if (remainder.tv_sec != 0 || remainder.tv_nsec != 0) {
		warnx("%s: non-zero time: %lld.%09ld", __func__,
		    (long long)remainder.tv_sec, remainder.tv_nsec);
		return 1;
	}

	return 0;
}

int
with_signal(void)
{
	struct timespec timeout, remainder;
	pid_t pid;
	int status;

	signal(SIGUSR1, sighandler);

	pid = getpid();

	switch(fork()) {
	case -1:
		err(1, "fork");
	case 0:
		timeout.tv_sec = 1;
		timeout.tv_nsec = 0;
		nanosleep(&timeout, NULL);
		kill(pid, SIGUSR1);
		_exit(0);
	default:
		break;
	}

	timeout.tv_sec = 10;
	timeout.tv_nsec = 0;
	remainder.tv_sec = 0;
	remainder.tv_nsec = 0;
	if (nanosleep(&timeout, &remainder) == 0) {
		warnx("%s: nanosleep", __func__);
		return 1;
	}

	if (remainder.tv_sec == 0 && remainder.tv_nsec == 0) {
		warnx("%s: zero time", __func__);
		return 1;
	}

	if (wait(&status) < 0)
		err(1, "wait");
	if (status != 0)
		errx(1, "status");

	return 0;
}

int
time_elapsed(void)
{
	struct timespec timeout;
	struct timespec start, end, duration;

	timeout.tv_sec = 0;
	timeout.tv_nsec = 500000000;

	if (clock_gettime(CLOCK_MONOTONIC, &start) < 0) {
		warn("%s: clock_gettime", __func__);
		return 1;
	}

	if (nanosleep(&timeout, NULL) < 0) {
		warn("%s: nanosleep", __func__);
		return 1;
	}

	if (clock_gettime(CLOCK_MONOTONIC, &end) < 0) {
		warn("%s: clock_gettime", __func__);
		return 1;
	}

	timespecsub(&end, &start, &duration);

	if (duration.tv_sec == 0 && duration.tv_nsec < 500000000) {
		warnx("%s: slept less than 0.5 sec: %lld.%09ld", __func__,
		    (long long)duration.tv_sec, duration.tv_nsec);
		return 1;
	}

	return 0;
}

int
time_elapsed_with_signal(void)
{
	struct timespec timeout, remainder;
	struct timespec start, end, duration;
	pid_t pid;
	int status;

	signal(SIGUSR1, sighandler);

	pid = getpid();

	switch(fork()) {
	case -1:
		err(1, "fork");
	case 0:
		timeout.tv_sec = 1;
		timeout.tv_nsec = 0;
		nanosleep(&timeout, NULL);
		kill(pid, SIGUSR1);
		_exit(0);
	default:
		break;
	}

	if (clock_gettime(CLOCK_MONOTONIC, &start) < 0) {
		warn("%s: clock_gettime", __func__);
		return 1;
	}

	timeout.tv_sec = 10;
	timeout.tv_nsec = 0;
	remainder.tv_sec = 0;
	remainder.tv_nsec = 0;
	if (nanosleep(&timeout, &remainder) == 0) {
		warnx("%s: nanosleep", __func__);
		return 1;
	}

	if (clock_gettime(CLOCK_MONOTONIC, &end) < 0) {
		warn("%s: clock_gettime", __func__);
		return 1;
	}

	timespecsub(&end, &start, &duration);
	timespecadd(&duration, &remainder, &timeout);
	/* XXX remainder may be one tick too small */
	remainder.tv_sec = 0;
	remainder.tv_nsec = 10000000;
	timespecadd(&timeout, &remainder, &timeout);

	if (timeout.tv_sec < 10) {
		warnx("%s: slept time + leftover time < 10 sec: %lld.%09ld",
		    __func__, (long long)timeout.tv_sec, timeout.tv_nsec);
		return 1;
	}

	if (wait(&status) < 0)
		err(1, "wait");
	if (status != 0)
		errx(1, "status");

	return 0;
}

int
short_time(void)
{
	struct timespec timeout;
	pid_t pid;
	int status;

	signal(SIGUSR1, sighandler);

	pid = getpid();

	switch(fork()) {
	case -1:
		err(1, "fork");
	case 0:
		/* Sleep two seconds, then shoot parent. */
		timeout.tv_sec = 2;
		timeout.tv_nsec = 0;
		nanosleep(&timeout, NULL);
		kill(pid, SIGUSR1);
		_exit(0);
	default:
		break;
	}

	timeout.tv_sec = 0;
	timeout.tv_nsec = 1;
	if (nanosleep(&timeout, NULL) < 0) {
		warn("%s: nanosleep", __func__);
		return 1;
	}

	if (wait(&status) < 0)
		err(1, "wait");
	if (status != 0)
		errx(1, "status");

	return 0;
}

int
invalid_time(void)
{
	struct timespec timeout[3] = { {-1, 0}, {0, -1}, {0, 1000000000L} };
	int i, status;

	for (i = 0; i < 3; i++) {
		status = nanosleep(&timeout[i], NULL);
		if (status != -1 || errno != EINVAL) {
			warnx("%s: nanosleep %lld %ld", __func__,
			    (long long)timeout[i].tv_sec, timeout[i].tv_nsec);
			return 1;
		}
	}
	return 0;
}