xref: /illumos-gate/usr/src/cmd/cron/at.c (revision 48bbca816818409505a6e214d0911fda44e622e3)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2011 Gary Mills
24  *
25  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
26  * Use is subject to license terms.
27  * Copyright (c) 2016 by Delphix. All rights reserved.
28  */
29 
30 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
31 /*	  All Rights Reserved  	*/
32 
33 #include <sys/resource.h>
34 #include <sys/stat.h>
35 #include <sys/types.h>
36 
37 #include <dirent.h>
38 #include <string.h>
39 #include <stdlib.h>
40 #include <fcntl.h>
41 #include <pwd.h>
42 #include <stdio.h>
43 #include <ctype.h>
44 #include <time.h>
45 #include <signal.h>
46 #include <errno.h>
47 #include <limits.h>
48 #include <ulimit.h>
49 #include <unistd.h>
50 #include <locale.h>
51 #include <libintl.h>
52 #include <tzfile.h>
53 #include <project.h>
54 #include <paths.h>
55 
56 #include "cron.h"
57 
58 #define	TMPFILE		"_at" /* prefix for temporary files	*/
59 /*
60  * Mode for creating files in ATDIR.
61  * Setuid bit on so that if an owner of a file gives that file
62  * away to someone else, the setuid bit will no longer be set.
63  * If this happens, atrun will not execute the file
64  */
65 #define	ATMODE		(S_ISUID | S_IRUSR | S_IRGRP | S_IROTH)
66 #define	ROOT		0	/* user-id of super-user */
67 #define	MAXTRYS		100	/* max trys to create at job file */
68 
69 #define	BADTIME		"bad time specification"
70 #define	BADQUEUE	"queue name must be a single character a-z"
71 #define	NOTCQUEUE	"queue c is reserved for cron entries"
72 #define	BADSHELL	"because your login shell isn't /usr/bin/sh,"\
73 			"you can't use at"
74 #define	WARNSHELL	"commands will be executed using %s\n"
75 #define	CANTCD		"can't change directory to the at directory"
76 #define	CANTCHOWN	"can't change the owner of your job to you"
77 #define	CANTCHUID	"can't change user identifier"
78 #define	CANTCREATE	"can't create a job for you"
79 #define	INVALIDUSER	"you are not a valid user (no entry in /etc/passwd)"
80 #define	NOOPENDIR	"can't open the at directory"
81 #define	NOTALLOWED	"you are not authorized to use at.  Sorry."
82 #define	USAGE\
83 	"usage: at [-c|-k|-s] [-m] [-f file] [-p project] [-q queuename] "\
84 	    "-t time\n"\
85 	"       at [-c|-k|-s] [-m] [-f file] [-p project] [-q queuename] "\
86 	    "timespec\n"\
87 	"       at -l [-p project] [-q queuename] [at_job_id...]\n"\
88 	"       at -r at_job_id ...\n"
89 
90 #define	FORMAT		"%a %b %e %H:%M:%S %Y"
91 
92 static int leap(int);
93 static int atoi_for2(char *);
94 static int check_queue(char *, int);
95 static int list_jobs(int, char **, int, int);
96 static int remove_jobs(int, char **, char *);
97 static void usage(void);
98 static void catch(int);
99 static void copy(char *, FILE *, int);
100 static void atime(struct tm *, struct tm *);
101 static int not_this_project(char *);
102 static char *mkjobname(time_t);
103 static time_t parse_time(char *);
104 static time_t gtime(struct tm *);
105 static void escapestr(const char *);
106 void atabort(char *)__NORETURN;
107 void yyerror(void);
108 extern int yyparse(void);
109 
110 extern void	audit_at_delete(char *, char *, int);
111 extern int	audit_at_create(char *, int);
112 extern int	audit_cron_is_anc_name(char *);
113 extern int	audit_cron_delete_anc_file(char *, char *);
114 
115 /*
116  * Error in getdate(3G)
117  */
118 static char 	*errlist[] = {
119 /* 0 */ 	"",
120 /* 1 */	"getdate: The DATEMSK environment variable is not set",
121 /* 2 */	"getdate: Error on \"open\" of the template file",
122 /* 3 */	"getdate: Error on \"stat\" of the template file",
123 /* 4 */	"getdate: The template file is not a regular file",
124 /* 5 */	"getdate: An error is encountered while reading the template",
125 /* 6 */	"getdate: Malloc(3C) failed",
126 /* 7 */	"getdate: There is no line in the template that matches the input",
127 /* 8 */	"getdate: Invalid input specification"
128 };
129 
130 int		gmtflag = 0;
131 int		mday[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
132 uid_t		user;
133 struct	tm	*tp, at, rt;
134 static int	cshflag		= 0;
135 static int	kshflag		= 0;
136 static int	shflag		= 0;
137 static int	mflag		= 0;
138 static int	pflag		= 0;
139 static char	*Shell;
140 static char	*tfname;
141 static char	pname[80];
142 static char	pname1[80];
143 static short	jobtype = ATEVENT;	/* set to 1 if batch job */
144 extern char	*argp;
145 extern int	per_errno;
146 static projid_t	project;
147 
148 int
149 main(int argc, char **argv)
150 {
151 	FILE		*inputfile;
152 	int		i, fd;
153 	int		try = 0;
154 	int		fflag = 0;
155 	int		lflag = 0;
156 	int		qflag = 0;
157 	int		rflag = 0;
158 	int		tflag = 0;
159 	int		c;
160 	int		tflen;
161 	char		*file;
162 	char		*login;
163 	char		*job;
164 	char		*jobfile = NULL; /* file containing job to be run */
165 	char		argpbuf[LINE_MAX], timebuf[80];
166 	time_t		now;
167 	time_t		when = 0;
168 	struct	tm	*ct;
169 	char		*proj;
170 	struct project	prj, *pprj;
171 	char		mybuf[PROJECT_BUFSZ];
172 	char		ipbuf[PROJECT_BUFSZ];
173 
174 	(void) setlocale(LC_ALL, "");
175 #if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
176 #define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it weren't */
177 #endif
178 	(void) textdomain(TEXT_DOMAIN);
179 
180 	user = getuid();
181 	login = getuser(user);
182 	if (login == NULL) {
183 		if (per_errno == 2)
184 			atabort(BADSHELL);
185 		else
186 			atabort(INVALIDUSER);
187 	}
188 
189 	if (!allowed(login, ATALLOW, ATDENY))
190 		atabort(NOTALLOWED);
191 
192 	while ((c = getopt(argc, argv, "cklmsrf:p:q:t:")) != EOF)
193 		switch (c) {
194 			case 'c':
195 				cshflag++;
196 				break;
197 			case 'f':
198 				fflag++;
199 				jobfile = optarg;
200 				break;
201 			case 'k':
202 				kshflag++;
203 				break;
204 			case 'l':
205 				lflag++;
206 				break;
207 			case 'm':
208 				mflag++;
209 				break;
210 			case 'p':
211 				proj = optarg;
212 				pprj = &prj;
213 				if ((pprj = getprojbyname(proj, pprj,
214 				    (void *)&mybuf, sizeof (mybuf))) != NULL) {
215 					project = pprj->pj_projid;
216 					if (inproj(login, pprj->pj_name,
217 					    (void *)&ipbuf, sizeof (ipbuf)))
218 						pflag++;
219 					else {
220 						(void) fprintf(stderr,
221 						    gettext("at: user %s is "
222 						    "not a member of "
223 						    "project %s (%d)\n"),
224 						    login, pprj->pj_name,
225 						    project);
226 						exit(2);
227 					}
228 					break;
229 				}
230 				pprj = &prj;
231 				if (isdigit(proj[0]) &&
232 				    (pprj = getprojbyid(atoi(proj), pprj,
233 				    (void *)&mybuf, sizeof (mybuf))) != NULL) {
234 					project = pprj->pj_projid;
235 					if (inproj(login, pprj->pj_name,
236 					    (void *)&ipbuf, sizeof (ipbuf)))
237 						pflag++;
238 					else {
239 						(void) fprintf(stderr,
240 						    gettext("at: user %s is "
241 						    "not a member of "
242 						    "project %s (%d)\n"),
243 						    login, pprj->pj_name,
244 						    project);
245 						exit(2);
246 					}
247 					break;
248 				}
249 				(void) fprintf(stderr, gettext("at: project "
250 				    "%s not found.\n"), proj);
251 				exit(2);
252 				break;
253 			case 'q':
254 				qflag++;
255 				if (optarg[1] != '\0')
256 					atabort(BADQUEUE);
257 				jobtype = *optarg - 'a';
258 				if ((jobtype < 0) || (jobtype > 25))
259 					atabort(BADQUEUE);
260 				if (jobtype == 2)
261 					atabort(NOTCQUEUE);
262 				break;
263 			case 'r':
264 				rflag++;
265 				break;
266 			case 's':
267 				shflag++;
268 				break;
269 			case 't':
270 				tflag++;
271 				when = parse_time(optarg);
272 				break;
273 			default:
274 				usage();
275 		}
276 
277 	argc -= optind;
278 	argv += optind;
279 
280 	if (lflag + rflag > 1)
281 		usage();
282 
283 	if (lflag) {
284 		if (cshflag || kshflag || shflag || mflag ||
285 		    fflag || tflag || rflag)
286 			usage();
287 		return (list_jobs(argc, argv, qflag, jobtype));
288 	}
289 
290 	if (rflag) {
291 		if (cshflag || kshflag || shflag || mflag ||
292 		    fflag || tflag || qflag)
293 			usage();
294 		return (remove_jobs(argc, argv, login));
295 	}
296 
297 	if ((argc + tflag == 0) && (jobtype != BATCHEVENT))
298 		usage();
299 
300 	if (cshflag + kshflag + shflag > 1)
301 		atabort("ambiguous shell request");
302 
303 	time(&now);
304 
305 	if (jobtype == BATCHEVENT)
306 		when = now;
307 
308 	if (when == 0) { /* figure out what time to run the job */
309 		int	argplen = sizeof (argpbuf) - 1;
310 
311 		argpbuf[0] = '\0';
312 		argp = argpbuf;
313 		i = 0;
314 		while (i < argc) {
315 			/* guard against buffer overflow */
316 			argplen -= strlen(argv[i]) + 1;
317 			if (argplen < 0)
318 				atabort(BADTIME);
319 
320 			strcat(argp, argv[i]);
321 			strcat(argp, " ");
322 			i++;
323 		}
324 		if ((file = getenv("DATEMSK")) == 0 || file[0] == '\0') {
325 			tp = localtime(&now);
326 			/*
327 			 * Fix for 1047182 - we have to let yyparse
328 			 * check bounds on mday[] first, then fixup
329 			 * the leap year case.
330 			 */
331 			yyparse();
332 
333 			mday[1] = 28 + leap(at.tm_year);
334 
335 			if (at.tm_mday > mday[at.tm_mon])
336 				atabort("bad date");
337 
338 			atime(&at, &rt);
339 			when = gtime(&at);
340 			if (!gmtflag) {
341 				when += timezone;
342 				if (localtime(&when)->tm_isdst)
343 					when -= (timezone-altzone);
344 			}
345 		} else {	/*   DATEMSK is set  */
346 			if ((ct = getdate(argpbuf)) == NULL)
347 				atabort(errlist[getdate_err]);
348 			else
349 				when = mktime(ct);
350 		}
351 	}
352 
353 	if (when < now)	/* time has already past */
354 		atabort("too late");
355 
356 	tflen = strlen(ATDIR) + 1 + strlen(TMPFILE) +
357 	    10 + 1; /* 10 for an INT_MAX pid */
358 	tfname = xmalloc(tflen);
359 	snprintf(tfname, tflen, "%s/%s%d", ATDIR, TMPFILE, getpid());
360 
361 	/* catch INT, HUP, TERM and QUIT signals */
362 	if (signal(SIGINT, catch) == SIG_IGN)
363 		signal(SIGINT, SIG_IGN);
364 	if (signal(SIGHUP, catch) == SIG_IGN)
365 		signal(SIGHUP, SIG_IGN);
366 	if (signal(SIGQUIT, catch) == SIG_IGN)
367 		signal(SIGQUIT, SIG_IGN);
368 	if (signal(SIGTERM, catch) == SIG_IGN)
369 		signal(SIGTERM, SIG_IGN);
370 	if ((fd = open(tfname, O_CREAT|O_EXCL|O_WRONLY, ATMODE)) < 0)
371 		atabort(CANTCREATE);
372 	if (chown(tfname, user, getgid()) == -1) {
373 		unlink(tfname);
374 		atabort(CANTCHOWN);
375 	}
376 	close(1);
377 	dup(fd);
378 	close(fd);
379 	sprintf(pname, "%s", PROTO);
380 	sprintf(pname1, "%s.%c", PROTO, 'a'+jobtype);
381 
382 	/*
383 	 * Open the input file with the user's permissions.
384 	 */
385 	if (jobfile != NULL) {
386 		if ((seteuid(user) < 0) ||
387 		    (inputfile = fopen(jobfile, "r")) == NULL) {
388 			unlink(tfname);
389 			fprintf(stderr, "at: %s: %s\n", jobfile, errmsg(errno));
390 			exit(1);
391 		}
392 		else
393 			seteuid(0);
394 	} else
395 		inputfile = stdin;
396 
397 	copy(jobfile, inputfile, when);
398 	while (rename(tfname, job = mkjobname(when)) == -1) {
399 		sleep(1);
400 		if (++try > MAXTRYS / 10) {
401 			unlink(tfname);
402 			atabort(CANTCREATE);
403 		}
404 	}
405 	unlink(tfname);
406 	if (audit_at_create(job, 0))
407 		atabort(CANTCREATE);
408 
409 	cron_sendmsg(ADD, login, strrchr(job, '/')+1, AT);
410 	if (per_errno == 2)
411 		fprintf(stderr, gettext(WARNSHELL), Shell);
412 	cftime(timebuf, FORMAT, &when);
413 	fprintf(stderr, gettext("job %s at %s\n"),
414 	    strrchr(job, '/')+1, timebuf);
415 	if (when - MINUTE < HOUR)
416 		fprintf(stderr, gettext(
417 		    "at: this job may not be executed at the proper time.\n"));
418 	return (0);
419 }
420 
421 
422 static char *
423 mkjobname(t)
424 time_t t;
425 {
426 	int i, fd;
427 	char *name;
428 
429 	name = xmalloc(200);
430 	for (i = 0; i < MAXTRYS; i++) {
431 		sprintf(name, "%s/%ld.%c", ATDIR, t, 'a'+jobtype);
432 		/* fix for 1099183, 1116833 - create file here, avoid race */
433 		if ((fd = open(name, O_CREAT | O_EXCL, ATMODE)) > 0) {
434 			close(fd);
435 			return (name);
436 		}
437 		t += 1;
438 	}
439 	atabort("queue full");
440 	/* NOTREACHED */
441 }
442 
443 
444 static void
445 catch(int x)
446 {
447 	unlink(tfname);
448 	exit(1);
449 }
450 
451 
452 void
453 atabort(msg)
454 char *msg;
455 {
456 	fprintf(stderr, "at: %s\n", gettext(msg));
457 
458 	exit(1);
459 }
460 
461 int
462 yywrap(void)
463 {
464 	return (1);
465 }
466 
467 void
468 yyerror(void)
469 {
470 	atabort(BADTIME);
471 }
472 
473 /*
474  * add time structures logically
475  */
476 static void
477 atime(struct tm *a, struct tm *b)
478 {
479 	if ((a->tm_sec += b->tm_sec) >= 60) {
480 		b->tm_min += a->tm_sec / 60;
481 		a->tm_sec %= 60;
482 	}
483 	if ((a->tm_min += b->tm_min) >= 60) {
484 		b->tm_hour += a->tm_min / 60;
485 		a->tm_min %= 60;
486 	}
487 	if ((a->tm_hour += b->tm_hour) >= 24) {
488 		b->tm_mday += a->tm_hour / 24;
489 		a->tm_hour %= 24;
490 	}
491 	a->tm_year += b->tm_year;
492 	if ((a->tm_mon += b->tm_mon) >= 12) {
493 		a->tm_year += a->tm_mon / 12;
494 		a->tm_mon %= 12;
495 	}
496 	a->tm_mday += b->tm_mday;
497 	mday[1] = 28 + leap(a->tm_year);
498 	while (a->tm_mday > mday[a->tm_mon]) {
499 		a->tm_mday -= mday[a->tm_mon++];
500 		if (a->tm_mon > 11) {
501 			a->tm_mon = 0;
502 			mday[1] = 28 + leap(++a->tm_year);
503 		}
504 	}
505 
506 }
507 
508 static int
509 leap(int year)
510 {
511 	return (isleap(year + TM_YEAR_BASE));
512 }
513 
514 /*
515  * return time from time structure
516  */
517 static time_t
518 gtime(tptr)
519 struct	tm *tptr;
520 {
521 	int i;
522 	long	tv;
523 	int	dmsize[12] =
524 	    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
525 
526 
527 	tv = 0;
528 	for (i = 1970; i != tptr->tm_year+TM_YEAR_BASE; i++)
529 		tv += (365 + isleap(i));
530 		/*
531 		 * We call isleap since leap() adds
532 		 * 1900 onto any value passed
533 		 */
534 
535 	if (!leap(tptr->tm_year) && at.tm_mday == 29 && at.tm_mon == 1)
536 		atabort("bad date - not a leap year");
537 
538 	if ((leap(tptr->tm_year)) && tptr->tm_mon >= 2)
539 		++tv;
540 
541 	for (i = 0; i < tptr->tm_mon; ++i)
542 		tv += dmsize[i];
543 	tv += tptr->tm_mday - 1;
544 	tv = 24 * tv + tptr->tm_hour;
545 	tv = 60 * tv + tptr->tm_min;
546 	tv = 60 * tv + tptr->tm_sec;
547 	return (tv);
548 }
549 
550 /*
551  * Escape a string to be used inside the job shell script.
552  */
553 static void
554 escapestr(const char *str)
555 {
556 	char c;
557 	(void) putchar('\'');
558 	while ((c = *str++) != '\0') {
559 		if (c != '\'')
560 			(void) putchar(c);
561 		else
562 			(void) fputs("'\\''", stdout); /* ' -> '\'' */
563 	}
564 	(void) putchar('\'');
565 }
566 
567 /*
568  * make job file from proto + stdin
569  */
570 static void
571 copy(char *jobfile, FILE *inputfile, int when)
572 {
573 	int c;
574 	FILE *pfp;
575 	char *shell;
576 	char	dirbuf[PATH_MAX + 1];
577 	char	line[LINE_MAX];
578 	char **ep;
579 	mode_t um;
580 	char *val;
581 	extern char **environ;
582 	uid_t realusr, effeusr;
583 	int ttyinput;
584 	int ulimit_flag = 0;
585 	struct rlimit rlp;
586 	struct project prj, *pprj;
587 	char pbuf[PROJECT_BUFSZ];
588 	char pbuf2[PROJECT_BUFSZ];
589 	char *user;
590 
591 	/*
592 	 * Fix for 1099381:
593 	 * If the inputfile is from a tty, then turn on prompting, and
594 	 * put out a prompt now, instead of waiting for a lot of file
595 	 * activity to complete.
596 	 */
597 	ttyinput = isatty(fileno(inputfile));
598 	if (ttyinput) {
599 		fputs("at> ", stderr);
600 		fflush(stderr);
601 	}
602 
603 	/*
604 	 * Fix for 1053807:
605 	 * Determine what shell we should use to run the job. If the user
606 	 * didn't explicitly request that their current shell be over-
607 	 * ridden (shflag or cshflag), then we use the current shell.
608 	 */
609 	if (cshflag)
610 		Shell = shell = "/bin/csh";
611 	else if (kshflag) {
612 		Shell = shell = "/bin/ksh";
613 		ulimit_flag = 1;
614 	} else if (shflag) {
615 		Shell = shell = "/bin/sh";
616 		ulimit_flag = 1;
617 	} else if (((Shell = val = getenv("SHELL")) != NULL) &&
618 	    (*val != '\0')) {
619 		shell = "$SHELL";
620 		if ((strstr(val, "/sh") != NULL) ||
621 		    (strstr(val, "/ksh") != NULL))
622 			ulimit_flag = 1;
623 	} else {
624 		/* SHELL is NULL or unset, therefore use default */
625 		Shell = shell = _PATH_BSHELL;
626 		ulimit_flag = 1;
627 	}
628 
629 	printf(": %s job\n", jobtype ? "batch" : "at");
630 	printf(": jobname: %.127s\n", (jobfile == NULL) ? "stdin" : jobfile);
631 	printf(": notify by mail: %s\n", (mflag) ? "yes" : "no");
632 
633 	if (pflag) {
634 		(void) printf(": project: %d\n", project);
635 	} else {
636 		/*
637 		 * Check if current user is a member of current project.
638 		 * This check is done here to avoid setproject() failure
639 		 * later when the job gets executed.  If current user does
640 		 * not belong to current project, user's default project
641 		 * will be used instead.  This is achieved by not specifying
642 		 * the project (": project: <project>\n") in the job file.
643 		 */
644 		if ((user = getuser(getuid())) == NULL)
645 			atabort(INVALIDUSER);
646 		project = getprojid();
647 		pprj = getprojbyid(project, &prj, pbuf, sizeof (pbuf));
648 		if (pprj != NULL) {
649 			if (inproj(user, pprj->pj_name, pbuf2, sizeof (pbuf2)))
650 				(void) printf(": project: %d\n", project);
651 		}
652 	}
653 
654 	for (ep = environ; *ep; ep++) {
655 		if ((val = strchr(*ep, '=')) == NULL)
656 			continue;
657 		*val++ = '\0';
658 		(void) printf("export %s; %s=", *ep, *ep);
659 		escapestr(val);
660 		(void) putchar('\n');
661 		*--val = '=';
662 	}
663 	if ((pfp = fopen(pname1, "r")) == NULL &&
664 	    (pfp = fopen(pname, "r")) == NULL)
665 		atabort("no prototype");
666 	/*
667 	 * Put in a line to run the proper shell using the rest of
668 	 * the file as input.  Note that 'exec'ing the shell will
669 	 * cause sh() to leave a /tmp/sh### file around. (1053807)
670 	 */
671 	printf("%s << '...the rest of this file is shell input'\n", shell);
672 
673 	um = umask(0);
674 	while ((c = getc(pfp)) != EOF) {
675 		if (c != '$')
676 			putchar(c);
677 		else switch (c =  getc(pfp)) {
678 		case EOF:
679 			goto out;
680 		case 'd':
681 			/*
682 			 * Must obtain current working directory as the user
683 			 */
684 
685 			dirbuf[0] = '\0';
686 			realusr = getuid();
687 			effeusr = geteuid();
688 			/* change euid for getcwd */
689 			if (seteuid(realusr) < 0) {
690 				atabort(CANTCHUID);
691 			}
692 			if (getcwd(dirbuf, sizeof (dirbuf)) == NULL) {
693 				atabort(
694 				    "can't obtain current working directory");
695 			}
696 			/* change back afterwards */
697 			if (seteuid(effeusr) < 0) {
698 				atabort(CANTCHUID);
699 			}
700 			escapestr(dirbuf);
701 			break;
702 		case 'm':
703 			printf("%o", um);
704 			break;
705 		case '<':
706 			if (ulimit_flag) {
707 				if (getrlimit(RLIMIT_FSIZE, &rlp) == 0) {
708 					if (rlp.rlim_cur == RLIM_INFINITY)
709 						printf("ulimit unlimited\n");
710 					else
711 						printf("ulimit %lld\n",
712 						    rlp.rlim_cur / 512);
713 				}
714 			}
715 			/*
716 			 * fix for 1113572 - use fputs() so that a
717 			 * newline isn't appended to the one returned
718 			 * with fgets(); 1099381 - prompt for input.
719 			 */
720 			while (fgets(line, LINE_MAX, inputfile) != NULL) {
721 				fputs(line, stdout);
722 				if (ttyinput)
723 					fputs("at> ", stderr);
724 			}
725 			if (ttyinput) /* clean up the final output */
726 				fputs("<EOT>\n", stderr);
727 			break;
728 		case 't':
729 			printf(":%lu", when);
730 			break;
731 		default:
732 			putchar(c);
733 		}
734 	}
735 out:
736 	fclose(pfp);
737 	fflush(NULL);
738 }
739 
740 static int
741 remove_jobs(int argc, char **argv, char *login)
742 /* remove jobs that are specified */
743 {
744 	int		i, r;
745 	int		error = 0;
746 	struct stat	buf;
747 	struct passwd *pw;
748 
749 	pw = getpwuid(user);
750 	if (pw == NULL) {
751 		atabort("Invalid user.\n");
752 	}
753 
754 	if (argc == 0)
755 		usage();
756 	if (chdir(ATDIR) == -1)
757 		atabort(CANTCD);
758 	for (i = 0; i < argc; i++)
759 		if (strchr(argv[i], '/') != NULL) {
760 			fprintf(stderr, "at: %s: not a valid job-id\n",
761 					argv[i]);
762 		} else if (stat(argv[i], &buf)) {
763 			fprintf(stderr, "at: %s: ", argv[i]);
764 			perror("");
765 		} else if ((user != buf.st_uid) &&
766 		    (!cron_admin(pw->pw_name))) {
767 			fprintf(stderr, "at: you don't own %s\n",
768 			    argv[i]);
769 			error = 1;
770 		} else {
771 			if (cron_admin(pw->pw_name)) {
772 				login = getuser((uid_t)buf.st_uid);
773 				if (login == NULL) {
774 					if (per_errno == 2)
775 						atabort(BADSHELL);
776 					else
777 						atabort(INVALIDUSER);
778 					}
779 			}
780 			cron_sendmsg(DELETE, login, argv[i], AT);
781 			r = unlink(argv[i]);
782 			audit_at_delete(argv[i], ATDIR, r);
783 		}
784 	return (error);
785 }
786 
787 
788 
789 static int
790 list_jobs(int argc, char **argv, int qflag, int queue)
791 {
792 	DIR		*dir;
793 	int		i;
794 	int		error = 0;
795 	char		*patdir, *atdir, *ptr;
796 	char		timebuf[80];
797 	time_t		t;
798 	struct stat	buf, st1, st2;
799 	struct dirent	*dentry;
800 	struct passwd	*pw;
801 	unsigned int	atdirlen;
802 	int r;
803 	struct passwd	*pwd, pwds;
804 	char buf_pwd[1024];
805 	char job_file[PATH_MAX];
806 
807 	pwd = getpwuid_r(user, &pwds, buf_pwd, sizeof (buf_pwd));
808 	if (pwd == NULL) {
809 		atabort("Invalid user.\n");
810 	}
811 
812 	/* list jobs for user */
813 	if (chdir(ATDIR) == -1)
814 		atabort(CANTCD);
815 
816 	atdirlen = strlen(ATDIR);
817 	atdir = xmalloc(atdirlen + 1);
818 	strcpy(atdir, ATDIR);
819 	patdir = strrchr(atdir, '/');
820 	*patdir = '\0';
821 	if (argc == 0) {
822 		/* list all jobs for a user */
823 		if (stat(ATDIR, &st1) != 0 || stat(atdir, &st2) != 0)
824 			atabort("Can not get status of spooling"
825 			    "directory for at");
826 		if ((dir = opendir(ATDIR)) == NULL)
827 			atabort(NOOPENDIR);
828 		while (1) {
829 			if ((dentry = readdir(dir)) == NULL)
830 				break;
831 			if ((dentry->d_ino == st1.st_ino) ||
832 			    (dentry->d_ino == st2.st_ino))
833 				continue;
834 			if ((r = audit_cron_is_anc_name(dentry->d_name)) == 1)
835 				continue;
836 			if (stat(dentry->d_name, &buf)) {
837 				unlink(dentry->d_name);
838 				audit_cron_delete_anc_file(dentry->d_name,
839 				    NULL);
840 				continue;
841 			}
842 			if ((!cron_admin(pwd->pw_name)) &&
843 			    (buf.st_uid != user))
844 				continue;
845 			ptr = dentry->d_name;
846 			if (((t = num(&ptr)) == 0) || (*ptr != '.'))
847 				continue;
848 			strcpy(job_file, patdir);
849 			strcat(job_file, dentry->d_name);
850 			if (pflag && not_this_project(job_file))
851 				continue;
852 			ascftime(timebuf, FORMAT, localtime(&t));
853 			if ((cron_admin(pwd->pw_name)) &&
854 			    ((pw = getpwuid(buf.st_uid)) != NULL)) {
855 				if (!qflag || (qflag &&
856 				    check_queue(ptr, queue)))
857 					printf("user = %s\t%s\t%s\n",
858 					    pw->pw_name, dentry->d_name,
859 					    timebuf);
860 			} else
861 				if (!qflag || (qflag &&
862 				    check_queue(ptr, queue)))
863 					printf("%s\t%s\n",
864 					    dentry->d_name, timebuf);
865 		}
866 		(void) closedir(dir);
867 	} else	/* list particular jobs for user */
868 		for (i = 0; i < argc; i++) {
869 			ptr = argv[i];
870 			strlcpy(job_file, patdir, PATH_MAX);
871 			strlcat(job_file, ptr, PATH_MAX);
872 			if (((t = num(&ptr)) == 0) || (*ptr != '.')) {
873 				fprintf(stderr, gettext(
874 				    "at: invalid job name %s\n"), argv[i]);
875 				error = 1;
876 			} else if (stat(argv[i], &buf)) {
877 				fprintf(stderr, "at: %s: ", argv[i]);
878 				perror("");
879 				error = 1;
880 			} else if ((user != buf.st_uid) &&
881 			    (!cron_admin(pwd->pw_name))) {
882 				fprintf(stderr, gettext(
883 				    "at: you don't own %s\n"), argv[i]);
884 				error = 1;
885 			} else if (pflag && not_this_project(job_file)) {
886 				continue;
887 			} else {
888 				if (!qflag || (qflag &&
889 				    check_queue(ptr, queue))) {
890 					ascftime(timebuf, FORMAT,
891 					    localtime(&t));
892 					printf("%s\t%s\n", argv[i], timebuf);
893 				}
894 			}
895 		}
896 	return (error);
897 }
898 
899 /*
900  * open the command file and read the project id line
901  * compare to the project number provided via -p on the command line
902  * return 0 if they match, 1 if they don't match or an error occurs.
903  */
904 #define	SKIPCOUNT 3	/* lines to skip to get to project line in file */
905 
906 static int
907 not_this_project(char *filename)
908 {
909 	FILE *fp;
910 	projid_t sproj;
911 	int i;
912 
913 	if ((fp = fopen(filename, "r")) == NULL)
914 		return (1);
915 
916 	for (i = 0; i < SKIPCOUNT; i++)
917 		fscanf(fp, "%*[^\n]\n");
918 
919 	fscanf(fp, ": project: %d\n", &sproj);
920 	fclose(fp);
921 
922 	return (sproj == project ? 0 : 1);
923 }
924 
925 static int
926 check_queue(char *name, int queue)
927 {
928 	if ((name[strlen(name) - 1] - 'a') == queue)
929 		return (1);
930 	else
931 		return (0);
932 }
933 
934 static time_t
935 parse_time(char *t)
936 {
937 	int		century = 0;
938 	int		seconds = 0;
939 	char		*p;
940 	time_t		when	= 0;
941 	struct tm	tm;
942 
943 	/*
944 	 * time in the following format (defined by the touch(1) spec):
945 	 *	[[CC]YY]MMDDhhmm[.SS]
946 	 */
947 	if ((p = strchr(t, '.')) != NULL) {
948 		if (strchr(p+1, '.') != NULL)
949 			atabort(BADTIME);
950 		seconds = atoi_for2(p+1);
951 		*p = '\0';
952 	}
953 
954 	memset(&tm, 0, sizeof (struct tm));
955 	when = time(0);
956 	tm.tm_year = localtime(&when)->tm_year;
957 
958 	switch (strlen(t)) {
959 		case 12:	/* CCYYMMDDhhmm */
960 			century = atoi_for2(t);
961 			t += 2;
962 		case 10:	/* YYMMDDhhmm */
963 			tm.tm_year = atoi_for2(t);
964 			t += 2;
965 			if (century == 0) {
966 				if (tm.tm_year < 69)
967 					tm.tm_year += 100;
968 			} else
969 				tm.tm_year += (century - 19) * 100;
970 		case 8:		/* MMDDhhmm */
971 			tm.tm_mon = atoi_for2(t) - 1;
972 			t += 2;
973 			tm.tm_mday = atoi_for2(t);
974 			t += 2;
975 			tm.tm_hour = atoi_for2(t);
976 			t += 2;
977 			tm.tm_min = atoi_for2(t);
978 			t += 2;
979 			tm.tm_sec = seconds;
980 			break;
981 		default:
982 			atabort(BADTIME);
983 	}
984 
985 	if ((when = mktime(&tm)) == -1)
986 		atabort(BADTIME);
987 	if (tm.tm_isdst)
988 		when -= (timezone-altzone);
989 	return (when);
990 }
991 
992 static int
993 atoi_for2(char *p) {
994 	int value;
995 
996 	value = (*p - '0') * 10 + *(p+1) - '0';
997 	if ((value < 0) || (value > 99))
998 		atabort(BADTIME);
999 	return (value);
1000 }
1001 
1002 static void
1003 usage(void)
1004 {
1005 	fprintf(stderr, USAGE);
1006 	exit(1);
1007 }
1008