NetBSD/usr.bin/at/at.c

/*	$NetBSD: at.c,v 1.27 2009/01/18 01:02:41 lukem Exp $	*/

/*
 *  at.c : Put file into atrun queue
 *  Copyright (C) 1993, 1994  Thomas Koenig
 *
 *  Atrun & Atq modifications
 *  Copyright (C) 1993  David Parsons
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. The name of the author(s) may not be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* System Headers */
#include <sys/types.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <ctype.h>
#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <locale.h>
#include <pwd.h>
#include <signal.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <util.h>

/* Local headers */
#include "at.h"
#include "panic.h"
#include "parsetime.h"
#include "perm.h"
#include "pathnames.h"
#include "stime.h"
#define MAIN
#include "privs.h"

/* Macros */
#define ALARMC 10		/* Number of seconds to wait for timeout */

#define TIMESIZE 50

enum { ATQ, ATRM, AT, BATCH, CAT };	/* what program we want to run */

/* File scope variables */
#ifndef lint
#if 0
static char rcsid[] = "$OpenBSD: at.c,v 1.15 1998/06/03 16:20:26 deraadt Exp $";
#else
__RCSID("$NetBSD: at.c,v 1.27 2009/01/18 01:02:41 lukem Exp $");
#endif
#endif

const char *no_export[] = {"TERM", "TERMCAP", "DISPLAY", "_"};
static int send_mail = 0;

/* External variables */

extern char **environ;
bool fcreated = false;
char atfile[FILENAME_MAX];

char *atinput = NULL;		/* where to get input from */
unsigned char atqueue = 0;	/* which queue to examine for jobs (atq) */
char atverify = 0;		/* verify time instead of queuing job */

/* Function declarations */

static void sigc	(int);
static void alarmc	(int);
static char *cwdname	(void);
static int  nextjob	(void);
static void writefile	(time_t, unsigned char);
static void list_jobs	(void);
static void process_jobs (int, char **, int);

/* Signal catching functions */

/*ARGSUSED*/
static void
sigc(int signo)
{

	/* If a signal interrupts us, remove the spool file and exit. */
	if (fcreated) {
		PRIV_START;
		(void)unlink(atfile);
		PRIV_END;
	}
	(void)raise_default_signal(signo);
	exit(EXIT_FAILURE);
}

/*ARGSUSED*/
static void
alarmc(int signo)
{

	/* Time out after some seconds. */
	warnx("File locking timed out");
	sigc(signo);
}

/* Local functions */

static char *
cwdname(void)
{

	/*
	 * Read in the current directory; the name will be overwritten on
	 * subsequent calls.
	 */
	static char path[MAXPATHLEN];

	return getcwd(path, sizeof(path));
}

static int
nextjob(void)
{
	int jobno;
	FILE *fid;

	if ((fid = fopen(_PATH_SEQFILE, "r+")) != NULL) {
		if (fscanf(fid, "%5x", &jobno) == 1) {
			(void)rewind(fid);
			jobno = (1+jobno) % 0xfffff;	/* 2^20 jobs enough? */
			(void)fprintf(fid, "%05x\n", jobno);
		} else
			jobno = EOF;
		(void)fclose(fid);
		return jobno;
	} else if ((fid = fopen(_PATH_SEQFILE, "w")) != NULL) {
		(void)fprintf(fid, "%05x\n", jobno = 1);
		(void)fclose(fid);
		return 1;
	}
	return EOF;
}

