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