crontab.c

Go to the documentation of this file.

/*      crontab 1.2 - user crontab manipulation         Author: Kees J. Bot
 *                                                              12 Jan 1997
 */
#define nil ((void*)0)
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <pwd.h>
#include <sys/stat.h>
#include "misc.h"
#include "tab.h"

#if __minix && !__minix_vmd
#define seteuid(uid)    ((uid),0)       /* Minix can't fiddle with uids. */
#endif

static int opentab(int uid, char *file, int how)
/* Open a crontab file under the given uid.  How is 'r' or 'w'.  Return
 * the result of open(2).
 */
{
        uid_t safe_uid;
        int flags, r, err;

        switch (how) {
        case 'r':       flags= O_RDONLY;                        break;
        case 'w':       flags= O_WRONLY | O_CREAT | O_TRUNC;    break;
        default:        errno= EINVAL;                          return -1;
        }

#if __minix && !__minix_vmd
        /* Standard Minix has no saved uid, so use the lousy old access(). */
        if (uid != 0) {
                if (access(file, how == 'r' ? R_OK : W_OK) < 0) return -1;
        }
#endif

        safe_uid= geteuid();
        seteuid(uid);
        r= open(file, flags, 0666);
        err= errno;
        seteuid(safe_uid);
        errno= err;
        return r;
}

static void copytab(int fd_in, char *file_in, int fd_out, char *file_out)
/* Copy one open file to another.  Complain and exit on errors. */
{
        ssize_t r, w;
        char buf[1024];

        while ((r= read(fd_in, buf, sizeof(buf))) > 0) {
                w= 0;
                while (w < r) {
                        if ((r= write(fd_out, buf+w, r-w)) <= 0) {
                                fprintf(stderr,
                                "%s: Write error on %s: %s\n",
                                        prog_name,
                                        file_out,
                                        r == 0 ? "End of file"
                                                        : strerror(errno));
                                exit(1);
                        }
                        w+= r;
                }
        }
        if (r < 0) {
                fprintf(stderr, "%s: Read error on %s: %s\n",
                        prog_name, file_in, strerror(errno));
                exit(1);
        }
}

static void usage(void)
{
        fprintf(stderr,
                "Usage: %s -c [user] file  # Change crontab\n"
                "       %s -l [user]       # List crontab\n"
                "       %s -r [user]       # Remove crontab\n"
                "       %s -p              # Tell cron to reload\n",
                prog_name, prog_name, prog_name, prog_name);
        exit(1);
}

int main(int argc, char **argv)
{
        int i;
        int cflag, lflag, rflag, pflag;
        uid_t uid;
        char *user, *file;
        struct passwd *pw;
        static char SPOOLDIR[]= "/usr/spool/crontabs";
        char tabfile[sizeof(SPOOLDIR) + NAME_MAX];

        prog_name= strrchr(argv[0], '/');
        if (prog_name == nil) prog_name= argv[0]; else prog_name++;

        cflag= lflag= rflag= pflag= 0;
        i= 1;
        while (i < argc && argv[i][0] == '-') {
                char *opt= argv[i++] + 1;

                if (opt[0] == '-' && opt[1] == 0) break;        /* -- */

                while (*opt != 0) switch (*opt++) {
                case 'c':       cflag= 1;       break;
                case 'l':       lflag= 1;       break;
                case 'r':       rflag= 1;       break;
                case 'p':       pflag= 1;       break;
                default:        usage();
                }
        }
        if (cflag + lflag + rflag + pflag != 1) usage();

        user= file= nil;
        if (!pflag && i < argc) user= argv[i++];
        if (cflag) {
                if (user == nil) usage();
                if (i < argc) {
                        file= argv[i++];
                } else {
                        file= user;
                        user= nil;
                }
        }
        if (i != argc) usage();

        if (geteuid() != 0) {
                fprintf(stderr, "%s: No root privileges?\n", prog_name);
        }
        uid= getuid();
        if (user == nil) {
                if ((pw= getpwuid(uid)) == nil) {
                        fprintf(stderr,
                                "%s: Don't know who you (uid %lu) are!\n",
                                prog_name, (unsigned long) uid);
                        exit(1);
                }
        } else {
                if ((pw= getpwnam(user)) == nil) {
                        fprintf(stderr,
                                "%s: Don't know who you (%s) are!\n",
                                prog_name, user);
                        exit(1);
                }
        }
        if (uid != 0 && pw->pw_uid != uid) {
                fprintf(stderr,
                "%s: Only root can change the crontabs of others!\n",
                        prog_name);
                exit(1);
        }
        user= pw->pw_name;
        uid= pw->pw_uid;
        seteuid(uid);
        umask(0077);

        selectlog(STDERR);
        sprintf(tabfile, "%s/%s", SPOOLDIR, user);

        if (lflag) {
                int fd;

                if ((fd= opentab(0, tabfile, 'r')) < 0) {
                        fprintf(stderr, "%s: Can't open %s: %s\n",
                                prog_name, tabfile, strerror(errno));
                        exit(1);
                }
                copytab(fd, tabfile, 1, "stdout");
                close(fd);
        }

        if (rflag) {
                seteuid(0);
                if (unlink(tabfile) < 0) {
                        fprintf(stderr, "%s: Can't remove %s: %s\n",
                                prog_name, tabfile, strerror(errno));
                        exit(1);
                }
                seteuid(uid);
                printf("Crontab of %s removed\n", user);
                pflag= 1;
        }

        /* Initialize current Time */
        time(&now);

        if (cflag) {
                int fd1, fd2;

                if ((fd1= opentab(uid, file, 'r')) < 0) {
                        fprintf(stderr, "%s: Can't open %s: %s\n",
                                prog_name, file, strerror(errno));
                        exit(1);
                }

                /* Try to parse the new crontab file.  If the parsing
                 * succeeds then 'crontabs' will be non-null.
                 */
                tab_parse(file, user);
                tab_purge();
                if (crontabs == nil) exit(1);

                if ((fd2= opentab(0, tabfile, 'w')) < 0) {
                        fprintf(stderr, "%s: Can't open %s: %s\n",
                                prog_name, tabfile, strerror(errno));
                        exit(1);
                }
                copytab(fd1, file, fd2, tabfile);
                close(fd1);
                close(fd2);
                printf("New crontab for %s installed\n", user);
                pflag= 1;
        }

        if (pflag) {
                /* Alert cron to the new situation. */
                FILE *fp;

                seteuid(0);
                if ((fp= fopen(PIDFILE, "r")) != NULL) {
                        unsigned long pid;
                        int c;

                        pid= 0;
                        while ((c= fgetc(fp)) != EOF && c != '\n') {
                                if ((unsigned) (c - '0') >= 10) {
                                        pid= 0; break;
                                }
                                pid= 10*pid + (c - '0');
                                if (pid >= 30000) { pid= 0; break; }
                        }
                        if (pid > 1 && kill((pid_t) pid, SIGHUP) == 0) {
                                pflag= 0;
                        }
                }
                seteuid(uid);
                if (pflag) {
                        fprintf(stderr,
                        "%s: Alerting cron has failed; cron still running?\n",
                                prog_name);
                        exit(1);
                }
                printf("Cron signalled to reload tables\n");
        }
        return 0;
}

/*
 * $PchId: crontab.c,v 1.4 2000/07/17 18:54:50 philip Exp $
 */

---