From bef639521001043085233d09fd5baf914056a884 Mon Sep 17 00:00:00 2001 From: nate Date: Wed, 5 Jan 1994 01:09:14 +0000 Subject: Added at/atrm/atq/batch from Linux as hacked by Chris Demetriou. --- usr.bin/at/Makefile | 15 ++ usr.bin/at/at.1 | 216 ++++++++++++++++++ usr.bin/at/at.c | 562 ++++++++++++++++++++++++++++++++++++++++++++++ usr.bin/at/at.h | 34 +++ usr.bin/at/panic.c | 91 ++++++++ usr.bin/at/panic.h | 32 +++ usr.bin/at/parsetime.c | 591 +++++++++++++++++++++++++++++++++++++++++++++++++ usr.bin/at/parsetime.h | 29 +++ usr.bin/at/pathnames.h | 42 ++++ usr.bin/at/privs.h | 92 ++++++++ 10 files changed, 1704 insertions(+) create mode 100644 usr.bin/at/Makefile create mode 100644 usr.bin/at/at.1 create mode 100644 usr.bin/at/at.c create mode 100644 usr.bin/at/at.h create mode 100644 usr.bin/at/panic.c create mode 100644 usr.bin/at/panic.h create mode 100644 usr.bin/at/parsetime.c create mode 100644 usr.bin/at/parsetime.h create mode 100644 usr.bin/at/pathnames.h create mode 100644 usr.bin/at/privs.h (limited to 'usr.bin/at') diff --git a/usr.bin/at/Makefile b/usr.bin/at/Makefile new file mode 100644 index 0000000..a2f9b85 --- /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 diff --git a/usr.bin/at/at.1 b/usr.bin/at/at.1 new file mode 100644 index 0000000..869b8b6 --- /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 0000000..53959e3 --- /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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* 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 0000000..80da0fe --- /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 0000000..cd19b5a --- /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 +#include +#include +#include + +/* 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 0000000..3b9c2ea --- /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 0000000..64c4eea --- /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 +#include +#include +#include +#include +#include +#include +#include + +/* 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 + * + * /[ 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 0000000..5df23f6 --- /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 0000000..400ecfa --- /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 + +#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 0000000..e1ad1b4 --- /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 + +/* 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 -- cgit v1.1