static void
writefile(time_t runtimer, unsigned char queue)
{
	/*
	 * This does most of the work if at or batch are invoked for
	 * writing a job.
	 */
	int jobno;
	char *ap, *ppos;
	const char *mailname;
	struct passwd *pass_entry;
	struct stat statbuf;
	int fdes, lockdes, fd2;
	FILE *fp, *fpin;
	struct sigaction act;
	char **atenv;
	int ch;
	mode_t cmask;
	struct flock lock;

	(void)setlocale(LC_TIME, "");

	/*
	 * Install the signal handler for SIGINT; terminate after removing the
	 * spool file if necessary
	 */
	(void)memset(&act, 0, sizeof(act));
	act.sa_handler = sigc;
	(void)sigemptyset(&act.sa_mask);
	act.sa_flags = 0;

	sigaction(SIGINT, &act, NULL);

	(void)strlcpy(atfile, _PATH_ATJOBS, sizeof(atfile));
	ppos = atfile + strlen(atfile);

	/*
	 * Loop over all possible file names for running something at this
	 * particular time, see if a file is there; the first empty slot at
	 * any particular time is used.  Lock the file _PATH_LOCKFILE first
	 * to make sure we're alone when doing this.
	 */

	PRIV_START;

	if ((lockdes = open(_PATH_LOCKFILE, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR)) < 0)
		perr("Cannot open lockfile " _PATH_LOCKFILE);

	lock.l_type = F_WRLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;

	act.sa_handler = alarmc;
	(void)sigemptyset(&act.sa_mask);
	act.sa_flags = 0;

	/*
	 * Set an alarm so a timeout occurs after ALARMC seconds, in case
	 * something is seriously broken.
	 */
	sigaction(SIGALRM, &act, NULL);
	(void)alarm(ALARMC);
	(void)fcntl(lockdes, F_SETLKW, &lock);
	(void)alarm(0);

	if ((jobno = nextjob()) == EOF)
	    perr("Cannot generate job number");

	(void)snprintf(ppos, sizeof(atfile) - (ppos - atfile),
	    "%c%5x%8lx", queue, jobno, (unsigned long) (runtimer/60));

	for (ap = ppos; *ap != '\0'; ap++)
		if (*ap == ' ')
			*ap = '0';

	if (stat(atfile, &statbuf) == -1)
		if (errno != ENOENT)
			perr("Cannot access " _PATH_ATJOBS);

	/*
	 * Create the file. The x bit is only going to be set after it has
	 * been completely written out, to make sure it is not executed in
	 * the meantime.  To make sure they do not get deleted, turn off
	 * their r bit.  Yes, this is a kluge.
	 */
	cmask = umask(S_IRUSR | S_IWUSR | S_IXUSR);
	if ((fdes = open(atfile, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR)) == -1)
		perr("Cannot create atjob file");

	if ((fd2 = dup(fdes)) == -1)
		perr("Error in dup() of job file");

	if (fchown(fd2, real_uid, real_gid) == -1)
		perr("Cannot give away file");

	PRIV_END;

	/*
	 * We've successfully created the file; let's set the flag so it
	 * gets removed in case of an interrupt or error.
	 */
	fcreated = true;

	/* Now we can release the lock, so other people can access it */
	lock.l_type = F_UNLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;
	(void)fcntl(lockdes, F_SETLKW, &lock);
	(void)close(lockdes);

	if ((fp = fdopen(fdes, "w")) == NULL)
		panic("Cannot reopen atjob file");

	/*
	 * Get the userid to mail to, first by trying getlogin(), which reads
	 * /etc/utmp, then from $LOGNAME or $USER, finally from getpwuid().
	 */
	mailname = getlogin();
	if (mailname == NULL && (mailname = getenv("LOGNAME")) == NULL)
		mailname = getenv("USER");

	if (mailname == NULL || mailname[0] == '\0' ||
	    strlen(mailname) > LOGIN_NAME_MAX || getpwnam(mailname) == NULL) {
		pass_entry = getpwuid(real_uid);
		if (pass_entry != NULL)
			mailname = pass_entry->pw_name;
	}

	if (atinput != NULL) {
		fpin = freopen(atinput, "r", stdin);
		if (fpin == NULL)
			perr("Cannot open input file");
	}
	(void)fprintf(fp,
	    "#!/bin/sh\n"
	    "# atrun uid=%u gid=%u\n"
	    "# mail %s %d\n",
	    real_uid, real_gid, mailname, send_mail);

	/* Write out the umask at the time of invocation */
	(void)fprintf(fp, "umask %o\n", cmask);

	/*
	 * Write out the environment. Anything that may look like a special
	 * character to the shell is quoted, except for \n, which is done
	 * with a pair of "'s.  Dont't export the no_export list (such as
	 * TERM or DISPLAY) because we don't want these.
	 */
	for (atenv = environ; *atenv != NULL; atenv++) {
		int export = 1;
		char *eqp;

		eqp = strchr(*atenv, '=');
		if (eqp == NULL)
			eqp = *atenv;
		else {
			size_t i;

			for (i = 0; i < __arraycount(no_export); i++) {
				export = export &&
				    strncmp(*atenv, no_export[i],
					(size_t)(eqp - *atenv)) != 0;
			}
			eqp++;
		}

		if (export) {
			(void)fwrite(*atenv, sizeof(char),
			    (size_t)(eqp - *atenv), fp);
			for (ap = eqp; *ap != '\0'; ap++) {
				if (*ap == '\n')
					(void)fprintf(fp, "\"\n\"");
				else {
					if (!isalnum((unsigned char)*ap)) {
						switch (*ap) {
						case '%': case '/': case '{':
						case '[': case ']': case '=':
						case '}': case '@': case '+':
						case '#': case ',': case '.':
						case ':': case '-': case '_':
							break;
						default:
							(void)fputc('\\', fp);
							break;
						}
					}
					(void)fputc(*ap, fp);
				}
			}
			(void)fputs("; export ", fp);
			(void)fwrite(*atenv, sizeof(char),
			    (size_t)(eqp - *atenv - 1), fp);
			(void)fputc('\n', fp);
		}
	}
	/*
	 * Cd to the directory at the time and write out all the
	 * commands the user supplies from stdin.
	 */
	(void)fputs("cd ", fp);
	for (ap = cwdname(); *ap != '\0'; ap++) {
		if (*ap == '\n')
			(void)fprintf(fp, "\"\n\"");
		else {
			if (*ap != '/' && !isalnum((unsigned char)*ap))
				(void)fputc('\\', fp);

			(void)fputc(*ap, fp);
		}
	}
	/*
	 * Test cd's exit status: die if the original directory has been
	 * removed, become unreadable or whatever.
	 */
	(void)fprintf(fp,
	    " || {\n"
	    "\t echo 'Execution directory inaccessible' >&2\n"
	    "\t exit 1\n"
	    "}\n");

	if ((ch = getchar()) == EOF)
		panic("Input error");

	do {
		(void)fputc(ch, fp);
	} while ((ch = getchar()) != EOF);

	(void)fprintf(fp, "\n");
	if (ferror(fp))
		panic("Output error");

	if (ferror(stdin))
		panic("Input error");

	(void)fclose(fp);

 	PRIV_START;

	/*
	 * Set the x bit so that we're ready to start executing
	 */
	if (fchmod(fd2, S_IRUSR | S_IWUSR | S_IXUSR) == -1)
		perr("Cannot give away file");

	PRIV_END;

	(void)close(fd2);
	(void)fprintf(stderr,
	    "Job %d will be executed using /bin/sh\n", jobno);
}

