![[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 [Research Unix] / researchv9 / cmd|
Return to cron.c CVS log | Up to [Research Unix] / researchv9 / cmd |
1.1 root 1: /*
2: * cron - clock daemon
3: *
4: * modified from Berkeley version 4.3 (7/5/81):
5: *
6: * place crontab in /etc/crontab
7: * new mandatory first field gives uid for command
8: */
9:
10: #include <sys/types.h>
11: #include <stdio.h>
12: #include <ctype.h>
13: #include <signal.h>
14: #include <time.h>
15: #include <sys/stat.h>
16: #include <pwd.h>
17:
18: #define LISTS 1024
19:
20: #define NAMESIZE 9
21:
22: #define EXACT 100
23: #define ANY 101
24: #define LIST 102
25: #define RANGE 103
26: #define EOS 104
27: #define BOL 105
28: char crontab[] = "/etc/crontab";
29: time_t itime;
30: struct tm *loct;
31: struct tm *localtime();
32: char *malloc();
33: char *realloc();
34: int flag;
35: char *list;
36: unsigned listsize;
37: struct passwd *getpwnam();
38:
39: main()
40: {
41: register char *cp;
42: char *cmp(), *getid(), *getname();
43: time_t filetime = 0;
44:
45: if (fork())
46: exit(0);
47: chdir("/");
48: freopen(crontab, "r", stdin);
49: freopen("/", "r", stdout);
50: freopen("/", "r", stderr);
51: signal(SIGHUP, SIG_IGN);
52: signal(SIGINT, SIG_IGN);
53: signal(SIGQUIT, SIG_IGN);
54: time(&itime);
55: itime -= localtime(&itime)->tm_sec;
56: fclose(stdin);
57:
58: for (;; itime+=60, slp()) {
59: struct stat cstat;
60:
61: if (stat(crontab, &cstat) == -1)
62: continue;
63: if (cstat.st_mtime > filetime) {
64: filetime = cstat.st_mtime;
65: init();
66: }
67: loct = localtime(&itime);
68: loct->tm_mon++; /* 1-12 for month */
69: for(cp = list; *cp != EOS;) {
70: int uid, gid;
71: char *np;
72:
73: cp++; /* skip start of line */
74: cp = getid (cp, &uid);
75: cp = getid (cp, &gid);
76: cp = getname(cp, &np);
77: flag = 0;
78: cp = cmp(cp, loct->tm_min);
79: cp = cmp(cp, loct->tm_hour);
80: cp = cmp(cp, loct->tm_mday);
81: cp = cmp(cp, loct->tm_mon);
82: cp = cmp(cp, loct->tm_wday);
83: if(flag == 0)
84: ex (cp, uid, gid, np);
85: while(*cp++ != 0)
86: ;
87: }
88: }
89: }
90:
91: /*
92: * getid and putid are somewhat machine-dependent.
93: * putid stores a uid or gid as some number of characters;
94: * getid retrieves the uid or gid. The number of characters
95: * and number of bits per character might be different
96: * on other machines. Each function returns a pointer to
97: * the char just past the last one it dealt with.
98: */
99: char *
100: getid (p, v)
101: register char *p;
102: int *v;
103: {
104: *v = ((p[0] & 0xff) + (p[1] << 8)) & 0xffff;
105: return p + 2;
106: }
107:
108: char *
109: putid (p, v)
110: register char *p;
111: int v;
112: {
113: p[0] = v & 0xff;
114: p[1] = (v >> 8) & 0xff;
115: return p + 2;
116: }
117:
118: char *
119: getname(p, vp)
120: char *p;
121: char **vp;
122: {
123:
124: *vp = p;
125: return (p + NAMESIZE);
126: }
127:
128: char *
129: putname(p, v)
130: register char *p;
131: register char *v;
132: {
133: register int i;
134:
135: for (i = 0; i < NAMESIZE-1; i++) {
136: *p++ = *v;
137: if (*v)
138: v++;
139: }
140: *p++ = '\0';
141: return (p);
142: }
143:
144: char *
145: cmp(p, v)
146: char *p;
147: {
148: register char *cp;
149:
150: cp = p;
151: switch(*cp++) {
152:
153: case EXACT:
154: if (*cp++ != v)
155: flag++;
156: return(cp);
157:
158: case ANY:
159: return(cp);
160:
161: case LIST:
162: while(*cp != LIST)
163: if(*cp++ == v) {
164: while(*cp++ != LIST)
165: ;
166: return(cp);
167: }
168: flag++;
169: return(cp+1);
170:
171: case RANGE:
172: if(*cp > v || cp[1] < v)
173: flag++;
174: return(cp+2);
175: }
176: if(cp[-1] != v)
177: flag++;
178: return(cp);
179: }
180:
181: slp()
182: {
183: register i;
184: time_t t;
185:
186: time(&t);
187: i = itime - t;
188: if(i < -60 * 60 || i > 60 * 60) {
189: itime = t;
190: i = 60 - localtime(&itime)->tm_sec;
191: itime += i;
192: }
193: if(i > 0)
194: sleep((unsigned) i);
195: }
196:
197: /*
198: * hack: setlogname wants exactly 8 characters
199: * we happen to know that there are at least 8 in name, always,
200: * because NAMESIZE > 8
201: */
202: ex (s, uid, gid, name)
203: char *s;
204: int uid, gid;
205: char *name;
206: {
207: int st;
208:
209: if(fork()) {
210: wait(&st);
211: return;
212: }
213: if(fork())
214: exit(0);
215: setlogname(name);
216: (void)setupshares(uid, (void (*)())0);
217: setupgroups(name, gid);
218: setgid (gid);
219: setuid (uid);
220: freopen("/dev/null", "r", stdin);
221: execl("/bin/sh", "sh", "-c", s, 0);
222: exit(0);
223: }
224:
225: init()
226: {
227: register i, c;
228: register char *cp;
229: register char *ocp;
230: register int n;
231: char username[NAMESIZE];
232: struct passwd *pw;
233:
234: freopen(crontab, "r", stdin);
235: if (list) {
236: free(list);
237: list = realloc(list, LISTS);
238: } else
239: list = malloc(LISTS);
240: listsize = LISTS;
241: cp = list;
242:
243: loop:
244: if(cp > list+listsize-500) {
245: char *olist;
246: listsize += LISTS;
247: olist = list;
248: free(list);
249: list = realloc(list, listsize);
250: cp = list + (cp - olist);
251: }
252: ocp = cp;
253:
254: /* skip leading white space on the line */
255: do c = getchar();
256: while (c == ' ' || c == '\t');
257:
258: /* accumulate the user name into "username" */
259: n = 0;
260: while (c != EOF && c != '\n' && c != ' ' && c != '\t') {
261: if (n < sizeof (username) - 1)
262: username[n++] = c;
263: c = getchar();
264: }
265: username[n] = '\0';
266:
267: /* look up the user name and store it */
268: pw = getpwnam (username);
269: if (pw == NULL)
270: goto ignore;
271: *cp++ = BOL;
272: cp = putid (cp, pw->pw_uid);
273: cp = putid (cp, pw->pw_gid);
274: cp = putname(cp, username);
275:
276: ungetc (c, stdin);
277:
278: /* scan the time fields */
279: for(i=0;; i++) {
280: do c = getchar();
281: while(c == ' ' || c == '\t');
282: if(c == EOF || c == '\n')
283: goto ignore;
284: if(i == 5)
285: break;
286: if(c == '*') {
287: *cp++ = ANY;
288: continue;
289: }
290: if ((n = number(c)) < 0)
291: goto ignore;
292: c = getchar();
293: if(c == ',')
294: goto mlist;
295: if(c == '-')
296: goto mrange;
297: if(c != '\t' && c != ' ')
298: goto ignore;
299: *cp++ = EXACT;
300: *cp++ = n;
301: continue;
302:
303: mlist:
304: *cp++ = LIST;
305: *cp++ = n;
306: do {
307: if ((n = number(getchar())) < 0)
308: goto ignore;
309: *cp++ = n;
310: c = getchar();
311: } while (c==',');
312: if(c != '\t' && c != ' ')
313: goto ignore;
314: *cp++ = LIST;
315: continue;
316:
317: mrange:
318: *cp++ = RANGE;
319: *cp++ = n;
320: if ((n = number(getchar())) < 0)
321: goto ignore;
322: c = getchar();
323: if(c != '\t' && c != ' ')
324: goto ignore;
325: *cp++ = n;
326: }
327: while(c != '\n') {
328: if(c == EOF)
329: goto ignore;
330: if(c == '%')
331: c = '\n';
332: *cp++ = c;
333: c = getchar();
334: }
335: *cp++ = '\n';
336: *cp++ = 0;
337: goto loop;
338:
339: ignore:
340: cp = ocp;
341: while(c != '\n') {
342: if(c == EOF) {
343: *cp++ = EOS;
344: *cp++ = EOS;
345: fclose(stdin);
346: return;
347: }
348: c = getchar();
349: }
350: goto loop;
351: }
352:
353: number(c)
354: register c;
355: {
356: register n = 0;
357:
358: while (isdigit(c)) {
359: n = n*10 + c - '0';
360: c = getchar();
361: }
362: ungetc(c, stdin);
363: if (n>100)
364: return(-1);
365: return(n);
366: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.