Added at/atrm/atq/batch from Linux as hacked by Chris Demetriou.

10 files changed, 1704 insertions, 0 deletions

diff --git a/usr.bin/at/Makefile b/usr.bin/at/Makefile
new file mode 100644
index 000000000000..a2f9b8539a0f
--- /dev/null
+++ b/usr.bin/at/Makefile
@@ -0,0 +1,15 @@
+#	$Id: Makefile,v 1.1 1993/12/05 11:35:35 cgd Exp $
+
+PROG=	at
+SRCS=	at.c panic.c parsetime.c
+LINKS=	${BINDIR}/at ${BINDIR}/atq \
+	${BINDIR}/at ${BINDIR}/atrm \
+	${BINDIR}/at ${BINDIR}/batch
+MLINKS=	at.1 batch.1 \
+	at.1 atq.1 \
+	at.1 atrm.1
+
+BINOWN=	root
+BINMODE= 4555
+
+.include <bsd.prog.mk>
diff --git a/usr.bin/at/at.1 b/usr.bin/at/at.1
new file mode 100644
index 000000000000..869b8b6c329e
--- /dev/null
+++ b/usr.bin/at/at.1
@@ -0,0 +1,216 @@
+.\"
+.\" Copyright (c) 1993 Christopher G. Demetriou
+.\" All rights reserved.
+.\"
+.\" 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. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"      This product includes software developed by Christopher G. Demetriou.
+.\" 3. The name of the author may not be used to endorse or promote products
+.\"    derived from this software withough specific prior written permission
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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, WHETHER 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.
+.\"
+.\"	$Id: at.1,v 1.1 1993/12/05 11:36:29 cgd Exp $
+.\"
+.Dd December 5, 1993
+.Dt "AT" 1
+.Os NetBSD 0.9a
+.Sh NAME
+.Nm at, batch, atq, atrm
+.Nd queue, examine, or delete jobs for later execution
+.\"
+.Sh SYOPSIS
+.Nm at
+.Op Fl q Ar queue
+.Op Fl f Ar file
+.Op Fl m
+.Ar time
+.Pp
+.Nm atq
+.Op Fl q Ar queue
+.Op Fl v
+.Pp
+.Nm atrm
+.Ar job
+.Op Ar job ...
+.Pp
+.Nm batch
+.Op Fl f Ar file
+.Op Fl m
+.Ar time
+.Sh DESCRIPTION
+The
+.Nm at
+and
+.Nm batch
+utilities read commands from the standard input or a specified file
+which are to be executed at a later time, using
+.Xr sh 1 .
+.Pp
+The functions of the commands are as follows:
+.Bl -tag -width indent
+.It Nm at
+Executes commands at a specified time.
+.It Nm atq
+Lists the user's pending jobs, unless the user is
+the superuser.  In that case, everybody's jobs are
+listed.
+.It Nm atrm
+Deletes jobs.
+.It Nm batch
+executes commands when system load levels  permit.
+In other words, it executes the commands when the load
+average drops below a specified level.
+.El
+.Pp
+For both
+.Nm at
+and
+.Nm batch ,
+the working directory, environment (except for the variables
+.Nm TERM ,
+.Nm TERMCAP ,
+.Nm DISPLAY ,
+and
+.Nm _ )
+and the umask are retained from the time of invocation.  The user
+will be mailed the standard output and standard error from
+his commands if any output is generated.  If
+.Nm at
+is executed from a
+.Xr su 1
+shell, the owner of the login whell will receive the mail.
+.Sh OPTIONS
+.Bl -tag -width indent
+The available options are as follows:
+.It Fl q Ar queue
+Use the specified queue.  A queue designation consists
+of a single letter; valid queue designation range from
+.Ar a
+to
+.Ar l .
+The
+.Ar a
+queue is the default, and
+.Ar b
+is the batch queue.  Queues with higher letters run with
+increased niceness.  If
+.Nm atq
+is given a specific queue, it will only show jobs pending
+in that queue.
+.It Fl m
+Send mail to the user when the job has completed, even if
+there was no output.
+.It Fl f Ar file
+Reads the job from
+.Ar file
+rather than the standard input.
+.It Fl v
+Shows completed but not yet deleted jobs in the queue.
+.Sh TIME SPECIFICATION
+.Nm At
+allows some moderately complex time specifications.
+It accepts times of the form
+.Ar HHMM
+or
+.Ar HH:MM
+to run a job at a specific time of day.  If
+that time is already passed, the next day is assumed.
+You may also specify
+.Nm midnight ,
+.Nm noon ,
+or
+.Nm teatime
+(4PM) and you can give a time of day suffixed with
+.Nm AM
+or
+.Nm PM
+for running in the morning or the evening.  You can
+also specify the date on which the job will be run
+by giving a date in the form
+.Ar month-name day
+with an optional
+.Ar year ,
+or giving a date of the form
+.Ar MMDDYY ,
+.Ar MM/DD/YY
+or
+.Ar DD.MM.YY .
+You can also give times like
+.Nm now +
+.Ar count time-units ,
+where the time units can be
+.Nm minutes, hours, days,
+or
+.Nm weeks
+You can suffix the time with
+.Nm today
+to run the job today, or
+.Nm tomorrow
+to run the job tomorrow.
+.Pp
+For example, to run a job at 4PM three days from now, you
+would specify a time of
+.Nm 4PM + 3 days .
+To run a job at 10:00AM on on July 31, you would specify
+a time of
+.Nm 10AM Jul 31 .
+Finally, to run a job at 1AM tomorrow, you would specify
+a time of
+.Nm 1AM tomorrow .
+.Sh FILES
+.Bl -tag -width /var/at/lockfile -compact
+.It Pa /var/at/jobs
+Directory containing job files
+.It Pa /var/at/spool
+Directory containing output spool files
+.It Pa /var/at/lockfile
+Job-creation lock file.
+.It Pa /var/run/utmp
+.El
+.Sh SEE ALSO
+.Xr crond 8 ,
+.Xr nice 1 ,
+.Xr sh 1 ,
+.Xr atrun 8
+.Sh AUTHOR
+.Bl -tag
+Thomas Koenig, ig25@rz.uni-karlsruhe.de
+.El
+.Sh BUGS
+Traditional access control to
+.Nm at
+and
+.Nm batch
+via the files
+.Pa /var/at/at.allow
+and
+.Pa /var/at/at.deny
+is not implemented.
+.Pp
+If the file
+.Pa /var/run/utmp
+is not available or corrupted, or if the user is not
+logged in at the time
+.Nm at
+is invoked, the mail is sent to the userid found in the
+environment variable
+.Nm LOGNAME .
+If that is undefined or empty, the current userid is assumed.
diff --git a/usr.bin/at/at.c b/usr.bin/at/at.c
new file mode 100644
index 000000000000..53959e34c782
--- /dev/null
+++ b/usr.bin/at/at.c
@@ -0,0 +1,562 @@
+/*
+ * at.c : Put file into atrun queue
+ * Copyright (C) 1993  Thomas Koenig
+ *
+ * Atrun & Atq modifications
+ * Copyright (C) 1993  David Parsons
+ * All rights reserved.
+ *
+ * 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 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.
+ */
+
+#define _USE_BSD 1
+
+/* System Headers */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pwd.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+/* Local headers */
+#include "at.h"
+#include "panic.h"
+#include "parsetime.h"
+#include "pathnames.h"
+#define MAIN
+#include "privs.h"
+
+/* Macros */
+#define ALARMC 10		/* Number of seconds to wait for timeout */
+
+#define SIZE 255
+#define TIMESIZE 50
+
+/* File scope variables */
+static char rcsid[] = "$Id: at.c,v 1.2 1993/12/06 04:10:42 cgd Exp $";
+char *no_export[] =
+{
+	"TERM", "TERMCAP", "DISPLAY", "_"
+};
+static send_mail = 0;
+
+/* External variables */
+extern char **environ;
+int fcreated;
+char *namep;
+char atfile[FILENAME_MAX];
+
+char *atinput = (char *) 0;	/* where to get input from */
+char atqueue = 0;		/* which queue to examine for jobs (atq) */
+char atverify = 0;		/* verify time instead of queuing job */
+
+/* Function declarations */
+static void sigc	__P((int signo));
+static void alarmc	__P((int signo));
+static char *cwdname	__P((void));
+static void writefile	__P((time_t runtimer, char queue));
+static void list_jobs	__P((void));
+
+/* Signal catching functions */
+
+static void 
+sigc(signo)
+	int signo;
+{
+/* If the user presses ^C, remove the spool file and exit
+ */
+	if (fcreated) {
+		PRIV_START
+		unlink(atfile);
+		PRIV_END
+	}
+
+	exit(EXIT_FAILURE);
+}
+
+static void 
+alarmc(signo)
+	int signo;
+{
+/* Time out after some seconds
+ */
+	panic("File locking timed out");
+}
+
+/* Local functions */
+
+static char *
+cwdname()
+{
+/* Read in the current directory; the name will be overwritten on
+ * subsequent calls.
+ */
+	static char *ptr = NULL;
+	static size_t size = SIZE;
+
+	if (ptr == NULL)
+		ptr = (char *) malloc(size);
+
+	while (1) {
+		if (ptr == NULL)
+			panic("Out of memory");
+
+		if (getcwd(ptr, size - 1) != NULL)
+			return ptr;
+
+		if (errno != ERANGE)
+			perr("Cannot get directory");
+
+		free(ptr);
+		size += SIZE;
+		ptr = (char *) malloc(size);
+	}
+}
+
+static void
+writefile(runtimer, queue)
+	time_t runtimer;
+	char queue;
+{
+	/*
+	 * This does most of the work if at or batch are invoked for
+	 * writing a job.
+	 */
+	int i;
+	char *ap, *ppos, *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;
+
+	/*
+	 * Install the signal handler for SIGINT; terminate after removing the
+	 * spool file if necessary
+	 */
+	act.sa_handler = sigc;
+	sigemptyset(&(act.sa_mask));
+	act.sa_flags = 0;
+
+	sigaction(SIGINT, &act, NULL);
+
+	strcpy(atfile, _PATH_ATJOBS);
+	ppos = atfile + strlen(_PATH_ATJOBS);
+
+	/*
+	 * 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, 0600)) < 0)
+		perr2("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;
+	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);
+	alarm(ALARMC);
+	fcntl(lockdes, F_SETLKW, &lock);
+	alarm(0);
+
+	for (i = 0; i < AT_MAXJOBS; i++) {
+		sprintf(ppos, "%c%8lx.%3x", queue,
+		    (unsigned long) (runtimer / 60), i);
+		for (ap = ppos; *ap != '\0'; ap++)
+			if (*ap == ' ')
+				*ap = '0';
+
+		if (stat(atfile, &statbuf) != 0) {
+			if (errno == ENOENT)
+				break;
+			else
+				perr2("Cannot access ", _PATH_ATJOBS);
+		}
+	}			/* for */
+
+	if (i >= AT_MAXJOBS)
+		panic("Too many jobs already");
+
+	/*
+	 * 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 = creat(atfile, O_WRONLY)) == -1)
+		perr("Cannot create atjob file");
+
+	if ((fd2 = dup(fdes)) < 0)
+		perr("Error in dup() of job file");
+
+	if (fchown(fd2, real_uid, -1) != 0)
+		perr("Cannot give away file");
+
+	PRIV_END
+
+	/*
+	 * We no longer need suid root; now we just need to be able to
+	 * write to the directory, if necessary.
+	 */
+
+	    REDUCE_PRIV(0);
+
+	/*
+	 * We've successfully created the file; let's set the flag so it
+	 * gets removed in case of an interrupt or error.
+	 */
+	fcreated = 1;
+
+	/* 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;
+	fcntl(lockdes, F_SETLKW, &lock);
+	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, finally from getpwuid().
+	 */
+	mailname = getlogin();
+	if (mailname == NULL)
+		mailname = getenv("LOGNAME");
+
+	if ((mailname == NULL) || (mailname[0] == '\0')
+	    || (strlen(mailname) > 8)) {
+		pass_entry = getpwuid(getuid());
+		if (pass_entry != NULL)
+			mailname = pass_entry->pw_name;
+	}
+
+	if (atinput != (char *) NULL) {
+		fpin = freopen(atinput, "r", stdin);
+		if (fpin == NULL)
+			perr("Cannot open input file");
+	}
+	fprintf(fp, "#! /bin/sh\n# mail %8s %d\n", mailname, send_mail);
+
+	/* Write out the umask at the time of invocation */
+	fprintf(fp, "umask %lo\n", (unsigned long) 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 (ap == NULL)
+			eqp = *atenv;
+		else {
+			int i;
+
+			for (i = 0;i < sizeof(no_export) /
+			    sizeof(no_export[0]); i++) {
+				export = export
+				    && (strncmp(*atenv, no_export[i],
+					(size_t) (eqp - *atenv)) != 0);
+			}
+			eqp++;
+		}
+
+		if (export) {
+			fwrite(*atenv, sizeof(char), eqp - *atenv, fp);
+			for (ap = eqp; *ap != '\0'; ap++) {
+				if (*ap == '\n')
+					fprintf(fp, "\"\n\"");
+				else {
+					if (!isalnum(*ap))
+						fputc('\\', fp);
+
+					fputc(*ap, fp);
+				}
+			}
+			fputs("; export ", fp);
+			fwrite(*atenv, sizeof(char), eqp - *atenv - 1, fp);
+			fputc('\n', fp);
+
+		}
+	}
+	/*
+	 * Cd to the directory at the time and write out all the commands
+	 * the user supplies from stdin.
+	 */
+	fprintf(fp, "cd %s\n", cwdname());
+
+	while ((ch = getchar()) != EOF)
+		fputc(ch, fp);
+
+	fprintf(fp, "\n");
+	if (ferror(fp))
+		panic("Output error");
+
+	if (ferror(stdin))
+		panic("Input error");
+
+	fclose(fp);
+
+	/*
+	 * Set the x bit so that we're ready to start executing
+	 */
+	if (fchmod(fd2, S_IRUSR | S_IWUSR | S_IXUSR) < 0)
+		perr("Cannot give away file");
+
+	close(fd2);
+	fprintf(stderr, "Job %s will be executed using /bin/sh\n", ppos);
+}
+
+static void
+list_jobs()
+{
+	/*
+	 * 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;
+	char queue;
+	time_t runtimer;
+	char timestr[TIMESIZE];
+	int first = 1;
+
+	PRIV_START
+
+	    if (chdir(_PATH_ATJOBS) != 0)
+		perr2("Cannot change to ", _PATH_ATJOBS);
+
+	if ((spool = opendir(".")) == NULL)
+		perr2("Cannot open ", _PATH_ATJOBS);
+
+	/* Loop over every file in the directory */
+	while ((dirent = readdir(spool)) != NULL) {
+		if (stat(dirent->d_name, &buf) != 0)
+			perr2("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%8lx", &queue, &ctm) != 2)
+			continue;
+
+		if (atqueue && (queue != atqueue))
+			continue;
+
+		runtimer = 60 * (time_t) ctm;
+		runtime = *localtime(&runtimer);
+		strftime(timestr, TIMESIZE, "%X %x", &runtime);
+		if (first) {
+			printf("Date\t\t\tOwner\tQueue\tJob#\n");
+			first = 0;
+		}
+		pw = getpwuid(buf.st_uid);
+
+		printf("%s\t%s\t%c%s\t%s\n",
+		    timestr,
+		    pw ? pw->pw_name : "???",
+		    queue,
+		    (S_IXUSR & buf.st_mode) ? "" : "(done)",
+		    dirent->d_name);
+	}
+	PRIV_END
+}
+
+static void
+delete_jobs(argc, argv)
+	int argc;
+	char **argv;
+{
+	/* Delete every argument (job - ID) given */
+	int i;
+	struct stat buf;
+
+	PRIV_START
+
+	    if (chdir(_PATH_ATJOBS) != 0)
+		perr2("Cannot change to ", _PATH_ATJOBS);
+
+	for (i = optind; i < argc; i++) {
+		if (stat(argv[i], &buf) != 0)
+			perr(argv[i]);
+		if ((buf.st_uid != real_uid) && !(real_uid == 0)) {
+			fprintf(stderr, "%s: Not owner\n", argv[i]);
+			exit(EXIT_FAILURE);
+		}
+		if (unlink(argv[i]) != 0)
+			perr(argv[i]);
+	}
+	PRIV_END
+}				/* delete_jobs */
+
+/* Global functions */
+
+int
+main(argc, argv)
+	int argc;
+	char **argv;
+{
+	int c;
+	char queue = 'a';
+	char *pgm;
+
+	enum {
+		ATQ, ATRM, AT, BATCH
+	};			/* what program we want to run */
+	int program = AT;	/* our default program */
+	char *options = "q:f:mv";	/* default options for at */
+	time_t timer;
+
+	RELINQUISH_PRIVS
+
+	/* Eat any leading paths */
+	if ((pgm = strrchr(argv[0], '/')) == NULL)
+		pgm = argv[0];
+	else
+		pgm++;
+
+	namep = pgm;
+
+	/* find out what this program is supposed to do */
+	if (strcmp(pgm, "atq") == 0) {
+		program = ATQ;
+		options = "q:v";
+	} else if (strcmp(pgm, "atrm") == 0) {
+		program = ATRM;
+		options = "";
+	} else if (strcmp(pgm, "batch") == 0) {
+		program = BATCH;
+		options = "f:mv";
+	}
+
+	/* process whatever options we can process */
+	opterr = 1;
+	while ((c = getopt(argc, argv, options)) != EOF)
+		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)) || (queue > 'l'))
+				usage();
+			break;
+
+		default:
+			usage();
+			break;
+		}
+	/* end of options eating */
+
+	/* select our program */
+	switch (program) {
+	case ATQ:
+
+		REDUCE_PRIV(0);
+
+		list_jobs();
+		break;
+
+	case ATRM:
+
+		REDUCE_PRIV(0);
+
+		delete_jobs(argc, argv);
+		break;
+
+	case AT:
+		timer = parsetime(argc, argv);
+		if (atverify) {
+			struct tm *tm = localtime(&timer);
+
+			fprintf(stderr, "%s\n", asctime(tm));
+		}
+		writefile(timer, queue);
+		break;
+
+	case BATCH:
+		writefile(time(NULL), 'b');
+		break;
+
+	default:
+		panic("Internal error");
+		break;
+	}
+	exit(EXIT_SUCCESS);
+}
diff --git a/usr.bin/at/at.h b/usr.bin/at/at.h
new file mode 100644
index 000000000000..80da0fe979a8
--- /dev/null
+++ b/usr.bin/at/at.h
@@ -0,0 +1,34 @@
+/*
+ * at.h -  header for at(1)
+ * Copyright (c) 1993 by Thomas Koenig
+ * All rights reserved.
+ *
+ * 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 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.
+ *
+ *	$Id: at.h,v 1.1 1993/12/05 11:36:45 cgd Exp $
+ */
+
+extern int fcreated;
+extern char *namep;
+extern char atfile[];
+extern char atverify;
+
+#define AT_MAXJOBS	255	/* max jobs outstanding per user */
diff --git a/usr.bin/at/panic.c b/usr.bin/at/panic.c
new file mode 100644
index 000000000000..cd19b5a986d5
--- /dev/null
+++ b/usr.bin/at/panic.c
@@ -0,0 +1,91 @@
+/*
+ * panic.c - terminate fast in case of error
+ * Copyright (c) 1993 by Thomas Koenig
+ * All rights reserved.
+ *
+ * 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 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 <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Local headers */
+
+#include "panic.h"
+#include "at.h"
+
+/* File scope variables */
+
+static char rcsid[] = "$Id: panic.c,v 1.1 1993/12/05 11:36:51 cgd Exp $";
+
+/* External variables */
+
+/* Global functions */
+
+void
+panic(a)
+	char *a;
+{
+/* Something fatal has happened, print error message and exit.
+ */
+	fprintf(stderr, "%s: %s\n", namep, a);
+	if (fcreated)
+		unlink(atfile);
+
+	exit(EXIT_FAILURE);
+}
+
+void
+perr(a)
+	char *a;
+{
+/* Some operating system error; print error message and exit.
+ */
+	perror(a);
+	if (fcreated)
+		unlink(atfile);
+
+	exit(EXIT_FAILURE);
+}
+
+void 
+perr2(a, b)
+	char *a, *b;
+{
+	fprintf(stderr, "%s", a);
+	perr(b);
+}
+
+void
+usage(void)
+{
+/* Print usage and exit.
+*/
+	fprintf(stderr, "Usage: at [-q x] [-f file] [-m] time\n"
+	    "       atq [-q x] [-v]\n"
+	    "       atrm [-q x] job ...\n"
+	    "       batch [-f file] [-m]\n");
+	exit(EXIT_FAILURE);
+}
diff --git a/usr.bin/at/panic.h b/usr.bin/at/panic.h
new file mode 100644
index 000000000000..3b9c2eadea10
--- /dev/null
+++ b/usr.bin/at/panic.h
@@ -0,0 +1,32 @@
+/*
+ * panic.h -  header for at(1)
+ * Copyright (c) 1993 Thomas Koenig
+ * All rights reserved.
+ *
+ * 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 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.
+ *
+ *	$Id: panic.h,v 1.1 1993/12/05 11:36:58 cgd Exp $
+ */
+
+void panic	__P((char *a));
+void perr	__P((char *a));
+void perr2	__P((char *a, char *b));
+void usage	__P((void));
diff --git a/usr.bin/at/parsetime.c b/usr.bin/at/parsetime.c
new file mode 100644
index 000000000000..64c4eeaea1ee
--- /dev/null
+++ b/usr.bin/at/parsetime.c
@@ -0,0 +1,591 @@
+/* 
+ * parsetime.c - parse time for at(1)
+ * Copyright (C) 1993  Thomas Koenig
+ *
+ * modifications for english-language times
+ * Copyright (C) 1993  David Parsons
+ * All rights reserved.
+ *
+ * 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 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.
+ *
+ *  at [NOW] PLUS NUMBER MINUTES|HOURS|DAYS|WEEKS
+ *     /NUMBER [DOT NUMBER] [AM|PM]\ /[MONTH NUMBER [NUMBER]]             \
+ *     |NOON                       | |[TOMORROW]                          |
+ *     |MIDNIGHT                   | |NUMBER [SLASH NUMBER [SLASH NUMBER]]|
+ *     \TEATIME                    / \PLUS NUMBER MINUTES|HOURS|DAYS|WEEKS/
+ */
+
+/* System Headers */
+
+#include <sys/types.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <ctype.h>
+
+/* Local headers */
+
+#include "at.h"
+#include "panic.h"
+
+
+/* Structures and unions */
+
+enum {	/* symbols */
+    MIDNIGHT, NOON, TEATIME,
+    PM, AM, TOMORROW, TODAY, NOW,
+    MINUTES, HOURS, DAYS, WEEKS,
+    NUMBER, PLUS, DOT, SLASH, ID, JUNK,
+    JAN, FEB, MAR, APR, MAY, JUN,
+    JUL, AUG, SEP, OCT, NOV, DEC
+};
+
+/*
+ * parse translation table - table driven parsers can be your FRIEND!
+ */
+struct {
+    char *name;	/* token name */
+    int value;	/* token id */
+} Specials[] = {
+    { "midnight", MIDNIGHT },	/* 00:00:00 of today or tomorrow */
+    { "noon", NOON },		/* 12:00:00 of today or tomorrow */
+    { "teatime", TEATIME },	/* 16:00:00 of today or tomorrow */
+    { "am", AM },		/* morning times for 0-12 clock */
+    { "pm", PM },		/* evening times for 0-12 clock */
+    { "tomorrow", TOMORROW },	/* execute 24 hours from time */
+    { "today", TODAY },		/* execute today - don't advance time */
+    { "now", NOW },		/* opt prefix for PLUS */
+
+    { "minute", MINUTES },	/* minutes multiplier */
+    { "min", MINUTES },
+    { "m", MINUTES },
+    { "minutes", MINUTES },	/* (pluralized) */
+    { "hour", HOURS },		/* hours ... */
+    { "hr", HOURS },		/* abbreviated */
+    { "h", HOURS },
+    { "hours", HOURS },		/* (pluralized) */
+    { "day", DAYS },		/* days ... */
+    { "d", DAYS },
+    { "days", DAYS },		/* (pluralized) */
+    { "week", WEEKS },		/* week ... */
+    { "w", WEEKS },
+    { "weeks", WEEKS },		/* (pluralized) */
+    { "jan", JAN },
+    { "feb", FEB },
+    { "mar", MAR },
+    { "apr", APR },
+    { "may", MAY },
+    { "jun", JUN },
+    { "jul", JUL },
+    { "aug", AUG },
+    { "sep", SEP },
+    { "oct", OCT },
+    { "nov", NOV },
+    { "dec", DEC }
+} ;
+
+/* File scope variables */
+
+static char **scp;	/* scanner - pointer at arglist */
+static char scc;	/* scanner - count of remaining arguments */
+static char *sct;	/* scanner - next char pointer in current argument */
+static int need;	/* scanner - need to advance to next argument */
+
+static char *sc_token;	/* scanner - token buffer */
+static size_t sc_len;   /* scanner - lenght of token buffer */
+static int sc_tokid;	/* scanner - token id */
+
+static char rcsid[] = "$Id: parsetime.c,v 1.1 1993/12/05 11:37:05 cgd Exp $";
+
+/* Local functions */
+
+/*
+ * parse a token, checking if it's something special to us
+ */
+static int
+parse_token(arg)
+	char *arg;
+{
+    int i;
+
+    for (i=0; i<(sizeof Specials/sizeof Specials[0]); i++)
+	if (strcasecmp(Specials[i].name, arg) == 0) {
+	    return sc_tokid = Specials[i].value;
+	}
+
+    /* not special - must be some random id */
+    return ID;
+} /* parse_token */
+
+
+/*
+ * init_scanner() sets up the scanner to eat arguments
+ */
+static void
+init_scanner(argc, argv)
+	int argc;
+	char **argv;
+{
+    scp = argv;
+    scc = argc;
+    need = 1;
+    sc_len = 1;
+    while (--argc > 0)
+	sc_len += strlen(*++argv);
+
+    sc_token = (char *) malloc(sc_len);
+    if (sc_token == NULL)
+	panic("Insufficient virtual memory");
+} /* init_scanner */
+
+/*
+ * token() fetches a token from the input stream
+ */
+static int
+token()
+{
+    int idx;
+
+    while (1) {
+	memset(sc_token, 0, sc_len);
+	sc_tokid = EOF;
+	idx = 0;
+
+	/*
+	 * if we need to read another argument, walk along the argument list;
+	 * when we fall off the arglist, we'll just return EOF forever
+	 */
+	if (need) {
+	    if (scc < 1)
+		return sc_tokid;
+	    sct = *scp;
+	    scp++;
+	    scc--;
+	    need = 0;
+	}
+	/*
+	 * eat whitespace now - if we walk off the end of the argument,
+	 * we'll continue, which puts us up at the top of the while loop
+	 * to fetch the next argument in
+	 */
+	while (isspace(*sct))
+	    ++sct;
+	if (!*sct) {
+	    need = 1;
+	    continue;
+	}
+
+	/*
+	 * preserve the first character of the new token
+	 */
+	sc_token[0] = *sct++;
+
+	/*
+	 * then see what it is
+	 */
+	if (isdigit(sc_token[0])) {
+	    while (isdigit(*sct))
+		sc_token[++idx] = *sct++;
+	    sc_token[++idx] = 0;
+	    return sc_tokid = NUMBER;
+	} else if (isalpha(sc_token[0])) {
+	    while (isalpha(*sct))
+		sc_token[++idx] = *sct++;
+	    sc_token[++idx] = 0;
+	    return parse_token(sc_token);
+	}
+	else if (sc_token[0] == ':' || sc_token[0] == '.')
+	    return sc_tokid = DOT;
+	else if (sc_token[0] == '+')
+	    return sc_tokid = PLUS;
+	else if (*sct == '/')
+	    return sc_tokid = SLASH;
+	else
+	    return sc_tokid = JUNK;
+    } /* while (1) */
+} /* token */
+
+
+/*
+ * plonk() gives an appropriate error message if a token is incorrect
+ */
+static void
+plonk(tok)
+	int tok;
+{
+    panic((tok == EOF) ? "incomplete time"
+		       : "garbled time");
+} /* plonk */
+
+
+/* 
+ * expect() gets a token and dies most horribly if it's not the token we want
+ */
+static void
+expect(desired)
+	int desired;
+{
+    if (token() != desired)
+	plonk(sc_tokid);	/* and we die here... */
+} /* expect */
+
+
+/*
+ * dateadd() adds a number of minutes to a date.  It is extraordinarily
+ * stupid regarding day-of-month overflow, and will most likely not
+ * work properly
+ */
+static void
+dateadd(minutes, tm)
+	int minutes;
+	struct tm *tm;
+{
+    /* increment days */
+
+    while (minutes > 24*60) {
+	minutes -= 24*60;
+	tm->tm_mday++;
+    }
+
+    /* increment hours */
+    while (minutes > 60) {
+	minutes -= 60;
+	tm->tm_hour++;
+	if (tm->tm_hour > 23) {
+	    tm->tm_mday++;
+	    tm->tm_hour = 0;
+	}
+    }
+
+    /* increment minutes */
+    tm->tm_min += minutes;
+
+    if (tm->tm_min > 59) {
+	tm->tm_hour++;
+	tm->tm_min -= 60;
+
+	if (tm->tm_hour > 23) {
+	    tm->tm_mday++;
+	    tm->tm_hour = 0;
+	}
+    }
+} /* dateadd */
+
+
+/*
+ * plus() parses a now + time
+ *
+ *  at [NOW] PLUS NUMBER [MINUTES|HOURS|DAYS|WEEKS]
+ *
+ */
+static void
+plus(tm)
+	struct tm *tm;
+{
+    int delay;
+
+    expect(NUMBER);
+
+    delay = atoi(sc_token);
+
+    switch (token()) {
+    case WEEKS:
+	    delay *= 7;
+    case DAYS:
+	    delay *= 24;
+    case HOURS:
+	    delay *= 60;
+    case MINUTES:
+	    dateadd(delay, tm);
+	    return;
+    }
+    plonk(sc_tokid);
+} /* plus */
+
+
+/*
+ * tod() computes the time of day
+ *     [NUMBER [DOT NUMBER] [AM|PM]]
+ */
+static void
+tod(tm)
+	struct tm *tm;
+{
+    int hour, minute = 0;
+    int tlen;
+
+    hour = atoi(sc_token);
+    tlen = strlen(sc_token);
+
+    /*
+     * first pick out the time of day - if it's 4 digits, we assume
+     * a HHMM time, otherwise it's HH DOT MM time
+     */
+    if (token() == DOT) {
+	expect(NUMBER);
+	minute = atoi(sc_token);
+	if (minute > 59)
+	    panic("garbled time");
+	token();
+    } else if (tlen == 4) {
+	minute = hour%100;
+	if (minute > 59)
+	    panic("garbeld time");
+	hour = hour/100;
+    }
+
+    /*
+     * check if an AM or PM specifier was given
+     */
+    if (sc_tokid == AM || sc_tokid == PM) {
+	if (hour > 12)
+	    panic("garbled time");
+
+	if (sc_tokid == PM)
+	    hour += 12;
+	token();
+    } else if (hour > 23)
+	panic("garbled time");
+
+    /*
+     * if we specify an absolute time, we don't want to bump the day even
+     * if we've gone past that time - but if we're specifying a time plus
+     * a relative offset, it's okay to bump things
+     */
+    if ((sc_tokid == EOF || sc_tokid == PLUS) && tm->tm_hour > hour)
+	tm->tm_mday++;
+
+    tm->tm_hour = hour;
+    tm->tm_min = minute;
+    if (tm->tm_hour == 24) {
+	tm->tm_hour = 0;
+	tm->tm_mday++;
+    }
+} /* tod */
+
+
+/*
+ * assign_date() assigns a date, wrapping to next year if needed
+ */
+static void
+assign_date(tm, mday, mon, year)
+	struct tm *tm;
+	long mday, mon, year;
+{
+    if (year > 99) {
+	if (year > 1899)
+	    year -= 1900;
+	else
+	    panic("garbled time");
+    }
+
+    if (year < 0 &&
+	(tm->tm_mon > mon ||(tm->tm_mon == mon && tm->tm_mday > mday)))
+	year = tm->tm_year + 1;
+
+    tm->tm_mday = mday;
+    tm->tm_mon = mon;
+
+    if (year >= 0)
+	tm->tm_year = year;
+} /* assign_date */
+
+
+/* 
+ * month() picks apart a month specification
+ *
+ *  /[<month> NUMBER [NUMBER]]           \
+ *  |[TOMORROW]                          |
+ *  |NUMBER [SLASH NUMBER [SLASH NUMBER]]|
+ *  \PLUS NUMBER MINUTES|HOURS|DAYS|WEEKS/
+ */
+static void
+month(tm)
+	struct tm *tm;
+{
+    long year= (-1);
+    long mday, mon;
+    int tlen;
+
+    switch (sc_tokid) {
+    case PLUS:
+	    plus(tm);
+	    break;
+
+    case TOMORROW:
+	    /* do something tomorrow */
+	    tm->tm_mday ++;
+    case TODAY:	/* force ourselves to stay in today - no further processing */
+	    token();
+	    break;
+
+    case JAN: case FEB: case MAR: case APR: case MAY: case JUN:
+    case JUL: case AUG: case SEP: case OCT: case NOV: case DEC:
+	    /*
+	     * do month mday [year]
+	     */
+	    mon = (sc_tokid-JAN);
+	    expect(NUMBER);
+	    mday = atol(sc_token)-1;
+	    if (token() == NUMBER) {
+		year = atol(sc_token);
+		token();
+	    }
+	    assign_date(tm, mday, mon, year);
+	    break;
+
+    case NUMBER:
+	    /*
+	     * get numeric MMDDYY, mm/dd/yy, or dd.mm.yy
+	     */
+	    tlen = strlen(sc_token);
+	    mon = atol(sc_token);
+	    token();
+
+	    if (sc_tokid == SLASH || sc_tokid == DOT) {
+		int sep;
+
+		sep = sc_tokid;
+		expect(NUMBER);
+		mday = atol(sc_token);
+		if (token() == sep) {
+		    expect(NUMBER);
+		    year = atol(sc_token);
+		    token();
+		}
+
+		/*
+		 * flip months and days for european timing
+		 */
+		if (sep == DOT) {
+		    int x = mday;
+		    mday = mon;
+		    mon = x;
+		}
+	    } else if (tlen == 6 || tlen == 8) {
+		if (tlen == 8) {
+		    year = (mon % 10000) - 1900;
+		    mon /= 10000;
+		} else {
+		    year = mon % 100;
+		    mon /= 100;
+		}
+		mday = mon % 100;
+		mon /= 100;
+	    } else
+		panic("garbled time");
+
+	    mon--;
+	    if (mon < 0 || mon > 11 || mday < 1 || mday > 31)
+		panic("garbled time");
+
+	    assign_date(tm, mday, mon, year);
+	    break;
+    } /* case */
+} /* month */
+
+
+/* Global functions */
+
+time_t
+parsetime(argc, argv)
+	int argc;
+	char **argv;
+{
+/*
+ * Do the argument parsing, die if necessary, and return the time the job
+ * should be run.
+ */
+    time_t nowtimer, runtimer;
+    struct tm nowtime, runtime;
+    int hr = 0;
+    /* this MUST be initialized to zero for midnight/noon/teatime */
+
+    nowtimer = time(NULL);
+    nowtime = *localtime(&nowtimer);
+
+    runtime = nowtime;
+    runtime.tm_sec = 0;
+    runtime.tm_isdst = 0;
+
+    if (argc <= optind)
+	usage();
+
+    init_scanner(argc-optind, argv+optind);
+
+    switch (token()) {
+    case NOW:	/* now is optional prefix for PLUS tree */
+	    expect(PLUS);
+    case PLUS:
+	    plus(&runtime);
+	    break;
+
+    case NUMBER:
+	    tod(&runtime);
+	    month(&runtime);
+	    break;
+
+	    /*
+	     * evil coding for TEATIME|NOON|MIDNIGHT - we've initialised
+	     * hr to zero up above, then fall into this case in such a
+	     * way so we add +12 +4 hours to it for teatime, +12 hours
+	     * to it for noon, and nothing at all for midnight, then
+	     * set our runtime to that hour before leaping into the
+	     * month scanner
+	     */
+    case TEATIME:
+	    hr += 4;
+    case NOON:
+	    hr += 12;
+    case MIDNIGHT:
+	    if (runtime.tm_hour >= hr)
+		runtime.tm_mday++;
+	    runtime.tm_hour = hr;
+	    runtime.tm_min = 0;
+	    token();
+	    /* fall through to month setting */
+    default:
+	    month(&runtime);
+	    break;
+    } /* ugly case statement */
+    expect(EOF);
+
+    /*
+     * adjust for daylight savings time
+     */
+    runtime.tm_isdst = -1;
+    runtimer = mktime(&runtime);
+    if (runtime.tm_isdst > 0) {
+	runtimer -= 3600;
+	runtimer = mktime(&runtime);
+    }
+
+    if (runtimer < 0)
+	panic("garbled time");
+
+    if (nowtimer > runtimer)
+	panic("Trying to travel back in time");
+
+    return runtimer;
+} /* parsetime */
diff --git a/usr.bin/at/parsetime.h b/usr.bin/at/parsetime.h
new file mode 100644
index 000000000000..5df23f679d47
--- /dev/null
+++ b/usr.bin/at/parsetime.h
@@ -0,0 +1,29 @@
+/*
+ * at.h -  header for at(1)
+ * Copyright (c) 1993 by Thomas Koenig
+ * All rights reserved.
+ *
+ * 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 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.
+ *
+ *	$Id: parsetime.h,v 1.1 1993/12/05 11:37:17 cgd Exp $
+ */
+
+time_t parsetime	__P((int argc, char **argv));
diff --git a/usr.bin/at/pathnames.h b/usr.bin/at/pathnames.h
new file mode 100644
index 000000000000..400ecfa9023c
--- /dev/null
+++ b/usr.bin/at/pathnames.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 1993 Christopher G. Demetriou
+ * All rights reserved.
+ *
+ * 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. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Christopher G. Demetriou.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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, WHETHER 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.
+ *
+ *	$Id: pathnames.h,v 1.1 1993/12/05 11:37:23 cgd Exp $
+ */
+
+#ifndef _PATHNAMES_H_
+#define	_PATHNAMES_H_
+
+#include <paths.h>
+
+#define _PATH_ATJOBS	"/var/at/jobs/"
+#define _PATH_ATSPOOL	"/var/at/spool/"
+#define _PATH_LOCKFILE	"/var/at/lockfile"
+
+#endif				/* !_PATHNAMES_H_ */
diff --git a/usr.bin/at/privs.h b/usr.bin/at/privs.h
new file mode 100644
index 000000000000..e1ad1b48c930
--- /dev/null
+++ b/usr.bin/at/privs.h
@@ -0,0 +1,92 @@
+/*
+ * privs.h - header for privileged operations
+ * Copyright (c) 1993 by Thomas Koenig
+ * All rights reserved.
+ *
+ * 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 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.
+ *
+ *	$Id: privs.h,v 1.1 1993/12/05 11:37:29 cgd Exp $
+ */
+
+#ifndef _PRIVS_H
+#define _PRIVS_H
+
+#include <unistd.h>
+
+/* Relinquish privileges temporarily for a setuid program
+ * with the option of getting them back later.  This is done by swapping
+ * the real and effective userid BSD style.  Call RELINQUISH_PRIVS once
+ * at the beginning of the main program.  This will cause all operatons
+ * to be executed with the real userid.  When you need the privileges
+ * of the setuid invocation, call PRIV_START; when you no longer
+ * need it, call PRIV_END.  Note that it is an error to call PRIV_START
+ * and not PRIV_END within the same function.
+ *
+ * Use RELINQUISH_PRIVS_ROOT(a) if your program started out running
+ * as root, and you want to drop back the effective userid to a
+ * and the effective group id to b, with the option to get them back
+ * later.
+ *
+ * If you no longer need root privileges, but those of some other
+ * userid/groupid, you can call REDUCE_PRIV(a) when your effective
+ * is the user's.
+ *
+ * Problems: Do not use return between PRIV_START and PRIV_END; this
+ * will cause the program to continue running in an unprivileged
+ * state.
+ *
+ * It is NOT safe to call exec(), system() or popen() with a user-
+ * supplied program (i.e. without carefully checking PATH and any
+ * library load paths) with relinquished privileges; the called program
+ * can aquire them just as easily.  Set both effective and real userid
+ * to the real userid before calling any of them.
+ */
+
+#ifndef MAIN
+extern
+#endif
+uid_t real_uid, effective_uid;
+
+#define RELINQUISH_PRIVS { \
+	real_uid = getuid(); \
+	effective_uid = geteuid(); \
+	setreuid(effective_uid,real_uid); \
+}
+
+#define RELINQUISH_PRIVS_ROOT(a) { \
+	real_uid = (a); \
+	effective_uid = geteuid(); \
+	setreuid(effective_uid,real_uid); \
+}
+
+#define PRIV_START { \
+	setreuid(real_uid,effective_uid);
+
+#define PRIV_END \
+	setreuid(effective_uid,real_uid); \
+}
+
+#define REDUCE_PRIV(a) { \
+	setreuid(real_uid,effective_uid); \
+	effective_uid = (a); \
+	setreuid(effective_uid,real_uid); \
+}
+#endif