![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cron.new CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / etc / SYSVcron / src|
Return to cron.new CVS log | Up to [MW Coherent from dump] / coherent / d / etc / SYSVcron / src |
1.1 root 1: /*
2: * The information contained herein is a trade secret of Mark Williams
3: * Company, and is confidential information. It is provided under a
4: * license agreement, and may be copied or disclosed only under the
5: * terms of that agreement. Any reproduction or disclosure of this
6: * material without the express written authorization of Mark Williams
7: * Company or persuant to the license agreement is unlawful.
8: *
9: * An unpublished work by Mark Williams Company, Chicago.
10: * All rights reserved.
11: */
12:
13: /* cron.c
14: *
15: * Execute commands stored in /usr/lib/crontab if it exist (3.2.0 compatibility)
16: * as daemon.
17: * Otherwise execute crontabs from /usr/spool/cron/crontabs.
18: * It sets uid and gid to user which crontab is going to be executed.
19: *
20: * $ 12-10-1991 vlad (Vladimir Smelyansky)
21: *
22: */
23: #include <stdio.h>
24: #include <time.h>
25: #include <signal.h>
26: #include <sys/msig.h>
27: #include <errno.h>
28: #include <ctype.h>
29: #include <pwd.h>
30: #include <sys/types.h>
31: #include <dirent.h>
32: #include "cron.h"
33:
34: /*
35: * Time field types.
36: */
37: #define MIN 0
38: #define HOUR 1
39: #define MDAY 2
40: #define MON 3
41: #define WDAY 4
42:
43: /*
44: * (Finite) States in valid().
45: */
46: #define START 0
47: #define INT 1
48: #define INTDASH 2
49: #define RANGE 3
50: #define STR 4
51: #define STRPLUS 5
52: #define ERR 6
53: #define END 7
54: #define GLOB ('*')
55:
56: /*
57: * Tokens returned by gettoken(). Tokens are integers. EOF is also a token.
58: * INT, STR and GLOB above are also tokens.
59: */
60: #define DASH ('-')
61: #define COMMA (',')
62: #define WS (' ')
63: #define PERCENT (-2)
64: #define NEWLINE (-3)
65:
66: extern DIR *opendir();
67: extern struct dirent *readdir();
68: extern char *realloc();
69:
70: extern int set_uid(); /* Set UID */
71: extern FILE *fpOpenTable(); /* Open crintable */
72: extern int lock(); /* Write a lock file */
73: extern FILE *cronpipe(); /* Popen for cron */
74:
75: extern void mail_entry(); /* Send mail to user if command failed */
76: extern child_id *add_entry(), /* Add an new entry to a link list */
77: *find_entry(), /* Find an entry in the link list */
78: *del_entry(); /* Remove an entry from the link list */
79:
80: int ifmail();
81:
82: child_id *current; /* Pointer to the current structure */
83: char acRealUser[MAX_UNAME]; /* Real user name */
84:
85: int mailFlag = TRUE;
86: int flag320 = FALSE;
87:
88: struct tm *tm;
89: time_t clock;
90: int tmfield[5];
91: FILE *f;
92: extern int errno;
93:
94: int ugtokflag = FALSE;
95: int ugtoken;
96: int ufetflag = FALSE;
97: int ufetval;
98: int set_uid_flag = FALSE;
99:
100: char *tokbuf;
101: int buflen = MAX_STR_LEN;
102: char crontab[] = "/usr/lib/crontab";
103: DIR *dirp = NULL;
104: struct dirent *dp;
105:
106: main()
107: {
108: int n;
109: int child_pid;
110:
111: sigsetup();
112:
113: tokbuf = malloc(buflen);
114: /* Check if crond chould be into cron 320 mode */
115: if ((f = fopen(crontab, "r")) != NULL) {
116: fclose(f);
117: chdir("/bin"); /* Under 3.2.0 cron started from /bin. */
118: flag320 = TRUE;
119: }
120:
121: if (flag320 == FALSE) {
122: /* Check if cron was fired. Do it only for SV cron. */
123: if (lock(F_LOCK) == FALSE) {
124: fprintf(stderr, "crond: locked.\n");
125: exit(1);
126: }
127: /* Open dirp only once */
128: /*if ((dirp = opendir(D_SPOOL)) == NULL) {
129: fprintf(stderr,
130: "crond: cannot open directory %s.\n", D_SPOOL);
131: exit(1);
132: }*/
133: }
134:
135: #if !DEBUG
136: /* Disassociate from controling terminal and process
137: * group. Close all open files.
138: */
139: bedaemon();
140: #endif
141:
142: time(&clock);
143: tm = localtime(&clock);
144: alarm(61 - tm->tm_sec);
145:
146: Dprint("Time is %s\n", ctime(&clock));
147: for (;;) {
148: system("echo Debug1 >/dev/console");
149: /* Put the time values into tmfield[] for easy reference.
150: * localtime() gives tm_mon in the range 0-11, tm_wday, 0-6
151: * (0=sunday). These are adjusted for cron's syntax.
152: */
153: tmfield[MIN] = tm->tm_min;
154: tmfield[HOUR] = tm->tm_hour;
155: tmfield[MDAY] = tm->tm_mday;
156: tmfield[MON] = tm->tm_mon + 1;
157: tmfield[WDAY] = tm->tm_wday;
158:
159: if (flag320 == TRUE) { /* Run 320 mode */
160: system("echo Debug1 286>/dev/console");
161: if ((f = fopen(crontab, "r")) != NULL) {
162: Dprint("File pointer is 0x%x\n", f);
163: strcpy(acRealUser, DAEMON);
164: while (tex() != EOF)
165: ;
166: fclose(f);
167: while (wait(&n) != -1)
168: ;
169: if (errno == ECHILD)
170: pause();
171: } else
172: fprintf(stderr, "crond: cannot open %s\n",
173: crontab);
174: } else { /* Run SV mode */
175: system("echo Debug1 386>/dev/console");
176: /* Open dirp only once */
177: if (dirp != NULL)
178: if ((dirp = opendir(D_SPOOL)) == NULL) {
179: fprintf(stderr,
180: "crond: cannot open directory %s.\n", D_SPOOL);
181: exit(1);
182: }
183:
184: while ((dp = readdir(dirp)) != NULL) {
185: char Dbuf[80];
186:
187: /* Skip '.' and '..' */
188: if (!strcmp(dp->d_name, ".") ||
189: !strcmp(dp->d_name, ".."))
190: continue;
191:
192: strcpy(acRealUser, dp->d_name);
193: Dprint("User name is %s\n", acRealUser);
194: set_uid_flag = FALSE;
195:
196: if ((f = fpOpenTable("r")) == NULL) {
197: fprintf(stderr,
198: "crond: cannot open table '%s'\n",
199: acRealUser);
200: sprintf(Dbuf,"crond: cannot open table"
201: " '%s'\n", acRealUser);
202: /*exit(1);*/
203: }
204: system("echo Debug >/dev/console");
205: sprintf(Dbuf, "echo %s > /dev/console", dp->d_name);
206: system(Dbuf);
207: while (tex() != EOF)
208: ;
209: fclose(f);
210: } /* while readdir */
211: system("echo Debug after while >/dev/console");
212: rewinddir(dirp);
213: /* Wait for the children */
214: while ((child_pid = wait(&n)) != -1) {
215: static child_id *pstDone;
216:
217: Dprint("\nmain: child id %d",child_pid);
218: Dprint("\treturn is %d\n", n);
219: pstDone = find_entry(child_pid);
220: if (n && ifmail(pstDone))
221: mail_entry(pstDone);
222:
223: current = del_entry(pstDone);
224: } /* while wait */
225: if (errno == ECHILD)
226: pause();
227:
228: } /* if 320 */
229: } /* for */
230: } /* main */
231:
232: /*
233: * Check do user want to have a mail messages.
234: */
235: int ifmail(entry)
236: child_id *entry;
237: {
238: char *cBuf;
239: int fd; /* Descriptor of lock file */
240:
241: if ((cBuf = malloc(sizeof(D_MAIN) + strlen(entry->name) + 1)) == NULL) {
242: fprintf(stderr, "crond: out of memory\n");
243: return(0);
244: }
245: sprintf(cBuf, "%s/%s", D_MAIN, entry->name);
246: if ((fd = open(cBuf, 0)) == -1)
247: return(1);
248: close(fd);
249: return(0);
250: }
251:
252: /*
253: * Test and Execute: tests a crontab entry against the time fields in `tm' to
254: * see if it should be executed, if so it executes. f is left pointing to the
255: * next entry (line). Returns EOF when encountered, something else otherwise.
256: */
257: tex()
258: {
259: register int fieldnum;
260:
261: for (fieldnum = MIN; fieldnum <= WDAY; ++fieldnum)
262: if (!valid(fieldnum))
263: return (skip_it());
264: return (do_it());
265: }
266:
267: /*
268: * Valid(fieldnum) parses the next time field from the current line in crontab
269: * and checks whether tmfield[fieldnum] satisfies the constraints of that time
270: * field. Returns TRUE if so, FALSE if not. Leaves f at the next field.
271: * Detects syntax errors in the time fields.
272: */
273: valid(fieldnum)
274: int fieldnum;
275: {
276: register int t;
277: register int ival;
278: register int state = START;
279: int ival2;
280: int tm_val = tmfield[fieldnum];
281:
282: if (fieldnum == MIN) {
283: while ((t = gettoken()) == WS || t == NEWLINE)
284: ;
285: ungettoken(t);
286: }
287:
288: for (;;) {
289: t = gettoken();
290: switch (state) {
291: case START:
292: switch (t) {
293: case INT:
294: if (strlen(tokbuf) <= 2) {
295: ival = atoi(tokbuf);
296: state = INT;
297: }
298: else
299: state = ERR;
300: break;
301: case GLOB:
302: state = GLOB;
303: break;
304: case WS:
305: state = END;
306: break;
307: default:
308: state = ERR;
309: break;
310: }
311: break;
312: case INT:
313: if (t == COMMA || t == WS) {
314: if (ival == tm_val) {
315: while (t != WS)
316: t = gettoken();
317: return (TRUE);
318: }
319: state = (t == WS) ? END : START;
320: }
321: else if (t == DASH)
322: state = INTDASH;
323: else
324: state = ERR;
325: break;
326: case INTDASH:
327: if (t == INT && strlen(tokbuf) <= 2) {
328: ival2 = atoi(tokbuf);
329: state = RANGE;
330: }
331: else
332: state = ERR;
333: break;
334: case RANGE:
335: if (t == COMMA || t == WS) {
336: if (ival <= tm_val && tm_val <= ival2) {
337: while (t != WS)
338: t = gettoken();
339: return (TRUE);
340: }
341: state = (t == WS) ? END : START;
342: }
343: else
344: state = ERR;
345: break;
346: case GLOB:
347: if (t == COMMA || t == WS) {
348: while (t != WS)
349: t = gettoken();
350: return (TRUE);
351: }
352: else
353: state = ERR;
354: break;
355: } /* End switch on state */
356:
357: if (state == END)
358: return (FALSE);
359: if (state == ERR) {
360: ungettoken(t);
361: ungettoken(skip_it());
362: return (FALSE);
363: }
364: }
365: }
366:
367:
368: ungettoken(t)
369: int t;
370: {
371: ugtokflag = TRUE;
372: ugtoken = t;
373: }
374:
375: gettoken()
376: {
377: register int c;
378: register char *sp = tokbuf;
379: register char *mark;
380: int posn;
381:
382: if (ugtokflag) {
383: ugtokflag = FALSE;
384: return (ugtoken);
385: }
386:
387: switch (c = fetch()) {
388: case NEWLINE:
389: case EOF:
390: case PERCENT:
391: return (c);
392: case ' ':
393: case '\t':
394: while ((c = fetch()) == ' ' || c == '\t')
395: ;
396: unfetch(c);
397: return (WS);
398: case '-':
399: return (DASH);
400: case ',':
401: return (COMMA);
402: case '*':
403: return (GLOB);
404: }
405:
406:
407: /*
408: * Case of INT. Place ascii digit string into tokbuf.
409: */
410: if (isdigit(c)) {
411: *sp++ = c;
412: while (isdigit(c = fetch()))
413: *sp++ = c;
414: unfetch(c);
415: *sp = '\0';
416: return (INT);
417: }
418:
419: /*
420: * The only remaining possibility is the token STR or STRPLUS.
421: */
422: *sp++ = c;
423: mark = tokbuf + buflen - 2;
424: while ((c = fetch()) != EOF && c != NEWLINE && c != PERCENT) {
425: if (sp == mark) {
426: posn = sp - tokbuf;
427: tokbuf = realloc(tokbuf, (buflen += 128));
428: sp = tokbuf + posn;
429: mark = sp + buflen;
430: }
431: *sp++ = c;
432: }
433: *sp = '\0';
434: if (c == PERCENT)
435: return (STRPLUS);
436: unfetch(c);
437: return (STR);
438: }
439:
440:
441: unfetch(c)
442: int c;
443: {
444: ufetval = c;
445: ufetflag = TRUE;
446: }
447:
448: fetch()
449: {
450: register int c;
451: register int c2;
452:
453: if (ufetflag) {
454: ufetflag = FALSE;
455: return (ufetval);
456: }
457:
458: for (;;)
459: switch (c = getc(f)) {
460: case '%':
461: return (PERCENT);
462: case '\n':
463: return (NEWLINE);
464: case '\\':
465: if ((c2 = getc(f)) == '%')
466: return ('%');
467: else if (c2 == '\n')
468: continue;
469: else {
470: ungetc(c2, f);
471: return ('\\');
472: }
473: default:
474: return (c);
475: }
476: }
477:
478:
479: skip_it()
480: {
481: register int t;
482:
483: while ((t = gettoken()) != EOF && t != NEWLINE)
484: ;
485: return (t);
486: }
487:
488: do_it()
489: {
490: register int c;
491: register FILE *fp;
492:
493: if ((c = gettoken()) != STR && c != STRPLUS) {
494: ungettoken(c);
495: return (skip_it());
496: }
497:
498: Dprint("Tokken is %s\n", tokbuf);
499:
500: if ((fp = cronpipe(tokbuf, "w")) == NULL) {
501: fprintf(stderr, "crond:\tCould not popen: %s\n\t\
502: errno = %d: %s.\n", tokbuf, errno, perror());
503: return (skip_it());
504: }
505:
506: if (c == STR) {
507: fclose(fp);
508: return (gettoken());
509: }
510: while ((c = fetch()) != NEWLINE && c != EOF)
511: if (c == PERCENT)
512: putc('\n', fp);
513: else
514: putc(c, fp);
515: putc('\n', fp);
516: fclose(fp);
517: return(c);
518: }
519:
520: /*
521: * We have to catch all signals.
522: * Ignore signals INT, HUP, & PIPE.
523: * Reset time on ALRM.
524: * Remove lock file and take default action on the rest of them.
525: */
526: sigsetup()
527: {
528: register int i;
529: int catchalarm(); /* Catch alarm signal */
530: int catchsignals(); /* Catch all signals */
531:
532: for (i = 1; i < NSIG; i++)
533: signal(i, catchsignals);
534:
535: signal(SIGINT, SIG_IGN);
536: signal(SIGHUP, SIG_IGN);
537: signal(SIGPIPE, SIG_IGN);
538: signal(SIGALRM, catchalarm);
539: }
540:
541: /*
542: * Remove lock file. Restore default action. Send the catched signal to itself.
543: */
544: int catchsignals(sig)
545: int sig;
546: {
547: unlink(F_LOCK); /* Remove lock FIFO. Do not care if unlink */
548: /* failed (case cron 3.2.0) */
549: Dprint("Remove lock file %s\n", F_LOCK);
550: signal(sig, SIG_DFL); /* Reset to default */
551: kill(getpid(), sig); /* Send catched signal */
552: wait();
553: }
554:
555: /*
556: * Catch alarm.
557: */
558: int catchalarm()
559: {
560: signal(SIGALRM, catchalarm);
561: time(&clock);
562: tm = localtime(&clock);
563: alarm(61 - tm->tm_sec);
564: }
565:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.