usr.sbin/cron/crontab/crontab.c

   1 /* Copyright 1988,1990,1993,1994 by Paul Vixie
   2  * All rights reserved
   3  *
   4  * Distribute freely, except: don't remove my name from the source or
   5  * documentation (don't take credit for my work), mark your changes (don't
   6  * get me blamed for your possible bugs), don't alter or remove this
   7  * notice.  May be sold if buildable source is provided to buyer.  No
   8  * warrantee of any kind, express or implied, is included with this
   9  * software; use at your own risk, responsibility for damages (if any) to
  10  * anyone resulting from the use of this software rests entirely with the
  11  * user.
  12  *
  13  * Send bug reports, bug fixes, enhancements, requests, flames, etc., and
  14  * I'll try to keep a version up to date.  I can be reached as follows:
  15  * Paul Vixie          <paul@vix.com>          uunet!decwrl!vixie!paul
  16  *
  17  * From Id: crontab.c,v 2.13 1994/01/17 03:20:37 vixie Exp
  18  * $FreeBSD: src/usr.sbin/cron/crontab/crontab.c,v 1.12.2.4 2001/06/16 03:18:37 peter Exp $
  19  * $DragonFly: src/usr.sbin/cron/crontab/crontab.c,v 1.3 2003/11/03 19:31:36 eirikn Exp $
  20  */
  21
  22 /* crontab - install and manage per-user crontab files
  23  * vix 02may87 [RCS has the rest of the log]
  24  * vix 26jan87 [original]
  25  */
  26
  27 static char version[] = "$DragonFly: src/usr.sbin/cron/crontab/crontab.c,v 1.3 2003/11/03 19:31:36 eirikn Exp $";
  28
  29 #define MAIN_PROGRAM
  30
  31 #include "cron.h"
  32 #include <errno.h>
  33 #include <fcntl.h>
  34 #include <paths.h>
  35 #include <sys/file.h>
  36 #include <sys/stat.h>
  37 #ifdef USE_UTIMES
  38 # include <sys/time.h>
  39 #else
  40 # include <time.h>
  41 # include <utime.h>
  42 #endif
  43 #if defined(POSIX)
  44 # include <locale.h>
  45 #endif
  46
  47
  48 #define NHEADER_LINES 3
  49
  50
  51 enum opt_t      { opt_unknown, opt_list, opt_delete, opt_edit, opt_replace };
  52
  53 #if DEBUGGING
  54 static char     *Options[] = { "???", "list", "delete", "edit", "replace" };
  55 #endif
  56
  57
  58 static  PID_T           Pid;
  59 static  char            User[MAX_UNAME], RealUser[MAX_UNAME];
  60 static  char            Filename[MAX_FNAME];
  61 static  FILE            *NewCrontab;
  62 static  int             CheckErrorCount;
  63 static  enum opt_t      Option;
  64 static  struct passwd   *pw;
  65 static  void            list_cmd(void),
  66                         delete_cmd(void),
  67                         edit_cmd(void),
  68                         poke_daemon(void),
  69                         check_error(char *),
  70                         parse_args(int c, char *v[]);
  71 static  int             replace_cmd(void);
  72
  73
  74 static void
  75 usage(msg)
  76         char *msg;
  77 {
  78         fprintf(stderr, "crontab: usage error: %s\n", msg);
  79         fprintf(stderr, "%s\n%s\n",
  80                 "usage: crontab [-u user] file",
  81                 "       crontab [-u user] { -e | -l | -r }");
  82         exit(ERROR_EXIT);
  83 }
  84
  85
  86 int
  87 main(argc, argv)
  88         int     argc;
  89         char    *argv[];
  90 {
  91         int     exitstatus;
  92
  93         Pid = getpid();
  94         ProgramName = argv[0];
  95
  96 #if defined(POSIX)
  97         setlocale(LC_ALL, "");
  98 #endif
  99
 100 #if defined(BSD)
 101         setlinebuf(stderr);
 102 #endif
 103         parse_args(argc, argv);         /* sets many globals, opens a file */
 104         set_cron_uid();
 105         set_cron_cwd();
 106         if (!allowed(User)) {
 107                 warnx("you (%s) are not allowed to use this program", User);
 108                 log_it(RealUser, Pid, "AUTH", "crontab command not allowed");
 109                 exit(ERROR_EXIT);
 110         }
 111         exitstatus = OK_EXIT;
 112         switch (Option) {
 113         case opt_list:          list_cmd();
 114                                 break;
 115         case opt_delete:        delete_cmd();
 116                                 break;
 117         case opt_edit:          edit_cmd();
 118                                 break;
 119         case opt_replace:       if (replace_cmd() < 0)
 120                                         exitstatus = ERROR_EXIT;
 121                                 break;
 122         case opt_unknown:
 123                                 break;
 124         }
 125         exit(0);
 126         /*NOTREACHED*/
 127 }
 128
 129
 130 static void
 131 parse_args(argc, argv)
 132         int     argc;
 133         char    *argv[];
 134 {
 135         int             argch;
 136
 137         if (!(pw = getpwuid(getuid())))
 138                 errx(ERROR_EXIT, "your UID isn't in the passwd file, bailing out");
 139         (void) strncpy(User, pw->pw_name, (sizeof User)-1);
 140         User[(sizeof User)-1] = '\0';
 141         strcpy(RealUser, User);
 142         Filename[0] = '\0';
 143         Option = opt_unknown;
 144         while ((argch = getopt(argc, argv, "u:lerx:")) != -1) {
 145                 switch (argch) {
 146                 case 'x':
 147                         if (!set_debug_flags(optarg))
 148                                 usage("bad debug option");
 149                         break;
 150                 case 'u':
 151                         if (getuid() != ROOT_UID)
 152                                 errx(ERROR_EXIT, "must be privileged to use -u");
 153                         if (!(pw = getpwnam(optarg)))
 154                                 errx(ERROR_EXIT, "user `%s' unknown", optarg);
 155                         (void) strncpy(User, pw->pw_name, (sizeof User)-1);
 156                         User[(sizeof User)-1] = '\0';
 157                         break;
 158                 case 'l':
 159                         if (Option != opt_unknown)
 160                                 usage("only one operation permitted");
 161                         Option = opt_list;
 162                         break;
 163                 case 'r':
 164                         if (Option != opt_unknown)
 165                                 usage("only one operation permitted");
 166                         Option = opt_delete;
 167                         break;
 168                 case 'e':
 169                         if (Option != opt_unknown)
 170                                 usage("only one operation permitted");
 171                         Option = opt_edit;
 172                         break;
 173                 default:
 174                         usage("unrecognized option");
 175                 }
 176         }
 177
 178         endpwent();
 179
 180         if (Option != opt_unknown) {
 181                 if (argv[optind] != NULL) {
 182                         usage("no arguments permitted after this option");
 183                 }
 184         } else {
 185                 if (argv[optind] != NULL) {
 186                         Option = opt_replace;
 187                         (void) strncpy (Filename, argv[optind], (sizeof Filename)-1);
 188                         Filename[(sizeof Filename)-1] = '\0';
 189
 190                 } else {
 191                         usage("file name must be specified for replace");
 192                 }
 193         }
 194
 195         if (Option == opt_replace) {
 196                 /* we have to open the file here because we're going to
 197                  * chdir(2) into /var/cron before we get around to
 198                  * reading the file.
 199                  */
 200                 if (!strcmp(Filename, "-")) {
 201                         NewCrontab = stdin;
 202                 } else {
 203                         /* relinquish the setuid status of the binary during
 204                          * the open, lest nonroot users read files they should
 205                          * not be able to read.  we can't use access() here
 206                          * since there's a race condition.  thanks go out to
 207                          * Arnt Gulbrandsen <agulbra@pvv.unit.no> for spotting
 208                          * the race.
 209                          */
 210
 211                         if (swap_uids() < OK)
 212                                 err(ERROR_EXIT, "swapping uids");
 213                         if (!(NewCrontab = fopen(Filename, "r")))
 214                                 err(ERROR_EXIT, "%s", Filename);
 215                         if (swap_uids() < OK)
 216                                 err(ERROR_EXIT, "swapping uids back");
 217                 }
 218         }
 219
 220         Debug(DMISC, ("user=%s, file=%s, option=%s\n",
 221                       User, Filename, Options[(int)Option]))
 222 }
 223
 224
 225 static void
 226 list_cmd() {
 227         char    n[MAX_FNAME];
 228         FILE    *f;
 229         int     ch, x;
 230
 231         log_it(RealUser, Pid, "LIST", User);
 232         (void) sprintf(n, CRON_TAB(User));
 233         if (!(f = fopen(n, "r"))) {
 234                 if (errno == ENOENT)
 235                         errx(ERROR_EXIT, "no crontab for %s", User);
 236                 else
 237                         err(ERROR_EXIT, "%s", n);
 238         }
 239
 240         /* file is open. copy to stdout, close.
 241          */
 242         Set_LineNum(1)
 243
 244         /* ignore the top few comments since we probably put them there.
 245          */
 246         for (x = 0;  x < NHEADER_LINES;  x++) {
 247                 ch = get_char(f);
 248                 if (EOF == ch)
 249                         break;
 250                 if ('#' != ch) {
 251                         putchar(ch);
 252                         break;
 253                 }
 254                 while (EOF != (ch = get_char(f)))
 255                         if (ch == '\n')
 256                                 break;
 257                 if (EOF == ch)
 258                         break;
 259         }
 260
 261         while (EOF != (ch = get_char(f)))
 262                 putchar(ch);
 263         fclose(f);
 264 }
 265
 266
 267 static void
 268 delete_cmd() {
 269         char    n[MAX_FNAME];
 270         int ch, first;
 271
 272         if (isatty(STDIN_FILENO)) {
 273                 (void)fprintf(stderr, "remove crontab for %s? ", User);
 274                 first = ch = getchar();
 275                 while (ch != '\n' && ch != EOF)
 276                         ch = getchar();
 277                 if (first != 'y' && first != 'Y')
 278                         return;
 279         }
 280
 281         log_it(RealUser, Pid, "DELETE", User);
 282         (void) sprintf(n, CRON_TAB(User));
 283         if (unlink(n)) {
 284                 if (errno == ENOENT)
 285                         errx(ERROR_EXIT, "no crontab for %s", User);
 286                 else
 287                         err(ERROR_EXIT, "%s", n);
 288         }
 289         poke_daemon();
 290 }
 291
 292
 293 static void
 294 check_error(msg)
 295         char    *msg;
 296 {
 297         CheckErrorCount++;
 298         fprintf(stderr, "\"%s\":%d: %s\n", Filename, LineNumber-1, msg);
 299 }
 300
 301
 302 static void
 303 edit_cmd() {
 304         char            n[MAX_FNAME], q[MAX_TEMPSTR], *editor;
 305         FILE            *f;
 306         int             ch, t, x;
 307         struct stat     statbuf, fsbuf;
 308         time_t          mtime;
 309         WAIT_T          waiter;
 310         PID_T           pid, xpid;
 311         mode_t          um;
 312
 313         log_it(RealUser, Pid, "BEGIN EDIT", User);
 314         (void) sprintf(n, CRON_TAB(User));
 315         if (!(f = fopen(n, "r"))) {
 316                 if (errno != ENOENT)
 317                         err(ERROR_EXIT, "%s", n);
 318                 warnx("no crontab for %s - using an empty one", User);
 319                 if (!(f = fopen(_PATH_DEVNULL, "r")))
 320                         err(ERROR_EXIT, _PATH_DEVNULL);
 321         }
 322
 323         um = umask(077);
 324         (void) sprintf(Filename, "/tmp/crontab.XXXXXXXXXX");
 325         if ((t = mkstemp(Filename)) == -1) {
 326                 warn("%s", Filename);
 327                 (void) umask(um);
 328                 goto fatal;
 329         }
 330         (void) umask(um);
 331 #ifdef HAS_FCHOWN
 332         if (fchown(t, getuid(), getgid()) < 0) {
 333 #else
 334         if (chown(Filename, getuid(), getgid()) < 0) {
 335 #endif
 336                 warn("fchown");
 337                 goto fatal;
 338         }
 339         if (!(NewCrontab = fdopen(t, "r+"))) {
 340                 warn("fdopen");
 341                 goto fatal;
 342         }
 343
 344         Set_LineNum(1)
 345
 346         /* ignore the top few comments since we probably put them there.
 347          */
 348         for (x = 0;  x < NHEADER_LINES;  x++) {
 349                 ch = get_char(f);
 350                 if (EOF == ch)
 351                         break;
 352                 if ('#' != ch) {
 353                         putc(ch, NewCrontab);
 354                         break;
 355                 }
 356                 while (EOF != (ch = get_char(f)))
 357                         if (ch == '\n')
 358                                 break;
 359                 if (EOF == ch)
 360                         break;
 361         }
 362
 363         /* copy the rest of the crontab (if any) to the temp file.
 364          */
 365         if (EOF != ch)
 366                 while (EOF != (ch = get_char(f)))
 367                         putc(ch, NewCrontab);
 368         fclose(f);
 369         if (fflush(NewCrontab))
 370                 err(ERROR_EXIT, "%s", Filename);
 371         if (fstat(t, &fsbuf) < 0) {
 372                 warn("unable to fstat temp file");
 373                 goto fatal;
 374         }
 375  again:
 376         if (stat(Filename, &statbuf) < 0) {
 377                 warn("stat");
 378  fatal:         unlink(Filename);
 379                 exit(ERROR_EXIT);
 380         }
 381         if (statbuf.st_dev != fsbuf.st_dev || statbuf.st_ino != fsbuf.st_ino)
 382                 errx(ERROR_EXIT, "temp file must be edited in place");
 383         mtime = statbuf.st_mtime;
 384
 385         if ((!(editor = getenv("VISUAL")))
 386          && (!(editor = getenv("EDITOR")))
 387             ) {
 388                 editor = EDITOR;
 389         }
 390
 391         /* we still have the file open.  editors will generally rewrite the
 392          * original file rather than renaming/unlinking it and starting a
 393          * new one; even backup files are supposed to be made by copying
 394          * rather than by renaming.  if some editor does not support this,
 395          * then don't use it.  the security problems are more severe if we
 396          * close and reopen the file around the edit.
 397          */
 398
 399         switch (pid = fork()) {
 400         case -1:
 401                 warn("fork");
 402                 goto fatal;
 403         case 0:
 404                 /* child */
 405                 if (setuid(getuid()) < 0)
 406                         err(ERROR_EXIT, "setuid(getuid())");
 407                 if (chdir("/tmp") < 0)
 408                         err(ERROR_EXIT, "chdir(/tmp)");
 409                 if (strlen(editor) + strlen(Filename) + 2 >= MAX_TEMPSTR)
 410                         errx(ERROR_EXIT, "editor or filename too long");
 411                 execlp(editor, editor, Filename, NULL);
 412                 err(ERROR_EXIT, "%s", editor);
 413                 /*NOTREACHED*/
 414         default:
 415                 /* parent */
 416                 break;
 417         }
 418
 419         /* parent */
 420         {
 421         void (*f[4])();
 422         f[0] = signal(SIGHUP, SIG_IGN);
 423         f[1] = signal(SIGINT, SIG_IGN);
 424         f[2] = signal(SIGTERM, SIG_IGN);
 425         xpid = wait(&waiter);
 426         signal(SIGHUP, f[0]);
 427         signal(SIGINT, f[1]);
 428         signal(SIGTERM, f[2]);
 429         }
 430         if (xpid != pid) {
 431                 warnx("wrong PID (%d != %d) from \"%s\"", xpid, pid, editor);
 432                 goto fatal;
 433         }
 434         if (WIFEXITED(waiter) && WEXITSTATUS(waiter)) {
 435                 warnx("\"%s\" exited with status %d", editor, WEXITSTATUS(waiter));
 436                 goto fatal;
 437         }
 438         if (WIFSIGNALED(waiter)) {
 439                 warnx("\"%s\" killed; signal %d (%score dumped)",
 440                         editor, WTERMSIG(waiter), WCOREDUMP(waiter) ?"" :"no ");
 441                 goto fatal;
 442         }
 443         if (stat(Filename, &statbuf) < 0) {
 444                 warn("stat");
 445                 goto fatal;
 446         }
 447         if (statbuf.st_dev != fsbuf.st_dev || statbuf.st_ino != fsbuf.st_ino)
 448                 errx(ERROR_EXIT, "temp file must be edited in place");
 449         if (mtime == statbuf.st_mtime) {
 450                 warnx("no changes made to crontab");
 451                 goto remove;
 452         }
 453         warnx("installing new crontab");
 454         switch (replace_cmd()) {
 455         case 0:
 456                 break;
 457         case -1:
 458                 for (;;) {
 459                         printf("Do you want to retry the same edit? ");
 460                         fflush(stdout);
 461                         q[0] = '\0';
 462                         (void) fgets(q, sizeof q, stdin);
 463                         switch (islower(q[0]) ? q[0] : tolower(q[0])) {
 464                         case 'y':
 465                                 goto again;
 466                         case 'n':
 467                                 goto abandon;
 468                         default:
 469                                 fprintf(stderr, "Enter Y or N\n");
 470                         }
 471                 }
 472                 /*NOTREACHED*/
 473         case -2:
 474         abandon:
 475                 warnx("edits left in %s", Filename);
 476                 goto done;
 477         default:
 478                 warnx("panic: bad switch() in replace_cmd()");
 479                 goto fatal;
 480         }
 481  remove:
 482         unlink(Filename);
 483  done:
 484         log_it(RealUser, Pid, "END EDIT", User);
 485 }
 486
 487
 488 /* returns      0       on success
 489  *              -1      on syntax error
 490  *              -2      on install error
 491  */
 492 static int
 493 replace_cmd() {
 494         char    n[MAX_FNAME], envstr[MAX_ENVSTR], tn[MAX_FNAME];
 495         FILE    *tmp;
 496         int     ch, eof;
 497         entry   *e;
 498         time_t  now = time(NULL);
 499         char    **envp = env_init();
 500
 501         if (envp == NULL) {
 502                 warnx("cannot allocate memory");
 503                 return (-2);
 504         }
 505
 506         (void) sprintf(n, "tmp.%d", Pid);
 507         (void) sprintf(tn, CRON_TAB(n));
 508         if (!(tmp = fopen(tn, "w+"))) {
 509                 warn("%s", tn);
 510                 return (-2);
 511         }
 512
 513         /* write a signature at the top of the file.
 514          *
 515          * VERY IMPORTANT: make sure NHEADER_LINES agrees with this code.
 516          */
 517         fprintf(tmp, "# DO NOT EDIT THIS FILE - edit the master and reinstall.\n");
 518         fprintf(tmp, "# (%s installed on %-24.24s)\n", Filename, ctime(&now));
 519         fprintf(tmp, "# (Cron version -- %s)\n", version);
 520
 521         /* copy the crontab to the tmp
 522          */
 523         rewind(NewCrontab);
 524         Set_LineNum(1)
 525         while (EOF != (ch = get_char(NewCrontab)))
 526                 putc(ch, tmp);
 527         ftruncate(fileno(tmp), ftell(tmp));
 528         fflush(tmp);  rewind(tmp);
 529
 530         if (ferror(tmp)) {
 531                 warnx("error while writing new crontab to %s", tn);
 532                 fclose(tmp);  unlink(tn);
 533                 return (-2);
 534         }
 535
 536         /* check the syntax of the file being installed.
 537          */
 538
 539         /* BUG: was reporting errors after the EOF if there were any errors
 540          * in the file proper -- kludged it by stopping after first error.
 541          *              vix 31mar87
 542          */
 543         Set_LineNum(1 - NHEADER_LINES)
 544         CheckErrorCount = 0;  eof = FALSE;
 545         while (!CheckErrorCount && !eof) {
 546                 switch (load_env(envstr, tmp)) {
 547                 case ERR:
 548                         eof = TRUE;
 549                         break;
 550                 case FALSE:
 551                         e = load_entry(tmp, check_error, pw, envp);
 552                         if (e)
 553                                 free(e);
 554                         break;
 555                 case TRUE:
 556                         break;
 557                 }
 558         }
 559
 560         if (CheckErrorCount != 0) {
 561                 warnx("errors in crontab file, can't install");
 562                 fclose(tmp);  unlink(tn);
 563                 return (-1);
 564         }
 565
 566 #ifdef HAS_FCHOWN
 567         if (fchown(fileno(tmp), ROOT_UID, -1) < OK)
 568 #else
 569         if (chown(tn, ROOT_UID, -1) < OK)
 570 #endif
 571         {
 572                 warn("chown");
 573                 fclose(tmp);  unlink(tn);
 574                 return (-2);
 575         }
 576
 577 #ifdef HAS_FCHMOD
 578         if (fchmod(fileno(tmp), 0600) < OK)
 579 #else
 580         if (chmod(tn, 0600) < OK)
 581 #endif
 582         {
 583                 warn("chown");
 584                 fclose(tmp);  unlink(tn);
 585                 return (-2);
 586         }
 587
 588         if (fclose(tmp) == EOF) {
 589                 warn("fclose");
 590                 unlink(tn);
 591                 return (-2);
 592         }
 593
 594         (void) sprintf(n, CRON_TAB(User));
 595         if (rename(tn, n)) {
 596                 warn("error renaming %s to %s", tn, n);
 597                 unlink(tn);
 598                 return (-2);
 599         }
 600         log_it(RealUser, Pid, "REPLACE", User);
 601
 602         poke_daemon();
 603
 604         return (0);
 605 }
 606
 607
 608 static void
 609 poke_daemon() {
 610 #ifdef USE_UTIMES
 611         struct timeval tvs[2];
 612         struct timezone tz;
 613
 614         (void) gettimeofday(&tvs[0], &tz);
 615         tvs[1] = tvs[0];
 616         if (utimes(SPOOL_DIR, tvs) < OK) {
 617                 warn("can't update mtime on spooldir %s", SPOOL_DIR);
 618                 return;
 619         }
 620 #else
 621         if (utime(SPOOL_DIR, NULL) < OK) {
 622                 warn("can't update mtime on spooldir %s", SPOOL_DIR);
 623                 return;
 624         }
 625 #endif /*USE_UTIMES*/
 626 }