miscutils/crond.c

   1 /*
   2  * crond -d[#] -c <crondir> -f -b
   3  *
   4  * run as root, but NOT setuid root
   5  *
   6  * Copyright 1994 Matthew Dillon (dillon@apollo.west.oic.com)
   7  * May be distributed under the GNU General Public License
   8  *
   9  * Vladimir Oleynik <dzo@simtreas.ru> (C) 2002 to be used in busybox
  10  */
  11
  12 #define VERSION "2.3.2"
  13
  14 #undef FEATURE_DEBUG_OPT
  15
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <stdarg.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <time.h>
  23 #include <dirent.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <syslog.h>
  27 #include <signal.h>
  28 #include <getopt.h>
  29 #include <sys/ioctl.h>
  30 #include <sys/wait.h>
  31 #include <sys/stat.h>
  32 #include <sys/resource.h>
  33
  34 #include "busybox.h"
  35
  36 #define arysize(ary)    (sizeof(ary)/sizeof((ary)[0]))
  37
  38 #ifndef CRONTABS
  39 #define CRONTABS        "/var/spool/cron/crontabs"
  40 #endif
  41 #ifndef TMPDIR
  42 #define TMPDIR          "/var/spool/cron"
  43 #endif
  44 #ifndef SENDMAIL
  45 #define SENDMAIL        "/usr/sbin/sendmail"
  46 #endif
  47 #ifndef SENDMAIL_ARGS
  48 #define SENDMAIL_ARGS   "-ti", "oem"
  49 #endif
  50 #ifndef CRONUPDATE
  51 #define CRONUPDATE      "cron.update"
  52 #endif
  53 #ifndef MAXLINES
  54 #define MAXLINES        256             /* max lines in non-root crontabs */
  55 #endif
  56
  57 static const char def_sh[] = "/bin/sh";
  58
  59
  60 typedef struct CronFile {
  61     struct CronFile *cf_Next;
  62     struct CronLine *cf_LineBase;
  63     char        *cf_User;       /* username                     */
  64     int         cf_Ready;       /* bool: one or more jobs ready */
  65     int         cf_Running;     /* bool: one or more jobs running */
  66     int         cf_Deleted;     /* marked for deletion, ignore  */
  67 } CronFile;
  68
  69 typedef struct CronLine {
  70     struct CronLine *cl_Next;
  71     char        *cl_Shell;      /* shell command                        */
  72     pid_t       cl_Pid;         /* running pid, 0, or armed (-1)        */
  73     int         cl_MailFlag;    /* running pid is for mail              */
  74     int         cl_MailPos;     /* 'empty file' size                    */
  75     char        cl_Mins[60];    /* 0-59                                 */
  76     char        cl_Hrs[24];     /* 0-23                                 */
  77     char        cl_Days[32];    /* 1-31                                 */
  78     char        cl_Mons[12];    /* 0-11                                 */
  79     char        cl_Dow[7];      /* 0-6, beginning sunday                */
  80 } CronLine;
  81
  82 #define RUN_RANOUT      1
  83 #define RUN_RUNNING     2
  84 #define RUN_FAILED      3
  85
  86 #define DaemonUid 0
  87
  88 #ifdef FEATURE_DEBUG_OPT
  89 static short DebugOpt;
  90 #endif
  91
  92 static short LogLevel = 8;
  93 static const char  *LogFile;
  94 static const char  *CDir = CRONTABS;
  95
  96 static void startlogger(void);
  97
  98 static void CheckUpdates(void);
  99 static void SynchronizeDir(void);
 100 static int TestJobs(time_t t1, time_t t2);
 101 static void RunJobs(void);
 102 static int CheckJobs(void);
 103
 104 static void RunJob(const char *user, CronLine *line);
 105 #ifdef CONFIG_FEATURE_CROND_CALL_SENDMAIL
 106 static void EndJob(const char *user, CronLine *line);
 107 #else
 108 #define EndJob(user, line)  line->cl_Pid = 0
 109 #endif
 110
 111 static void DeleteFile(const char *userName);
 112
 113 static CronFile *FileBase;
 114
 115
 116 static void
 117 log(const char *ctl, ...)
 118 {
 119     va_list va;
 120     int level = (int)(ctl[0] & 0xf);
 121     int type = level == 20 ?
 122                     LOG_ERR : ((ctl[0] & 0100) ? LOG_WARNING : LOG_NOTICE);
 123
 124
 125     va_start(va, ctl);
 126     if (level >= LogLevel) {
 127
 128 #ifdef FEATURE_DEBUG_OPT
 129         if (DebugOpt) vfprintf(stderr, ctl, va);
 130         else
 131 #endif
 132             if (LogFile == 0) vsyslog(type, ctl, va);
 133             else {
 134                  int  logfd;
 135
 136                  if ((logfd = open(LogFile, O_WRONLY|O_CREAT|O_APPEND, 600)) >= 0) {
 137                     vdprintf(logfd, ctl, va);
 138                     close(logfd);
 139 #ifdef FEATURE_DEBUG_OPT
 140                  } else {
 141                     bb_perror_msg("Can't open log file");
 142 #endif
 143                 }
 144             }
 145     }
 146     va_end(va);
 147     if(ctl[0] & 0200)
 148         exit(20);
 149 }
 150
 151 int
 152 crond_main(int ac, char **av)
 153 {
 154     unsigned long opt;
 155     char *lopt, *Lopt, *copt;
 156 #ifdef FEATURE_DEBUG_OPT
 157     char *dopt;
 158     bb_opt_complementaly = "f-b:b-f:S-L:L-S:d-l";
 159 #else
 160     bb_opt_complementaly = "f-b:b-f:S-L:L-S";
 161 #endif
 162
 163     opterr = 0;         /* disable getopt 'errors' message.*/
 164     opt = bb_getopt_ulflags(ac, av, "l:L:fbSc:"
 165 #ifdef FEATURE_DEBUG_OPT
 166                                 "d:"
 167 #endif
 168             , &lopt, &Lopt, &copt
 169 #ifdef FEATURE_DEBUG_OPT
 170             , &dopt
 171 #endif
 172             );
 173     if(opt & 1)
 174         LogLevel = atoi(lopt);
 175     if(opt & 2)
 176         if (*Lopt != 0) LogFile = Lopt;
 177     if(opt & 32) {
 178         if (*copt != 0) CDir = copt;
 179         }
 180 #ifdef FEATURE_DEBUG_OPT
 181     if(opt & 64) {
 182         DebugOpt = atoi(dopt);
 183         LogLevel = 0;
 184     }
 185 #endif
 186
 187     /*
 188      * change directory
 189      */
 190
 191     if (chdir(CDir) != 0)
 192         bb_perror_msg_and_die("%s", CDir);
 193
 194     signal(SIGHUP,SIG_IGN);   /* hmm.. but, if kill -HUP original
 195                                  * version - his died. ;(
 196                                  */
 197     /*
 198      * close stdin and stdout, stderr.
 199      * close unused descriptors -  don't need.
 200      * optional detach from controlling terminal
 201      */
 202
 203     if (!(opt & 4)) {
 204         if(daemon(1, 0) < 0) {
 205                 bb_perror_msg_and_die("daemon");
 206 #if defined(__uClinux__)
 207         } else {
 208             /* reexec for vfork() do continue parent */
 209             vfork_daemon_rexec(ac, av, "-f");
 210         }
 211 #endif /* uClinux */
 212     }
 213
 214     (void)startlogger();                /* need if syslog mode selected */
 215
 216     /*
 217      * main loop - synchronize to 1 second after the minute, minimum sleep
 218      *             of 1 second.
 219      */
 220
 221     log("\011%s " VERSION " dillon, started, log level %d\n", bb_applet_name,
 222                                                 LogLevel);
 223
 224     SynchronizeDir();
 225
 226     {
 227         time_t t1 = time(NULL);
 228         time_t t2;
 229         long dt;
 230         short rescan = 60;
 231         short sleep_time = 60;
 232
 233         for (;;) {
 234             sleep((sleep_time + 1) - (short)(time(NULL) % sleep_time));
 235
 236             t2 = time(NULL);
 237             dt = t2 - t1;
 238
 239             /*
 240              * The file 'cron.update' is checked to determine new cron
 241              * jobs.  The directory is rescanned once an hour to deal
 242              * with any screwups.
 243              *
 244              * check for disparity.  Disparities over an hour either way
 245              * result in resynchronization.  A reverse-indexed disparity
 246              * less then an hour causes us to effectively sleep until we
 247              * match the original time (i.e. no re-execution of jobs that
 248              * have just been run).  A forward-indexed disparity less then
 249              * an hour causes intermediate jobs to be run, but only once
 250              * in the worst case.
 251              *
 252              * when running jobs, the inequality used is greater but not
 253              * equal to t1, and less then or equal to t2.
 254              */
 255
 256             if (--rescan == 0) {
 257                 rescan = 60;
 258                 SynchronizeDir();
 259             }
 260             CheckUpdates();
 261 #ifdef FEATURE_DEBUG_OPT
 262             if (DebugOpt)
 263                 log("\005Wakeup dt=%d\n", dt);
 264 #endif
 265             if (dt < -60*60 || dt > 60*60) {
 266                 t1 = t2;
 267                 log("\111time disparity of %d minutes detected\n", dt / 60);
 268             } else if (dt > 0) {
 269                 TestJobs(t1, t2);
 270                 RunJobs();
 271                 sleep(5);
 272                 if (CheckJobs() > 0)
 273                    sleep_time = 10;
 274                 else
 275                    sleep_time = 60;
 276                 t1 = t2;
 277             }
 278         }
 279     }
 280     /* not reached */
 281 }
 282
 283
 284 #if defined(FEATURE_DEBUG_OPT) || defined(CONFIG_FEATURE_CROND_CALL_SENDMAIL)
 285 /*
 286     write to temp file..
 287 */
 288 static void
 289 fdprintf(int fd, const char *ctl, ...)
 290 {
 291     va_list va;
 292
 293     va_start(va, ctl);
 294     vdprintf(fd, ctl, va);
 295     va_end(va);
 296 }
 297 #endif
 298
 299
 300 static int
 301 ChangeUser(const char *user)
 302 {
 303     struct passwd *pas;
 304
 305     /*
 306      * Obtain password entry and change privilages
 307      */
 308
 309     if ((pas = getpwnam(user)) == 0) {
 310         log("\011failed to get uid for %s", user);
 311         return(-1);
 312     }
 313     setenv("USER", pas->pw_name, 1);
 314     setenv("HOME", pas->pw_dir, 1);
 315     setenv("SHELL", def_sh, 1);
 316
 317     /*
 318      * Change running state to the user in question
 319      */
 320
 321     if (initgroups(user, pas->pw_gid) < 0) {
 322         log("\011initgroups failed: %s %m", user);
 323         return(-1);
 324     }
 325     /* drop all priviledges */
 326     if (setgid(pas->pw_gid) < 0) {
 327         log("\011setgid failed: %s %d", user, pas->pw_gid);
 328         return(-1);
 329     }
 330     if (setuid(pas->pw_uid) < 0) {
 331         log("\011setuid failed: %s %d", user, pas->pw_uid);
 332         return(-1);
 333     }
 334         if (chdir(pas->pw_dir) < 0) {
 335         log("\011chdir failed: %s: %m", pas->pw_dir);
 336             if (chdir(TMPDIR) < 0) {
 337             log("\011chdir failed: %s: %m", TMPDIR);
 338                 return(-1);
 339             }
 340         }
 341     return(pas->pw_uid);
 342 }
 343
 344 static void
 345 startlogger(void)
 346 {
 347     if (LogFile == 0)
 348         openlog(bb_applet_name, LOG_CONS|LOG_PID, LOG_CRON);
 349 #ifdef FEATURE_DEBUG_OPT
 350     else { /* test logfile */
 351     int  logfd;
 352
 353         if ((logfd = open(LogFile, O_WRONLY|O_CREAT|O_APPEND, 600)) >= 0)
 354            close(logfd);
 355         else
 356            bb_perror_msg("Failed to open log file '%s' reason", LogFile);
 357     }
 358 #endif
 359 }
 360
 361
 362 static const char * const DowAry[] = {
 363     "sun",
 364     "mon",
 365     "tue",
 366     "wed",
 367     "thu",
 368     "fri",
 369     "sat",
 370
 371     "Sun",
 372     "Mon",
 373     "Tue",
 374     "Wed",
 375     "Thu",
 376     "Fri",
 377     "Sat",
 378     NULL
 379 };
 380
 381 static const char * const MonAry[] = {
 382     "jan",
 383     "feb",
 384     "mar",
 385     "apr",
 386     "may",
 387     "jun",
 388     "jul",
 389     "aug",
 390     "sep",
 391     "oct",
 392     "nov",
 393     "dec",
 394
 395     "Jan",
 396     "Feb",
 397     "Mar",
 398     "Apr",
 399     "May",
 400     "Jun",
 401     "Jul",
 402     "Aug",
 403     "Sep",
 404     "Oct",
 405     "Nov",
 406     "Dec",
 407     NULL
 408 };
 409
 410 static char *
 411 ParseField(char *user, char *ary, int modvalue, int off,
 412                                 const char * const *names, char *ptr)
 413 {
 414     char *base = ptr;
 415     int n1 = -1;
 416     int n2 = -1;
 417
 418     if (base == NULL)
 419         return(NULL);
 420
 421     while (*ptr != ' ' && *ptr != '\t' && *ptr != '\n') {
 422         int skip = 0;
 423
 424         /*
 425          * Handle numeric digit or symbol or '*'
 426          */
 427
 428         if (*ptr == '*') {
 429             n1 = 0;                     /* everything will be filled */
 430             n2 = modvalue - 1;
 431             skip = 1;
 432             ++ptr;
 433         } else if (*ptr >= '0' && *ptr <= '9') {
 434             if (n1 < 0)
 435                 n1 = strtol(ptr, &ptr, 10) + off;
 436             else
 437                 n2 = strtol(ptr, &ptr, 10) + off;
 438             skip = 1;
 439         } else if (names) {
 440             int i;
 441
 442             for (i = 0; names[i]; ++i) {
 443                 if (strncmp(ptr, names[i], strlen(names[i])) == 0) {
 444                     break;
 445                 }
 446             }
 447             if (names[i]) {
 448                 ptr += strlen(names[i]);
 449                 if (n1 < 0)
 450                     n1 = i;
 451                 else
 452                     n2 = i;
 453                 skip = 1;
 454             }
 455         }
 456
 457         /*
 458          * handle optional range '-'
 459          */
 460
 461         if (skip == 0) {
 462             log("\111failed user %s parsing %s\n", user, base);
 463             return(NULL);
 464         }
 465         if (*ptr == '-' && n2 < 0) {
 466             ++ptr;
 467             continue;
 468         }
 469
 470         /*
 471          * collapse single-value ranges, handle skipmark, and fill
 472          * in the character array appropriately.
 473          */
 474
 475         if (n2 < 0)
 476             n2 = n1;
 477
 478         if (*ptr == '/')
 479             skip = strtol(ptr + 1, &ptr, 10);
 480
 481         /*
 482          * fill array, using a failsafe is the easiest way to prevent
 483          * an endless loop
 484          */
 485
 486         {
 487             int s0 = 1;
 488             int failsafe = 1024;
 489
 490             --n1;
 491             do {
 492                 n1 = (n1 + 1) % modvalue;
 493
 494                 if (--s0 == 0) {
 495                     ary[n1 % modvalue] = 1;
 496                     s0 = skip;
 497                 }
 498             } while (n1 != n2 && --failsafe);
 499
 500             if (failsafe == 0) {
 501                 log("\111failed user %s parsing %s\n", user, base);
 502                 return(NULL);
 503             }
 504         }
 505         if (*ptr != ',')
 506             break;
 507         ++ptr;
 508         n1 = -1;
 509         n2 = -1;
 510     }
 511
 512     if (*ptr != ' ' && *ptr != '\t' && *ptr != '\n') {
 513         log("\111failed user %s parsing %s\n", user, base);
 514         return(NULL);
 515     }
 516
 517     while (*ptr == ' ' || *ptr == '\t' || *ptr == '\n')
 518         ++ptr;
 519
 520 #ifdef FEATURE_DEBUG_OPT
 521     if (DebugOpt) {
 522         int i;
 523
 524         for (i = 0; i < modvalue; ++i)
 525             log("\005%d", ary[i]);
 526         log("\005\n");
 527     }
 528 #endif
 529
 530     return(ptr);
 531 }
 532
 533 static void
 534 FixDayDow(CronLine *line)
 535 {
 536     short i;
 537     short weekUsed = 0;
 538     short daysUsed = 0;
 539
 540     for (i = 0; i < arysize(line->cl_Dow); ++i) {
 541         if (line->cl_Dow[i] == 0) {
 542             weekUsed = 1;
 543             break;
 544         }
 545     }
 546     for (i = 0; i < arysize(line->cl_Days); ++i) {
 547         if (line->cl_Days[i] == 0) {
 548             daysUsed = 1;
 549             break;
 550         }
 551     }
 552     if (weekUsed && !daysUsed) {
 553         memset(line->cl_Days, 0, sizeof(line->cl_Days));
 554     }
 555     if (daysUsed && !weekUsed) {
 556         memset(line->cl_Dow, 0, sizeof(line->cl_Dow));
 557     }
 558 }
 559
 560
 561
 562 static void
 563 SynchronizeFile(const char *fileName)
 564 {
 565     int maxEntries = MAXLINES;
 566     int maxLines;
 567     char buf[1024];
 568
 569     if (strcmp(fileName, "root") == 0)
 570         maxEntries = 65535;
 571     maxLines = maxEntries * 10;
 572
 573     if (fileName) {
 574         FILE *fi;
 575
 576         DeleteFile(fileName);
 577
 578         if ((fi = fopen(fileName, "r")) != NULL) {
 579             struct stat sbuf;
 580
 581             if (fstat(fileno(fi), &sbuf) == 0 && sbuf.st_uid == DaemonUid) {
 582                 CronFile *file = calloc(1, sizeof(CronFile));
 583                 CronLine **pline;
 584
 585                 file->cf_User = strdup(fileName);
 586                 pline = &file->cf_LineBase;
 587
 588                 while (fgets(buf, sizeof(buf), fi) != NULL && --maxLines) {
 589                     CronLine line;
 590                     char *ptr;
 591
 592                     if (buf[0])
 593                         buf[strlen(buf)-1] = 0;
 594
 595                     if (buf[0] == 0 || buf[0] == '#' || buf[0] == ' ' || buf[0] == '\t')
 596                         continue;
 597
 598                     if (--maxEntries == 0)
 599                         break;
 600
 601                     memset(&line, 0, sizeof(line));
 602
 603 #ifdef FEATURE_DEBUG_OPT
 604                     if (DebugOpt)
 605                         log("\111User %s Entry %s\n", fileName, buf);
 606 #endif
 607
 608                     /*
 609                      * parse date ranges
 610                      */
 611
 612                     ptr = ParseField(file->cf_User, line.cl_Mins, 60, 0, NULL, buf);
 613                     ptr = ParseField(file->cf_User, line.cl_Hrs,  24, 0, NULL, ptr);
 614                     ptr = ParseField(file->cf_User, line.cl_Days, 32, 0, NULL, ptr);
 615                     ptr = ParseField(file->cf_User, line.cl_Mons, 12, -1, MonAry, ptr);
 616                     ptr = ParseField(file->cf_User, line.cl_Dow, 7, 0, DowAry, ptr);
 617
 618                     /*
 619                      * check failure
 620                      */
 621
 622                     if (ptr == NULL)
 623                         continue;
 624
 625                     /*
 626                      * fix days and dow - if one is not * and the other
 627                      * is *, the other is set to 0, and vise-versa
 628                      */
 629
 630                     FixDayDow(&line);
 631
 632                     *pline = calloc(1, sizeof(CronLine));
 633                     **pline = line;
 634
 635                     /*
 636                      * copy command
 637                      */
 638
 639                     (*pline)->cl_Shell = strdup(ptr);
 640
 641 #ifdef FEATURE_DEBUG_OPT
 642                     if (DebugOpt) {
 643                         log("\111    Command %s\n", ptr);
 644                     }
 645 #endif
 646
 647                     pline = &((*pline)->cl_Next);
 648                 }
 649                 *pline = NULL;
 650
 651                 file->cf_Next = FileBase;
 652                 FileBase = file;
 653
 654                 if (maxLines == 0 || maxEntries == 0)
 655                     log("\111Maximum number of lines reached for user %s\n", fileName);
 656             }
 657             fclose(fi);
 658         }
 659     }
 660 }
 661
 662 static void
 663 CheckUpdates(void)
 664 {
 665     FILE *fi;
 666     char buf[256];
 667
 668     if ((fi = fopen(CRONUPDATE, "r")) != NULL) {
 669         remove(CRONUPDATE);
 670         while (fgets(buf, sizeof(buf), fi) != NULL) {
 671             SynchronizeFile(strtok(buf, " \t\r\n"));
 672         }
 673         fclose(fi);
 674     }
 675 }
 676
 677 static void
 678 SynchronizeDir(void)
 679 {
 680     /*
 681      * Attempt to delete the database.
 682      */
 683
 684     for (;;) {
 685         CronFile *file;
 686
 687         for (file = FileBase; file && file->cf_Deleted; file = file->cf_Next)
 688             ;
 689         if (file == NULL)
 690             break;
 691         DeleteFile(file->cf_User);
 692     }
 693
 694     /*
 695      * Remove cron update file
 696      *
 697      * Re-chdir, in case directory was renamed & deleted, or otherwise
 698      * screwed up.
 699      *
 700      * scan directory and add associated users
 701      */
 702
 703     remove(CRONUPDATE);
 704     if (chdir(CDir) < 0) {
 705         log("\311unable to find %s\n", CDir);
 706     }
 707     {
 708         DIR *dir;
 709         struct dirent *den;
 710
 711         if ((dir = opendir("."))) {
 712             while ((den = readdir(dir))) {
 713                 if (strchr(den->d_name, '.') != NULL)
 714                     continue;
 715                 if (getpwnam(den->d_name))
 716                     SynchronizeFile(den->d_name);
 717                 else
 718                     log("\007ignoring %s\n", den->d_name);
 719             }
 720             closedir(dir);
 721         } else {
 722             log("\311Unable to open current dir!\n");
 723         }
 724     }
 725 }
 726
 727
 728 /*
 729  *  DeleteFile() - delete user database
 730  *
 731  *  Note: multiple entries for same user may exist if we were unable to
 732  *  completely delete a database due to running processes.
 733  */
 734
 735 static void
 736 DeleteFile(const char *userName)
 737 {
 738     CronFile **pfile = &FileBase;
 739     CronFile *file;
 740
 741     while ((file = *pfile) != NULL) {
 742         if (strcmp(userName, file->cf_User) == 0) {
 743             CronLine **pline = &file->cf_LineBase;
 744             CronLine *line;
 745
 746             file->cf_Running = 0;
 747             file->cf_Deleted = 1;
 748
 749             while ((line = *pline) != NULL) {
 750                 if (line->cl_Pid > 0) {
 751                     file->cf_Running = 1;
 752                     pline = &line->cl_Next;
 753                 } else {
 754                     *pline = line->cl_Next;
 755                     free(line->cl_Shell);
 756                     free(line);
 757                 }
 758             }
 759             if (file->cf_Running == 0) {
 760                 *pfile = file->cf_Next;
 761                 free(file->cf_User);
 762                 free(file);
 763             } else {
 764                 pfile = &file->cf_Next;
 765             }
 766         } else {
 767             pfile = &file->cf_Next;
 768         }
 769     }
 770 }
 771
 772 /*
 773  * TestJobs()
 774  *
 775  * determine which jobs need to be run.  Under normal conditions, the
 776  * period is about a minute (one scan).  Worst case it will be one
 777  * hour (60 scans).
 778  */
 779
 780 static int
 781 TestJobs(time_t t1, time_t t2)
 782 {
 783     short nJobs = 0;
 784     time_t t;
 785
 786     /*
 787      * Find jobs > t1 and <= t2
 788      */
 789
 790     for (t = t1 - t1 % 60; t <= t2; t += 60) {
 791         if (t > t1) {
 792             struct tm *tp = localtime(&t);
 793             CronFile *file;
 794             CronLine *line;
 795
 796             for (file = FileBase; file; file = file->cf_Next) {
 797 #ifdef FEATURE_DEBUG_OPT
 798                 if (DebugOpt)
 799                     log("\005FILE %s:\n", file->cf_User);
 800 #endif
 801                 if (file->cf_Deleted)
 802                     continue;
 803                 for (line = file->cf_LineBase; line; line = line->cl_Next) {
 804 #ifdef FEATURE_DEBUG_OPT
 805                     if (DebugOpt)
 806                         log("\005    LINE %s\n", line->cl_Shell);
 807 #endif
 808                     if (line->cl_Mins[tp->tm_min] &&
 809                         line->cl_Hrs[tp->tm_hour] &&
 810                         (line->cl_Days[tp->tm_mday] || line->cl_Dow[tp->tm_wday]) &&
 811                         line->cl_Mons[tp->tm_mon]
 812                     ) {
 813 #ifdef FEATURE_DEBUG_OPT
 814                         if (DebugOpt)
 815                             log("\005    JobToDo: %d %s\n", line->cl_Pid, line->cl_Shell);
 816 #endif
 817                         if (line->cl_Pid > 0) {
 818                             log("\010    process already running: %s %s\n",
 819                                 file->cf_User,
 820                                 line->cl_Shell
 821                             );
 822                         } else if (line->cl_Pid == 0) {
 823                             line->cl_Pid = -1;
 824                             file->cf_Ready = 1;
 825                             ++nJobs;
 826                         }
 827                     }
 828                 }
 829             }
 830         }
 831     }
 832     return(nJobs);
 833 }
 834
 835 static void
 836 RunJobs(void)
 837 {
 838     CronFile *file;
 839     CronLine *line;
 840
 841     for (file = FileBase; file; file = file->cf_Next) {
 842         if (file->cf_Ready) {
 843             file->cf_Ready = 0;
 844
 845             for (line = file->cf_LineBase; line; line = line->cl_Next) {
 846                 if (line->cl_Pid < 0) {
 847
 848                     RunJob(file->cf_User, line);
 849
 850                     log("\010USER %s pid %3d cmd %s\n",
 851                         file->cf_User,
 852                         line->cl_Pid,
 853                         line->cl_Shell
 854                     );
 855                     if (line->cl_Pid < 0)
 856                         file->cf_Ready = 1;
 857                     else if (line->cl_Pid > 0)
 858                         file->cf_Running = 1;
 859                 }
 860             }
 861         }
 862     }
 863 }
 864
 865 /*
 866  * CheckJobs() - check for job completion
 867  *
 868  * Check for job completion, return number of jobs still running after
 869  * all done.
 870  */
 871
 872 static int
 873 CheckJobs(void)
 874 {
 875     CronFile *file;
 876     CronLine *line;
 877     int nStillRunning = 0;
 878
 879     for (file = FileBase; file; file = file->cf_Next) {
 880         if (file->cf_Running) {
 881             file->cf_Running = 0;
 882
 883             for (line = file->cf_LineBase; line; line = line->cl_Next) {
 884                 if (line->cl_Pid > 0) {
 885                     int status;
 886                     int r = wait4(line->cl_Pid, &status, WNOHANG, NULL);
 887
 888                     if (r < 0 || r == line->cl_Pid) {
 889                         EndJob(file->cf_User, line);
 890                         if (line->cl_Pid)
 891                             file->cf_Running = 1;
 892                     } else if (r == 0) {
 893                         file->cf_Running = 1;
 894                     }
 895                 }
 896             }
 897         }
 898         nStillRunning += file->cf_Running;
 899     }
 900     return(nStillRunning);
 901 }
 902
 903
 904 #ifdef CONFIG_FEATURE_CROND_CALL_SENDMAIL
 905 static void
 906 ForkJob(const char *user, CronLine *line, int mailFd,
 907         const char *prog, const char *cmd, const char *arg, const char *mailf)
 908 {
 909     /*
 910      * Fork as the user in question and run program
 911      */
 912     pid_t pid = fork();
 913
 914     line->cl_Pid = pid;
 915     if (pid == 0) {
 916         /*
 917          * CHILD
 918          */
 919
 920         /*
 921          * Change running state to the user in question
 922          */
 923
 924         if (ChangeUser(user) < 0)
 925             exit(0);
 926
 927 #ifdef FEATURE_DEBUG_OPT
 928         if (DebugOpt)
 929             log("\005Child Running %s\n", prog);
 930 #endif
 931
 932         if (mailFd >= 0) {
 933             dup2(mailFd, mailf != NULL);
 934             dup2((mailf ? mailFd : 1), 2);
 935             close(mailFd);
 936         }
 937         execl(prog, prog, cmd, arg, NULL);
 938         log("\024unable to exec, user %s cmd %s %s %s\n", user,
 939             prog, cmd, arg);
 940         if(mailf)
 941             fdprintf(1, "Exec failed: %s -c %s\n", prog, arg);
 942         exit(0);
 943     } else if (pid < 0) {
 944         /*
 945          * FORK FAILED
 946          */
 947         log("\024couldn't fork, user %s\n", user);
 948         line->cl_Pid = 0;
 949         if(mailf)
 950             remove(mailf);
 951     } else if(mailf) {
 952         /*
 953          * PARENT, FORK SUCCESS
 954          *
 955          * rename mail-file based on pid of process
 956          */
 957         char mailFile2[128];
 958
 959         snprintf(mailFile2, sizeof(mailFile2), TMPDIR "/cron.%s.%d",
 960                                     user, pid);
 961         rename(mailf, mailFile2);
 962     }
 963     /*
 964      * Close the mail file descriptor.. we can't just leave it open in
 965      * a structure, closing it later, because we might run out of descriptors
 966      */
 967
 968     if (mailFd >= 0)
 969         close(mailFd);
 970 }
 971
 972 static void
 973 RunJob(const char *user, CronLine *line)
 974 {
 975     char mailFile[128];
 976     int mailFd;
 977
 978     line->cl_Pid = 0;
 979     line->cl_MailFlag = 0;
 980
 981     /*
 982      * open mail file - owner root so nobody can screw with it.
 983      */
 984
 985     snprintf(mailFile, sizeof(mailFile), TMPDIR "/cron.%s.%d",
 986              user, getpid());
 987     mailFd = open(mailFile, O_CREAT|O_TRUNC|O_WRONLY|O_EXCL|O_APPEND, 0600);
 988
 989     if (mailFd >= 0) {
 990         line->cl_MailFlag = 1;
 991         fdprintf(mailFd, "To: %s\nSubject: cron: %s\n\n", user,
 992                                                     line->cl_Shell);
 993         line->cl_MailPos = lseek(mailFd, 0, 1);
 994     } else {
 995             log("\024unable to create mail file user %s file %s, output to /dev/null\n",
 996                         user, mailFile);
 997     }
 998
 999     ForkJob(user, line, mailFd, def_sh, "-c", line->cl_Shell, mailFile);
1000 }
1001
1002 /*
1003  * EndJob - called when job terminates and when mail terminates
1004  */
1005
1006 static void
1007 EndJob(const char *user, CronLine *line)
1008 {
1009     int mailFd;
1010     char mailFile[128];
1011     struct stat sbuf;
1012
1013     /*
1014      * No job
1015      */
1016
1017     if (line->cl_Pid <= 0) {
1018         line->cl_Pid = 0;
1019         return;
1020     }
1021
1022     /*
1023      * End of job and no mail file
1024      * End of sendmail job
1025      */
1026
1027     snprintf(mailFile, sizeof(mailFile), TMPDIR "/cron.%s.%d",
1028              user, line->cl_Pid);
1029     line->cl_Pid = 0;
1030
1031     if (line->cl_MailFlag != 1)
1032         return;
1033
1034     line->cl_MailFlag = 0;
1035
1036     /*
1037      * End of primary job - check for mail file.  If size has increased and
1038      * the file is still valid, we sendmail it.
1039      */
1040
1041     mailFd = open(mailFile, O_RDONLY);
1042     remove(mailFile);
1043     if (mailFd < 0) {
1044         return;
1045     }
1046
1047     if (fstat(mailFd, &sbuf) < 0 ||
1048         sbuf.st_uid != DaemonUid ||
1049         sbuf.st_nlink != 0 ||
1050         sbuf.st_size == line->cl_MailPos ||
1051         !S_ISREG(sbuf.st_mode)
1052     ) {
1053         close(mailFd);
1054         return;
1055     }
1056     ForkJob(user, line, mailFd, SENDMAIL, SENDMAIL_ARGS, NULL);
1057 }
1058 #else
1059 /* crond whithout sendmail */
1060
1061 static void
1062 RunJob(const char *user, CronLine *line)
1063 {
1064         /*
1065      * Fork as the user in question and run program
1066          */
1067     pid_t pid = fork();
1068
1069     if (pid == 0) {
1070         /*
1071          * CHILD
1072          */
1073
1074         /*
1075          * Change running state to the user in question
1076          */
1077
1078         if (ChangeUser(user) < 0)
1079             exit(0);
1080
1081 #ifdef FEATURE_DEBUG_OPT
1082         if (DebugOpt)
1083             log("\005Child Running %s\n", def_sh);
1084 #endif
1085
1086         execl(def_sh, def_sh, "-c", line->cl_Shell, NULL);
1087         log("\024unable to exec, user %s cmd %s -c %s\n", user,
1088             def_sh, line->cl_Shell);
1089         exit(0);
1090     } else if (pid < 0) {
1091         /*
1092          * FORK FAILED
1093          */
1094         log("\024couldn't fork, user %s\n", user);
1095         pid = 0;
1096     }
1097     line->cl_Pid = pid;
1098 }
1099 #endif /* CONFIG_FEATURE_CROND_CALL_SENDMAIL */