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