static void
list_jobs(void)
{
	/*
	 * List all a user's jobs in the queue, by looping through
	 * _PATH_ATJOBS, or everybody's if we are root
	 */
	struct passwd *pw;
	DIR *spool;
	struct dirent *dirent;
	struct stat buf;
	struct tm runtime;
	unsigned long ctm;
	unsigned char queue;
	int jobno;
	time_t runtimer;
	char timestr[TIMESIZE];
	int first = 1;

	PRIV_START;

	if (chdir(_PATH_ATJOBS) == -1)
		perr("Cannot change to " _PATH_ATJOBS);

	if ((spool = opendir(".")) == NULL)
		perr("Cannot open " _PATH_ATJOBS);

	/* Loop over every file in the directory */
	while ((dirent = readdir(spool)) != NULL) {
		if (stat(dirent->d_name, &buf) == -1)
			perr("Cannot stat in " _PATH_ATJOBS);

		/*
		 * See it's a regular file and has its x bit turned on and
		 * is the user's
		 */
		if (!S_ISREG(buf.st_mode)
		    || (buf.st_uid != real_uid && real_uid != 0)
		    || !(S_IXUSR & buf.st_mode || atverify))
			continue;

		if (sscanf(dirent->d_name, "%c%5x%8lx", &queue, &jobno, &ctm) != 3)
			continue;

		if (atqueue && queue != atqueue)
			continue;

		runtimer = 60 * (time_t)ctm;
		runtime = *localtime(&runtimer);
		(void)strftime(timestr, TIMESIZE, "%X %x", &runtime);
		if (first) {
			(void)printf("%-*s  %-*s  %-*s  %s\n",
			    (int)strlen(timestr), "Date",
			    LOGIN_NAME_MAX, "Owner",
			    7, "Queue",
			    "Job");
			first = 0;
		}
		pw = getpwuid(buf.st_uid);

		(void)printf("%s  %-*s  %c%-*s  %d\n",
		    timestr,
		    LOGIN_NAME_MAX, pw ? pw->pw_name : "???",
		    queue,
		    6, (S_IXUSR & buf.st_mode) ? "" : "(done)",
		    jobno);
	}
	PRIV_END;
}

