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