![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to at.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / at|
Return to at.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / at |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: char copyright[] =
9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)at.c 5.4 (Berkeley) 5/28/86";
15: #endif not lint
16:
17: /*
18: * Synopsis: at [-s] [-c] [-m] time [filename]
19: *
20: *
21: *
22: * Execute commands at a later date.
23: *
24: *
25: * Modifications by: Steve Wall
26: * Computer Systems Research Group
27: * University of California @ Berkeley
28: *
29: */
30: #include <stdio.h>
31: #include <ctype.h>
32: #include <signal.h>
33: #include <pwd.h>
34: #include <sys/param.h>
35: #include <sys/time.h>
36: #include <sys/file.h>
37:
38: #define HOUR 100 /* 1 hour (using military time) */
39: #define HALFDAY (12 * HOUR) /* half a day (12 hours) */
40: #define FULLDAY (24 * HOUR) /* a full day (24 hours) */
41:
42: #define WEEK 1 /* day requested is 'week' */
43: #define DAY 2 /* day requested is a weekday */
44: #define MONTH 3 /* day requested is a month */
45:
46: #define BOURNE "/bin/sh" /* run commands with Bourne shell*/
47: #define CSHELL "/bin/csh" /* run commands with C shell */
48:
49: #define NODATEFOUND -1 /* no date was given on command line */
50:
51: #define ATDIR "/usr/spool/at" /* spooling area */
52:
53: #define LINSIZ 256 /* length of input buffer */
54:
55: /*
56: * A table to identify potential command line values for "time".
57: *
58: * We need this so that we can do some decent error checking on the
59: * command line arguments. (This was inspired by the old "at", which
60: * accepted "at 900 jan 55" as valid input and other small bugs.
61: */
62: struct datetypes {
63: int type;
64: char *name;
65: } dates_info[22] = {
66: { DAY, "sunday" },
67: { DAY, "monday" },
68: { DAY, "tuesday" },
69: { DAY, "wednesday" },
70: { DAY, "thursday" },
71: { DAY, "friday" },
72: { DAY, "saturday" },
73: { MONTH, "january" },
74: { MONTH, "february" },
75: { MONTH, "march" },
76: { MONTH, "april" },
77: { MONTH, "may" },
78: { MONTH, "june" },
79: { MONTH, "july" },
80: { MONTH, "august" },
81: { MONTH, "september" },
82: { MONTH, "october" },
83: { MONTH, "november" },
84: { MONTH, "december" },
85: { 0, ""},
86: };
87:
88: /*
89: * Months of the year.
90: */
91: char *months[13] = {
92: "jan", "feb", "mar", "apr", "may", "jun",
93: "jul", "aug", "sep", "oct", "nov", "dec", 0,
94: };
95:
96: /*
97: * A table of the number of days in each month of the year.
98: *
99: * yeartable[0] -- normal year
100: * yeartable[1] -- leap year
101: */
102: static int yeartable[2][13] = {
103: { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
104: { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
105: };
106:
107: /*
108: * Structure holding the relevant values needed to create a spoolfile.
109: * "attime" will contain the info about when a job is to be run, and
110: * "nowtime" will contain info about what time the "at" command is in-
111: * voked.
112: */
113: struct times {
114: int year; /* year that job is to be run */
115: int yday; /* day of year that job is to be run */
116: int mon; /* month of year that job is to be run*/
117: int mday; /* day of month that job is to be run */
118: int wday; /* day of week that job is to be run */
119: int hour; /* hour of day that job is to be run */
120: int min; /* min. of hour that job is to be run */
121: } attime, nowtime;
122:
123: char atfile[100]; /* name of spoolfile "yy.ddd.hhhh.??" */
124: char *getenv(); /* get info on user's environment */
125: char **environ; /* user's environment */
126: FILE *spoolfile; /* spool file */
127: FILE *inputfile; /* input file ("stdin" or "filename") */
128: char *getwd(); /* used to get current directory info */
129:
130:
131: main(argc, argv)
132: int argc;
133: char **argv;
134: {
135: int c; /* scratch variable */
136: int usage(); /* print usage info and exit */
137: int cleanup(); /* do cleanup on an interrupt signal */
138: int dateindex = NODATEFOUND; /* if a day is specified, what option
139: is it? (mon day, week, dayofweek) */
140: char *shell = BOURNE; /* what shell do we use to run job? */
141: int shflag = 0; /* override the current shell and run
142: job using the Bourne Shell */
143: int cshflag = 0; /* override the current shell and run
144: job using the Cshell */
145: int mailflag = 0; /* send mail after a job has been run?*/
146: int standardin = 0; /* are we reading from stardard input */
147: char *tmp; /* scratch pointer */
148: char line[LINSIZ]; /* a line from input file */
149: char pwbuf[MAXPATHLEN]; /* the current working directory */
150: char *jobfile = "stdin"; /* file containing job to be run */
151: char *getname(); /* get the login name of a user */
152: int pid; /* For forking for security reasons */
153:
154:
155:
156: argv++; argc--;
157:
158: /*
159: * Interpret command line flags if they exist.
160: */
161: while (argc > 0 && **argv == '-') {
162: (*argv)++;
163: while (**argv) switch (*(*argv)++) {
164:
165: case 'c' : cshflag++;
166: shell = CSHELL;
167: break;
168:
169: case 's' : shflag++;
170: shell = BOURNE;
171: break;
172:
173: case 'm' : mailflag++;
174: break;
175:
176: default : usage();
177:
178: }
179: --argc, ++argv;
180: }
181: if (shflag && cshflag) {
182: fprintf(stderr,"ambiguous shell request.\n");
183: exit(1);
184: }
185:
186: /*
187: * Get the time it is when "at" is invoked. We set both nowtime and
188: * attime to this value so that as we interpret the time the job is to
189: * be run we can compare the two values to determine such things as
190: * whether of not the job should be run the same day the "at" command
191: * is given, whether a job is to be run next year, etc.
192: */
193: getnowtime(&nowtime, &attime);
194:
195: #ifdef DEBUG
196: printit();
197: #endif
198:
199: if (argc <= 0)
200: usage();
201:
202: /*
203: * Interpret argv[1] and create the time of day that the job is to
204: * be run. This is the same function that was used in the old "at"
205: */
206: maketime(&attime, *argv);
207: --argc; ++argv;
208:
209: #ifdef DEBUG
210: printf("\n\nAFTER MAKETIME\n");
211: printit();
212: #endif
213:
214: /*
215: * If argv[(2)] exists, this is a request to run a job on a certain
216: * day of year or a certain day of week.
217: *
218: * We send argv to the function "getdateindex" which returns the
219: * index value of the requested day in the table "dates_info"
220: * (see line 50 for table). If 'getdateindex" returns a NODATEFOUND,
221: * then the requested day format was not found in the table (usually
222: * this means that the argument is a "filename"). If the requested
223: * day is found, we continue to process command line arguments.
224: */
225: if (argc > 0) {
226: if ((dateindex = getdateindex(*argv)) != NODATEFOUND) {
227:
228: ++argv; --argc;
229:
230: /*
231: * Determine the day of year that the job will be run
232: * depending on the value of argv.
233: */
234: makedayofyear(dateindex, &argv, &argc);
235: }
236: }
237:
238: /*
239: * If we get to this point and "dateindex" is set to NODATEFOUND,
240: * then we are dealing with a request with only a "time" specified
241: * (i.e. at 400p) and perhaps 'week' specified (i.e. at 400p week).
242: * If 'week' is specified, we just set excecution for 7 days in the
243: * future. Otherwise, we need to check to see if the requested time
244: * has already passed for the current day. If it has, then we add
245: * one to the day of year that the job will be executed.
246: */
247: if (dateindex == NODATEFOUND) {
248: int daysinyear;
249: if ((argc > 0) && (strcmp(*argv,"week") == 0)) {
250: attime.yday += 7;
251: ++argv; --argc;
252: } else if (istomorrow())
253: ++attime.yday;
254:
255: daysinyear = isleap(attime.year) ? 366 : 365;
256: if (attime.yday >= daysinyear) {
257: attime.yday -= daysinyear;
258: ++attime.year;
259: }
260: }
261:
262: /*
263: * If no more arguments exist, then we are reading
264: * from standard input. Thus, we set the standard
265: * input flag (++standardin).
266: */
267: if (argc <= 0)
268: ++standardin;
269:
270:
271: #ifdef DEBUG
272: printf("\n\nAFTER ADDDAYS\n");
273: printit();
274: #endif
275:
276: /*
277: * Start off assuming we're going to read from standard input,
278: * but if a filename has been given to read from, we will open it
279: * later.
280: */
281: inputfile = stdin;
282:
283: /*
284: * Create the filename for the spoolfile.
285: */
286: makeatfile(atfile,attime.year,attime.yday,attime.hour,attime.min);
287:
288: /*
289: * Open the spoolfile for writing.
290: */
291: if ((spoolfile = fopen(atfile, "w")) == NULL){
292: perror(atfile);
293: exit(1);
294: }
295:
296: /*
297: * Make the file not world readable.
298: */
299: fchmod(fileno(spoolfile), 0400);
300:
301: /*
302: * The protection mechanism works like this:
303: * We are running ruid=user, euid=daemon. So far we have been
304: * messing around in the spool directory, so we needed the
305: * daemon stuff. Now, we want to read the users file,
306: * so we must give up the daemon protection, but we might
307: * need the daemon's protection if the user interrupts and
308: * we need to remove the spool files.
309: * So, we fork and let the kid set the real and effective
310: * user id's to the user, so he can read everything of his
311: * own, but not his professor's final exam and not stuff
312: * owned by daemon. If the kid exits with non-zero status,
313: * that means that the user typed interrupt, and the parent
314: * (still with daemon permissions) removes the spool file.
315: */
316: signal(SIGINT, SIG_IGN);
317: pid = fork();
318: if (pid == -1) {
319: perror("fork");
320: exit(1);
321: }
322: if (pid) {
323: int wpid, status;
324:
325: /*
326: * We are the parent. If the kid has problems,
327: * cleanup the spool directory.
328: */
329: wpid = wait(&status);
330: if (wpid != pid || status) {
331: cleanup();
332: exit(1);
333: }
334: /*
335: * The kid should have alread flushed the buffers.
336: */
337: _exit(0);
338: }
339:
340: /*
341: * Exit on interrupt.
342: */
343: signal(SIGINT, SIG_DFL);
344:
345: /*
346: * We are the kid, give up daemon permissions.
347: */
348: setuid(getuid());
349:
350: /*
351: * Open the input file with the user's permissions.
352: */
353: if (!standardin) {
354: jobfile = *argv;
355: if ((inputfile = fopen(jobfile, "r")) == NULL) {
356: perror(jobfile);
357: exit(1);
358: }
359: }
360:
361: /*
362: * If the inputfile is not from a tty then turn off standardin
363: * If the inputfile is a tty, put out a prompt now, instead of
364: * waiting for a lot of file activity to complete.
365: */
366: if (!(isatty(fileno(inputfile))))
367: standardin = 0 ;
368: if (standardin) {
369: fputs("at> ", stdout);
370: fflush(stdout);
371: }
372:
373: /*
374: * Determine what shell we should use to run the job. If the user
375: * didn't explicitly request that his/her current shell be over-
376: * ridden (shflag of cshflag) then we use the current shell.
377: */
378: if ((!shflag) && (!cshflag) && (getenv("SHELL") != NULL))
379: shell = "$SHELL";
380:
381: /*
382: * Put some standard information at the top of the spoolfile.
383: * This info is used by the other "at"-oriented programs (atq,
384: * atrm, atrun).
385: */
386: fprintf(spoolfile, "# owner: %.127s\n",getname(getuid()));
387: fprintf(spoolfile, "# jobname: %.127s\n",jobfile);
388: fprintf(spoolfile, "# shell: sh\n");
389: fprintf(spoolfile, "# notify by mail: %s\n",(mailflag) ? "yes" : "no");
390: fprintf(spoolfile, "\n");
391:
392: /*
393: * Set the modes for any files created by the job being run.
394: */
395: c = umask(0);
396: umask(c);
397: fprintf(spoolfile, "umask %.1o\n", c);
398:
399: /*
400: * Get the current working directory so we know what directory to
401: * run the job from.
402: */
403: if (getwd(pwbuf) == NULL) {
404: fprintf(stderr, "at: can't get working directory\n");
405: exit(1);
406: }
407: fprintf(spoolfile, "cd %s\n", pwbuf);
408:
409: /*
410: * Copy the user's environment to the spoolfile.
411: */
412: if (environ) {
413: copyenvironment(&spoolfile);
414: }
415:
416: /*
417: * Put in a line to run the proper shell using the rest of
418: * the file as input. Note that 'exec'ing the shell will
419: * cause sh() to leave a /tmp/sh### file around.
420: */
421: fprintf(spoolfile,
422: "%s << '...the rest of this file is shell input'\n", shell);
423:
424: /*
425: * Now that we have all the files set up, we can start reading in
426: * the job. (I added the prompt "at>" so that the user could tell
427: * when/if he/she was supposed to enter commands from standard
428: * input. The old "at" just sat there and didn't send any kind of
429: * message that said it was waiting for input if it was reading
430: * form standard input).
431: */
432: while (fgets(line, LINSIZ, inputfile) != NULL) {
433: fputs(line, spoolfile);
434: if (standardin)
435: fputs("at> ", stdout);
436: }
437: if (standardin)
438: fputs("<EOT>\n", stdout); /* clean up the final output */
439:
440: /*
441: * Close all files and change the mode of the spoolfile.
442: */
443: fclose(inputfile);
444: fclose(spoolfile);
445:
446: exit(0);
447:
448: }
449:
450: /*
451: * Copy the user's environment to the spoolfile in the syntax of the
452: * Bourne shell. After the environment is set up, the proper shell
453: * will be invoked.
454: */
455: copyenvironment(spoolfile)
456: FILE **spoolfile;
457: {
458: char *tmp; /* scratch pointer */
459: char **environptr = environ; /* pointer to an environment setting */
460:
461: while(*environptr) {
462: tmp = *environptr;
463:
464: /*
465: * We don't want the termcap or terminal entry so skip them.
466: */
467: if ((strncmp(tmp,"TERM=",5) == 0) ||
468: (strncmp(tmp,"TERMCAP=",8) == 0)) {
469: ++environptr;
470: continue;
471: }
472:
473: /*
474: * Set up the proper syntax.
475: */
476: while (*tmp != '=')
477: fputc(*tmp++,*spoolfile);
478: fputc('=', *spoolfile);
479: fputc('\'' , *spoolfile);
480: ++tmp;
481:
482: /*
483: * Now copy the entry.
484: */
485: while (*tmp) {
486: if (*tmp == '\'')
487: fputs("'\\''", *spoolfile);
488: else if (*tmp == '\n')
489: fputs("\\",*spoolfile);
490: else
491: fputc(*tmp, *spoolfile);
492: ++tmp;
493: }
494: fputc('\'' , *spoolfile);
495:
496: /*
497: * We need to "export" environment settings.
498: */
499: fprintf(*spoolfile, "\nexport ");
500: tmp = *environptr;
501: while (*tmp != '=')
502: fputc(*tmp++,*spoolfile);
503: fputc('\n',*spoolfile);
504: ++environptr;
505: }
506: return;
507: }
508:
509: /*
510: * Create the filename for the spoolfile. The format is "yy.ddd.mmmm.??"
511: * where "yy" is the year the job will be run, "ddd" the day of year,
512: * "mmmm" the hour and minute, and "??" a scratch value used to dis-
513: * tinguish between two files that are to be run at the same time.
514: */
515: makeatfile(atfile,year,dayofyear,hour,minute)
516: int year;
517: int hour;
518: int minute;
519: int dayofyear;
520: char *atfile;
521: {
522: int i; /* scratch variable */
523:
524: for (i=0; ; i += 53) {
525: sprintf(atfile, "%s/%02d.%03d.%02d%02d.%02d", ATDIR, year,
526: dayofyear, hour, minute, (getpid() + i) % 100);
527:
528: /*
529: * Make sure that the file name that we've created is unique.
530: */
531: if (access(atfile, F_OK) == -1)
532: return;
533: }
534: }
535:
536: /*
537: * Has the requested time already passed for the currrent day? If so, we
538: * will run the job "tomorrow".
539: */
540: istomorrow()
541: {
542: if (attime.hour < nowtime.hour)
543: return(1);
544: if ((attime.hour == nowtime.hour) && (attime.min < nowtime.min))
545: return(1);
546:
547: return(0);
548: }
549:
550: /*
551: * Debugging wreckage.
552: */
553: printit()
554: {
555: printf("YEAR\tnowtime: %d\tattime: %d\n",nowtime.year,attime.year);
556: printf("YDAY\tnowtime: %d\tattime: %d\n",nowtime.yday,attime.yday);
557: printf("MON\tnowtime: %d\tattime: %d\n",nowtime.mon,attime.mon);
558: printf("MONDAY\tnowtime: %d\tattime: %d\n",nowtime.mday,attime.mday);
559: printf("WDAY\tnowtime: %d\tattime: %d\n",nowtime.wday,attime.wday);
560: printf("HOUR\tnowtime: %d\tattime: %d\n",nowtime.hour,attime.hour);
561: printf("MIN\tnowtime: %d\tattime: %d\n",nowtime.min,attime.min);
562: }
563:
564: /*
565: * Calculate the day of year that the job will be executed.
566: * The av,ac arguments are ptrs to argv,argc; updated as necessary.
567: */
568: makedayofyear(dateindex, av, ac)
569: int dateindex;
570: char ***av;
571: int *ac;
572: {
573: char **argv = *av; /* imitate argc,argv and update args at end */
574: int argc = *ac;
575: char *ptr; /* scratch pointer */
576: struct datetypes *daterequested; /* pointer to information about
577: the type of date option
578: we're dealing with */
579:
580: daterequested = &dates_info[dateindex];
581:
582: /*
583: * If we're dealing with a day of week, determine the number of days
584: * in the future the next day of this type will fall on. Add this
585: * value to "attime.yday".
586: */
587: if (daterequested->type == DAY) {
588: if (attime.wday < dateindex)
589: attime.yday += dateindex - attime.wday;
590: else if(attime.wday > dateindex)
591: attime.yday += (7 - attime.wday) + dateindex;
592: else attime.yday += 7;
593: }
594:
595: /*
596: * If we're dealing with a month and day of month, determine the
597: * day of year that this date will fall on.
598: */
599: if (daterequested->type == MONTH) {
600:
601: /*
602: * If a day of month isn't specified, print a message
603: * and exit.
604: */
605: if (argc <= 0) {
606: fprintf(stderr,"day of month not specified.\n");
607: exit(1);
608: }
609:
610: /*
611: * Scan the day of month value and make sure that it
612: * has no characters in it. If characters are found or
613: * the day requested is zero, print a message and exit.
614: */
615: ptr = *argv;
616: while (isdigit(*ptr))
617: ++ptr;
618: if ((*ptr != '\0') || (atoi(*argv) == 0)) {
619: fprintf(stderr,"\"%s\": illegal day of month\n",*argv);
620: exit(1);
621: }
622:
623: /*
624: * Set the month of year and day of month values. Since
625: * the first 7 values in our dateinfo table do not deal
626: * with month names, we subtract 7 from the month of year
627: * value.
628: */
629: attime.mon = (dateindex - 7);
630: attime.mday = (atoi(*argv) - 1);
631:
632: /*
633: * Test the day of month value to make sure that the
634: * value is legal.
635: */
636: if ((attime.mday + 1) >
637: yeartable[isleap(attime.year)][attime.mon + 1]) {
638: fprintf(stderr,"\"%s\": illegal day of month\n",*argv);
639: exit(1);
640: }
641:
642: /*
643: * Finally, we determine the day of year.
644: */
645: attime.yday = (countdays());
646: ++argv; --argc;
647: }
648:
649: /*
650: * If 'week' is specified, add 7 to the day of year.
651: */
652: if ((argc > 0) && (strcmp(*argv,"week") == 0)) {
653: attime.yday += 7;
654: ++argv; --argc;
655: }
656:
657: /*
658: * Now that all that is done, see if the requested execution time
659: * has already passed for this year, and if it has, set execution
660: * for next year.
661: */
662: if (isnextyear())
663: ++attime.year;
664:
665: /*
666: * Finally, reflect the updated argc,argv to the caller
667: */
668: *av = argv;
669: *ac = argc;
670: }
671:
672: /*
673: * Should the job be run next year? We check for the following situations:
674: *
675: * 1) the requested time has already passed for the current year.
676: * 2) the day of year is greater than the number of days in the year.
677: *
678: * If either of these tests succeed, we increment "attime.year" by 1.
679: * If #2 is true, we also subtract the number of days in the current year
680: * from "attime.yday". #2 can only occur if someone specifies a job to
681: * be run "tomorrow" on Dec. 31 or if they specify a job to be run a
682: * 'week' later and the date is at least Dec. 24. (I think so anyway)
683: */
684: isnextyear()
685: { register daysinyear;
686: if (attime.yday < nowtime.yday)
687: return(1);
688:
689: if ((attime.yday == nowtime.yday) && (attime.hour < nowtime.hour))
690: return(1);
691:
692: daysinyear = isleap(attime.year) ? 366 : 365;
693: if (attime.yday >= daysinyear) {
694: attime.yday -= daysinyear;
695: return(1);
696: }
697: if (attime.yday > (isleap(attime.year) ? 366 : 365)) {
698: attime.yday -= (isleap(attime.year) ? 366 : 365);
699: return(1);
700: }
701:
702: return(0);
703: }
704:
705: /*
706: * Determine the day of year given a month and day of month value.
707: */
708: countdays()
709: {
710: int leap; /* are we dealing with a leap year? */
711: int dayofyear; /* the day of year after conversion */
712: int monthofyear; /* the month of year that we are
713: dealing with */
714:
715: /*
716: * Are we dealing with a leap year?
717: */
718: leap = isleap(attime.year);
719:
720: monthofyear = attime.mon;
721: dayofyear = attime.mday;
722:
723: /*
724: * Determine the day of year.
725: */
726: while (monthofyear > 0)
727: dayofyear += yeartable[leap][monthofyear--];
728:
729: return(dayofyear);
730: }
731:
732: /*
733: * Is a year a leap year?
734: */
735: isleap(year)
736: int year;
737:
738: {
739: return((year%4 == 0 && year%100 != 0) || year%100 == 0);
740: }
741:
742: getdateindex(date)
743: char *date;
744: {
745: int i = 0;
746: struct datetypes *ptr;
747:
748: ptr = dates_info;
749:
750: for (ptr = dates_info; ptr->type != 0; ptr++, i++) {
751: if (isprefix(date, ptr->name))
752: return(i);
753: }
754: return(NODATEFOUND);
755: }
756:
757: isprefix(prefix, fullname)
758: char *prefix, *fullname;
759: {
760: char ch;
761: char *ptr;
762: char *ptr1;
763:
764: ptr = prefix;
765: ptr1 = fullname;
766:
767: while (*ptr) {
768: ch = *ptr;
769: if (isupper(ch))
770: ch = tolower(ch);
771:
772: if (ch != *ptr1++)
773: return(0);
774:
775: ++ptr;
776: }
777: return(1);
778: }
779:
780: getnowtime(nowtime, attime)
781: struct times *nowtime;
782: struct times *attime;
783: {
784: struct tm *now;
785: struct timeval time;
786: struct timezone zone;
787:
788: if (gettimeofday(&time,&zone) < 0) {
789: perror("gettimeofday");
790: exit(1);
791: }
792: now = localtime(&time.tv_sec);
793:
794: attime->year = nowtime->year = now->tm_year;
795: attime->yday = nowtime->yday = now->tm_yday;
796: attime->mon = nowtime->mon = now->tm_mon;
797: attime->mday = nowtime->mday = now->tm_mday;
798: attime->wday = nowtime->wday = now->tm_wday;
799: attime->hour = nowtime->hour = now->tm_hour;
800: attime->min = nowtime->min = now->tm_min;
801: }
802:
803: /*
804: * This is the same routine used in the old "at", so I won't bother
805: * commenting it. It'll give you an idea of what the code looked
806: * like when I got it.
807: */
808: maketime(attime,ptr)
809: char *ptr;
810: struct times *attime;
811: {
812: int val;
813: char *p;
814:
815: p = ptr;
816: val = 0;
817: while(isdigit(*p)) {
818: val = val*10+(*p++ -'0');
819: }
820: if (p-ptr < 3)
821: val *= HOUR;
822:
823: for (;;) {
824: switch(*p) {
825:
826: case ':':
827: ++p;
828: if (isdigit(*p)) {
829: if (isdigit(p[1])) {
830: val +=(10* *p + p[1] - 11*'0');
831: p += 2;
832: continue;
833: }
834: }
835: fprintf(stderr, "bad time format:\n");
836: exit(1);
837:
838: case 'A':
839: case 'a':
840: if (val >= HALFDAY+HOUR)
841: val = FULLDAY+1; /* illegal */
842: if (val >= HALFDAY && val <(HALFDAY+HOUR))
843: val -= HALFDAY;
844: break;
845:
846: case 'P':
847: case 'p':
848: if (val >= HALFDAY+HOUR)
849: val = FULLDAY+1; /* illegal */
850: if (val < HALFDAY)
851: val += HALFDAY;
852: break;
853:
854: case 'n':
855: case 'N':
856: if ((val == 0) || (val == HALFDAY))
857: val = HALFDAY;
858: else
859: val = FULLDAY+1; /* illegal */
860: break;
861:
862: case 'M':
863: case 'm':
864: if ((val == 0) || (val == HALFDAY))
865: val = 0;
866: else
867: val = FULLDAY+1; /* illegal */
868: break;
869:
870:
871: case '\0':
872: case ' ':
873: /* 24 hour time */
874: if (val == FULLDAY)
875: val -= FULLDAY;
876: break;
877:
878: default:
879: fprintf(stderr, "bad time format\n");
880: exit(1);
881:
882: }
883: break;
884: }
885: if (val < 0 || val >= FULLDAY) {
886: fprintf(stderr, "time out of range\n");
887: exit(1);
888: }
889: if (val%HOUR >= 60) {
890: fprintf(stderr, "illegal minute field\n");
891: exit(1);
892: }
893: attime->hour = val/HOUR;
894: attime->min = val%HOUR;
895: }
896:
897: /*
898: * Get the full login name of a person using his/her user id.
899: */
900: char *
901: getname(uid)
902: int uid;
903: {
904: struct passwd *pwdinfo; /* password info structure */
905:
906:
907: if ((pwdinfo = getpwuid(uid)) == 0) {
908: perror(uid);
909: exit(1);
910: }
911: return(pwdinfo->pw_name);
912: }
913:
914: /*
915: * Do general cleanup.
916: */
917: cleanup()
918: {
919: if (unlink(atfile) == -1)
920: perror(atfile);
921: exit(1);
922: }
923:
924: /*
925: * Print usage info and exit.
926: */
927: usage()
928: {
929: fprintf(stderr,"usage: at [-csm] time [date] [filename]\n");
930: exit(1);
931: }
932:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.