static void
process_jobs(int argc, char **argv, int what)
{
	/* Delete every argument (job - ID) given */
	int i;
	struct stat buf;
	DIR *spool;
	struct dirent *dirent;
	unsigned long ctm;
	unsigned char queue;
	int jobno;

	PRIV_START;

	if (chdir(_PATH_ATJOBS) == -1)
		perr("Cannot change to " _PATH_ATJOBS);

	if ((spool = opendir(".")) == NULL)
		perr("Cannot open " _PATH_ATJOBS);

	PRIV_END;

	/* Loop over every file in the directory */
	while((dirent = readdir(spool)) != NULL) {

		PRIV_START;
		if (stat(dirent->d_name, &buf) == -1)
			perr("Cannot stat in " _PATH_ATJOBS);
		PRIV_END;

		if (sscanf(dirent->d_name, "%c%5x%8lx", &queue, &jobno, &ctm) !=3)
			continue;

		for (i = optind; i < argc; i++) {
			if (atoi(argv[i]) == jobno) {
				if (buf.st_uid != real_uid && real_uid != 0)
					errx(EXIT_FAILURE,
					    "%s: Not owner", argv[i]);

				switch (what) {
				case ATRM:
					PRIV_START;

					if (unlink(dirent->d_name) == -1)
						perr(dirent->d_name);

					PRIV_END;
					break;

				case CAT: {
					FILE *fp;
					int ch;

					PRIV_START;

					fp = fopen(dirent->d_name, "r");

					PRIV_END;

					if (!fp)
						perr("Cannot open file");
					else {
						while((ch = getc(fp)) != EOF)
							(void)putchar(ch);
						(void)fclose(fp);
					}
				}
					break;

				default:
					errx(EXIT_FAILURE,
					    "Internal error, process_jobs = %d",
						what);
					break;
				}
			}
		}
	}
}

/* Global functions */

int
main(int argc, char **argv)
{
	int c;
	unsigned char queue = DEFAULT_AT_QUEUE;
	char queue_set = 0;
	char time_set = 0;
	char *pgm;

	int program = AT;			/* our default program */
	const char *options = "q:f:t:mvldbrVc";	/* default options for at */
	int disp_version = 0;
	time_t timer;

	RELINQUISH_PRIVS;

	/* Eat any leading paths */
	if ((pgm = strrchr(argv[0], '/')) == NULL)
		pgm = argv[0];
	else
		pgm++;

	/* find out what this program is supposed to do */
	if (strcmp(pgm, "atq") == 0) {
		program = ATQ;
		options = "q:vV";
	} else if (strcmp(pgm, "atrm") == 0) {
		program = ATRM;
		options = "V";
	} else if (strcmp(pgm, "batch") == 0) {
		program = BATCH;
		options = "f:q:t:mvV";
	}

	/* process whatever options we can process */
	opterr = 1;
	while ((c = getopt(argc, argv, options)) != -1) {
		switch (c) {
		case 'v':	/* verify time settings */
			atverify = 1;
			break;

		case 'm':	/* send mail when job is complete */
			send_mail = 1;
			break;

		case 'f':
			atinput = optarg;
			break;

		case 'q':	/* specify queue */
			if (strlen(optarg) > 1)
				usage();

			atqueue = queue = *optarg;
			if (!(islower(queue) || isupper(queue)))
				usage();

			queue_set = 1;
			break;
		case 't':	/* touch(1) date format */
			timer = stime(optarg);
			time_set = 1;
			break;

		case 'd':
		case 'r':
			if (program != AT)
				usage();

			program = ATRM;
			options = "V";
			break;

		case 'l':
			if (program != AT)
				usage();

			program = ATQ;
			options = "q:vV";
			break;

		case 'b':
			if (program != AT)
				usage();

			program = BATCH;
			options = "f:q:mvV";
			break;

		case 'V':
			disp_version = 1;
			break;

		case 'c':
			program = CAT;
			options = "";
			break;

		default:
			usage();
			break;
		}
	} /* end of options eating */

	if (disp_version)
		(void)fprintf(stderr, "%s version %.1f\n", pgm, AT_VERSION);

	if (!check_permission())
		errx(EXIT_FAILURE,
		    "You do not have permission to use %s.", pgm);

	/* select our program */
	switch (program) {
	case ATQ:
		if (optind != argc)
			usage();
		list_jobs();
		break;

	case ATRM:
	case CAT:
		if (optind == argc)
			usage();
		process_jobs(argc, argv, program);
		break;

	case AT:
		if (argc > optind) {
			/* -t and timespec argument are mutually exclusive */
			if (time_set) {
				usage();
				exit(EXIT_FAILURE);
			} else {
				timer = parsetime(argc, argv);
				time_set = 1;
			}
		}

		if (atverify) {
			struct tm *tm = localtime(&timer);
			(void)fprintf(stderr, "%s\n", asctime(tm));
		}
		writefile(timer, queue);
		break;

	case BATCH:
		if (queue_set)
			queue = toupper(queue);
		else
			queue = DEFAULT_BATCH_QUEUE;

		if (argc > optind) {
			/* -t and timespec argument are mutually exclusive */
			if (time_set) {
				usage();
				exit(EXIT_FAILURE);
			} else {
				timer = parsetime(argc, argv);
				time_set = 1;
			}
		} else if (!time_set)
			timer = time(NULL);

		if (atverify) {
			struct tm *tm = localtime(&timer);
			(void)fprintf(stderr, "%s\n", asctime(tm));
		}

		writefile(timer, queue);
		break;

	default:
		panic("Internal error");
		break;
	}
	return EXIT_SUCCESS;
}