![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cron.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / cron|
Return to cron.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / cron |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)cron.c 4.16 (Berkeley) 6/29/90";
3: #endif
4:
5: #include <sys/types.h>
6: #include <sys/signal.h>
7: #include <sys/time.h>
8: #include <sys/stat.h>
9: #include <sys/wait.h>
10: #include <sys/ioctl.h>
11: #include <sys/file.h>
12: #include <sys/resource.h>
13: #include <pwd.h>
14: #include <fcntl.h>
15: #include <syslog.h>
16: #include <stdio.h>
17: #include <ctype.h>
18: #include "pathnames.h"
19:
20: #define LISTS (2*BUFSIZ)
21: #define MAXLIN BUFSIZ
22:
23: #define EXACT 100
24: #define ANY 101
25: #define LIST 102
26: #define RANGE 103
27: #define EOS 104
28:
29: char crontab[] = _PATH_CRON;
30: char loc_crontab[] = _PATH_LCRON;
31: time_t itime, time();
32: struct tm *loct;
33: struct tm *localtime();
34: char *malloc();
35: char *realloc();
36: int reapchild();
37: int flag;
38: char *list;
39: char *listend;
40: unsigned listsize;
41:
42: FILE *debug;
43: #define dprintf if (debug) fprintf
44:
45: main(argc, argv)
46: int argc;
47: char **argv;
48: {
49: register char *cp;
50: char *cmp();
51: time_t filetime = 0;
52: time_t lfiletime = 0;
53: char c;
54: extern char *optarg;
55:
56: if (geteuid()) {
57: fprintf(stderr, "cron: NOT super-user\n");
58: exit(1);
59: }
60:
61: openlog("cron", LOG_PID | LOG_CONS | LOG_NOWAIT, LOG_DAEMON);
62: switch (fork()) {
63:
64: case -1:
65: syslog(LOG_ERR, "fork: %m");
66: exit(1);
67: /* NOTREACHED */
68: case 0:
69: break;
70: default:
71: exit(0);
72: /* NOTREACHED */
73: }
74:
75: c = getopt(argc, argv, "d:");
76: if (c == 'd') {
77: debug = fopen(optarg, "w");
78: if (debug == NULL)
79: exit(1);
80: (void) fcntl(fileno(debug), F_SETFL, FAPPEND);
81: }
82: daemon(0, 0);
83: (void) signal(SIGHUP, SIG_IGN);
84: (void) signal(SIGINT, SIG_IGN);
85: (void) signal(SIGQUIT, SIG_IGN);
86: (void) signal(SIGCHLD, reapchild);
87: (void) time(&itime);
88: itime -= localtime(&itime)->tm_sec;
89:
90: for (;; itime+=60, slp()) {
91: struct stat cstat, lcstat;
92: int newcron, newloc;
93:
94: newcron = 0;
95: if (stat(crontab, &cstat) < 0)
96: cstat.st_mtime = 1;
97: if (cstat.st_mtime != filetime) {
98: filetime = cstat.st_mtime;
99: newcron++;
100: }
101:
102: newloc = 0;
103: if (stat(loc_crontab, &lcstat) < 0)
104: lcstat.st_mtime = 1;
105: if (lcstat.st_mtime != lfiletime) {
106: lfiletime = lcstat.st_mtime;
107: newloc++;
108: }
109:
110: if (newcron || newloc) {
111: init();
112: append(crontab);
113: append(loc_crontab);
114: *listend++ = EOS;
115: *listend++ = EOS;
116: }
117:
118: loct = localtime(&itime);
119: loct->tm_mon++; /* 1-12 for month */
120: if (loct->tm_wday == 0)
121: loct->tm_wday = 7; /* sunday is 7, not 0 */
122: for(cp = list; *cp != EOS;) {
123: flag = 0;
124: cp = cmp(cp, loct->tm_min);
125: cp = cmp(cp, loct->tm_hour);
126: cp = cmp(cp, loct->tm_mday);
127: cp = cmp(cp, loct->tm_mon);
128: cp = cmp(cp, loct->tm_wday);
129: if(flag == 0)
130: ex(cp);
131: while(*cp++ != 0)
132: ;
133: }
134: }
135: }
136:
137: char *
138: cmp(p, v)
139: char *p;
140: {
141: register char *cp;
142:
143: cp = p;
144: switch(*cp++) {
145:
146: case EXACT:
147: if (*cp++ != v)
148: flag++;
149: return(cp);
150:
151: case ANY:
152: return(cp);
153:
154: case LIST:
155: while(*cp != LIST)
156: if(*cp++ == v) {
157: while(*cp++ != LIST)
158: ;
159: return(cp);
160: }
161: flag++;
162: return(cp+1);
163:
164: case RANGE:
165: if(*cp > v || cp[1] < v)
166: flag++;
167: return(cp+2);
168: }
169: if(cp[-1] != v)
170: flag++;
171: return(cp);
172: }
173:
174: slp()
175: {
176: register i;
177: time_t t;
178:
179: (void) time(&t);
180: i = itime - t;
181: if(i < -60 * 60 || i > 60 * 60) {
182: itime = t;
183: i = 60 - localtime(&itime)->tm_sec;
184: itime += i;
185: }
186: if(i > 0)
187: sleep((u_int)i);
188: }
189:
190: ex(s)
191: char *s;
192: {
193: register struct passwd *pwd;
194: char user[BUFSIZ];
195: char *c = user;
196: int pid;
197:
198: switch (fork()) {
199: case 0:
200: break;
201: case -1:
202: syslog(LOG_ERR, "cannot fork: %m (running %.40s%s)",
203: s, strlen(s) > 40 ? "..." : "");
204: /*FALLTHROUGH*/
205: default:
206: return;
207: }
208: pid = getpid();
209: while(*s != ' ' && *s != '\t')
210: *c++ = *s++;
211: *c = '\0';
212: s++;
213: if ((pwd = getpwnam(user)) == NULL) {
214: syslog(LOG_ERR, "invalid user name \"%s\"", user);
215: dprintf(debug, "%d: cannot find %s\n", pid, user),
216: fflush(debug);
217: exit(1);
218: }
219: (void) setgid(pwd->pw_gid);
220: (void) initgroups(pwd->pw_name, pwd->pw_gid);
221: (void) setuid(pwd->pw_uid);
222: (void) freopen("/", "r", stdin);
223: closelog();
224: dprintf(debug, "%d: executing %s", pid, s), fflush (debug);
225: execl(_PATH_BSHELL, "sh", "-c", s, 0);
226: syslog(LOG_ERR, "cannot exec %s: %m");
227: dprintf(debug, "%d: cannot execute sh\n", pid), fflush (debug);
228: exit(0);
229: }
230:
231: init()
232: {
233: /*
234: * Don't free in case was longer than LISTS. Trades off
235: * the rare case of crontab shrinking vs. the common case of
236: * extra realloc's needed in append() for a large crontab.
237: */
238: if (list == 0) {
239: list = malloc(LISTS);
240: listsize = LISTS;
241: }
242: listend = list;
243: }
244:
245: append(fn)
246: char *fn;
247: {
248: register i, c;
249: register char *cp;
250: register char *ocp;
251: register int n;
252:
253: if (freopen(fn, "r", stdin) == NULL)
254: return;
255: cp = listend;
256: loop:
257: if(cp > list+listsize-MAXLIN) {
258: int length = cp - list;
259:
260: listsize += LISTS;
261: list = realloc(list, listsize);
262: cp = list + length;
263: }
264: ocp = cp;
265: for(i=0;; i++) {
266: do
267: c = getchar();
268: while(c == ' ' || c == '\t')
269: ;
270: if(c == EOF || c == '\n')
271: goto ignore;
272: if(i == 5)
273: break;
274: if(c == '*') {
275: *cp++ = ANY;
276: continue;
277: }
278: if ((n = number(c)) < 0)
279: goto ignore;
280: c = getchar();
281: if(c == ',')
282: goto mlist;
283: if(c == '-')
284: goto mrange;
285: if(c != '\t' && c != ' ')
286: goto ignore;
287: *cp++ = EXACT;
288: *cp++ = n;
289: continue;
290:
291: mlist:
292: *cp++ = LIST;
293: *cp++ = n;
294: do {
295: if ((n = number(getchar())) < 0)
296: goto ignore;
297: *cp++ = n;
298: c = getchar();
299: } while (c==',');
300: if(c != '\t' && c != ' ')
301: goto ignore;
302: *cp++ = LIST;
303: continue;
304:
305: mrange:
306: *cp++ = RANGE;
307: *cp++ = n;
308: if ((n = number(getchar())) < 0)
309: goto ignore;
310: c = getchar();
311: if(c != '\t' && c != ' ')
312: goto ignore;
313: *cp++ = n;
314: }
315: while(c != '\n') {
316: if(c == EOF)
317: goto ignore;
318: if(c == '%')
319: c = '\n';
320: *cp++ = c;
321: c = getchar();
322: }
323: *cp++ = '\n';
324: *cp++ = 0;
325: goto loop;
326:
327: ignore:
328: cp = ocp;
329: while(c != '\n') {
330: if(c == EOF) {
331: (void) fclose(stdin);
332: listend = cp;
333: return;
334: }
335: c = getchar();
336: }
337: goto loop;
338: }
339:
340: number(c)
341: register c;
342: {
343: register n = 0;
344:
345: while (isdigit(c)) {
346: n = n*10 + c - '0';
347: c = getchar();
348: }
349: (void) ungetc(c, stdin);
350: if (n>=100)
351: return(-1);
352: return(n);
353: }
354:
355: reapchild()
356: {
357: union wait status;
358: int pid;
359:
360: while ((pid = wait3(&status, WNOHANG, (struct rusage *)0)) > 0)
361: dprintf(debug, "%d: child exits with signal %d status %d\n",
362: pid, status.w_termsig, status.w_retcode),
363: fflush (debug);
364: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.