home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2757 < prev    next >
Internet Message Format  |  1991-02-13  |  59KB
  1. From: keith@sequoia.execu.com (Keith Pyle)
  2. Newsgroups: alt.sources
  3. Subject: Keith's at package, part 2 of 2
  4. Message-ID: <32217@sequoia.execu.com>
  5. Date: 14 Feb 91 04:46:51 GMT
  6.  
  7.  
  8. #! /bin/sh
  9. # This is a shell archive.  Remove anything before this line, then unpack
  10. # it by saving it into a file and typing "sh file".  To overwrite existing
  11. # files, type "sh file -c".  You can also feed this as standard input via
  12. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  13. # will see the following message at the end:
  14. #        "End of archive 2 (of 2)."
  15. # Contents:  doc/at.1 src/at.c src/atq.c src/atrun.c src/date.y
  16. # Wrapped by keith@lime on Wed Feb 13 22:33:50 1991
  17. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  18. if test -f 'doc/at.1' -a "${1}" != "-c" ; then 
  19.   echo shar: Will not clobber existing file \"'doc/at.1'\"
  20. else
  21. echo shar: Extracting \"'doc/at.1'\" \(7841 characters\)
  22. sed "s/^X//" >'doc/at.1' <<'END_OF_FILE'
  23. X.TH "AT" 1L "7 November 1990" "Execucom" "LOCAL USER COMMANDS"
  24. X.SH NAME
  25. Xat \- execute commands at a specified time
  26. X.SH SYNOPSIS
  27. X.LP
  28. X.B at
  29. X[
  30. X.B \-m
  31. X] [
  32. X.B \-cks
  33. X]
  34. X.I time
  35. X[
  36. X.I date
  37. X] [
  38. X.B \+increment
  39. X] [
  40. X.I script
  41. X]
  42. X.SH DESCRIPTION
  43. X.B at
  44. Xis a utility which accepts user commands to be executed at a specified later
  45. Xtime.  The execution time can be given as a time only, as a time and date,
  46. Xor as either of these with an increment added.  If a
  47. X.I script
  48. Xis specified, this file will be read to obtain the commands that will be
  49. Xexecuted.  Otherwise,
  50. X.B at
  51. Xwill read standard input for the commands to be queued.  If standard input
  52. Xis a terminal device,
  53. X.B at
  54. Xwill prompt for input with the string
  55. X.LP
  56. X.RS
  57. Xat>
  58. X.RE
  59. X.LP
  60. XThe shell used to process the commands will be determined as follows: (1) if
  61. Xa command line argument is used to specify a shell, that shell will be used,
  62. X(2) if the commands come from a
  63. X.I script
  64. Xand that script specifies a shell on its first line, e.g., #!/bin/sh, the
  65. Xindicated shell will be used, or (3) the shell specified in the current
  66. XSHELL environment variable will be used.
  67. X.LP
  68. XIf the queued job generates output on either standard output or standard
  69. Xerror, the output will be mailed to the user who submitted the job.  If no
  70. Xoutput is generated or if it is redirected in the commands, there will be
  71. Xno mail to the user unless either (1) the commands terminated with an
  72. Xerror status, or (2) the user requests confirmation of the run through the
  73. X.B \-m
  74. Xoption.
  75. X.LP
  76. XThe user's environment variables (except TERM), current directory, and
  77. Xumask are copied to the queued job when it is created.  If
  78. X.I script
  79. Xis specified, its contents are copied to the queued job.  Thus, subsequent
  80. Xchanges to
  81. X.I script
  82. Xor its deletion will not affect the
  83. X.B at
  84. Xjob.
  85. X.LP
  86. XThe format of
  87. X.I time
  88. Xis quite flexible.  It may consist of one or two digits to indicate hours only.
  89. XIf three or four digits are given, they are taken to indicate hours and minutes.
  90. XAn optional colon between the hours and minutes is allowed.  The hours
  91. Xspecification is assumed to be a 24 hour clock reference unless an am or pm
  92. Xsuffix is present.  The time zone may be included; if not, the current time
  93. Xzone is assumed.  The special times
  94. X.B now, noon,
  95. Xand
  96. X.B midnight
  97. Xare also recognized.  Case is not significant for any of the character fields.
  98. X.LP
  99. XThe
  100. X.I date
  101. Xis optional and may be any of the following forms: (1) month name and day,
  102. X(2) month name, day, comma, and year, (3) day and month name, (4) day, month
  103. Xname, and year, (5) month number, slash, and day, (6) month number,
  104. Xslash, day, slash, and year, or (7) a day of the week reference.
  105. XThe month name may be abbreviated to the first
  106. Xthree letters in the forms using it.
  107. XIn those forms where the year is not specified,
  108. Xthe current year is used.  If a two digit year is specified, 1900 is added to
  109. Xit.  The special dates today and tomorrow can be used in place of the
  110. X.I date
  111. Xfield.  If no
  112. X.I date
  113. Xis specified, the current date is used.
  114. X.LP
  115. XThe optional
  116. X.I +increment
  117. Xor
  118. X.I -increment
  119. Xconsists of a simple number suffixed by one of the following: minute, hour,
  120. Xday, week, month, or year.  The plural form of any of these keywords will also
  121. Xwork.  The following abbreviations are also valid: min, m, hr, h, d, wk, w,
  122. Xmon, yr, and y.
  123. X.LP
  124. XIf the
  125. X.I date
  126. Xspecification is omitted, the time will be interpreted as the next occurrence
  127. Xof that time.  For instance, if it is 11 AM and the command
  128. X.LP
  129. X.RS
  130. Xat 10 am
  131. X.RE
  132. X.LP
  133. Xis given, the at job will be scheduled for 10 AM on the following day.
  134. X.LP
  135. XThe following are example of allowable time/date specifications for the
  136. Xcurrent time assuming it is 1:00 AM on August 24, 1990:
  137. X.LP
  138. X.RS
  139. X1
  140. X.br
  141. X100
  142. X.br
  143. X1:00
  144. X.br
  145. X0100
  146. X.br
  147. X1:00 am
  148. X.br
  149. X1:00 aug 24
  150. X.br
  151. X1:00 24 aug
  152. X.br
  153. X0100 8/24
  154. X.br
  155. X01 8/24/90
  156. X.RE
  157. X.LP
  158. XThe use of the day of week reference consists of a time and the name of a
  159. Xday of the week.  The day name may be preceded by an ordinal reference (e.g.,
  160. Xthird). For example,
  161. X.LP
  162. X.RS
  163. X1 pm friday
  164. X.br
  165. X1300 second friday
  166. X.RE
  167. X.LP
  168. XThe special ordinal value
  169. X.B this
  170. Xis provided, however, it has no influence on the computation since
  171. X"this Friday" is synonymous with simply "Friday".
  172. X.B next
  173. Xis synonymous
  174. Xwith the ordinal
  175. X.B first
  176. Xand both imply the next occurence of the specified day.
  177. XThus, both "first Friday"
  178. Xand "next Friday" will be
  179. Xthe first Friday after today.  If today were Friday, either of these would
  180. Xrefer to the day one week from now.
  181. X.LP
  182. XWhen the job is entered into the
  183. X.B at
  184. Xqueue, a unique job number and the scheduled time will be displayed on
  185. Xstandard output.
  186. X.LP
  187. XThere may be restrictions on
  188. X.B at
  189. Xusage depending upon the policies of the installation.  These restrictions
  190. Xare accomplished through one of two files:
  191. X.B at\.allow
  192. Xor
  193. X.B at\.deny.
  194. XIf
  195. X.B at\.allow
  196. Xexists, only those users listed in it may use the
  197. X.B at
  198. Xprograms.  If it does not exist, but
  199. X.B at\.deny
  200. Xdoes exist, all users except those listed may submit jobs.  If
  201. X.B at\.deny
  202. Xis empty, all users are allowed to submit jobs.  If neither file exists,
  203. Xonly the super-user may use
  204. X.B at.
  205. XEntries in either file consist of one user name per line.
  206. X.LP
  207. XThe execution time specified is the earliest that the job will be run.
  208. XAll jobs are run via the
  209. X.BR atrun (8)
  210. Xcommand, which is typically invoked periodically by
  211. X.BR cron (8).
  212. XThe exact time of execution will depend upon the frequency of execution
  213. Xof
  214. X.BR atrun (8).
  215. X.SH OPTIONS
  216. X.TP
  217. X.B \-c
  218. XUse the C shell to execute the specified commands.
  219. X.TP
  220. X.B \-k
  221. XUse the Korn shell to execute the specified commands.
  222. X.TP
  223. X.B \-m
  224. XSend mail to the user who submitted the job on completion, even if no
  225. Xoutput is generated and no error occurs.
  226. X.TP
  227. X.B \-s
  228. XUse the Bourne shell to execute the specified commands.
  229. X.SH EXAMPLES
  230. X(1) To delete a .forward file on June 29 at 10:38 in the morning (e.g., to
  231. Xterminate vacation processing), the sequence could be
  232. X.sp
  233. X.RS
  234. X.B "at 10:38 am June 29"
  235. X.br
  236. Xat>
  237. X.B "rm .forward"
  238. X.br
  239. Xat>
  240. X.B "CTRL-D"
  241. X.RE
  242. X.sp
  243. XThere is no limit on the number of commands that can be entered.
  244. XNote that CTRL-D is the control-D character (hold down control and press D).
  245. X.LP
  246. X(2) To execute the script
  247. X.B cleanup
  248. Xat 3:00 AM on this coming Friday, the
  249. X.B at
  250. Xcommand could be
  251. X.sp
  252. X.RS
  253. X.B "at 3:00 AM Friday cleanup"
  254. X.RE
  255. X.LP
  256. X(3) To perform the same script at the same time, but with notification of
  257. Xits completion, the following command could be used.
  258. X.sp
  259. X.RS
  260. X.B "at -m 0300 fri cleanup"
  261. X.RE
  262. X.LP
  263. X(4) If the
  264. X.B cleanup
  265. Xscript were written for the C shell and the
  266. X.B at
  267. Xjob is being submitted while running a different shell (e.g., the Bourne
  268. Xshell), it would be necessary to force
  269. X.B at
  270. Xto run the commands in the script using the C shell.
  271. X.sp
  272. X.RS
  273. X.B "at -c -m 3 Fri cleanup"
  274. X.RE
  275. X.sp
  276. XNote that the time specifications shown in the preceding three examples
  277. Xwill all result in the same execution time.
  278. X.SH AUTHOR
  279. XKeith Pyle
  280. X.SH FILES
  281. X.ta 2.5i
  282. X\fB/usr/spool/at\fR    spool directory
  283. X.br
  284. X\fB/usr/spool/at/at.allow\fR    allowed users
  285. X.br
  286. X\fB/usr/spool/at/at.deny\fR    prohibited users
  287. X.br
  288. X\fB/usr/spool/at/.seq\fR    job sequence number
  289. X.SH "SEE ALSO"
  290. X.BR atcat (1L),
  291. X.BR atq (1L),
  292. X.BR atrm (1L),
  293. X.BR atrun (8)
  294. X.SH DIAGNOSTICS
  295. XThe exit status is 0 when a job is correctly queued.  For file access failures
  296. Xand other execution problems, the exit status is set to 1.
  297. XAn exit status of 2 is set for syntax errors.
  298. X.SH BUGS
  299. X.LP
  300. XIf a job does not complete due to a system failure, it will not be requeued.
  301. XHowever, it would be possible to affect this function by modification of the
  302. Xappropriate boot file (e.g., rc.local on a BSD system).  Assuming that the
  303. X.B at
  304. Xqueue directory is /usr/spool/at and the working directory is
  305. X/usr/spool/at/past, the following shell
  306. Xcommand could be used:
  307. X.sp
  308. X.RS
  309. X.ft B
  310. Xfind /usr/spool/at/past -name '[1-9]*'
  311. X.if n \{ \\
  312. X.br
  313. X.ti +0.5i
  314. X\}
  315. X-exec mv {} /usr/spool/at \\;
  316. X.ft R
  317. X.RE
  318. X.LP
  319. XThe next execution of
  320. X.BR atrun (8)
  321. Xwill restart these jobs.
  322. END_OF_FILE
  323. if test 7841 -ne `wc -c <'doc/at.1'`; then
  324.     echo shar: \"'doc/at.1'\" unpacked with wrong size!
  325. fi
  326. # end of 'doc/at.1'
  327. fi
  328. if test -f 'src/at.c' -a "${1}" != "-c" ; then 
  329.   echo shar: Will not clobber existing file \"'src/at.c'\"
  330. else
  331. echo shar: Extracting \"'src/at.c'\" \(8859 characters\)
  332. sed "s/^X//" >'src/at.c' <<'END_OF_FILE'
  333. X/* at --- a member of the kat family (Keith's at package) */
  334. X
  335. X/* at(1) queues jobs for later execution by atrun.  It is similar in */
  336. X/* function to the at(1) supplied with most BSD systems, but with additional */
  337. X/* capabilities in date parsing, shell selection, and confirmation of the */
  338. X/* run. */
  339. X
  340. X/* Copyright (c) 1990, W. Keith Pyle, Austin, Texas */
  341. X
  342. X#include "at.h"
  343. X
  344. Xchar at_file[MAXPATHLEN];
  345. Xchar at_tmp[MAXPATHLEN];
  346. Xchar buffer[MAXLINE];
  347. Xchar *verstring = PATCHLEVEL;
  348. X
  349. Xint jobno;
  350. X
  351. Xchar *atname();
  352. Xchar *ctime();
  353. Xchar *rindex();
  354. Xtime_t parse_date();
  355. Xvoid quit();
  356. X
  357. Xextern char *optarg;
  358. X
  359. Xextern int opterr;
  360. Xextern int optind;
  361. X
  362. X/* -------------------------------------------------------------------------- */
  363. X
  364. Xmain(argc, argv, envp)
  365. X
  366. Xint argc;
  367. Xchar *argv[];
  368. Xchar *envp[];
  369. X
  370. X{
  371. X    char *lastarg;
  372. X    char owner[32];
  373. X    char script[128];
  374. X    char shell[33];
  375. X
  376. X    int flag;
  377. X    int mail;
  378. X    int mask;
  379. X
  380. X    time_t at_time;
  381. X    time_t now_time;
  382. X
  383. X    FILE *fp_at_file;
  384. X    FILE *fp_script;
  385. X
  386. X    if (argc == 1)
  387. X        usage();
  388. X
  389. X    /* Some initialization */
  390. X
  391. X    mail = FALSE;
  392. X    shell[0] = '\0';
  393. X
  394. X    /* Get the user name */
  395. X
  396. X    whoami(owner);
  397. X
  398. X    /* Check for allowed at usage (just use two handy arrays for the names) */
  399. X
  400. X    (void)sprintf(at_tmp, "%s/%s", ATDIR, ALLOW_FILE);
  401. X    (void)sprintf(at_file, "%s/%s", ATDIR, DENY_FILE);
  402. X    
  403. X    if (!permit(owner, at_tmp, at_file)) {
  404. X
  405. X        (void)fprintf(stderr, "you are not authorized to use at.  Sorry.\n");
  406. X        exit(1);
  407. X    }
  408. X
  409. X    /* Parse any option flags */
  410. X
  411. X    while ((flag = getopt(argc, argv, "ckms")) != EOF) {
  412. X
  413. X        switch (flag) {
  414. X
  415. X            case 'c':
  416. X
  417. X                (void)strcpy(shell,  C_SHELL);
  418. X                break;
  419. X            
  420. X            case 'k':
  421. X
  422. X                (void)strcpy(shell, KORN_SHELL);
  423. X                break;
  424. X            
  425. X            case 'm':
  426. X
  427. X                mail = TRUE;
  428. X                break;
  429. X            
  430. X            case 's':
  431. X
  432. X                (void)strcpy(shell, BOURNE_SHELL);
  433. X                break;
  434. X            
  435. X            default:
  436. X
  437. X                usage();
  438. X        }
  439. X    }
  440. X
  441. X    /* Try to parse all of the remaining arguments as a time specification. */
  442. X    /* If this fails and there at least three arguments, see if the last */
  443. X    /* argument is a file name. */
  444. X
  445. X    lastarg = argv[argc - 1];
  446. X    (void)time(&now_time);
  447. X    now_time -= now_time % 60;
  448. X
  449. X    if ((at_time = parse_args(argc - optind, argv + optind)) != -1) {
  450. X
  451. X        fp_script = stdin;
  452. X        (void)strcpy(script, "stdin");
  453. X    }
  454. X
  455. X    else if ((argc - optind) > 1 &&
  456. X            (at_time = parse_args(argc - optind - 1, argv + optind)) != -1) {
  457. X
  458. X        char *ptr;
  459. X
  460. X        if (access(lastarg, F_OK) != 0) {
  461. X
  462. X            (void)fprintf(stderr, "at: %s does not exist\n", lastarg);
  463. X            exit(1);
  464. X        }
  465. X
  466. X        if ((ptr = rindex(lastarg, '/')) == NULL)
  467. X            ptr = lastarg;
  468. X        else
  469. X            ptr++;
  470. X            
  471. X        (void)strncpy(script, ptr, 127);
  472. X
  473. X        if ((fp_script = fopen(lastarg, "r")) == NULL) {
  474. X
  475. X            perror(lastarg);
  476. X            exit(1);
  477. X        }
  478. X    }
  479. X
  480. X    else {
  481. X
  482. X        (void)fprintf(stderr, "bad date/time specification\n");
  483. X        exit(2);
  484. X    }
  485. X
  486. X    /* Check the 'at time' against the current time */
  487. X
  488. X    if (at_time < now_time) {
  489. X
  490. X        (void)fprintf(stderr, "too late\n");
  491. X        exit(1);
  492. X    }
  493. X
  494. X    /* Build file names for the temporary file and the 'at file' */
  495. X
  496. X    (void)sprintf(at_tmp, "%s/_at%d", ATDIR, getpid());
  497. X    jobno = atseq();
  498. X    (void)sprintf(at_file, "%s/%s", ATDIR, atname(at_time, jobno));
  499. X
  500. X    /* Set up signal handlers */
  501. X
  502. X    signal_init();
  503. X
  504. X    /* Open the temporary file */
  505. X
  506. X    if ((fp_at_file = fopen(at_tmp, "w")) == NULL) {
  507. X
  508. X        perror("can't create a job for you");
  509. X        exit(1);
  510. X    }
  511. X
  512. X    /* If the shell hasn't been specified, determine what should be used */
  513. X
  514. X    if (shell[0] == '\0') {
  515. X
  516. X        /* If the commands are from stdin, use the default shell; */
  517. X        /* otherwise, look at the script to see if a shell is specified */
  518. X
  519. X        if (fp_script == stdin || which_shell(fp_script, shell))
  520. X            (void)strcpy(shell, "$SHELL");
  521. X    }
  522. X
  523. X    /* Put the identification comments in the job file, copy the current */
  524. X    /* environment, and the shell command */
  525. X
  526. X    comments(owner, script, mail, fp_at_file);
  527. X    dumpenv(envp, fp_at_file);
  528. X    shell_start(shell, fp_at_file);
  529. X
  530. X    /* Copy commands from the appropriate source to the job file */
  531. X
  532. X    if (copy_commands(fp_script, fp_at_file) == 0) {
  533. X
  534. X        (void)fprintf(stderr, "nothing specified\n");
  535. X        quit();
  536. X        /* NOTREACHED */
  537. X    }
  538. X
  539. X    /* Change the ownership of the job file to the real user */
  540. X
  541. X    if (chown(at_tmp, getuid(), getgid()) < 0) {
  542. X    
  543. X        perror("can't change the owner/group of your job to you");
  544. X        exit(1);
  545. X    }
  546. X
  547. X    /* Set the mode of the file according to the owner's preference */
  548. X    /* (but allow owner read/write access in any case) */
  549. X    
  550. X    mask = umask(0);
  551. X    (void)umask(mask);
  552. X
  553. X    if (chmod(at_tmp, (mask ^ 0777) | 0600) < 0) {
  554. X
  555. X        perror("can't change the mode of your job");
  556. X        exit(1);
  557. X    }
  558. X
  559. X    /* Close the temporary job file and rename it to the 'at name' */
  560. X
  561. X    (void)fclose(fp_at_file);
  562. X
  563. X    if (rename(at_tmp, at_file) < 0) {
  564. X        
  565. X        perror(at_tmp);
  566. X        (void)unlink(at_tmp);
  567. X        exit(1);
  568. X    }
  569. X
  570. X    /* Say, "Nice user, good user..." */
  571. X
  572. X    (void)printf("job %d at %s", jobno, ctime(&at_time));
  573. X
  574. X    exit(0);
  575. X    /* NOTREACHED */
  576. X}
  577. X
  578. X/* -------------------------------------------------------------------------- */
  579. X
  580. Xvoid
  581. Xquit()
  582. X
  583. X{
  584. X    (void)unlink(at_tmp);
  585. X    (void)unlink(at_file);
  586. X    exit(1);
  587. X}
  588. X
  589. X/* -------------------------------------------------------------------------- */
  590. X
  591. Xcomments(owner, script, mail, fp_at_file)
  592. X
  593. Xchar *owner;
  594. Xchar *script;
  595. Xint mail;
  596. XFILE *fp_at_file;
  597. X
  598. X{
  599. X    (void)fprintf(fp_at_file, "# at job\n");
  600. X    (void)fprintf(fp_at_file, "# owner: %.127s\n", owner);
  601. X    (void)fprintf(fp_at_file, "# jobname: %.127s\n", script);
  602. X    (void)fprintf(fp_at_file, "# shell: sh\n");
  603. X    (void)fprintf(fp_at_file, "# notify by mail: %s\n", mail ? "yes" : "no");
  604. X    (void)fprintf(fp_at_file, "\n");
  605. X}
  606. X
  607. X/* -------------------------------------------------------------------------- */
  608. X
  609. Xcopy_commands(fp_script, fp_at_file)
  610. X
  611. XFILE *fp_script;
  612. XFILE *fp_at_file;
  613. X
  614. X{
  615. X    int ncmd;
  616. X
  617. X    /* If a script has been specified or if stdin has been redirected, */
  618. X    /* read and copy the script */
  619. X
  620. X    if (fp_script != stdin || isatty(0) == 0) {
  621. X
  622. X        for (ncmd = 0 ; fgets(buffer, sizeof(buffer), fp_script) ; ncmd++)
  623. X            fputs(buffer, fp_at_file);
  624. X    }
  625. X
  626. X    /* Otherwise, prompt for each line and copy it */
  627. X
  628. X    else {
  629. X
  630. X        for (ncmd = 0 ; (void)printf("at> "), fgets(buffer, sizeof(buffer),
  631. X                stdin) ; ncmd++)
  632. X            fputs(buffer, fp_at_file);
  633. X
  634. X        (void)printf("<EOT>\n");
  635. X    }
  636. X
  637. X    return(ncmd);
  638. X}
  639. X
  640. X/* -------------------------------------------------------------------------- */
  641. X
  642. X#if defined(GENERIC_SYSV)
  643. X
  644. X/* A dummy routine to keep certain System V machines happy since parse_date */
  645. X/* wants to use it and we want to use the stock version of parse_date */
  646. X
  647. Xftime(dummy)
  648. X
  649. Xstruct timeb *dummy;
  650. X
  651. X{
  652. X}
  653. X
  654. X#endif
  655. X
  656. X/* -------------------------------------------------------------------------- */
  657. X
  658. Xparse_args(nargs, argv)
  659. X
  660. Xint nargs;
  661. Xchar *argv[];
  662. X
  663. X{
  664. X    int i;
  665. X
  666. X    struct timeb *now;
  667. X
  668. X    time_t at_time;
  669. X
  670. X    buffer[0] = '\0';
  671. X
  672. X    /* Build up a string of the specified arguments */
  673. X
  674. X    for (i = 0 ; i < nargs ; i++) {
  675. X
  676. X        (void)strcat(buffer, argv[i]);
  677. X        (void)strcat(buffer, " ");
  678. X    }
  679. X
  680. X    /* Now try to parse it as a time specification */
  681. X
  682. X    now = NULL;
  683. X    at_time = parse_date(buffer, now);
  684. X
  685. X    /* Drop any seconds in the specification */
  686. X
  687. X    if (at_time > 0)
  688. X        at_time -= at_time % 60;
  689. X
  690. X    return(at_time);
  691. X}
  692. X
  693. X/* -------------------------------------------------------------------------- */
  694. X
  695. Xshell_start(shell, fp_at_file)
  696. X
  697. Xchar *shell;
  698. XFILE *fp_at_file;
  699. X
  700. X{
  701. X    char path[MAXPATHLEN];
  702. X    int mask;
  703. X
  704. X    (void)fprintf(fp_at_file,
  705. X        "%s << '...use the rest of this file for input'\n", shell);
  706. X
  707. X#ifdef HAS_GETCWD
  708. X    if (getcwd(path, MAXPATHLEN) == (char *)NULL) {
  709. X#else
  710. X    if (getwd(path) == (char *)NULL) {
  711. X#endif
  712. X
  713. X        (void)fprintf(stderr, "%s\n", path);
  714. X        exit(1);
  715. X    }
  716. X
  717. X    (void)fprintf(fp_at_file, "cd %s\n", path);
  718. X    mask = umask(0);
  719. X    umask(mask);
  720. X    (void)fprintf(fp_at_file, "umask %o\n", mask);
  721. X}
  722. X
  723. X/* -------------------------------------------------------------------------- */
  724. X
  725. Xsignal_init()
  726. X
  727. X{
  728. X    (void)signal(SIGHUP, quit);
  729. X    (void)signal(SIGQUIT, quit);
  730. X    (void)signal(SIGINT, quit);
  731. X    (void)signal(SIGTERM, quit);
  732. X}
  733. X
  734. X/* -------------------------------------------------------------------------- */
  735. X
  736. Xusage()
  737. X
  738. X{
  739. X    (void)printf("usage: at [-c|k|s] [-m] time [date] [script]\n");
  740. X    exit(2);
  741. X}
  742. X
  743. X/* -------------------------------------------------------------------------- */
  744. X
  745. Xwhich_shell(fp_script, shell)
  746. X
  747. XFILE *fp_script;
  748. Xchar *shell;
  749. X
  750. X{
  751. X    char *ptr;
  752. X
  753. X    int length;
  754. X
  755. X    /* Determine if a shell is specified in the script */
  756. X
  757. X    /* If we get EOF, just use the current shell */
  758. X
  759. X    if (fgets(buffer, sizeof(buffer), fp_script) == NULL)
  760. X        return(1);
  761. X    
  762. X    /* Reposition to the beginning of the file */
  763. X
  764. X    if (fseek(fp_script, 0L, 0) < 0) {
  765. X
  766. X        perror("seek on input script failed");
  767. X        exit(1);
  768. X    }
  769. X    
  770. X    /* If we don't get a cookie, forget it */
  771. X
  772. X    if (buffer[0] != '#' || buffer[1] != '!')
  773. X        return(1);
  774. X    
  775. X    /* Skip leading spaces and drop the newline */
  776. X
  777. X    for (ptr = buffer + 2 ; *ptr == ' ' ; ptr++)
  778. X        ;
  779. X    
  780. X    length = strlen(ptr);
  781. X    *(ptr + --length) = '\0';
  782. X
  783. X    /* Is this too long? */
  784. X
  785. X    if (length > 32) {
  786. X
  787. X        (void)fprintf(stderr,
  788. X            "shell specifier (%s) in script is too long - using default\n",
  789. X            ptr);
  790. X        return(1);
  791. X    }
  792. X
  793. X    (void)strcpy(shell, ptr);
  794. X    return(0);
  795. X}
  796. END_OF_FILE
  797. if test 8859 -ne `wc -c <'src/at.c'`; then
  798.     echo shar: \"'src/at.c'\" unpacked with wrong size!
  799. fi
  800. # end of 'src/at.c'
  801. fi
  802. if test -f 'src/atq.c' -a "${1}" != "-c" ; then 
  803.   echo shar: Will not clobber existing file \"'src/atq.c'\"
  804. else
  805. echo shar: Extracting \"'src/atq.c'\" \(6069 characters\)
  806. sed "s/^X//" >'src/atq.c' <<'END_OF_FILE'
  807. X/* atq --- a member of the kat family (Keith's at package) */
  808. X
  809. X/* atq(1) lists all or part of the queue of jobs submitted via at(1). */
  810. X
  811. X/* Copyright (c) 1990, W. Keith Pyle, Austin, Texas */
  812. X
  813. X#include "at.h"
  814. X
  815. Xchar *verstring = PATCHLEVEL;
  816. X
  817. Xchar *disp_date();
  818. Xchar *nth();
  819. Xint comp_ctime();
  820. Xint comp_start();
  821. X
  822. Xextern char *optarg;
  823. Xextern char *sys_errlist[];
  824. X
  825. Xextern int optind;
  826. Xextern int opterr;
  827. X
  828. X/* -------------------------------------------------------------------------- */
  829. X
  830. Xmain(argc, argv)
  831. X
  832. Xint argc;
  833. Xchar *argv[];
  834. X
  835. X{
  836. X    char jobname[32];                    /* Jobname from queued jobfile */
  837. X    char owner[16];                        /* Owner of queued job */
  838. X
  839. X    int count_only;                        /* TRUE for display count only */
  840. X    int flag;                            /* The getopt found flag */
  841. X    int i;                                /* An index */
  842. X    int n_jobs;                            /* The number of jobs to be listed */
  843. X    int qsize;                            /* Size of queue data structure */
  844. X
  845. X    int (*sort_func)();                    /* Pointer to function for sort use */
  846. X
  847. X    struct dirent *entry;                /* Pointer to directory entry */
  848. X    struct queue *atq;                    /* The queue list data structure ptr */
  849. X    register struct queue *qptr;        /* A working queue list pointer */
  850. X
  851. X    DIR *dp;                            /* Descriptor for queue directory */
  852. X
  853. X    /* Check for allowed at usage */
  854. X     
  855. X    whoami(owner);
  856. X    
  857. X    /* Change to the at directory and check permissions */
  858. X
  859. X    if (chdir(ATDIR) < 0) {
  860. X
  861. X        perror("can't change directory to the at directory");
  862. X        exit(1);
  863. X    }
  864. X
  865. X    if (!permit(owner, ALLOW_FILE, DENY_FILE)) {
  866. X 
  867. X        fprintf(stderr, "you are not authorized to use at.  Sorry.\n");
  868. X        exit(1);
  869. X    }
  870. X
  871. X    /* Some initialization */
  872. X
  873. X    count_only = FALSE;
  874. X    qsize = 0;
  875. X    sort_func = comp_start;
  876. X
  877. X    /* Parse any arguments */
  878. X
  879. X    while ((flag = getopt(argc, argv, "cn")) != EOF) {
  880. X
  881. X        switch (flag) {
  882. X
  883. X            case 'c':
  884. X
  885. X                sort_func = comp_ctime;
  886. X                break;
  887. X            
  888. X            case 'n':
  889. X
  890. X                count_only = TRUE;
  891. X                break;
  892. X
  893. X            default:
  894. X
  895. X                fprintf(stderr, "usage: atq [-c|n] [username]\n");
  896. X                exit(2);
  897. X        }
  898. X    }
  899. X
  900. X    /* Try to open the at job directory */
  901. X
  902. X    if ((dp = opendir(".")) == NULL) {
  903. X
  904. X        perror("can't read the at directory");
  905. X        exit(1);
  906. X    }
  907. X
  908. X    /* Process all of the directory entries which have names of the proper */
  909. X    /* format for a queued at job */
  910. X
  911. X    while ((entry = readdir(dp)) != NULL) {
  912. X
  913. X        int jobno;
  914. X
  915. X        time_t tod;
  916. X
  917. X        struct stat statbuf;
  918. X
  919. X        /* Is the name of the proper format? */
  920. X
  921. X        if (sscanf(entry->d_name, "%d.%d", &tod, &jobno) != 2)
  922. X            continue;
  923. X        
  924. X        if (stat(entry->d_name, &statbuf) < 0) {
  925. X
  926. X            perror(entry->d_name);
  927. X            continue;
  928. X        }
  929. X
  930. X        /* If there are names in the argument list, do any of them */
  931. X        /* match the owner of this jobfile? */
  932. X
  933. X        if (optind < argc) {
  934. X
  935. X            int found;
  936. X
  937. X            struct passwd *pw;
  938. X
  939. X            if ((pw = getpwuid(statbuf.st_uid)) == NULL) {
  940. X
  941. X                perror(entry->d_name);
  942. X                continue;
  943. X            }
  944. X
  945. X            found = FALSE;
  946. X
  947. X            for (i = optind ; i < argc ; i++) {
  948. X
  949. X                if (strcmp(argv[i], pw->pw_name) == 0) {
  950. X                    
  951. X                    found = TRUE;
  952. X                    break;
  953. X                }
  954. X            }
  955. X
  956. X            if (!found)
  957. X                continue;
  958. X        }
  959. X
  960. X        /* This entry should be listed.  Make sure there is space */
  961. X        /* in the queue data structure to store it */
  962. X
  963. X        if ((n_jobs + 1) > qsize) {
  964. X
  965. X            if ((qsize = qalloc(&atq, qsize)) < 0) {
  966. X
  967. X                fprintf(stderr, "can't allocate space for queue data\n");
  968. X                exit(1);
  969. X            }
  970. X        }
  971. X            
  972. X        /* Save the info */
  973. X
  974. X        atq[n_jobs].qu_start = tod;
  975. X        strcpy(atq[n_jobs].qu_name, entry->d_name);
  976. X        atq[n_jobs].qu_jobno = jobno;
  977. X        atq[n_jobs].qu_ctime = statbuf.st_ctime;
  978. X        n_jobs++;
  979. X    }
  980. X
  981. X    closedir(dp);
  982. X
  983. X    /* Do we do a count only? */
  984. X
  985. X    if (count_only) {
  986. X
  987. X        printf("%d\n", n_jobs);
  988. X        exit(0);
  989. X    }
  990. X
  991. X    /* Were there any jobs? */
  992. X
  993. X    if (n_jobs == 0) {
  994. X
  995. X        printf("no files in queue\n");
  996. X        exit(0);
  997. X    }
  998. X
  999. X    /* If more than one job, sort them */
  1000. X
  1001. X    else if (n_jobs > 1)
  1002. X        qsort(atq, n_jobs, sizeof(struct queue), sort_func);
  1003. X    
  1004. X    /* Print the info on the selected queued entries */
  1005. X
  1006. X    printf(" Rank     Execution Date     Owner     Job #   Job Name\n");
  1007. X
  1008. X    for (i = 1, qptr = atq ; i <= n_jobs ; i++, qptr++) {
  1009. X
  1010. X        if (get_ident(qptr->qu_name, owner, jobname) < 0)
  1011. X            continue;
  1012. X
  1013. X        printf("%3d%s   %s   %-10s%5d   %s\n", i, nth(i),
  1014. X            disp_date(qptr->qu_start), owner, qptr->qu_jobno, jobname);
  1015. X    }
  1016. X
  1017. X    exit(0);
  1018. X}
  1019. X
  1020. X/* -------------------------------------------------------------------------- */
  1021. X
  1022. Xcomp_ctime(str1, str2)
  1023. X
  1024. Xstruct queue *str1;
  1025. Xstruct queue *str2;
  1026. X
  1027. X{
  1028. X    /* Compare the creation times of the two entries */
  1029. X
  1030. X    return(str1->qu_ctime - str2->qu_ctime);
  1031. X}
  1032. X
  1033. X/* -------------------------------------------------------------------------- */
  1034. X
  1035. Xcomp_start(str1, str2)
  1036. X
  1037. Xstruct queue *str1;
  1038. Xstruct queue *str2;
  1039. X
  1040. X{        
  1041. X    /* Compare the start times of the two entries */
  1042. X
  1043. X    return(str1->qu_start - str2->qu_start);
  1044. X}
  1045. X
  1046. X/* -------------------------------------------------------------------------- */
  1047. X
  1048. Xchar *
  1049. Xdisp_date(tod)
  1050. X
  1051. Xtime_t tod;
  1052. X
  1053. X{
  1054. X    static char datebuf[20];
  1055. X    static char *mon[] = {
  1056. X        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  1057. X        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
  1058. X        };
  1059. X
  1060. X    struct tm *tm;
  1061. X
  1062. X    tm = localtime(&tod);
  1063. X    sprintf(datebuf, "%s %2d, %4d %02d:%02d", mon[tm->tm_mon], tm->tm_mday,
  1064. X        tm->tm_year + 1900, tm->tm_hour, tm->tm_min);
  1065. X    
  1066. X    return(datebuf);
  1067. X}
  1068. X
  1069. X/* -------------------------------------------------------------------------- */
  1070. X
  1071. Xget_ident(jobfile, owner, jobname)
  1072. X
  1073. Xchar *jobfile;
  1074. Xchar *owner;
  1075. Xchar *jobname;
  1076. X
  1077. X{
  1078. X    char line[MAXLINE];
  1079. X
  1080. X    int found_job;
  1081. X    int found_owner;
  1082. X
  1083. X    FILE *fp;
  1084. X
  1085. X    /* Open the jobfile */
  1086. X
  1087. X    if ((fp = fopen(jobfile, "r")) == NULL) {
  1088. X
  1089. X        printf("atq: Can't open job file %s: %s\n",
  1090. X            jobfile, sys_errlist[errno]);
  1091. X        return(-1);
  1092. X    }
  1093. X
  1094. X    /* Look for the owner and jobname lines of the jobfile */
  1095. X    
  1096. X    found_job = found_owner = FALSE;
  1097. X    *owner = *jobname = '\0';
  1098. X
  1099. X    while (fgets(line, sizeof(line), fp)) {
  1100. X
  1101. X        if (sscanf(line, "# owner: %10s", owner) == 1)
  1102. X            found_owner = TRUE;
  1103. X        
  1104. X        else if (sscanf(line, "# jobname: %27s%*[^\n]", jobname) == 1)
  1105. X            found_job = TRUE;
  1106. X        
  1107. X        if (found_owner && found_job)
  1108. X            break;
  1109. X    }
  1110. X
  1111. X    fclose(fp);
  1112. X    return(0);
  1113. X}
  1114. X
  1115. X/* -------------------------------------------------------------------------- */
  1116. X
  1117. Xchar *
  1118. Xnth(n)
  1119. X
  1120. Xint n;
  1121. X
  1122. X{
  1123. X    switch (n) {
  1124. X
  1125. X        case 1:
  1126. X
  1127. X            return("st");
  1128. X        
  1129. X        case 2:
  1130. X
  1131. X            return("nd");
  1132. X        
  1133. X        case 3:
  1134. X
  1135. X            return("rd");
  1136. X        
  1137. X        default:
  1138. X
  1139. X            return("th");
  1140. X    }
  1141. X}
  1142. END_OF_FILE
  1143. if test 6069 -ne `wc -c <'src/atq.c'`; then
  1144.     echo shar: \"'src/atq.c'\" unpacked with wrong size!
  1145. fi
  1146. # end of 'src/atq.c'
  1147. fi
  1148. if test -f 'src/atrun.c' -a "${1}" != "-c" ; then 
  1149.   echo shar: Will not clobber existing file \"'src/atrun.c'\"
  1150. else
  1151. echo shar: Extracting \"'src/atrun.c'\" \(17097 characters\)
  1152. sed "s/^X//" >'src/atrun.c' <<'END_OF_FILE'
  1153. X/* atrun --- a member of the kat family (Keith's at package) */
  1154. X
  1155. X/* atrun(8) controls execution of jobs in the at(1) queue.  Provision is */
  1156. X/* made to mail output generated during the execution to the submitting */
  1157. X/* user and to control the number of concurrent at processes.  atrun(8) */
  1158. X/* is typically run by cron periodically (e.g., every 15 minutes). */
  1159. X
  1160. X/* Copyright (c) 1990, W. Keith Pyle, Austin, Texas */
  1161. X
  1162. X#include "at.h"
  1163. X
  1164. Xchar *verstring = PATCHLEVEL;
  1165. X
  1166. X#include <syslog.h>
  1167. X#ifdef HAS_TERMIO
  1168. X#include <termio.h>
  1169. X#else
  1170. X#include <sgtty.h> 
  1171. X#endif
  1172. X
  1173. X#define LOCKFILE    "atrun.lock"
  1174. X
  1175. Xchar *progname;
  1176. X
  1177. X#ifdef DEBUG
  1178. X
  1179. X/* These options define logging behavior for a debugging version only */
  1180. X
  1181. Xint debug_level;
  1182. Xextern char *optarg;
  1183. X
  1184. X#ifdef NOSYSLOG
  1185. X#define syslog    fprintf
  1186. X#define LOGDEST    logfile
  1187. X#define LOGFILE    "./atrun.debug"
  1188. XFILE *logfile;
  1189. X#endif
  1190. X
  1191. X#else
  1192. X
  1193. X/* These options apply to logging in the production version */
  1194. X
  1195. X#ifdef HAS_SYSLOGFACILITY
  1196. X#define LOGDEST LOG_ERR | LOG_DAEMON
  1197. X#else
  1198. X#define LOGDEST LOG_ERR
  1199. X#endif
  1200. X
  1201. X#endif    /* DEBUG */
  1202. X
  1203. Xchar *rindex();
  1204. X
  1205. Xint comp_start();
  1206. X
  1207. Xextern char *sys_errlist[];
  1208. X
  1209. X/* -------------------------------------------------------------------------- */
  1210. X
  1211. Xmain(argc, argv)
  1212. X
  1213. Xint argc;
  1214. Xchar *argv[];
  1215. X
  1216. X{
  1217. X    char lockfile[MAXPATHLEN];
  1218. X    char logname[32];
  1219. X    char *ptr;
  1220. X
  1221. X    int flag;
  1222. X    int n_jobs;
  1223. X    int tod;
  1224. X
  1225. X    struct queue *atq;
  1226. X
  1227. X    FILE *fp;
  1228. X
  1229. X    /* Make sure only root runs this */
  1230. X
  1231. X    if (geteuid() != 0) {
  1232. X
  1233. X        fprintf(stderr, "permission denied\n");
  1234. X        exit(1);
  1235. X    }
  1236. X
  1237. X    /* Make sure we are allowed to run: check for lock file */
  1238. X
  1239. X    sprintf(lockfile, "%s/%s", ATDIR, LOCKFILE);
  1240. X
  1241. X    if (access(lockfile, F_OK) == 0) {
  1242. X
  1243. X        fprintf(stderr, "atrun.lock exists: cannot execute\n");
  1244. X        exit(1);
  1245. X    }
  1246. X
  1247. X    /* Convert to a daemon */
  1248. X
  1249. X    daemonize();
  1250. X
  1251. X    /* Set up syslog options */
  1252. X
  1253. X#ifndef NOSYSLOG
  1254. X    if ((ptr = rindex(argv[0], '/')) != NULL)
  1255. X        ptr++;
  1256. X    else
  1257. X        ptr = argv[0];
  1258. X    
  1259. X    strcpy(logname, ptr);
  1260. X    
  1261. X#ifdef HAS_SYSLOGFACILITY
  1262. X    openlog(logname, LOG_CONS, LOG_DAEMON);
  1263. X#else
  1264. X    openlog(logname, 0);
  1265. X#endif
  1266. X#else
  1267. X    if ((logfile = fopen(LOGFILE, "a")) == NULL) {
  1268. X
  1269. X        perror(LOGFILE);
  1270. X        exit(1);
  1271. X    }
  1272. X
  1273. X    setbuf(logfile, NULL);
  1274. X    time(&tod);
  1275. X    fprintf(logfile, "atrun started at %s", ctime(&tod));
  1276. X#endif
  1277. X
  1278. X    /* Make our name stand out for ps(1) */
  1279. X
  1280. X    progname = argv[0];
  1281. X
  1282. X    for (ptr = argv[0] ; *ptr ; ptr++)
  1283. X        *ptr = islower(*ptr) ? toupper(*ptr) : *ptr;
  1284. X
  1285. X#ifdef DEBUG
  1286. X    /* In the DEBUG version, check for a debug level argument */
  1287. X
  1288. X    while ((flag = getopt(argc, argv, "x")) != EOF) {
  1289. X
  1290. X        switch (flag) {
  1291. X
  1292. X            case 'x':
  1293. X
  1294. X                debug_level = TRUE;
  1295. X                break;
  1296. X            
  1297. X            default:
  1298. X
  1299. X                syslog(LOGDEST, "invalid argument: %c\n", flag);
  1300. X                exit(1);
  1301. X        }
  1302. X    }
  1303. X#endif
  1304. X
  1305. X    /* Change to the at job directory */
  1306. X
  1307. X    if (chdir(ATDIR) < 0) {
  1308. X
  1309. X        syslog(LOGDEST, "can't chdir to %s: %s\n", ATDIR, sys_errlist[errno]);
  1310. X        exit(1);
  1311. X    }
  1312. X
  1313. X    /* Make sure we can update the last done file */
  1314. X
  1315. X    if ((fp = fopen("lasttimedone", "w")) == NULL) {
  1316. X
  1317. X        syslog(LOGDEST, "can't open 'lasttimedone': %s\n", sys_errlist[errno]);
  1318. X        exit(1);
  1319. X    }
  1320. X
  1321. X    /* Select the job files to be run */
  1322. X
  1323. X    n_jobs = select_jobs(&atq);
  1324. X
  1325. X    /* Update the last done file */
  1326. X
  1327. X    time(&tod);
  1328. X    fprintf(fp, "%d (%.19s)\n", tod, ctime(&tod));
  1329. X    fclose(fp);
  1330. X
  1331. X    /* Now run the selected jobs */
  1332. X
  1333. X    if (n_jobs != 0)
  1334. X        run_all(n_jobs, atq);
  1335. X
  1336. X    exit(0);
  1337. X}
  1338. X
  1339. X/* -------------------------------------------------------------------------- */
  1340. X
  1341. X/* Compare function for use with sort: compare job start times */
  1342. X
  1343. Xcomp_start(ptr1, ptr2)
  1344. X
  1345. Xstruct queue *ptr1;
  1346. Xstruct queue *ptr2;
  1347. X
  1348. X{
  1349. X    return(ptr1->qu_start - ptr2->qu_start);
  1350. X}
  1351. X
  1352. X/* -------------------------------------------------------------------------- */
  1353. X
  1354. X/* Determine if the user requested mail confirming the completion */
  1355. X/* of the job */
  1356. X
  1357. Xconfirmation(mail_uid, jobfile, jobno)
  1358. X
  1359. Xint mail_uid;
  1360. Xchar *jobfile;
  1361. Xint jobno;
  1362. X
  1363. X{
  1364. X    char buffer[MAXLINE];
  1365. X
  1366. X    int confirm;
  1367. X
  1368. X    FILE *jobfile_fp;
  1369. X
  1370. X    confirm = FALSE;
  1371. X
  1372. X    /* Open the job file and look for the notify line */
  1373. X
  1374. X    if ((jobfile_fp = fopen(jobfile, "r")) != NULL) {
  1375. X
  1376. X        while (fgets(buffer, sizeof(buffer), jobfile_fp)) {
  1377. X
  1378. X            if (strcmp(buffer, "# notify by mail: yes\n") == 0) {
  1379. X
  1380. X                confirm = TRUE;
  1381. X                break;
  1382. X            }
  1383. X        }
  1384. X
  1385. X        fclose(jobfile_fp);
  1386. X    }
  1387. X
  1388. X    /* Did we find a comfirm line? */
  1389. X
  1390. X    if (confirm) {
  1391. X
  1392. X        /* Oh, yes, we did! */
  1393. X
  1394. X        open_mail(mail_uid);
  1395. X        sprintf(buffer, "Your \"at\" job \"%d\" completed.\n", jobno);
  1396. X        write(1, buffer, strlen(buffer));
  1397. X    }
  1398. X
  1399. X    return(confirm);
  1400. X}
  1401. X
  1402. X/* -------------------------------------------------------------------------- */
  1403. X
  1404. X/* Send generated output to user via mail */
  1405. X
  1406. Xcopy_output(jobfile, jobno, outfile)
  1407. X
  1408. Xchar *jobfile;
  1409. Xint jobno;
  1410. Xchar *outfile;
  1411. X
  1412. X{
  1413. X    char buffer [8192];
  1414. X
  1415. X    int bytes;
  1416. X    int outfile_fd;
  1417. X
  1418. X    sprintf(buffer,
  1419. X        "Your \"at\" job \"%d\" generated the following output:\n\n",
  1420. X        jobno);
  1421. X    write(1, buffer, strlen(buffer));
  1422. X
  1423. X    /* Open the generated output file and write it to sendmail */
  1424. X
  1425. X    if ((outfile_fd = open(outfile, O_RDONLY)) >= 0) {
  1426. X
  1427. X        while ((bytes = read(outfile_fd, buffer, sizeof(buffer))) > 0)
  1428. X            write(1, buffer, bytes);
  1429. X    
  1430. X        close(outfile_fd);
  1431. X    }
  1432. X
  1433. X    else
  1434. X        syslog(LOGDEST,
  1435. X            "couldn't open output %s from jobfile %s for reading: %s\n",
  1436. X            outfile, jobfile, sys_errlist[errno]);
  1437. X}
  1438. X
  1439. X/* -------------------------------------------------------------------------- */
  1440. X
  1441. X/* Convert the master process to a daemon */
  1442. X
  1443. Xdaemonize()
  1444. X
  1445. X{
  1446. X    int fd;
  1447. X    int pid;
  1448. X
  1449. X    /* Ignore the terminal stop signals */
  1450. X
  1451. X    (void) signal(SIGTTOU, SIG_IGN);
  1452. X    (void) signal(SIGTTIN, SIG_IGN);
  1453. X    (void) signal(SIGTSTP, SIG_IGN);
  1454. X
  1455. X    /* Fork to a child process, parent terminates */
  1456. X
  1457. X    if ((pid = fork()) < 0) {
  1458. X
  1459. X        syslog(LOGDEST, "could not fork to create daemon\n");
  1460. X        exit(1);
  1461. X    }
  1462. X
  1463. X    else if (pid > 0)
  1464. X        exit(0);
  1465. X    
  1466. X    /* Disassociate ourselves from the old process group */
  1467. X
  1468. X    if (setpgrp(0, getpid()) == -1) {
  1469. X
  1470. X        syslog(LOGDEST, "couldn't set process group in master atrun\n");
  1471. X        exit(1);
  1472. X    }
  1473. X
  1474. X#ifdef HAS_TIOCNOTTY
  1475. X    /* Lose the controlling terminal */
  1476. X
  1477. X    if ((fd = open("/dev/tty", O_RDWR)) >= 0) {
  1478. X
  1479. X        (void) ioctl(fd, TIOCNOTTY, (char *) NULL);
  1480. X        (void) close(fd);
  1481. X    }
  1482. X#endif
  1483. X
  1484. X    /* Make stdin, stdout, and stderr worthless but keep them as placeholders */
  1485. X    /* since we may need to do forks and use them in the child */
  1486. X
  1487. X    close(0);
  1488. X    close(1);
  1489. X
  1490. X    if (open("/dev/null", O_RDONLY) != 0) {
  1491. X
  1492. X        syslog(LOGDEST, "couldn't reopen stdin as /dev/null");
  1493. X        exit(1);
  1494. X    }
  1495. X
  1496. X    if (open("/dev/null", O_WRONLY) != 1) {
  1497. X
  1498. X        syslog(LOGDEST, "couldn't reopen stdout as /dev/null");
  1499. X        exit(1);
  1500. X    }
  1501. X
  1502. X    close(2);
  1503. X    dup(1);
  1504. X}
  1505. X
  1506. X/* -------------------------------------------------------------------------- */
  1507. X
  1508. X/* Create a sendmail process to mail output to the at job owner */
  1509. X
  1510. Xopen_mail(uid)
  1511. X
  1512. Xuid_t uid;
  1513. X
  1514. X{
  1515. X    int mail_pipe[2];
  1516. X    int pid;
  1517. X
  1518. X    struct passwd *pw;
  1519. X
  1520. X    /* Determine the user name for this job */
  1521. X
  1522. X    if ((pw = getpwuid(uid)) == NULL) {
  1523. X
  1524. X        syslog(LOGDEST, "can't find passwd entry for uid %d: %s\n",
  1525. X            uid, sys_errlist[errno]);
  1526. X        return;
  1527. X    }
  1528. X
  1529. X#ifdef DEBUG
  1530. X    if (debug_level)
  1531. X        syslog(LOGDEST, "opening mail for %s in slave atrun (pid=%d)\n",
  1532. X            pw->pw_name, getpid());
  1533. X#endif
  1534. X
  1535. X    if (pipe(mail_pipe) < 0) {
  1536. X
  1537. X        syslog(LOGDEST, "can't create pipe for mail: %s\n", sys_errlist[errno]);
  1538. X        return;
  1539. X    }
  1540. X
  1541. X    if ((pid = fork()) < 0) {
  1542. X
  1543. X        syslog(LOGDEST, "can't fork for mail: %s\n", sys_errlist[errno]);
  1544. X        return;
  1545. X    }
  1546. X
  1547. X    else if (pid > 0) {
  1548. X
  1549. X        char buffer[256];
  1550. X
  1551. X        /* Parent (slave atrun): make stdout go to sendmail and write header */
  1552. X
  1553. X        close(1);
  1554. X        dup(mail_pipe[1]);
  1555. X        close(mail_pipe[0]);
  1556. X        close(mail_pipe[1]);
  1557. X
  1558. X#ifdef USE_SENDMAIL
  1559. X        sprintf(buffer, "To: %s\nSubject: Output from \"at\" job\n\n",
  1560. X            pw->pw_name);
  1561. X        write(1, buffer, strlen(buffer));
  1562. X#endif
  1563. X
  1564. X        return;
  1565. X    }
  1566. X
  1567. X    else {
  1568. X
  1569. X        /* Child: convert pipe to stdin and exec to sendmail */
  1570. X
  1571. X        close(0);
  1572. X        dup(mail_pipe[0]);
  1573. X        close(mail_pipe[0]);
  1574. X        close(mail_pipe[1]);
  1575. X
  1576. X#ifdef USE_SENDMAIL
  1577. X        execl("/usr/lib/sendmail", "sendmail", "-t", (char *)NULL);
  1578. X#endif
  1579. X
  1580. X#ifdef USE_UCBMAIL
  1581. X        execl("/usr/ucb/Mail", "Mail", "-s", "Output from \"at\" job",
  1582. X            pw->pw_name, (char *)NULL);
  1583. X#endif
  1584. X
  1585. X#ifdef USE_BINMAIL
  1586. X        execl("/bin/mail", "mail", pw->pw_name, (char *)NULL);
  1587. X#endif
  1588. X
  1589. X        syslog(LOGDEST, "exec to mailer failed: %s\n", sys_errlist[errno]);
  1590. X        exit(1);
  1591. X    }
  1592. X}
  1593. X
  1594. X/* -------------------------------------------------------------------------- */
  1595. X
  1596. X/* If a slave atrun fails, this will try to move the jobfile back to the */
  1597. X/* normal queue directory */
  1598. X
  1599. Xrecover(jobfile)
  1600. X
  1601. Xchar *jobfile;
  1602. X
  1603. X{
  1604. X    char newname[MAXPATHLEN];
  1605. X
  1606. X#ifdef DEBUG
  1607. X    if (debug_level)
  1608. X        syslog(LOGDEST,
  1609. X            "attempting recovery of jobfile %s in slave atrun (pid=%d)\n",
  1610. X            jobfile, getpid());
  1611. X#endif
  1612. X
  1613. X    sprintf(newname, "%s/%s", ATDIR, jobfile);
  1614. X
  1615. X    if (rename(jobfile, newname) < 0)
  1616. X        syslog(LOGDEST,
  1617. X            "couldn't recover jobfile %s from the past directory: %s\n",
  1618. X            jobfile, sys_errlist[errno]);
  1619. X}
  1620. X
  1621. X/* -------------------------------------------------------------------------- */
  1622. X
  1623. X/* Create slave atrun processes for each job in queue. Manage total */
  1624. X/* number running so as not to exceed configured limit. */
  1625. X
  1626. Xrun_all(n_jobs, atq)
  1627. X
  1628. Xint n_jobs;
  1629. Xstruct queue *atq;
  1630. X
  1631. X{
  1632. X    int i;
  1633. X    int n_slave;
  1634. X    int status;
  1635. X
  1636. X    register struct queue *qptr;
  1637. X
  1638. X    /* cd to the working directory */
  1639. X
  1640. X    if (chdir(PASTDIR) < 0) {
  1641. X
  1642. X        syslog(LOGDEST, "can't chdir to past: %s\n", sys_errlist[errno]);
  1643. X        exit(1);
  1644. X    }
  1645. X
  1646. X    /* Sort the entries in order of starting time */
  1647. X
  1648. X    if (n_jobs > 1)
  1649. X        qsort(atq, n_jobs, sizeof(struct queue), comp_start);
  1650. X
  1651. X    /* Run them */
  1652. X
  1653. X    n_slave = 0;
  1654. X
  1655. X    for (i = 0 , qptr = atq ; i < n_jobs ; i++, qptr++) {
  1656. X
  1657. X#if MAXATPROC
  1658. X        /* Check number of slaves running */
  1659. X
  1660. X        if (n_slave >= MAXATPROC) {
  1661. X
  1662. X            /* At configured limit; wait for one to finish */
  1663. X
  1664. X#ifdef DEBUG
  1665. X            if (debug_level)
  1666. X                syslog(LOGDEST,
  1667. X                    "MAXATPROC hit; waiting for slave to finish...\n");
  1668. X#endif
  1669. X
  1670. X            if (wait(&status) == -1)
  1671. X                syslog(LOGDEST,
  1672. X                    "shouldn't happen: wait reports no slaves running\n");
  1673. X
  1674. X            n_slave--;
  1675. X        }
  1676. X#endif    /* MAXATPROC */
  1677. X
  1678. X        /* Run the next queue entry */
  1679. X
  1680. X        run_one(qptr);
  1681. X        n_slave++;
  1682. X    }
  1683. X
  1684. X    /* Wait for any remaining slaves to finish */
  1685. X
  1686. X    while (wait(&status) != -1)
  1687. X        ;
  1688. X}
  1689. X
  1690. X/* -------------------------------------------------------------------------- */
  1691. X
  1692. X/* Manage creation and execution of one queue entry */
  1693. X
  1694. Xrun_one(qptr)
  1695. X
  1696. Xstruct queue *qptr;
  1697. X
  1698. X{
  1699. X    char *ptr;
  1700. X    char *jobfile;
  1701. X    char outfile[32];
  1702. X
  1703. X    int jobno;
  1704. X    int pid;
  1705. X    int mail_pipe[2];
  1706. X    int outfile_fd;
  1707. X
  1708. X    struct stat statbuf;
  1709. X
  1710. X    jobfile = qptr->qu_name;
  1711. X    jobno = qptr->qu_jobno;
  1712. X
  1713. X    /* Create a slave atrun; return if master process */
  1714. X
  1715. X    if ((pid = fork()) < 0) {
  1716. X
  1717. X        syslog(LOGDEST, "can't create fork slave atrun for jobfile %s: %s\n",
  1718. X            jobfile, sys_errlist[errno]);
  1719. X        recover(jobfile);
  1720. X        return;
  1721. X    }
  1722. X
  1723. X    else if (pid > 0)
  1724. X        return;
  1725. X
  1726. X#ifdef DEBUG
  1727. X    if (debug_level)
  1728. X        syslog(LOGDEST, "slave atrun (pid=%d) created for jobfile %s\n",
  1729. X            getpid(), jobfile);
  1730. X#endif
  1731. X    
  1732. X    /* We're now a slave atrun responsible for only one jobfile. */
  1733. X    /* Fix our name so ps(1) shows it a little differently than the master. */
  1734. X
  1735. X    if ((ptr = rindex(progname, '/')) != NULL)
  1736. X        ptr += 2;
  1737. X    else
  1738. X        ptr = progname + 1;
  1739. X
  1740. X    for ( ; *ptr ; ptr++)
  1741. X        *ptr = isupper(*ptr) ? tolower(*ptr) : *ptr;
  1742. X
  1743. X    /* Create a file to receive the stdout and stderr from the at job. */
  1744. X
  1745. X    strcpy(outfile, "atoutXXXXXX");
  1746. X
  1747. X    if (mktemp(outfile) == NULL) {
  1748. X
  1749. X        syslog(LOGDEST,
  1750. X            "can't create tmp file for output from jobfile %s: %s\n",
  1751. X            jobfile, sys_errlist[errno]);
  1752. X        recover(jobfile);
  1753. X        exit(1);
  1754. X    }
  1755. X
  1756. X    if ((outfile_fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC,
  1757. X            0600)) < 0) {
  1758. X        
  1759. X        syslog(LOGDEST,
  1760. X            "can't open tmp file for output from jobfile %s: %s\n",
  1761. X            jobfile, sys_errlist[errno]);
  1762. X        recover(jobfile);
  1763. X        exit(1);
  1764. X    }
  1765. X
  1766. X#ifdef DEBUG
  1767. X    syslog(LOGDEST,
  1768. X        "tmp file %s created for jobfile %s in slave atrun (pid=%d)\n",
  1769. X        outfile, jobfile, getpid());
  1770. X#endif
  1771. X
  1772. X    /* Find out who the owner of the job should be */
  1773. X
  1774. X    if (stat(jobfile, &statbuf) < 0) {
  1775. X
  1776. X        syslog(LOGDEST, "couldn't stat jobfile %s: %s\n", jobfile,
  1777. X            sys_errlist[errno]);
  1778. X        recover(jobfile);
  1779. X        exit(1);
  1780. X    }
  1781. X
  1782. X    /* Fork to create child for running at job */
  1783. X
  1784. X    if ((pid = fork()) < 0) {
  1785. X
  1786. X        syslog(LOGDEST, "can't fork from slave atrun for jobfile %s: %s\n",
  1787. X            jobfile, sys_errlist[errno]);
  1788. X        recover(jobfile);
  1789. X        exit(1);
  1790. X    }
  1791. X
  1792. X    else if (pid == 0) {
  1793. X
  1794. X        /* Child: close stdout and stderr, dup the write pipe onto both */
  1795. X
  1796. X        close(1);
  1797. X        dup(outfile_fd);
  1798. X        close(2);
  1799. X        dup(outfile_fd);
  1800. X        close(outfile_fd);
  1801. X
  1802. X        /* Set the group and owner for the at job */
  1803. X
  1804. X        if(setgid(statbuf.st_gid) < 0) {
  1805. X
  1806. X            syslog(LOGDEST, "couldn't set gid for jobfile %s: %s\n",
  1807. X                jobfile, sys_errlist[errno]);
  1808. X            recover(jobfile);
  1809. X            exit(1);
  1810. X        }
  1811. X
  1812. X        if(setuid(statbuf.st_uid) < 0) {
  1813. X
  1814. X            syslog(LOGDEST, "couldn't set uid for jobfile %s: %s\n",
  1815. X                jobfile, sys_errlist[errno]);
  1816. X            recover(jobfile);
  1817. X            exit(1);
  1818. X        }
  1819. X
  1820. X        /* Now run the at job via sh passing a NULL environment */
  1821. X
  1822. X        execle("/bin/sh", "sh", jobfile, (char *)NULL, (char *)NULL);
  1823. X
  1824. X        /* If we're here, the exec failed! */
  1825. X
  1826. X        syslog(LOGDEST,
  1827. X            "could exec /bin/sh from slave atrun for jobfile %s: %s\n",
  1828. X            jobfile, sys_errlist[errno]);
  1829. X        recover(jobfile);
  1830. X        exit(1);
  1831. X    }
  1832. X
  1833. X    else {
  1834. X
  1835. X        int mail_open;
  1836. X        int mail_uid;
  1837. X        int status;
  1838. X
  1839. X#ifdef DEBUG
  1840. X        if (debug_level)
  1841. X            syslog(LOGDEST,
  1842. X                "slave atrun (pid=%d) created child (pid=%d) to 'sh %s'\n",
  1843. X                getpid(), pid, jobfile);
  1844. X#endif
  1845. X
  1846. X        /* Parent (slave atrun): close tmp output file */
  1847. X
  1848. X        close(outfile_fd);
  1849. X        mail_open = FALSE;
  1850. X        mail_uid = statbuf.st_uid;
  1851. X
  1852. X        /* Wait for an exit status from the at job */
  1853. X
  1854. X        wait(&status);
  1855. X#ifdef DEBUG
  1856. X        if (debug_level)
  1857. X            syslog(LOGDEST, "jobfile %s (pid=%d) terminated with status=%d\n",
  1858. X                jobfile, pid, status);
  1859. X#endif
  1860. X
  1861. X        /* Determine if the job generated any output: stat the file ... */
  1862. X
  1863. X        if (stat(outfile, &statbuf) < 0) {
  1864. X
  1865. X            syslog(LOGDEST, "couldn't stat output file for jobfile %s: %s\n",
  1866. X                jobfile, sys_errlist[errno]);
  1867. X        }
  1868. X
  1869. X        /* ... and check its size */
  1870. X
  1871. X        else if (statbuf.st_size > 0) {
  1872. X
  1873. X            mail_open = TRUE;
  1874. X            open_mail(mail_uid);
  1875. X            copy_output(jobfile, jobno, outfile);
  1876. X        }
  1877. X
  1878. X#ifdef DEBUG
  1879. X        if (debug_level)
  1880. X            syslog(LOGDEST, "output file for jobfile %s was %d bytes\n",
  1881. X                jobfile, statbuf.st_size);
  1882. X#endif
  1883. X
  1884. X        /* Dispose of the temporary file */
  1885. X
  1886. X        if (unlink(outfile) < 0)
  1887. X            syslog(LOGDEST, "couldn't unlink output %s from jobfile %s: %s\n",
  1888. X                outfile, jobfile, sys_errlist[errno]);
  1889. X
  1890. X        /* If an error status is received, put it in the mail message */
  1891. X
  1892. X        if (status != 0) {
  1893. X
  1894. X            char buffer[128];
  1895. X
  1896. X            if (!mail_open)
  1897. X                open_mail(mail_uid);
  1898. X            else
  1899. X                write(1, "\n", 1);
  1900. X
  1901. X            sprintf(buffer, "Your \"at\" job \"%d\" exited with status=%d\n",
  1902. X                jobno, status);
  1903. X            write(1, buffer, strlen(buffer));
  1904. X        }
  1905. X
  1906. X        /* If there hasn't been any mail generated, see if the user */
  1907. X        /* requested confirmation of the run by mail */
  1908. X
  1909. X        else if (!mail_open)
  1910. X            mail_open = confirmation(mail_uid, jobfile, jobno);
  1911. X
  1912. X        /* Close the mail pipe, if any; check status */
  1913. X
  1914. X        if (mail_open) {
  1915. X
  1916. X            close(1);
  1917. X
  1918. X            if (wait(&status) != -1 && status != 0)
  1919. X                syslog(LOGDEST, "mailer exited with status=%d\n", status);
  1920. X        }
  1921. X        
  1922. X        /* Dispose of the at jobfile */
  1923. X
  1924. X        if (unlink(jobfile) < 0)
  1925. X            syslog(LOGDEST, "can't unlink completed jobfile %s: %s\n",
  1926. X                jobfile, sys_errlist[errno]);
  1927. X
  1928. X        /* Exit the slave atrun */
  1929. X
  1930. X        exit(0);
  1931. X    }
  1932. X}
  1933. X
  1934. X/* -------------------------------------------------------------------------- */
  1935. X
  1936. X/* Select at jobfiles from the queue directory that should be run.  Move */
  1937. X/* them to the working directory and store their file names. */
  1938. X
  1939. Xselect_jobs(atq)
  1940. X
  1941. Xstruct queue **atq;
  1942. X
  1943. X{
  1944. X    char buffer[MAXPATHLEN];
  1945. X
  1946. X    int n_jobs;
  1947. X    int qsize;
  1948. X
  1949. X    struct dirent *entry;
  1950. X    register struct queue *qptr;
  1951. X
  1952. X    time_t tod;
  1953. X
  1954. X    DIR *dp;
  1955. X
  1956. X    n_jobs = 0;
  1957. X    qsize = 0;
  1958. X    time(&tod);
  1959. X
  1960. X    /* Open the queue directory */
  1961. X
  1962. X    if ((dp = opendir(".")) == NULL) {
  1963. X
  1964. X        syslog(LOGDEST, "can't open at directory\n");
  1965. X        exit(1);
  1966. X    }
  1967. X
  1968. X    /* Get the name of each directory entry */
  1969. X
  1970. X    while ((entry = readdir(dp)) != NULL) {
  1971. X
  1972. X        int runtime;
  1973. X        int jobno;
  1974. X
  1975. X        struct stat statbuf;
  1976. X
  1977. X        /* See if the file name matches the jobfile name format */
  1978. X
  1979. X        if (sscanf(entry->d_name, "%d.%d", &runtime, &jobno) != 2) {
  1980. X
  1981. X#ifdef DEBUG
  1982. X            if (debug_level)
  1983. X                syslog(LOGDEST, "file %s rejected - not a jobfile name\n",
  1984. X                    entry->d_name);
  1985. X#endif
  1986. X            continue;
  1987. X        }
  1988. X
  1989. X        /* Should this one be run yet? */
  1990. X        
  1991. X        if (runtime > tod) {
  1992. X
  1993. X#ifdef DEBUG
  1994. X            if (debug_level)
  1995. X                syslog(LOGDEST, "jobfile %s rejected - not time yet\n",
  1996. X                    entry->d_name);
  1997. X#endif
  1998. X            continue;
  1999. X        }
  2000. X
  2001. X        /* Is the queue data structure large enough to store this entry? */
  2002. X
  2003. X        if ((n_jobs + 1) > qsize) {
  2004. X
  2005. X            if ((qsize = qalloc(atq, qsize)) < 0) {
  2006. X
  2007. X                fprintf(stderr, "can't allocate space for queue data\n");
  2008. X                exit(1);
  2009. X            }
  2010. X
  2011. X            qptr = *atq;
  2012. X        }
  2013. X
  2014. X        /* Save the info on this entry */
  2015. X
  2016. X        qptr[n_jobs].qu_start = runtime;
  2017. X        qptr[n_jobs].qu_jobno = jobno;
  2018. X        strcpy(qptr[n_jobs].qu_name, entry->d_name);
  2019. X        
  2020. X        /* Move the entry to the working directory */
  2021. X
  2022. X        sprintf(buffer, "%s/%s", PASTDIR, entry->d_name);
  2023. X
  2024. X        if (rename(entry->d_name, buffer) < 0) {
  2025. X
  2026. X            syslog(LOGDEST, "can't rename job file %s: %s\n",
  2027. X                entry->d_name, sys_errlist[errno]);
  2028. X            continue;
  2029. X        }
  2030. X
  2031. X#ifdef DEBUG
  2032. X        if (debug_level)
  2033. X            syslog(LOGDEST, "jobfile %s selected\n", entry->d_name);
  2034. X#endif
  2035. X
  2036. X        n_jobs++;
  2037. X    }
  2038. X
  2039. X    closedir(dp);
  2040. X
  2041. X#ifdef DEBUG
  2042. X    if (debug_level)
  2043. X        syslog(LOGDEST, "%d jobs selected\n", n_jobs);
  2044. X#endif
  2045. X
  2046. X    return(n_jobs);
  2047. X}
  2048. END_OF_FILE
  2049. if test 17097 -ne `wc -c <'src/atrun.c'`; then
  2050.     echo shar: \"'src/atrun.c'\" unpacked with wrong size!
  2051. fi
  2052. # end of 'src/atrun.c'
  2053. fi
  2054. if test -f 'src/date.y' -a "${1}" != "-c" ; then 
  2055.   echo shar: Will not clobber existing file \"'src/date.y'\"
  2056. else
  2057. echo shar: Extracting \"'src/date.y'\" \(13039 characters\)
  2058. sed "s/^X//" >'src/date.y' <<'END_OF_FILE'
  2059. X%token MONTH DAY RELDAY MERIDIAN NUMBER ORDINAL UNIT MONUNIT
  2060. X%token SECOND STDZONE DSTZONE ABSHOUR STRING
  2061. X
  2062. X%{
  2063. X
  2064. X#include <stdio.h>
  2065. X#include <sys/types.h>
  2066. X#include <ctype.h>
  2067. X#include <sys/timeb.h>
  2068. X#include <sys/time.h>
  2069. X
  2070. X/* Define some useful time constants */
  2071. X
  2072. X#define SEC_PER_MIN        (60)
  2073. X#define SEC_PER_HOUR    (3600)
  2074. X#define MIN_PER_HOUR    (60)
  2075. X#define HOUR_PER_DAY    (24)
  2076. X#define SEC_PER_DAY        (SEC_PER_HOUR * HOUR_PER_DAY)
  2077. X#define DAY_PER_WEEK    (7)
  2078. X
  2079. X#define EPOCH            1970
  2080. X
  2081. X/* Define some symbolic values */
  2082. X
  2083. X#define FALSE        0
  2084. X#define TRUE        1
  2085. X
  2086. X#define AM            0
  2087. X#define PM            1
  2088. X#define MILITARY    2
  2089. X
  2090. X#define    NOT_GIVEN    -1
  2091. X#define STANDARD    0
  2092. X#define DST            1
  2093. X
  2094. X/* Declare external values used by the following routines */
  2095. X
  2096. Xstatic char *lptr;            /* Pointer to input string for parsing */
  2097. Xstatic char *lstring;        /* Input string pointer (allocated space) */
  2098. X
  2099. Xchar yyerrmsg[1024];        /* Description of any detected error */
  2100. X
  2101. Xstatic int day;                /* Day-of-month value */
  2102. Xstatic int hour;            /* Hour value */
  2103. Xstatic int inc_mon;            /* Number of incremental months */
  2104. Xstatic int meridian;        /* AM/PM/Military flag */
  2105. Xstatic int minute;            /* Minute value */
  2106. Xstatic int month;            /* Month value */
  2107. Xstatic int ordinal;            /* Ordinal value (first=1, etc.) */
  2108. Xstatic int second;            /* Second value */
  2109. Xstatic int timezone;        /* Time zone value */
  2110. Xstatic int weekday;            /* Day-of-week value */
  2111. Xstatic int year;            /* Year value */
  2112. Xstatic int zone_type;        /* Indicates if DST is possible */
  2113. X
  2114. Xstatic int month_len[12] =
  2115. X    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};    /* Length of months */
  2116. X
  2117. Xstatic time_t inc_sec;        /* Number of incremental seconds */
  2118. Xstatic time_t rel_sec;        /* Number of relative day seconds */
  2119. X
  2120. X/* The following externals contain field counts used in syntax checking */
  2121. X
  2122. Xstatic int date_fields;        /* Number of date fields */
  2123. Xstatic int day_fields;        /* Number of day of week fields */
  2124. Xstatic int inc_fields;        /* Number of increment/decrement fields */
  2125. Xstatic int rday_fields;        /* Number of relative day fields */
  2126. Xstatic int time_fields;        /* Number of time-of-day fields */
  2127. Xstatic int zone_fields;        /* Number of time zone fields */
  2128. X
  2129. X/* Declare function types */
  2130. X
  2131. Xchar *malloc();
  2132. Xtime_t parse_date();
  2133. Xvoid num_to_time();
  2134. X
  2135. X/* Declare external variables */
  2136. X
  2137. Xextern char *sys_errlist[];
  2138. X
  2139. Xextern int errno;
  2140. X
  2141. X%}
  2142. X
  2143. X%%
  2144. X
  2145. Xfullspec: timestr increment
  2146. X    ;
  2147. X
  2148. Xtimestr: /* empty */
  2149. X    | timestr field
  2150. X    ;
  2151. X
  2152. Xfield:  date
  2153. X        { date_fields++; }
  2154. X    | day
  2155. X        { day_fields++; }
  2156. X    | number
  2157. X    | relday
  2158. X        { rday_fields++; }
  2159. X    | time
  2160. X        { time_fields++; }
  2161. X    | zone
  2162. X        { zone_fields++; }
  2163. X    ;
  2164. X
  2165. Xdate:    NUMBER '/' NUMBER
  2166. X        { month = $1 - 1; day = $3; }
  2167. X    | NUMBER '/' NUMBER '/' NUMBER
  2168. X        { month = $1 - 1; day = $3; year = $5; }
  2169. X    | MONTH NUMBER
  2170. X        { month = $1; day = $2; }
  2171. X    | MONTH NUMBER ',' NUMBER
  2172. X        { month = $1; day = $2; year = $4; }
  2173. X    | NUMBER MONTH NUMBER
  2174. X        { month = $2; day = $1; year = $3; }
  2175. X    | NUMBER MONTH
  2176. X        { month = $2; day = $1; }
  2177. X    ;
  2178. X
  2179. Xday:    DAY
  2180. X        { weekday = $1; ordinal = 1; }
  2181. X    | DAY ','
  2182. X        { weekday = $1; ordinal = 1; }
  2183. X    | ORDINAL DAY
  2184. X        { weekday = $2; ordinal = $1; }
  2185. X    | SECOND DAY
  2186. X        { weekday = $2; ordinal = 2; }
  2187. X    ;
  2188. X
  2189. Xrelday:    RELDAY
  2190. X        { rel_sec += $1; }
  2191. X    | ORDINAL RELDAY
  2192. X        { rel_sec += ($1 * $2); }
  2193. X    | SECOND RELDAY
  2194. X        { rel_sec += (2 * $2); }
  2195. X    ;
  2196. X
  2197. Xtime:    NUMBER MERIDIAN
  2198. X        { hour = $1; minute = 0;  second = 0; meridian = $2; }
  2199. X    | NUMBER ':' NUMBER
  2200. X        { hour = $1; minute = $3; second = 0; meridian = MILITARY; }
  2201. X    | NUMBER ':' NUMBER MERIDIAN
  2202. X        { hour = $1; minute = $3; second = 0; meridian = $4; }
  2203. X    | NUMBER ':' NUMBER ':' NUMBER
  2204. X        { hour = $1; minute = $3; second = $5; meridian = MILITARY; }
  2205. X    | NUMBER ':' NUMBER ':' NUMBER MERIDIAN
  2206. X        { hour = $1; minute = $3; second = $5; meridian = $6; }
  2207. X    | ABSHOUR
  2208. X        { hour = $1; minute = 0; second = 0; meridian = MILITARY; }
  2209. X    ;
  2210. X
  2211. Xzone:    STDZONE
  2212. X        { timezone = $1; zone_type = STANDARD; }
  2213. X    | DSTZONE
  2214. X        { timezone = $1; zone_type = DST; }
  2215. X    ;
  2216. X
  2217. Xincrement:    /* empty */
  2218. X    | increment incfield
  2219. X        { inc_fields++; }
  2220. X    ;
  2221. X
  2222. Xincfield:    sign unit
  2223. X        { inc_sec += ($1 * $2); }
  2224. X    | sign NUMBER unit
  2225. X        { inc_sec += ($1 * $2 * $3); }
  2226. X    | sign MONUNIT
  2227. X        { inc_mon += ($1 * $2); }
  2228. X    | sign NUMBER MONUNIT
  2229. X        { inc_mon += ($1 * $2 * $3); }
  2230. X    ;
  2231. X
  2232. Xsign:    '+'
  2233. X        { $$ = 1; }
  2234. X    | '-'
  2235. X        { $$ = -1; }
  2236. X    ;
  2237. X
  2238. Xunit:    UNIT
  2239. X    | SECOND
  2240. X    ;
  2241. X
  2242. Xnumber:    NUMBER
  2243. X        {
  2244. X            if (time_fields > 0 && date_fields > 0)
  2245. X                year = $1;
  2246. X            else {
  2247. X
  2248. X                time_fields++;
  2249. X                num_to_time($1);
  2250. X                meridian = MILITARY;
  2251. X            }
  2252. X        }
  2253. X    ;
  2254. X
  2255. X%%
  2256. X
  2257. X/* ------------------------------------------------------------------------- */
  2258. X
  2259. X#include "lex.yy.c"
  2260. X
  2261. X/* ------------------------------------------------------------------------- */
  2262. X
  2263. Xtime_t
  2264. Xparse_date(string, base)
  2265. X
  2266. Xchar *string;
  2267. Xstruct timeb *base;
  2268. X
  2269. X{
  2270. X    register int i;
  2271. X    int length;
  2272. X    int rc;
  2273. X
  2274. X    struct timeb *ourtime;
  2275. X    struct timeb current;
  2276. X    struct tm *local;
  2277. X
  2278. X    time_t tod;
  2279. X
  2280. X    /* Initialize the various global variables */
  2281. X
  2282. X    date_fields = 0;
  2283. X    day_fields = 0;
  2284. X    inc_fields = 0;
  2285. X    rday_fields = 0;
  2286. X    time_fields = 0;
  2287. X    zone_fields = 0;
  2288. X
  2289. X    inc_mon = 0;
  2290. X    inc_sec = 0;
  2291. X    rel_sec = 0;
  2292. X    ordinal = 0;
  2293. X    meridian = MILITARY;
  2294. X    yyerrmsg[0] = '\0';
  2295. X    zone_type = NOT_GIVEN;
  2296. X
  2297. X    /* Determine the base time (for "now" and relative references) */
  2298. X
  2299. X    if (base == NULL) {
  2300. X
  2301. X        ourtime = ¤t;
  2302. X
  2303. X        if (ftime(ourtime) < 0) {
  2304. X
  2305. X            sprintf(yyerrmsg, "can't get current time via ftime: %s",
  2306. X                sys_errlist[errno]);
  2307. X            return(-1);
  2308. X        }
  2309. X    }
  2310. X
  2311. X    else
  2312. X        ourtime = base;
  2313. X    
  2314. X    tod = ourtime->time;
  2315. X    
  2316. X    if ((local = localtime(&tod)) == NULL) {
  2317. X
  2318. X        sprintf(yyerrmsg, "couldn't convert time via localtime: %s",
  2319. X            sys_errlist[errno]);
  2320. X        return(-1);
  2321. X    }
  2322. X
  2323. X    /* Initialize values for current time */
  2324. X
  2325. X    month = local->tm_mon;
  2326. X    day = local->tm_mday;
  2327. X    weekday = local->tm_wday;
  2328. X    year = local->tm_year;
  2329. X    hour = local->tm_hour;
  2330. X    minute = local->tm_min;
  2331. X    second = local->tm_sec;
  2332. X    timezone = ourtime->timezone * SEC_PER_MIN;
  2333. X
  2334. X    /* Make a local, lower case copy of the date/time string */
  2335. X
  2336. X    length = strlen(string);
  2337. X
  2338. X    if ((lstring = malloc(length + 1)) == NULL) {
  2339. X
  2340. X        sprintf(yyerrmsg, "couldn't allocate memory for date/time string: %s",
  2341. X            sys_errlist[errno]);
  2342. X        return(-1);
  2343. X    }
  2344. X
  2345. X    for (i = 0 ; i <= length ; i++) {
  2346. X
  2347. X        register char ch;
  2348. X
  2349. X        ch = string[i];
  2350. X
  2351. X        if (isalpha(ch) && isupper(ch))
  2352. X            lstring[i] = tolower(ch);
  2353. X        else
  2354. X            lstring[i] = ch;
  2355. X    }
  2356. X
  2357. X    lptr = lstring;
  2358. X
  2359. X    /* Attempt to parse the input */
  2360. X
  2361. X    if ((rc = yyparse()) != 0)
  2362. X        return(-1);
  2363. X
  2364. X    /* Check for an allowable number of each field */
  2365. X
  2366. X    if ((day_fields + rday_fields) > 1) {
  2367. X
  2368. X        strcpy(yyerrmsg, "more than one day specified");
  2369. X        return(-1);
  2370. X    }
  2371. X
  2372. X    if (date_fields > 1) {
  2373. X
  2374. X        strcpy(yyerrmsg, "more than one date specified");
  2375. X        return(-1);
  2376. X    }
  2377. X
  2378. X    if (time_fields > 1) {
  2379. X
  2380. X        strcpy(yyerrmsg, "more than one time specified");
  2381. X        return(-1);
  2382. X    }
  2383. X
  2384. X    if (zone_fields > 1) {
  2385. X
  2386. X        strcpy(yyerrmsg, "more than one timezone specified");
  2387. X        return(-1);
  2388. X    }
  2389. X
  2390. X    /* Convert the parsed fields into a time from epoch */
  2391. X
  2392. X    if (date_fields > 0 || time_fields > 0 || day_fields > 0) {
  2393. X
  2394. X        if ((tod = comp_tval()) <  0)
  2395. X            return(tod);
  2396. X    }
  2397. X
  2398. X    /* Adjust for any relative day (e.g., tomorrow) specified */
  2399. X
  2400. X    tod += rel_sec;
  2401. X    
  2402. X    /* Rationalize the time value, if no date is given (i.e., make */
  2403. X    /* certain it is not a past time) */
  2404. X
  2405. X    if (date_fields == 0  && rday_fields == 0 && tod < ourtime->time
  2406. X            && ordinal >= 0)
  2407. X        tod += SEC_PER_DAY;
  2408. X
  2409. X    /* Adjust for any increment(s) specified */
  2410. X
  2411. X    if (inc_mon > 0)
  2412. X        tod += month_adjust(tod);
  2413. X    
  2414. X    if (day_fields > 0 && date_fields == 0)
  2415. X        tod += day_adjust(tod);
  2416. X
  2417. X    tod += inc_sec;
  2418. X
  2419. X    /* Free the storage for the local copy of the input string */
  2420. X
  2421. X    (void)free(lstring);
  2422. X
  2423. X    /* Return the computed time */
  2424. X
  2425. X    return(tod);
  2426. X}
  2427. X
  2428. X/* ------------------------------------------------------------------------- */
  2429. X
  2430. Xtime_t
  2431. Xcomp_tval()
  2432. X
  2433. X{
  2434. X    register int i;
  2435. X    int n_days;
  2436. X    int offset;
  2437. X    int rc;
  2438. X
  2439. X    time_t tval;
  2440. X
  2441. X    /* Adjust year, if necessary */
  2442. X
  2443. X    if (year < EPOCH)
  2444. X        year += 1900;
  2445. X
  2446. X    /* Adjust length of February for leap year, if necessary */
  2447. X    /* (True, reality is more complicated, but not needed for this program) */
  2448. X
  2449. X    month_len[1] = 28 + (year % 4 == 0);
  2450. X
  2451. X    /* Check for valid month and day */
  2452. X
  2453. X    if (month < 0 || month > 11) {
  2454. X
  2455. X        strcpy(yyerrmsg, "invalid month");
  2456. X        return(-1);
  2457. X    }
  2458. X
  2459. X    if (day < 1 || day > month_len[month]) {
  2460. X
  2461. X        strcpy(yyerrmsg, "invalid day of month");
  2462. X        return(-1);
  2463. X    }
  2464. X
  2465. X    /* Compute number of days from epoch to this day */
  2466. X
  2467. X    n_days = day - 1;
  2468. X
  2469. X    for (i = 0 ; i < month ; i++)
  2470. X        n_days += month_len[i];
  2471. X
  2472. X    for (i = EPOCH ; i < year ; i++)
  2473. X        n_days += 365 + (i % 4 == 0);
  2474. X
  2475. X    /* Check for valid minutes and seconds */
  2476. X
  2477. X    if (minute < 0 || minute > 59) {
  2478. X
  2479. X        strcpy(yyerrmsg, "invalid minutes value");
  2480. X        return(-1);
  2481. X    }
  2482. X
  2483. X
  2484. X    if (second < 0 || second > 59) {
  2485. X
  2486. X        strcpy(yyerrmsg, "invalid seconds value");
  2487. X        return(-1);
  2488. X    }
  2489. X
  2490. X    /* Compute the number of seconds since beginning of this day */
  2491. X
  2492. X    rc = 0;
  2493. X    offset = 0;
  2494. X
  2495. X    switch (meridian) {
  2496. X
  2497. X        case MILITARY:
  2498. X
  2499. X            if (hour < 0 || hour > 23)
  2500. X                rc = -1;
  2501. X
  2502. X            else
  2503. X                tval = ((hour * MIN_PER_HOUR) + minute) * SEC_PER_MIN + second;
  2504. X
  2505. X            break;
  2506. X
  2507. X        case PM:
  2508. X
  2509. X            offset = 12;
  2510. X            /* fall through to next case */
  2511. X
  2512. X        case AM:
  2513. X
  2514. X            if (hour < 1 || hour > 12)
  2515. X                rc = -1;
  2516. X
  2517. X            else
  2518. X                tval = (((hour + offset) * MIN_PER_HOUR) + minute)
  2519. X                    * SEC_PER_MIN + second;
  2520. X
  2521. X            break;
  2522. X
  2523. X        default:
  2524. X
  2525. X            strcpy(yyerrmsg,
  2526. X                "can't happen: unknown meridian value in comp_tval");
  2527. X            return(-1);
  2528. X    }
  2529. X
  2530. X    if (rc < 0) {
  2531. X
  2532. X        strcpy(yyerrmsg, "invalid hours value");
  2533. X        return(-1);
  2534. X    }
  2535. X
  2536. X    /* Add seconds since beginning of epoch to seconds this day */
  2537. X
  2538. X    tval += n_days * SEC_PER_DAY;
  2539. X
  2540. X    /* Add in adjustment for timezone (to get to GMT) */
  2541. X
  2542. X    tval += timezone;
  2543. X
  2544. X    /* Adjust for daylight saving time, if necessary */
  2545. X
  2546. X    if (zone_type == DST ||
  2547. X            (zone_type == NOT_GIVEN && localtime(&tval)->tm_isdst))
  2548. X        tval -= SEC_PER_HOUR;
  2549. X    
  2550. X    return(tval);
  2551. X}
  2552. X
  2553. X/* ------------------------------------------------------------------------- */
  2554. X
  2555. Xday_adjust(tod)
  2556. X
  2557. Xtime_t tod;
  2558. X
  2559. X{
  2560. X    int day_diff;
  2561. X    int inc;
  2562. X    int ord_value;
  2563. X
  2564. X    struct tm *now;
  2565. X
  2566. X    now = localtime(&tod);
  2567. X
  2568. X    /* Compute the number of days until the specified day */
  2569. X    /* and the corresponding number of seconds */
  2570. X
  2571. X    day_diff = (weekday - now->tm_wday + 7) % 7;
  2572. X    inc = SEC_PER_DAY * day_diff;
  2573. X
  2574. X    /* If a postitive ordinal value was specified (e.g., third), */
  2575. X    /* adjust the value used in the subsequent computations */
  2576. X
  2577. X    if (ordinal > 0) {
  2578. X
  2579. X        /* If the ordinal is "first" or "next" and the day is the same */
  2580. X        /* as today, make sure we move ahead one week */
  2581. X
  2582. X        if (ordinal == 1 && day_diff == 0)
  2583. X            ord_value = 1;
  2584. X        else
  2585. X            ord_value = ordinal - 1;
  2586. X    }
  2587. X
  2588. X    else
  2589. X        ord_value = ordinal;
  2590. X
  2591. X    /* Adjust for the number of weeks until the specified day */
  2592. X
  2593. X    inc += 7 * SEC_PER_DAY * ord_value;
  2594. X
  2595. X    return(inc);
  2596. X}
  2597. X
  2598. X/* ------------------------------------------------------------------------- */
  2599. X
  2600. X#include "table.h"
  2601. X
  2602. Xstatic int hash[256];                /* One value for each ASCII character */
  2603. Xstatic int lookup_init = TRUE;        /* TRUE if init needs to be done */
  2604. Xstatic int table_size;                /* Number of string table entries */
  2605. X
  2606. Xstatic void linit();
  2607. X
  2608. X/* -------------------------------------------------------------------------- */
  2609. X
  2610. Xlookup_string(string)
  2611. X
  2612. Xchar *string;
  2613. X
  2614. X{
  2615. X    register int i;
  2616. X
  2617. X    /* Do we need to initialize the string and hash tables? */
  2618. X
  2619. X    if (lookup_init)
  2620. X        linit();
  2621. X    
  2622. X    /* Scan all table entries with a matching first letter */
  2623. X
  2624. X    for (i = hash[*string] ;
  2625. X            i < table_size && *string_table[i].ta_name == *string ; i++) {
  2626. X
  2627. X        if (strcmp(string_table[i].ta_name, string) == 0) {
  2628. X
  2629. X            yylval = string_table[i].ta_value;
  2630. X            return(string_table[i].ta_type);
  2631. X        }
  2632. X    }
  2633. X
  2634. X    return(-1);
  2635. X}
  2636. X
  2637. X/* -------------------------------------------------------------------------- */
  2638. X
  2639. Xstatic
  2640. Xentry_comp(ptr1, ptr2)
  2641. X
  2642. Xregister struct table_def *ptr1;
  2643. Xregister struct table_def *ptr2;
  2644. X
  2645. X{
  2646. X    return(strcmp(ptr1->ta_name, ptr2->ta_name));
  2647. X}
  2648. X
  2649. X/* -------------------------------------------------------------------------- */
  2650. X
  2651. Xstatic void
  2652. Xlinit()
  2653. X
  2654. X{
  2655. X    register int ch;
  2656. X    register int i;
  2657. X
  2658. X    /* Indicate that an initialization is no longer needed */
  2659. X
  2660. X    lookup_init = FALSE;
  2661. X    table_size = sizeof(string_table) / sizeof(struct table_def);
  2662. X
  2663. X    /* Sort the table by ASCII code */
  2664. X
  2665. X    qsort(string_table, table_size, sizeof(struct table_def), entry_comp);
  2666. X
  2667. X    /* Build a simple hash code table (based on first character of string) */
  2668. X    /* If there are no entries for a hash value, the hash table has the */
  2669. X    /* index of the next existing hash value. */
  2670. X
  2671. X    for (i = 0, ch = 0 ; i < table_size ; i++) {
  2672. X
  2673. X        while (*string_table[i].ta_name >= ch)
  2674. X            hash[ch++] = i;
  2675. X    }
  2676. X
  2677. X    return;
  2678. X}
  2679. X
  2680. X/* ------------------------------------------------------------------------- */
  2681. X
  2682. Xmonth_adjust(tod)
  2683. X
  2684. Xtime_t tod;
  2685. X
  2686. X{
  2687. X    int n_months;
  2688. X
  2689. X    struct tm *now;
  2690. X
  2691. X    now = localtime(&tod);
  2692. X    n_months = now->tm_mon + inc_mon;
  2693. X    year += n_months / 12;
  2694. X    month = n_months % 12;
  2695. X
  2696. X    return(comp_tval() - tod);
  2697. X}
  2698. X
  2699. X/* ------------------------------------------------------------------------- */
  2700. X
  2701. Xvoid
  2702. Xnum_to_time(value)
  2703. X
  2704. Xint value;
  2705. X
  2706. X{
  2707. X    minute = 0;
  2708. X    second = 0;
  2709. X
  2710. X    if (value >= 10000) {
  2711. X        second = value % 100;
  2712. X        value /= 100;
  2713. X    }
  2714. X    if (value >= 100) {
  2715. X        minute = value % 100;
  2716. X        value /= 100;
  2717. X    }
  2718. X
  2719. X    hour = value;
  2720. X    return;
  2721. X}
  2722. X
  2723. X/* ------------------------------------------------------------------------- */
  2724. X
  2725. Xyyerror(string)
  2726. X
  2727. Xchar *string;
  2728. X
  2729. X{
  2730. X    sprintf(yyerrmsg, "%s: at or near token \"%s\"", string, yytext);
  2731. X}
  2732. END_OF_FILE
  2733. if test 13039 -ne `wc -c <'src/date.y'`; then
  2734.     echo shar: \"'src/date.y'\" unpacked with wrong size!
  2735. fi
  2736. # end of 'src/date.y'
  2737. fi
  2738. echo shar: End of archive 2 \(of 2\).
  2739. cp /dev/null ark2isdone
  2740. MISSING=""
  2741. for I in 1 2 ; do
  2742.     if test ! -f ark${I}isdone ; then
  2743.     MISSING="${MISSING} ${I}"
  2744.     fi
  2745. done
  2746. if test "${MISSING}" = "" ; then
  2747.     echo You have unpacked both archives.
  2748.     rm -f ark[1-9]isdone
  2749. else
  2750.     echo You still need to unpack the following archives:
  2751.     echo "        " ${MISSING}
  2752. fi
  2753. ##  End of shell archive.
  2754. exit 0
  2755. -- 
  2756. -----------------------------------------------------------------------------
  2757. Keith Pyle                                UUCP: ...!cs.utexas.edu!execu!keith
  2758. Execucom Systems Corp., Austin, Texas     Internet: keith@execu.com
  2759. "It's 10 o'clock.  Do you know where      Disclaimer: Everything I say is
  2760.    your child processes are?"               true unless I use the word 'the'.
  2761. -----------------------------------------------------------------------------
  2762.