Contents of /tags/mkinitrd-6_1_1/busybox/miscutils/crond.c
Parent Directory | Revision Log
Revision 841 -
(show annotations)
(download)
Mon May 4 16:31:54 2009 UTC (15 years, 4 months ago) by niro
File MIME type: text/plain
File size: 22402 byte(s)
Mon May 4 16:31:54 2009 UTC (15 years, 4 months ago) by niro
File MIME type: text/plain
File size: 22402 byte(s)
tagged 'mkinitrd-6_1_1'
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * crond -d[#] -c <crondir> -f -b |
4 | * |
5 | * run as root, but NOT setuid root |
6 | * |
7 | * Copyright 1994 Matthew Dillon (dillon@apollo.west.oic.com) |
8 | * (version 2.3.2) |
9 | * Vladimir Oleynik <dzo@simtreas.ru> (C) 2002 |
10 | * |
11 | * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. |
12 | */ |
13 | |
14 | #include "libbb.h" |
15 | #include <syslog.h> |
16 | |
17 | /* glibc frees previous setenv'ed value when we do next setenv() |
18 | * of the same variable. uclibc does not do this! */ |
19 | #if (defined(__GLIBC__) && !defined(__UCLIBC__)) /* || OTHER_SAFE_LIBC... */ |
20 | #define SETENV_LEAKS 0 |
21 | #else |
22 | #define SETENV_LEAKS 1 |
23 | #endif |
24 | |
25 | |
26 | #ifndef CRONTABS |
27 | #define CRONTABS "/var/spool/cron/crontabs" |
28 | #endif |
29 | #ifndef TMPDIR |
30 | #define TMPDIR "/var/spool/cron" |
31 | #endif |
32 | #ifndef SENDMAIL |
33 | #define SENDMAIL "sendmail" |
34 | #endif |
35 | #ifndef SENDMAIL_ARGS |
36 | #define SENDMAIL_ARGS "-ti", "oem" |
37 | #endif |
38 | #ifndef CRONUPDATE |
39 | #define CRONUPDATE "cron.update" |
40 | #endif |
41 | #ifndef MAXLINES |
42 | #define MAXLINES 256 /* max lines in non-root crontabs */ |
43 | #endif |
44 | |
45 | |
46 | typedef struct CronFile { |
47 | struct CronFile *cf_Next; |
48 | struct CronLine *cf_LineBase; |
49 | char *cf_User; /* username */ |
50 | smallint cf_Ready; /* bool: one or more jobs ready */ |
51 | smallint cf_Running; /* bool: one or more jobs running */ |
52 | smallint cf_Deleted; /* marked for deletion, ignore */ |
53 | } CronFile; |
54 | |
55 | typedef struct CronLine { |
56 | struct CronLine *cl_Next; |
57 | char *cl_Shell; /* shell command */ |
58 | pid_t cl_Pid; /* running pid, 0, or armed (-1) */ |
59 | #if ENABLE_FEATURE_CROND_CALL_SENDMAIL |
60 | int cl_MailPos; /* 'empty file' size */ |
61 | smallint cl_MailFlag; /* running pid is for mail */ |
62 | char *cl_MailTo; /* whom to mail results */ |
63 | #endif |
64 | /* ordered by size, not in natural order. makes code smaller: */ |
65 | char cl_Dow[7]; /* 0-6, beginning sunday */ |
66 | char cl_Mons[12]; /* 0-11 */ |
67 | char cl_Hrs[24]; /* 0-23 */ |
68 | char cl_Days[32]; /* 1-31 */ |
69 | char cl_Mins[60]; /* 0-59 */ |
70 | } CronLine; |
71 | |
72 | |
73 | #define DaemonUid 0 |
74 | |
75 | |
76 | enum { |
77 | OPT_l = (1 << 0), |
78 | OPT_L = (1 << 1), |
79 | OPT_f = (1 << 2), |
80 | OPT_b = (1 << 3), |
81 | OPT_S = (1 << 4), |
82 | OPT_c = (1 << 5), |
83 | OPT_d = (1 << 6) * ENABLE_FEATURE_CROND_D, |
84 | }; |
85 | #if ENABLE_FEATURE_CROND_D |
86 | #define DebugOpt (option_mask32 & OPT_d) |
87 | #else |
88 | #define DebugOpt 0 |
89 | #endif |
90 | |
91 | |
92 | struct globals { |
93 | unsigned LogLevel; /* = 8; */ |
94 | const char *LogFile; |
95 | const char *CDir; /* = CRONTABS; */ |
96 | CronFile *FileBase; |
97 | #if SETENV_LEAKS |
98 | char *env_var_user; |
99 | char *env_var_home; |
100 | #endif |
101 | }; |
102 | #define G (*(struct globals*)&bb_common_bufsiz1) |
103 | #define LogLevel (G.LogLevel ) |
104 | #define LogFile (G.LogFile ) |
105 | #define CDir (G.CDir ) |
106 | #define FileBase (G.FileBase ) |
107 | #define env_var_user (G.env_var_user ) |
108 | #define env_var_home (G.env_var_home ) |
109 | #define INIT_G() do { \ |
110 | LogLevel = 8; \ |
111 | CDir = CRONTABS; \ |
112 | } while (0) |
113 | |
114 | |
115 | static void CheckUpdates(void); |
116 | static void SynchronizeDir(void); |
117 | static int TestJobs(time_t t1, time_t t2); |
118 | static void RunJobs(void); |
119 | static int CheckJobs(void); |
120 | static void RunJob(const char *user, CronLine *line); |
121 | #if ENABLE_FEATURE_CROND_CALL_SENDMAIL |
122 | static void EndJob(const char *user, CronLine *line); |
123 | #else |
124 | #define EndJob(user, line) ((line)->cl_Pid = 0) |
125 | #endif |
126 | static void DeleteFile(const char *userName); |
127 | |
128 | |
129 | #define LVL5 "\x05" |
130 | #define LVL7 "\x07" |
131 | #define LVL8 "\x08" |
132 | #define LVL9 "\x09" |
133 | #define WARN9 "\x49" |
134 | #define DIE9 "\xc9" |
135 | /* level >= 20 is "error" */ |
136 | #define ERR20 "\x14" |
137 | |
138 | static void crondlog(const char *ctl, ...) |
139 | { |
140 | va_list va; |
141 | int level = (ctl[0] & 0x1f); |
142 | |
143 | va_start(va, ctl); |
144 | if (level >= (int)LogLevel) { |
145 | /* Debug mode: all to (non-redirected) stderr, */ |
146 | /* Syslog mode: all to syslog (logmode = LOGMODE_SYSLOG), */ |
147 | if (!DebugOpt && LogFile) { |
148 | /* Otherwise (log to file): we reopen log file at every write: */ |
149 | int logfd = open3_or_warn(LogFile, O_WRONLY | O_CREAT | O_APPEND, 0600); |
150 | if (logfd >= 0) |
151 | xmove_fd(logfd, STDERR_FILENO); |
152 | } |
153 | // TODO: ERR -> error, WARN -> warning, LVL -> info |
154 | bb_verror_msg(ctl + 1, va, /* strerr: */ NULL); |
155 | } |
156 | va_end(va); |
157 | if (ctl[0] & 0x80) |
158 | exit(20); |
159 | } |
160 | |
161 | int crond_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
162 | int crond_main(int argc UNUSED_PARAM, char **argv) |
163 | { |
164 | unsigned opt; |
165 | |
166 | INIT_G(); |
167 | |
168 | /* "-b after -f is ignored", and so on for every pair a-b */ |
169 | opt_complementary = "f-b:b-f:S-L:L-S" USE_FEATURE_CROND_D(":d-l") |
170 | ":l+:d+"; /* -l and -d have numeric param */ |
171 | opt = getopt32(argv, "l:L:fbSc:" USE_FEATURE_CROND_D("d:"), |
172 | &LogLevel, &LogFile, &CDir |
173 | USE_FEATURE_CROND_D(,&LogLevel)); |
174 | /* both -d N and -l N set the same variable: LogLevel */ |
175 | |
176 | if (!(opt & OPT_f)) { |
177 | /* close stdin, stdout, stderr. |
178 | * close unused descriptors - don't need them. */ |
179 | bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, argv); |
180 | } |
181 | |
182 | if (!DebugOpt && LogFile == NULL) { |
183 | /* logging to syslog */ |
184 | openlog(applet_name, LOG_CONS | LOG_PID, LOG_CRON); |
185 | logmode = LOGMODE_SYSLOG; |
186 | } |
187 | |
188 | xchdir(CDir); |
189 | //signal(SIGHUP, SIG_IGN); /* ? original crond dies on HUP... */ |
190 | xsetenv("SHELL", DEFAULT_SHELL); /* once, for all future children */ |
191 | crondlog(LVL9 "crond (busybox "BB_VER") started, log level %d", LogLevel); |
192 | SynchronizeDir(); |
193 | |
194 | /* main loop - synchronize to 1 second after the minute, minimum sleep |
195 | * of 1 second. */ |
196 | { |
197 | time_t t1 = time(NULL); |
198 | time_t t2; |
199 | long dt; |
200 | int rescan = 60; |
201 | int sleep_time = 60; |
202 | |
203 | write_pidfile("/var/run/crond.pid"); |
204 | for (;;) { |
205 | sleep((sleep_time + 1) - (time(NULL) % sleep_time)); |
206 | |
207 | t2 = time(NULL); |
208 | dt = (long)t2 - (long)t1; |
209 | |
210 | /* |
211 | * The file 'cron.update' is checked to determine new cron |
212 | * jobs. The directory is rescanned once an hour to deal |
213 | * with any screwups. |
214 | * |
215 | * check for disparity. Disparities over an hour either way |
216 | * result in resynchronization. A reverse-indexed disparity |
217 | * less then an hour causes us to effectively sleep until we |
218 | * match the original time (i.e. no re-execution of jobs that |
219 | * have just been run). A forward-indexed disparity less then |
220 | * an hour causes intermediate jobs to be run, but only once |
221 | * in the worst case. |
222 | * |
223 | * when running jobs, the inequality used is greater but not |
224 | * equal to t1, and less then or equal to t2. |
225 | */ |
226 | if (--rescan == 0) { |
227 | rescan = 60; |
228 | SynchronizeDir(); |
229 | } |
230 | CheckUpdates(); |
231 | if (DebugOpt) |
232 | crondlog(LVL5 "wakeup dt=%ld", dt); |
233 | if (dt < -60 * 60 || dt > 60 * 60) { |
234 | crondlog(WARN9 "time disparity of %d minutes detected", dt / 60); |
235 | } else if (dt > 0) { |
236 | TestJobs(t1, t2); |
237 | RunJobs(); |
238 | sleep(5); |
239 | if (CheckJobs() > 0) { |
240 | sleep_time = 10; |
241 | } else { |
242 | sleep_time = 60; |
243 | } |
244 | } |
245 | t1 = t2; |
246 | } |
247 | } |
248 | return 0; /* not reached */ |
249 | } |
250 | |
251 | #if SETENV_LEAKS |
252 | /* We set environment *before* vfork (because we want to use vfork), |
253 | * so we cannot use setenv() - repeated calls to setenv() may leak memory! |
254 | * Using putenv(), and freeing memory after unsetenv() won't leak */ |
255 | static void safe_setenv4(char **pvar_val, const char *var, const char *val /*, int len*/) |
256 | { |
257 | const int len = 4; /* both var names are 4 char long */ |
258 | char *var_val = *pvar_val; |
259 | |
260 | if (var_val) { |
261 | var_val[len] = '\0'; /* nuke '=' */ |
262 | unsetenv(var_val); |
263 | free(var_val); |
264 | } |
265 | *pvar_val = xasprintf("%s=%s", var, val); |
266 | putenv(*pvar_val); |
267 | } |
268 | #endif |
269 | |
270 | static void SetEnv(struct passwd *pas) |
271 | { |
272 | #if SETENV_LEAKS |
273 | safe_setenv4(&env_var_user, "USER", pas->pw_name); |
274 | safe_setenv4(&env_var_home, "HOME", pas->pw_dir); |
275 | /* if we want to set user's shell instead: */ |
276 | /*safe_setenv(env_var_user, "SHELL", pas->pw_shell, 5);*/ |
277 | #else |
278 | xsetenv("USER", pas->pw_name); |
279 | xsetenv("HOME", pas->pw_dir); |
280 | #endif |
281 | /* currently, we use constant one: */ |
282 | /*setenv("SHELL", DEFAULT_SHELL, 1); - done earlier */ |
283 | } |
284 | |
285 | static void ChangeUser(struct passwd *pas) |
286 | { |
287 | /* careful: we're after vfork! */ |
288 | change_identity(pas); /* - initgroups, setgid, setuid */ |
289 | if (chdir(pas->pw_dir) < 0) { |
290 | crondlog(LVL9 "can't chdir(%s)", pas->pw_dir); |
291 | if (chdir(TMPDIR) < 0) { |
292 | crondlog(DIE9 "can't chdir(%s)", TMPDIR); /* exits */ |
293 | } |
294 | } |
295 | } |
296 | |
297 | static const char DowAry[] ALIGN1 = |
298 | "sun""mon""tue""wed""thu""fri""sat" |
299 | /* "Sun""Mon""Tue""Wed""Thu""Fri""Sat" */ |
300 | ; |
301 | |
302 | static const char MonAry[] ALIGN1 = |
303 | "jan""feb""mar""apr""may""jun""jul""aug""sep""oct""nov""dec" |
304 | /* "Jan""Feb""Mar""Apr""May""Jun""Jul""Aug""Sep""Oct""Nov""Dec" */ |
305 | ; |
306 | |
307 | static void ParseField(char *user, char *ary, int modvalue, int off, |
308 | const char *names, char *ptr) |
309 | /* 'names' is a pointer to a set of 3-char abbreviations */ |
310 | { |
311 | char *base = ptr; |
312 | int n1 = -1; |
313 | int n2 = -1; |
314 | |
315 | // this can't happen due to config_read() |
316 | /*if (base == NULL) |
317 | return;*/ |
318 | |
319 | while (1) { |
320 | int skip = 0; |
321 | |
322 | /* Handle numeric digit or symbol or '*' */ |
323 | if (*ptr == '*') { |
324 | n1 = 0; /* everything will be filled */ |
325 | n2 = modvalue - 1; |
326 | skip = 1; |
327 | ++ptr; |
328 | } else if (isdigit(*ptr)) { |
329 | if (n1 < 0) { |
330 | n1 = strtol(ptr, &ptr, 10) + off; |
331 | } else { |
332 | n2 = strtol(ptr, &ptr, 10) + off; |
333 | } |
334 | skip = 1; |
335 | } else if (names) { |
336 | int i; |
337 | |
338 | for (i = 0; names[i]; i += 3) { |
339 | /* was using strncmp before... */ |
340 | if (strncasecmp(ptr, &names[i], 3) == 0) { |
341 | ptr += 3; |
342 | if (n1 < 0) { |
343 | n1 = i / 3; |
344 | } else { |
345 | n2 = i / 3; |
346 | } |
347 | skip = 1; |
348 | break; |
349 | } |
350 | } |
351 | } |
352 | |
353 | /* handle optional range '-' */ |
354 | if (skip == 0) { |
355 | goto err; |
356 | } |
357 | if (*ptr == '-' && n2 < 0) { |
358 | ++ptr; |
359 | continue; |
360 | } |
361 | |
362 | /* |
363 | * collapse single-value ranges, handle skipmark, and fill |
364 | * in the character array appropriately. |
365 | */ |
366 | if (n2 < 0) { |
367 | n2 = n1; |
368 | } |
369 | if (*ptr == '/') { |
370 | skip = strtol(ptr + 1, &ptr, 10); |
371 | } |
372 | |
373 | /* |
374 | * fill array, using a failsafe is the easiest way to prevent |
375 | * an endless loop |
376 | */ |
377 | { |
378 | int s0 = 1; |
379 | int failsafe = 1024; |
380 | |
381 | --n1; |
382 | do { |
383 | n1 = (n1 + 1) % modvalue; |
384 | |
385 | if (--s0 == 0) { |
386 | ary[n1 % modvalue] = 1; |
387 | s0 = skip; |
388 | } |
389 | if (--failsafe == 0) { |
390 | goto err; |
391 | } |
392 | } while (n1 != n2); |
393 | |
394 | } |
395 | if (*ptr != ',') { |
396 | break; |
397 | } |
398 | ++ptr; |
399 | n1 = -1; |
400 | n2 = -1; |
401 | } |
402 | |
403 | if (*ptr) { |
404 | err: |
405 | crondlog(WARN9 "user %s: parse error at %s", user, base); |
406 | return; |
407 | } |
408 | |
409 | if (DebugOpt && (LogLevel <= 5)) { /* like LVL5 */ |
410 | /* can't use crondlog, it inserts '\n' */ |
411 | int i; |
412 | for (i = 0; i < modvalue; ++i) |
413 | fprintf(stderr, "%d", (unsigned char)ary[i]); |
414 | fputc('\n', stderr); |
415 | } |
416 | } |
417 | |
418 | static void FixDayDow(CronLine *line) |
419 | { |
420 | unsigned i; |
421 | int weekUsed = 0; |
422 | int daysUsed = 0; |
423 | |
424 | for (i = 0; i < ARRAY_SIZE(line->cl_Dow); ++i) { |
425 | if (line->cl_Dow[i] == 0) { |
426 | weekUsed = 1; |
427 | break; |
428 | } |
429 | } |
430 | for (i = 0; i < ARRAY_SIZE(line->cl_Days); ++i) { |
431 | if (line->cl_Days[i] == 0) { |
432 | daysUsed = 1; |
433 | break; |
434 | } |
435 | } |
436 | if (weekUsed != daysUsed) { |
437 | if (weekUsed) |
438 | memset(line->cl_Days, 0, sizeof(line->cl_Days)); |
439 | else /* daysUsed */ |
440 | memset(line->cl_Dow, 0, sizeof(line->cl_Dow)); |
441 | } |
442 | } |
443 | |
444 | static void SynchronizeFile(const char *fileName) |
445 | { |
446 | struct parser_t *parser; |
447 | struct stat sbuf; |
448 | int maxLines; |
449 | char *tokens[6]; |
450 | #if ENABLE_FEATURE_CROND_CALL_SENDMAIL |
451 | char *mailTo = NULL; |
452 | #endif |
453 | |
454 | if (!fileName) |
455 | return; |
456 | |
457 | DeleteFile(fileName); |
458 | parser = config_open(fileName); |
459 | if (!parser) |
460 | return; |
461 | |
462 | maxLines = (strcmp(fileName, "root") == 0) ? 65535 : MAXLINES; |
463 | |
464 | if (fstat(fileno(parser->fp), &sbuf) == 0 && sbuf.st_uid == DaemonUid) { |
465 | CronFile *file = xzalloc(sizeof(CronFile)); |
466 | CronLine **pline; |
467 | int n; |
468 | |
469 | file->cf_User = xstrdup(fileName); |
470 | pline = &file->cf_LineBase; |
471 | |
472 | while (1) { |
473 | CronLine *line; |
474 | |
475 | if (!--maxLines) |
476 | break; |
477 | n = config_read(parser, tokens, 6, 1, "# \t", PARSE_NORMAL | PARSE_KEEP_COPY); |
478 | if (!n) |
479 | break; |
480 | |
481 | if (DebugOpt) |
482 | crondlog(LVL5 "user:%s entry:%s", fileName, parser->data); |
483 | |
484 | /* check if line is setting MAILTO= */ |
485 | if (0 == strncmp(tokens[0], "MAILTO=", 7)) { |
486 | #if ENABLE_FEATURE_CROND_CALL_SENDMAIL |
487 | free(mailTo); |
488 | mailTo = (tokens[0][7]) ? xstrdup(&tokens[0][7]) : NULL; |
489 | #endif /* otherwise just ignore such lines */ |
490 | continue; |
491 | } |
492 | /* check if a minimum of tokens is specified */ |
493 | if (n < 6) |
494 | continue; |
495 | *pline = line = xzalloc(sizeof(*line)); |
496 | /* parse date ranges */ |
497 | ParseField(file->cf_User, line->cl_Mins, 60, 0, NULL, tokens[0]); |
498 | ParseField(file->cf_User, line->cl_Hrs, 24, 0, NULL, tokens[1]); |
499 | ParseField(file->cf_User, line->cl_Days, 32, 0, NULL, tokens[2]); |
500 | ParseField(file->cf_User, line->cl_Mons, 12, -1, MonAry, tokens[3]); |
501 | ParseField(file->cf_User, line->cl_Dow, 7, 0, DowAry, tokens[4]); |
502 | /* |
503 | * fix days and dow - if one is not "*" and the other |
504 | * is "*", the other is set to 0, and vise-versa |
505 | */ |
506 | FixDayDow(line); |
507 | #if ENABLE_FEATURE_CROND_CALL_SENDMAIL |
508 | /* copy mailto (can be NULL) */ |
509 | line->cl_MailTo = xstrdup(mailTo); |
510 | #endif |
511 | /* copy command */ |
512 | line->cl_Shell = xstrdup(tokens[5]); |
513 | if (DebugOpt) { |
514 | crondlog(LVL5 " command:%s", tokens[5]); |
515 | } |
516 | pline = &line->cl_Next; |
517 | //bb_error_msg("M[%s]F[%s][%s][%s][%s][%s][%s]", mailTo, tokens[0], tokens[1], tokens[2], tokens[3], tokens[4], tokens[5]); |
518 | } |
519 | *pline = NULL; |
520 | |
521 | file->cf_Next = FileBase; |
522 | FileBase = file; |
523 | |
524 | if (maxLines == 0) { |
525 | crondlog(WARN9 "user %s: too many lines", fileName); |
526 | } |
527 | } |
528 | config_close(parser); |
529 | } |
530 | |
531 | static void CheckUpdates(void) |
532 | { |
533 | FILE *fi; |
534 | char buf[256]; |
535 | |
536 | fi = fopen_for_read(CRONUPDATE); |
537 | if (fi != NULL) { |
538 | unlink(CRONUPDATE); |
539 | while (fgets(buf, sizeof(buf), fi) != NULL) { |
540 | /* use first word only */ |
541 | SynchronizeFile(strtok(buf, " \t\r\n")); |
542 | } |
543 | fclose(fi); |
544 | } |
545 | } |
546 | |
547 | static void SynchronizeDir(void) |
548 | { |
549 | CronFile *file; |
550 | /* Attempt to delete the database. */ |
551 | again: |
552 | for (file = FileBase; file; file = file->cf_Next) { |
553 | if (!file->cf_Deleted) { |
554 | DeleteFile(file->cf_User); |
555 | goto again; |
556 | } |
557 | } |
558 | |
559 | /* |
560 | * Remove cron update file |
561 | * |
562 | * Re-chdir, in case directory was renamed & deleted, or otherwise |
563 | * screwed up. |
564 | * |
565 | * scan directory and add associated users |
566 | */ |
567 | unlink(CRONUPDATE); |
568 | if (chdir(CDir) < 0) { |
569 | crondlog(DIE9 "can't chdir(%s)", CDir); |
570 | } |
571 | { |
572 | DIR *dir = opendir("."); |
573 | struct dirent *den; |
574 | |
575 | if (!dir) |
576 | crondlog(DIE9 "can't chdir(%s)", "."); /* exits */ |
577 | while ((den = readdir(dir)) != NULL) { |
578 | if (strchr(den->d_name, '.') != NULL) { |
579 | continue; |
580 | } |
581 | if (getpwnam(den->d_name)) { |
582 | SynchronizeFile(den->d_name); |
583 | } else { |
584 | crondlog(LVL7 "ignoring %s", den->d_name); |
585 | } |
586 | } |
587 | closedir(dir); |
588 | } |
589 | } |
590 | |
591 | /* |
592 | * DeleteFile() - delete user database |
593 | * |
594 | * Note: multiple entries for same user may exist if we were unable to |
595 | * completely delete a database due to running processes. |
596 | */ |
597 | static void DeleteFile(const char *userName) |
598 | { |
599 | CronFile **pfile = &FileBase; |
600 | CronFile *file; |
601 | |
602 | while ((file = *pfile) != NULL) { |
603 | if (strcmp(userName, file->cf_User) == 0) { |
604 | CronLine **pline = &file->cf_LineBase; |
605 | CronLine *line; |
606 | |
607 | file->cf_Running = 0; |
608 | file->cf_Deleted = 1; |
609 | |
610 | while ((line = *pline) != NULL) { |
611 | if (line->cl_Pid > 0) { |
612 | file->cf_Running = 1; |
613 | pline = &line->cl_Next; |
614 | } else { |
615 | *pline = line->cl_Next; |
616 | free(line->cl_Shell); |
617 | free(line); |
618 | } |
619 | } |
620 | if (file->cf_Running == 0) { |
621 | *pfile = file->cf_Next; |
622 | free(file->cf_User); |
623 | free(file); |
624 | } else { |
625 | pfile = &file->cf_Next; |
626 | } |
627 | } else { |
628 | pfile = &file->cf_Next; |
629 | } |
630 | } |
631 | } |
632 | |
633 | /* |
634 | * TestJobs() |
635 | * |
636 | * determine which jobs need to be run. Under normal conditions, the |
637 | * period is about a minute (one scan). Worst case it will be one |
638 | * hour (60 scans). |
639 | */ |
640 | static int TestJobs(time_t t1, time_t t2) |
641 | { |
642 | int nJobs = 0; |
643 | time_t t; |
644 | |
645 | /* Find jobs > t1 and <= t2 */ |
646 | |
647 | for (t = t1 - t1 % 60; t <= t2; t += 60) { |
648 | struct tm *tp; |
649 | CronFile *file; |
650 | CronLine *line; |
651 | |
652 | if (t <= t1) |
653 | continue; |
654 | |
655 | tp = localtime(&t); |
656 | for (file = FileBase; file; file = file->cf_Next) { |
657 | if (DebugOpt) |
658 | crondlog(LVL5 "file %s:", file->cf_User); |
659 | if (file->cf_Deleted) |
660 | continue; |
661 | for (line = file->cf_LineBase; line; line = line->cl_Next) { |
662 | if (DebugOpt) |
663 | crondlog(LVL5 " line %s", line->cl_Shell); |
664 | if (line->cl_Mins[tp->tm_min] && line->cl_Hrs[tp->tm_hour] |
665 | && (line->cl_Days[tp->tm_mday] || line->cl_Dow[tp->tm_wday]) |
666 | && line->cl_Mons[tp->tm_mon] |
667 | ) { |
668 | if (DebugOpt) { |
669 | crondlog(LVL5 " job: %d %s", |
670 | (int)line->cl_Pid, line->cl_Shell); |
671 | } |
672 | if (line->cl_Pid > 0) { |
673 | crondlog(LVL8 "user %s: process already running: %s", |
674 | file->cf_User, line->cl_Shell); |
675 | } else if (line->cl_Pid == 0) { |
676 | line->cl_Pid = -1; |
677 | file->cf_Ready = 1; |
678 | ++nJobs; |
679 | } |
680 | } |
681 | } |
682 | } |
683 | } |
684 | return nJobs; |
685 | } |
686 | |
687 | static void RunJobs(void) |
688 | { |
689 | CronFile *file; |
690 | CronLine *line; |
691 | |
692 | for (file = FileBase; file; file = file->cf_Next) { |
693 | if (!file->cf_Ready) |
694 | continue; |
695 | |
696 | file->cf_Ready = 0; |
697 | for (line = file->cf_LineBase; line; line = line->cl_Next) { |
698 | if (line->cl_Pid >= 0) |
699 | continue; |
700 | |
701 | RunJob(file->cf_User, line); |
702 | crondlog(LVL8 "USER %s pid %3d cmd %s", |
703 | file->cf_User, (int)line->cl_Pid, line->cl_Shell); |
704 | if (line->cl_Pid < 0) { |
705 | file->cf_Ready = 1; |
706 | } else if (line->cl_Pid > 0) { |
707 | file->cf_Running = 1; |
708 | } |
709 | } |
710 | } |
711 | } |
712 | |
713 | /* |
714 | * CheckJobs() - check for job completion |
715 | * |
716 | * Check for job completion, return number of jobs still running after |
717 | * all done. |
718 | */ |
719 | static int CheckJobs(void) |
720 | { |
721 | CronFile *file; |
722 | CronLine *line; |
723 | int nStillRunning = 0; |
724 | |
725 | for (file = FileBase; file; file = file->cf_Next) { |
726 | if (file->cf_Running) { |
727 | file->cf_Running = 0; |
728 | |
729 | for (line = file->cf_LineBase; line; line = line->cl_Next) { |
730 | int status, r; |
731 | if (line->cl_Pid <= 0) |
732 | continue; |
733 | |
734 | r = waitpid(line->cl_Pid, &status, WNOHANG); |
735 | if (r < 0 || r == line->cl_Pid) { |
736 | EndJob(file->cf_User, line); |
737 | if (line->cl_Pid) { |
738 | file->cf_Running = 1; |
739 | } |
740 | } else if (r == 0) { |
741 | file->cf_Running = 1; |
742 | } |
743 | } |
744 | } |
745 | nStillRunning += file->cf_Running; |
746 | } |
747 | return nStillRunning; |
748 | } |
749 | |
750 | #if ENABLE_FEATURE_CROND_CALL_SENDMAIL |
751 | |
752 | // TODO: sendmail should be _run-time_ option, not compile-time! |
753 | |
754 | static void |
755 | ForkJob(const char *user, CronLine *line, int mailFd, |
756 | const char *prog, const char *cmd, const char *arg, |
757 | const char *mail_filename) |
758 | { |
759 | struct passwd *pas; |
760 | pid_t pid; |
761 | |
762 | /* prepare things before vfork */ |
763 | pas = getpwnam(user); |
764 | if (!pas) { |
765 | crondlog(LVL9 "can't get uid for %s", user); |
766 | goto err; |
767 | } |
768 | SetEnv(pas); |
769 | |
770 | pid = vfork(); |
771 | if (pid == 0) { |
772 | /* CHILD */ |
773 | /* change running state to the user in question */ |
774 | ChangeUser(pas); |
775 | if (DebugOpt) { |
776 | crondlog(LVL5 "child running %s", prog); |
777 | } |
778 | if (mailFd >= 0) { |
779 | xmove_fd(mailFd, mail_filename ? 1 : 0); |
780 | dup2(1, 2); |
781 | } |
782 | /* crond 3.0pl1-100 puts tasks in separate process groups */ |
783 | bb_setpgrp(); |
784 | execlp(prog, prog, cmd, arg, NULL); |
785 | crondlog(ERR20 "can't exec, user %s cmd %s %s %s", user, prog, cmd, arg); |
786 | if (mail_filename) { |
787 | fdprintf(1, "Exec failed: %s -c %s\n", prog, arg); |
788 | } |
789 | _exit(EXIT_SUCCESS); |
790 | } |
791 | |
792 | line->cl_Pid = pid; |
793 | if (pid < 0) { |
794 | /* FORK FAILED */ |
795 | crondlog(ERR20 "can't vfork"); |
796 | err: |
797 | line->cl_Pid = 0; |
798 | if (mail_filename) { |
799 | unlink(mail_filename); |
800 | } |
801 | } else if (mail_filename) { |
802 | /* PARENT, FORK SUCCESS |
803 | * rename mail-file based on pid of process |
804 | */ |
805 | char mailFile2[128]; |
806 | |
807 | snprintf(mailFile2, sizeof(mailFile2), "%s/cron.%s.%d", TMPDIR, user, pid); |
808 | rename(mail_filename, mailFile2); // TODO: xrename? |
809 | } |
810 | |
811 | /* |
812 | * Close the mail file descriptor.. we can't just leave it open in |
813 | * a structure, closing it later, because we might run out of descriptors |
814 | */ |
815 | if (mailFd >= 0) { |
816 | close(mailFd); |
817 | } |
818 | } |
819 | |
820 | static void RunJob(const char *user, CronLine *line) |
821 | { |
822 | char mailFile[128]; |
823 | int mailFd = -1; |
824 | |
825 | line->cl_Pid = 0; |
826 | line->cl_MailFlag = 0; |
827 | |
828 | if (line->cl_MailTo) { |
829 | /* open mail file - owner root so nobody can screw with it. */ |
830 | snprintf(mailFile, sizeof(mailFile), "%s/cron.%s.%d", TMPDIR, user, getpid()); |
831 | mailFd = open(mailFile, O_CREAT | O_TRUNC | O_WRONLY | O_EXCL | O_APPEND, 0600); |
832 | |
833 | if (mailFd >= 0) { |
834 | line->cl_MailFlag = 1; |
835 | fdprintf(mailFd, "To: %s\nSubject: cron: %s\n\n", line->cl_MailTo, |
836 | line->cl_Shell); |
837 | line->cl_MailPos = lseek(mailFd, 0, SEEK_CUR); |
838 | } else { |
839 | crondlog(ERR20 "cannot create mail file %s for user %s, " |
840 | "discarding output", mailFile, user); |
841 | } |
842 | } |
843 | |
844 | ForkJob(user, line, mailFd, DEFAULT_SHELL, "-c", line->cl_Shell, mailFile); |
845 | } |
846 | |
847 | /* |
848 | * EndJob - called when job terminates and when mail terminates |
849 | */ |
850 | static void EndJob(const char *user, CronLine *line) |
851 | { |
852 | int mailFd; |
853 | char mailFile[128]; |
854 | struct stat sbuf; |
855 | |
856 | /* No job */ |
857 | if (line->cl_Pid <= 0) { |
858 | line->cl_Pid = 0; |
859 | return; |
860 | } |
861 | |
862 | /* |
863 | * End of job and no mail file |
864 | * End of sendmail job |
865 | */ |
866 | snprintf(mailFile, sizeof(mailFile), "%s/cron.%s.%d", TMPDIR, user, line->cl_Pid); |
867 | line->cl_Pid = 0; |
868 | |
869 | if (line->cl_MailFlag == 0) { |
870 | return; |
871 | } |
872 | line->cl_MailFlag = 0; |
873 | |
874 | /* |
875 | * End of primary job - check for mail file. If size has increased and |
876 | * the file is still valid, we sendmail it. |
877 | */ |
878 | mailFd = open(mailFile, O_RDONLY); |
879 | unlink(mailFile); |
880 | if (mailFd < 0) { |
881 | return; |
882 | } |
883 | |
884 | if (fstat(mailFd, &sbuf) < 0 || sbuf.st_uid != DaemonUid |
885 | || sbuf.st_nlink != 0 || sbuf.st_size == line->cl_MailPos |
886 | || !S_ISREG(sbuf.st_mode) |
887 | ) { |
888 | close(mailFd); |
889 | return; |
890 | } |
891 | if (line->cl_MailTo) |
892 | ForkJob(user, line, mailFd, SENDMAIL, SENDMAIL_ARGS, NULL); |
893 | } |
894 | |
895 | #else /* crond without sendmail */ |
896 | |
897 | static void RunJob(const char *user, CronLine *line) |
898 | { |
899 | struct passwd *pas; |
900 | pid_t pid; |
901 | |
902 | /* prepare things before vfork */ |
903 | pas = getpwnam(user); |
904 | if (!pas) { |
905 | crondlog(LVL9 "can't get uid for %s", user); |
906 | goto err; |
907 | } |
908 | SetEnv(pas); |
909 | |
910 | /* fork as the user in question and run program */ |
911 | pid = vfork(); |
912 | if (pid == 0) { |
913 | /* CHILD */ |
914 | /* change running state to the user in question */ |
915 | ChangeUser(pas); |
916 | if (DebugOpt) { |
917 | crondlog(LVL5 "child running %s", DEFAULT_SHELL); |
918 | } |
919 | /* crond 3.0pl1-100 puts tasks in separate process groups */ |
920 | bb_setpgrp(); |
921 | execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", line->cl_Shell, NULL); |
922 | crondlog(ERR20 "can't exec, user %s cmd %s %s %s", user, |
923 | DEFAULT_SHELL, "-c", line->cl_Shell); |
924 | _exit(EXIT_SUCCESS); |
925 | } |
926 | if (pid < 0) { |
927 | /* FORK FAILED */ |
928 | crondlog(ERR20 "can't vfork"); |
929 | err: |
930 | pid = 0; |
931 | } |
932 | line->cl_Pid = pid; |
933 | } |
934 | |
935 | #endif /* ENABLE_FEATURE_CROND_CALL_SENDMAIL */ |