diff options
Diffstat (limited to 'usr.sbin/cron/lib')
| -rw-r--r-- | usr.sbin/cron/lib/Makefile | 12 | ||||
| -rw-r--r-- | usr.sbin/cron/lib/Makefile.depend | 14 | ||||
| -rw-r--r-- | usr.sbin/cron/lib/compat.c | 237 | ||||
| -rw-r--r-- | usr.sbin/cron/lib/entry.c | 667 | ||||
| -rw-r--r-- | usr.sbin/cron/lib/env.c | 269 | ||||
| -rw-r--r-- | usr.sbin/cron/lib/misc.c | 600 |
6 files changed, 1799 insertions, 0 deletions
diff --git a/usr.sbin/cron/lib/Makefile b/usr.sbin/cron/lib/Makefile new file mode 100644 index 0000000..51316c1 --- /dev/null +++ b/usr.sbin/cron/lib/Makefile @@ -0,0 +1,12 @@ +# $FreeBSD$ + +LIB= cron +INTERNALLIB= +SRCS= entry.c env.c misc.c + +WARNS?= 3 + +CFLAGS+= -I${.CURDIR}/../cron +CFLAGS+= -DLOGIN_CAP -DPAM + +.include <bsd.lib.mk> diff --git a/usr.sbin/cron/lib/Makefile.depend b/usr.sbin/cron/lib/Makefile.depend new file mode 100644 index 0000000..cf2961c --- /dev/null +++ b/usr.sbin/cron/lib/Makefile.depend @@ -0,0 +1,14 @@ +# $FreeBSD$ +# Autogenerated - do NOT edit! + +DIRDEPS = \ + include \ + include/xlocale \ + lib/libutil \ + + +.include <dirdeps.mk> + +.if ${DEP_RELDIR} == ${_DEP_RELDIR} +# local dependencies - needed for -jN in clean tree +.endif diff --git a/usr.sbin/cron/lib/compat.c b/usr.sbin/cron/lib/compat.c new file mode 100644 index 0000000..9686012 --- /dev/null +++ b/usr.sbin/cron/lib/compat.c @@ -0,0 +1,237 @@ +/* Copyright 1988,1990,1993,1994 by Paul Vixie + * All rights reserved + * + * Distribute freely, except: don't remove my name from the source or + * documentation (don't take credit for my work), mark your changes (don't + * get me blamed for your possible bugs), don't alter or remove this + * notice. May be sold if buildable source is provided to buyer. No + * warrantee of any kind, express or implied, is included with this + * software; use at your own risk, responsibility for damages (if any) to + * anyone resulting from the use of this software rests entirely with the + * user. + * + * Send bug reports, bug fixes, enhancements, requests, flames, etc., and + * I'll try to keep a version up to date. I can be reached as follows: + * Paul Vixie <paul@vix.com> uunet!decwrl!vixie!paul + */ + +#if !defined(lint) && !defined(LINT) +static char rcsid[] = "$FreeBSD$"; +#endif + +/* vix 30dec93 [broke this out of misc.c - see RCS log for history] + * vix 15jan87 [added TIOCNOTTY, thanks csg@pyramid] + */ + + +#include "cron.h" +#ifdef NEED_GETDTABLESIZE +# include <limits.h> +#endif +#if defined(NEED_SETSID) && defined(BSD) +# include <sys/ioctl.h> +#endif +#include <errno.h> +#include <paths.h> + + +/* the code does not depend on any of vfork's + * side-effects; it just uses it as a quick + * fork-and-exec. + */ +#ifdef NEED_VFORK +PID_T +vfork() { + return (fork()); +} +#endif + + +#ifdef NEED_STRDUP +char * +strdup(str) + char *str; +{ + char *temp; + + if ((temp = malloc(strlen(str) + 1)) == NULL) { + errno = ENOMEM; + return NULL; + } + (void) strcpy(temp, str); + return temp; +} +#endif + + +#ifdef NEED_STRERROR +char * +strerror(error) + int error; +{ + extern char *sys_errlist[]; + extern int sys_nerr; + static char buf[32]; + + if ((error <= sys_nerr) && (error > 0)) { + return sys_errlist[error]; + } + + sprintf(buf, "Unknown error: %d", error); + return buf; +} +#endif + + +#ifdef NEED_STRCASECMP +int +strcasecmp(left, right) + char *left; + char *right; +{ + while (*left && (MkLower(*left) == MkLower(*right))) { + left++; + right++; + } + return MkLower(*left) - MkLower(*right); +} +#endif + + +#ifdef NEED_SETSID +int +setsid() +{ + int newpgrp; +# if defined(BSD) + int fd; +# if defined(POSIX) + newpgrp = setpgid((pid_t)0, getpid()); +# else + newpgrp = setpgrp(0, getpid()); +# endif + if ((fd = open(_PATH_TTY, 2)) >= 0) + { + (void) ioctl(fd, TIOCNOTTY, (char*)0); + (void) close(fd); + } +# else /*BSD*/ + newpgrp = setpgrp(); + + (void) close(STDIN); (void) open(_PATH_DEVNULL, 0); + (void) close(STDOUT); (void) open(_PATH_DEVNULL, 1); + (void) close(STDERR); (void) open(_PATH_DEVNULL, 2); +# endif /*BSD*/ + return newpgrp; +} +#endif /*NEED_SETSID*/ + + +#ifdef NEED_GETDTABLESIZE +int +getdtablesize() { +#ifdef _SC_OPEN_MAX + return sysconf(_SC_OPEN_MAX); +#else + return _POSIX_OPEN_MAX; +#endif +} +#endif + + +#ifdef NEED_FLOCK +/* The following flock() emulation snarfed intact *) from the HP-UX + * "BSD to HP-UX porting tricks" maintained by + * system@alchemy.chem.utoronto.ca (System Admin (Mike Peterson)) + * from the version "last updated: 11-Jan-1993" + * Snarfage done by Jarkko Hietaniemi <Jarkko.Hietaniemi@hut.fi> + * *) well, almost, had to K&R the function entry, HPUX "cc" + * does not grok ANSI function prototypes */ + +/* + * flock (fd, operation) + * + * This routine performs some file locking like the BSD 'flock' + * on the object described by the int file descriptor 'fd', + * which must already be open. + * + * The operations that are available are: + * + * LOCK_SH - get a shared lock. + * LOCK_EX - get an exclusive lock. + * LOCK_NB - don't block (must be ORed with LOCK_SH or LOCK_EX). + * LOCK_UN - release a lock. + * + * Return value: 0 if lock successful, -1 if failed. + * + * Note that whether the locks are enforced or advisory is + * controlled by the presence or absence of the SETGID bit on + * the executable. + * + * Note that there is no difference between shared and exclusive + * locks, since the 'lockf' system call in SYSV doesn't make any + * distinction. + * + * The file "<sys/file.h>" should be modified to contain the definitions + * of the available operations, which must be added manually (see below + * for the values). + */ + +/* this code has been reformatted by vixie */ + +int +flock(fd, operation) + int fd; + int operation; +{ + int i; + + switch (operation) { + case LOCK_SH: /* get a shared lock */ + case LOCK_EX: /* get an exclusive lock */ + i = lockf (fd, F_LOCK, 0); + break; + + case LOCK_SH|LOCK_NB: /* get a non-blocking shared lock */ + case LOCK_EX|LOCK_NB: /* get a non-blocking exclusive lock */ + i = lockf (fd, F_TLOCK, 0); + if (i == -1) + if ((errno == EAGAIN) || (errno == EACCES)) + errno = EWOULDBLOCK; + break; + + case LOCK_UN: /* unlock */ + i = lockf (fd, F_ULOCK, 0); + break; + + default: /* can't decipher operation */ + i = -1; + errno = EINVAL; + break; + } + + return (i); +} +#endif /*NEED_FLOCK*/ + + +#ifdef NEED_SETENV +int +setenv(name, value, overwrite) + char *name, *value; + int overwrite; +{ + char *tmp; + + if (overwrite && getenv(name)) + return -1; + + if (!(tmp = malloc(strlen(name) + strlen(value) + 2))) { + errno = ENOMEM; + return -1; + } + + sprintf(tmp, "%s=%s", name, value); + return putenv(tmp); /* intentionally orphan 'tmp' storage */ +} +#endif diff --git a/usr.sbin/cron/lib/entry.c b/usr.sbin/cron/lib/entry.c new file mode 100644 index 0000000..57f7255 --- /dev/null +++ b/usr.sbin/cron/lib/entry.c @@ -0,0 +1,667 @@ +/* Copyright 1988,1990,1993,1994 by Paul Vixie + * All rights reserved + * + * Distribute freely, except: don't remove my name from the source or + * documentation (don't take credit for my work), mark your changes (don't + * get me blamed for your possible bugs), don't alter or remove this + * notice. May be sold if buildable source is provided to buyer. No + * warrantee of any kind, express or implied, is included with this + * software; use at your own risk, responsibility for damages (if any) to + * anyone resulting from the use of this software rests entirely with the + * user. + * + * Send bug reports, bug fixes, enhancements, requests, flames, etc., and + * I'll try to keep a version up to date. I can be reached as follows: + * Paul Vixie <paul@vix.com> uunet!decwrl!vixie!paul + */ + +#if !defined(lint) && !defined(LINT) +static const char rcsid[] = + "$FreeBSD$"; +#endif + +/* vix 26jan87 [RCS'd; rest of log is in RCS file] + * vix 01jan87 [added line-level error recovery] + * vix 31dec86 [added /step to the from-to range, per bob@acornrc] + * vix 30dec86 [written] + */ + + +#include "cron.h" +#include <grp.h> +#ifdef LOGIN_CAP +#include <login_cap.h> +#endif + +typedef enum ecode { + e_none, e_minute, e_hour, e_dom, e_month, e_dow, + e_cmd, e_timespec, e_username, e_group, e_mem +#ifdef LOGIN_CAP + , e_class +#endif +} ecode_e; + +static char get_list(bitstr_t *, int, int, char *[], int, FILE *), + get_range(bitstr_t *, int, int, char *[], int, FILE *), + get_number(int *, int, char *[], int, FILE *); +static int set_element(bitstr_t *, int, int, int); + +static char *ecodes[] = + { + "no error", + "bad minute", + "bad hour", + "bad day-of-month", + "bad month", + "bad day-of-week", + "bad command", + "bad time specifier", + "bad username", + "bad group name", + "out of memory", +#ifdef LOGIN_CAP + "bad class name", +#endif + }; + + +void +free_entry(e) + entry *e; +{ +#ifdef LOGIN_CAP + if (e->class != NULL) + free(e->class); +#endif + if (e->cmd != NULL) + free(e->cmd); + if (e->envp != NULL) + env_free(e->envp); + free(e); +} + + +/* return NULL if eof or syntax error occurs; + * otherwise return a pointer to a new entry. + */ +entry * +load_entry(file, error_func, pw, envp) + FILE *file; + void (*error_func)(char *); + struct passwd *pw; + char **envp; +{ + /* this function reads one crontab entry -- the next -- from a file. + * it skips any leading blank lines, ignores comments, and returns + * EOF if for any reason the entry can't be read and parsed. + * + * the entry is also parsed here. + * + * syntax: + * user crontab: + * minutes hours doms months dows cmd\n + * system crontab (/etc/crontab): + * minutes hours doms months dows USERNAME cmd\n + */ + + ecode_e ecode = e_none; + entry *e; + int ch; + char cmd[MAX_COMMAND]; + char envstr[MAX_ENVSTR]; + char **prev_env; + + Debug(DPARS, ("load_entry()...about to eat comments\n")) + + skip_comments(file); + + ch = get_char(file); + if (ch == EOF) + return NULL; + + /* ch is now the first useful character of a useful line. + * it may be an @special or it may be the first character + * of a list of minutes. + */ + + e = (entry *) calloc(sizeof(entry), sizeof(char)); + + if (e == NULL) { + warn("load_entry: calloc failed"); + return NULL; + } + + if (ch == '@') { + /* all of these should be flagged and load-limited; i.e., + * instead of @hourly meaning "0 * * * *" it should mean + * "close to the front of every hour but not 'til the + * system load is low". Problems are: how do you know + * what "low" means? (save me from /etc/cron.conf!) and: + * how to guarantee low variance (how low is low?), which + * means how to we run roughly every hour -- seems like + * we need to keep a history or let the first hour set + * the schedule, which means we aren't load-limited + * anymore. too much for my overloaded brain. (vix, jan90) + * HINT + */ + Debug(DPARS, ("load_entry()...about to test shortcuts\n")) + ch = get_string(cmd, MAX_COMMAND, file, " \t\n"); + if (!strcmp("reboot", cmd)) { + Debug(DPARS, ("load_entry()...reboot shortcut\n")) + e->flags |= WHEN_REBOOT; + } else if (!strcmp("yearly", cmd) || !strcmp("annually", cmd)){ + Debug(DPARS, ("load_entry()...yearly shortcut\n")) + bit_set(e->second, 0); + bit_set(e->minute, 0); + bit_set(e->hour, 0); + bit_set(e->dom, 0); + bit_set(e->month, 0); + bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1)); + e->flags |= DOW_STAR; + } else if (!strcmp("monthly", cmd)) { + Debug(DPARS, ("load_entry()...monthly shortcut\n")) + bit_set(e->second, 0); + bit_set(e->minute, 0); + bit_set(e->hour, 0); + bit_set(e->dom, 0); + bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1)); + bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1)); + e->flags |= DOW_STAR; + } else if (!strcmp("weekly", cmd)) { + Debug(DPARS, ("load_entry()...weekly shortcut\n")) + bit_set(e->second, 0); + bit_set(e->minute, 0); + bit_set(e->hour, 0); + bit_nset(e->dom, 0, (LAST_DOM-FIRST_DOM+1)); + e->flags |= DOM_STAR; + bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1)); + bit_set(e->dow, 0); + } else if (!strcmp("daily", cmd) || !strcmp("midnight", cmd)) { + Debug(DPARS, ("load_entry()...daily shortcut\n")) + bit_set(e->second, 0); + bit_set(e->minute, 0); + bit_set(e->hour, 0); + bit_nset(e->dom, 0, (LAST_DOM-FIRST_DOM+1)); + bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1)); + bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1)); + } else if (!strcmp("hourly", cmd)) { + Debug(DPARS, ("load_entry()...hourly shortcut\n")) + bit_set(e->second, 0); + bit_set(e->minute, 0); + bit_nset(e->hour, 0, (LAST_HOUR-FIRST_HOUR+1)); + bit_nset(e->dom, 0, (LAST_DOM-FIRST_DOM+1)); + bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1)); + bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1)); + } else if (!strcmp("every_minute", cmd)) { + Debug(DPARS, ("load_entry()...every_minute shortcut\n")) + bit_set(e->second, 0); + bit_nset(e->minute, 0, (LAST_MINUTE-FIRST_MINUTE+1)); + bit_nset(e->hour, 0, (LAST_HOUR-FIRST_HOUR+1)); + bit_nset(e->dom, 0, (LAST_DOM-FIRST_DOM+1)); + bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1)); + bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1)); + } else if (!strcmp("every_second", cmd)) { + Debug(DPARS, ("load_entry()...every_second shortcut\n")) + e->flags |= SEC_RES; + bit_nset(e->second, 0, (LAST_SECOND-FIRST_SECOND+1)); + bit_nset(e->minute, 0, (LAST_MINUTE-FIRST_MINUTE+1)); + bit_nset(e->hour, 0, (LAST_HOUR-FIRST_HOUR+1)); + bit_nset(e->dom, 0, (LAST_DOM-FIRST_DOM+1)); + bit_nset(e->month, 0, (LAST_MONTH-FIRST_MONTH+1)); + bit_nset(e->dow, 0, (LAST_DOW-FIRST_DOW+1)); + } else { + ecode = e_timespec; + goto eof; + } + /* Advance past whitespace between shortcut and + * username/command. + */ + Skip_Blanks(ch, file); + if (ch == EOF) { + ecode = e_cmd; + goto eof; + } + } else { + Debug(DPARS, ("load_entry()...about to parse numerics\n")) + bit_set(e->second, 0); + + ch = get_list(e->minute, FIRST_MINUTE, LAST_MINUTE, + PPC_NULL, ch, file); + if (ch == EOF) { + ecode = e_minute; + goto eof; + } + + /* hours + */ + + ch = get_list(e->hour, FIRST_HOUR, LAST_HOUR, + PPC_NULL, ch, file); + if (ch == EOF) { + ecode = e_hour; + goto eof; + } + + /* DOM (days of month) + */ + + if (ch == '*') + e->flags |= DOM_STAR; + ch = get_list(e->dom, FIRST_DOM, LAST_DOM, + PPC_NULL, ch, file); + if (ch == EOF) { + ecode = e_dom; + goto eof; + } + + /* month + */ + + ch = get_list(e->month, FIRST_MONTH, LAST_MONTH, + MonthNames, ch, file); + if (ch == EOF) { + ecode = e_month; + goto eof; + } + + /* DOW (days of week) + */ + + if (ch == '*') + e->flags |= DOW_STAR; + ch = get_list(e->dow, FIRST_DOW, LAST_DOW, + DowNames, ch, file); + if (ch == EOF) { + ecode = e_dow; + goto eof; + } + } + + /* make sundays equivalent */ + if (bit_test(e->dow, 0) || bit_test(e->dow, 7)) { + bit_set(e->dow, 0); + bit_set(e->dow, 7); + } + + /* ch is the first character of a command, or a username */ + unget_char(ch, file); + + if (!pw) { + char *username = cmd; /* temp buffer */ + char *s; + struct group *grp; +#ifdef LOGIN_CAP + login_cap_t *lc; +#endif + + Debug(DPARS, ("load_entry()...about to parse username\n")) + ch = get_string(username, MAX_COMMAND, file, " \t"); + + Debug(DPARS, ("load_entry()...got %s\n",username)) + if (ch == EOF) { + ecode = e_cmd; + goto eof; + } + +#ifdef LOGIN_CAP + if ((s = strrchr(username, '/')) != NULL) { + *s = '\0'; + e->class = strdup(s + 1); + if (e->class == NULL) + warn("strdup(\"%s\")", s + 1); + } else { + e->class = strdup(RESOURCE_RC); + if (e->class == NULL) + warn("strdup(\"%s\")", RESOURCE_RC); + } + if (e->class == NULL) { + ecode = e_mem; + goto eof; + } + if ((lc = login_getclass(e->class)) == NULL) { + ecode = e_class; + goto eof; + } + login_close(lc); +#endif + grp = NULL; + if ((s = strrchr(username, ':')) != NULL) { + *s = '\0'; + if ((grp = getgrnam(s + 1)) == NULL) { + ecode = e_group; + goto eof; + } + } + + pw = getpwnam(username); + if (pw == NULL) { + ecode = e_username; + goto eof; + } + if (grp != NULL) + pw->pw_gid = grp->gr_gid; + Debug(DPARS, ("load_entry()...uid %d, gid %d\n",pw->pw_uid,pw->pw_gid)) +#ifdef LOGIN_CAP + Debug(DPARS, ("load_entry()...class %s\n",e->class)) +#endif + } + +#ifndef PAM /* PAM takes care of account expiration by itself */ + if (pw->pw_expire && time(NULL) >= pw->pw_expire) { + ecode = e_username; + goto eof; + } +#endif /* !PAM */ + + e->uid = pw->pw_uid; + e->gid = pw->pw_gid; + + /* copy and fix up environment. some variables are just defaults and + * others are overrides. + */ + e->envp = env_copy(envp); + if (e->envp == NULL) { + warn("env_copy"); + ecode = e_mem; + goto eof; + } + if (!env_get("SHELL", e->envp)) { + prev_env = e->envp; + sprintf(envstr, "SHELL=%s", _PATH_BSHELL); + e->envp = env_set(e->envp, envstr); + if (e->envp == NULL) { + warn("env_set(%s)", envstr); + env_free(prev_env); + ecode = e_mem; + goto eof; + } + } + if (!env_get("HOME", e->envp)) { + prev_env = e->envp; + sprintf(envstr, "HOME=%s", pw->pw_dir); + e->envp = env_set(e->envp, envstr); + if (e->envp == NULL) { + warn("env_set(%s)", envstr); + env_free(prev_env); + ecode = e_mem; + goto eof; + } + } + if (!env_get("PATH", e->envp)) { + prev_env = e->envp; + sprintf(envstr, "PATH=%s", _PATH_DEFPATH); + e->envp = env_set(e->envp, envstr); + if (e->envp == NULL) { + warn("env_set(%s)", envstr); + env_free(prev_env); + ecode = e_mem; + goto eof; + } + } + prev_env = e->envp; + sprintf(envstr, "%s=%s", "LOGNAME", pw->pw_name); + e->envp = env_set(e->envp, envstr); + if (e->envp == NULL) { + warn("env_set(%s)", envstr); + env_free(prev_env); + ecode = e_mem; + goto eof; + } +#if defined(BSD) + prev_env = e->envp; + sprintf(envstr, "%s=%s", "USER", pw->pw_name); + e->envp = env_set(e->envp, envstr); + if (e->envp == NULL) { + warn("env_set(%s)", envstr); + env_free(prev_env); + ecode = e_mem; + goto eof; + } +#endif + + Debug(DPARS, ("load_entry()...about to parse command\n")) + + /* Everything up to the next \n or EOF is part of the command... + * too bad we don't know in advance how long it will be, since we + * need to malloc a string for it... so, we limit it to MAX_COMMAND. + * XXX - should use realloc(). + */ + ch = get_string(cmd, MAX_COMMAND, file, "\n"); + + /* a file without a \n before the EOF is rude, so we'll complain... + */ + if (ch == EOF) { + ecode = e_cmd; + goto eof; + } + + /* got the command in the 'cmd' string; save it in *e. + */ + e->cmd = strdup(cmd); + if (e->cmd == NULL) { + warn("strdup(\"%s\")", cmd); + ecode = e_mem; + goto eof; + } + Debug(DPARS, ("load_entry()...returning successfully\n")) + + /* success, fini, return pointer to the entry we just created... + */ + return e; + + eof: + free_entry(e); + if (ecode != e_none && error_func) + (*error_func)(ecodes[(int)ecode]); + while (ch != EOF && ch != '\n') + ch = get_char(file); + return NULL; +} + + +static char +get_list(bits, low, high, names, ch, file) + bitstr_t *bits; /* one bit per flag, default=FALSE */ + int low, high; /* bounds, impl. offset for bitstr */ + char *names[]; /* NULL or *[] of names for these elements */ + int ch; /* current character being processed */ + FILE *file; /* file being read */ +{ + register int done; + + /* we know that we point to a non-blank character here; + * must do a Skip_Blanks before we exit, so that the + * next call (or the code that picks up the cmd) can + * assume the same thing. + */ + + Debug(DPARS|DEXT, ("get_list()...entered\n")) + + /* list = range {"," range} + */ + + /* clear the bit string, since the default is 'off'. + */ + bit_nclear(bits, 0, (high-low+1)); + + /* process all ranges + */ + done = FALSE; + while (!done) { + ch = get_range(bits, low, high, names, ch, file); + if (ch == ',') + ch = get_char(file); + else + done = TRUE; + } + + /* exiting. skip to some blanks, then skip over the blanks. + */ + Skip_Nonblanks(ch, file) + Skip_Blanks(ch, file) + + Debug(DPARS|DEXT, ("get_list()...exiting w/ %02x\n", ch)) + + return ch; +} + + +static char +get_range(bits, low, high, names, ch, file) + bitstr_t *bits; /* one bit per flag, default=FALSE */ + int low, high; /* bounds, impl. offset for bitstr */ + char *names[]; /* NULL or names of elements */ + int ch; /* current character being processed */ + FILE *file; /* file being read */ +{ + /* range = number | number "-" number [ "/" number ] + */ + + register int i; + auto int num1, num2, num3; + + Debug(DPARS|DEXT, ("get_range()...entering, exit won't show\n")) + + if (ch == '*') { + /* '*' means "first-last" but can still be modified by /step + */ + num1 = low; + num2 = high; + ch = get_char(file); + if (ch == EOF) + return EOF; + } else { + if (EOF == (ch = get_number(&num1, low, names, ch, file))) + return EOF; + + if (ch == '/') + num2 = high; + else if (ch != '-') { + /* not a range, it's a single number. + */ + if (EOF == set_element(bits, low, high, num1)) + return EOF; + return ch; + } else { + /* eat the dash + */ + ch = get_char(file); + if (ch == EOF) + return EOF; + + /* get the number following the dash + */ + ch = get_number(&num2, low, names, ch, file); + if (ch == EOF) + return EOF; + } + } + + /* check for step size + */ + if (ch == '/') { + /* eat the slash + */ + ch = get_char(file); + if (ch == EOF) + return EOF; + + /* get the step size -- note: we don't pass the + * names here, because the number is not an + * element id, it's a step size. 'low' is + * sent as a 0 since there is no offset either. + */ + ch = get_number(&num3, 0, PPC_NULL, ch, file); + if (ch == EOF || num3 == 0) + return EOF; + } else { + /* no step. default==1. + */ + num3 = 1; + } + + /* range. set all elements from num1 to num2, stepping + * by num3. (the step is a downward-compatible extension + * proposed conceptually by bob@acornrc, syntactically + * designed then implmented by paul vixie). + */ + for (i = num1; i <= num2; i += num3) + if (EOF == set_element(bits, low, high, i)) + return EOF; + + return ch; +} + + +static char +get_number(numptr, low, names, ch, file) + int *numptr; /* where does the result go? */ + int low; /* offset applied to result if symbolic enum used */ + char *names[]; /* symbolic names, if any, for enums */ + int ch; /* current character */ + FILE *file; /* source */ +{ + char temp[MAX_TEMPSTR], *pc; + int len, i, all_digits; + + /* collect alphanumerics into our fixed-size temp array + */ + pc = temp; + len = 0; + all_digits = TRUE; + while (isalnum(ch)) { + if (++len >= MAX_TEMPSTR) + return EOF; + + *pc++ = ch; + + if (!isdigit(ch)) + all_digits = FALSE; + + ch = get_char(file); + } + *pc = '\0'; + if (len == 0) + return (EOF); + + /* try to find the name in the name list + */ + if (names) { + for (i = 0; names[i] != NULL; i++) { + Debug(DPARS|DEXT, + ("get_num, compare(%s,%s)\n", names[i], temp)) + if (!strcasecmp(names[i], temp)) { + *numptr = i+low; + return ch; + } + } + } + + /* no name list specified, or there is one and our string isn't + * in it. either way: if it's all digits, use its magnitude. + * otherwise, it's an error. + */ + if (all_digits) { + *numptr = atoi(temp); + return ch; + } + + return EOF; +} + + +static int +set_element(bits, low, high, number) + bitstr_t *bits; /* one bit per flag, default=FALSE */ + int low; + int high; + int number; +{ + Debug(DPARS|DEXT, ("set_element(?,%d,%d,%d)\n", low, high, number)) + + if (number < low || number > high) + return EOF; + + bit_set(bits, (number-low)); + return OK; +} diff --git a/usr.sbin/cron/lib/env.c b/usr.sbin/cron/lib/env.c new file mode 100644 index 0000000..fd35817 --- /dev/null +++ b/usr.sbin/cron/lib/env.c @@ -0,0 +1,269 @@ +/* Copyright 1988,1990,1993,1994 by Paul Vixie + * All rights reserved + * + * Distribute freely, except: don't remove my name from the source or + * documentation (don't take credit for my work), mark your changes (don't + * get me blamed for your possible bugs), don't alter or remove this + * notice. May be sold if buildable source is provided to buyer. No + * warrantee of any kind, express or implied, is included with this + * software; use at your own risk, responsibility for damages (if any) to + * anyone resulting from the use of this software rests entirely with the + * user. + * + * Send bug reports, bug fixes, enhancements, requests, flames, etc., and + * I'll try to keep a version up to date. I can be reached as follows: + * Paul Vixie <paul@vix.com> uunet!decwrl!vixie!paul + */ + +#if !defined(lint) && !defined(LINT) +static const char rcsid[] = + "$FreeBSD$"; +#endif + + +#include "cron.h" + + +char ** +env_init() +{ + register char **p = (char **) malloc(sizeof(char *)); + + if (p) + p[0] = NULL; + return (p); +} + + +void +env_free(envp) + char **envp; +{ + char **p; + + if ((p = envp)) + for (; *p; p++) + free(*p); + free(envp); +} + + +char ** +env_copy(envp) + register char **envp; +{ + register int count, i; + register char **p; + + for (count = 0; envp[count] != NULL; count++) + ; + p = (char **) malloc((count+1) * sizeof(char *)); /* 1 for the NULL */ + if (p == NULL) { + errno = ENOMEM; + return NULL; + } + for (i = 0; i < count; i++) + if ((p[i] = strdup(envp[i])) == NULL) { + while (--i >= 0) + (void) free(p[i]); + free(p); + errno = ENOMEM; + return NULL; + } + p[count] = NULL; + return (p); +} + + +char ** +env_set(envp, envstr) + char **envp; + char *envstr; +{ + register int count, found; + register char **p; + char *q; + + /* + * count the number of elements, including the null pointer; + * also set 'found' to -1 or index of entry if already in here. + */ + found = -1; + for (count = 0; envp[count] != NULL; count++) { + if (!strcmp_until(envp[count], envstr, '=')) + found = count; + } + count++; /* for the NULL */ + + if (found != -1) { + /* + * it exists already, so just free the existing setting, + * save our new one there, and return the existing array. + */ + q = envp[found]; + if ((envp[found] = strdup(envstr)) == NULL) { + envp[found] = q; + /* XXX env_free(envp); */ + errno = ENOMEM; + return NULL; + } + free(q); + return (envp); + } + + /* + * it doesn't exist yet, so resize the array, move null pointer over + * one, save our string over the old null pointer, and return resized + * array. + */ + p = (char **) realloc((void *) envp, + (unsigned) ((count+1) * sizeof(char *))); + if (p == NULL) { + /* XXX env_free(envp); */ + errno = ENOMEM; + return NULL; + } + p[count] = p[count-1]; + if ((p[count-1] = strdup(envstr)) == NULL) { + env_free(p); + errno = ENOMEM; + return NULL; + } + return (p); +} + + +/* return ERR = end of file + * FALSE = not an env setting (file was repositioned) + * TRUE = was an env setting + */ +int +load_env(envstr, f) + char *envstr; + FILE *f; +{ + long filepos; + int fileline; + char name[MAX_ENVSTR], val[MAX_ENVSTR]; + char quotechar, *c, *str; + int state; + + /* The following states are traversed in order: */ +#define NAMEI 0 /* First char of NAME, may be quote */ +#define NAME 1 /* Subsequent chars of NAME */ +#define EQ1 2 /* After end of name, looking for '=' sign */ +#define EQ2 3 /* After '=', skipping whitespace */ +#define VALUEI 4 /* First char of VALUE, may be quote */ +#define VALUE 5 /* Subsequent chars of VALUE */ +#define FINI 6 /* All done, skipping trailing whitespace */ +#define ERROR 7 /* Error */ + + filepos = ftell(f); + fileline = LineNumber; + skip_comments(f); + if (EOF == get_string(envstr, MAX_ENVSTR, f, "\n")) + return (ERR); + + Debug(DPARS, ("load_env, read <%s>\n", envstr)); + + bzero (name, sizeof name); + bzero (val, sizeof val); + str = name; + state = NAMEI; + quotechar = '\0'; + c = envstr; + while (state != ERROR && *c) { + switch (state) { + case NAMEI: + case VALUEI: + if (*c == '\'' || *c == '"') + quotechar = *c++; + ++state; + /* FALLTHROUGH */ + case NAME: + case VALUE: + if (quotechar) { + if (*c == quotechar) { + state++; + c++; + break; + } + if (state == NAME && *c == '=') { + state = ERROR; + break; + } + } else { + if (state == NAME) { + if (isspace (*c)) { + c++; + state++; + break; + } + if (*c == '=') { + state++; + break; + } + } + } + *str++ = *c++; + break; + + case EQ1: + if (*c == '=') { + state++; + str = val; + quotechar = '\0'; + } else { + if (!isspace (*c)) + state = ERROR; + } + c++; + break; + case EQ2: + case FINI: + if (isspace (*c)) + c++; + else + state++; + break; + } + } + if (state != FINI && !(state == VALUE && !quotechar)) { + Debug(DPARS, ("load_env, parse error, state = %d\n", state)) + fseek(f, filepos, 0); + Set_LineNum(fileline); + return (FALSE); + } + if (state == VALUE) { + /* End of unquoted value: trim trailing whitespace */ + c = val + strlen (val); + while (c > val && isspace (*(c - 1))) + *(--c) = '\0'; + } + + /* 2 fields from parser; looks like an env setting */ + + if (strlen(name) + 1 + strlen(val) >= MAX_ENVSTR-1) + return (FALSE); + (void) sprintf(envstr, "%s=%s", name, val); + Debug(DPARS, ("load_env, <%s> <%s> -> <%s>\n", name, val, envstr)) + return (TRUE); +} + + +char * +env_get(name, envp) + register char *name; + register char **envp; +{ + register int len = strlen(name); + register char *p, *q; + + while ((p = *envp++)) { + if (!(q = strchr(p, '='))) + continue; + if ((q - p) == len && !strncmp(p, name, len)) + return (q+1); + } + return (NULL); +} diff --git a/usr.sbin/cron/lib/misc.c b/usr.sbin/cron/lib/misc.c new file mode 100644 index 0000000..afed07f --- /dev/null +++ b/usr.sbin/cron/lib/misc.c @@ -0,0 +1,600 @@ +/* Copyright 1988,1990,1993,1994 by Paul Vixie + * All rights reserved + * + * Distribute freely, except: don't remove my name from the source or + * documentation (don't take credit for my work), mark your changes (don't + * get me blamed for your possible bugs), don't alter or remove this + * notice. May be sold if buildable source is provided to buyer. No + * warrantee of any kind, express or implied, is included with this + * software; use at your own risk, responsibility for damages (if any) to + * anyone resulting from the use of this software rests entirely with the + * user. + * + * Send bug reports, bug fixes, enhancements, requests, flames, etc., and + * I'll try to keep a version up to date. I can be reached as follows: + * Paul Vixie <paul@vix.com> uunet!decwrl!vixie!paul + */ + +#if !defined(lint) && !defined(LINT) +static const char rcsid[] = + "$FreeBSD$"; +#endif + +/* vix 26jan87 [RCS has the rest of the log] + * vix 30dec86 [written] + */ + + +#include "cron.h" +#if SYS_TIME_H +# include <sys/time.h> +#else +# include <time.h> +#endif +#include <sys/file.h> +#include <sys/stat.h> +#include <err.h> +#include <errno.h> +#include <string.h> +#include <fcntl.h> +#if defined(SYSLOG) +# include <syslog.h> +#endif + + +#if defined(LOG_DAEMON) && !defined(LOG_CRON) +#define LOG_CRON LOG_DAEMON +#endif + + +static int LogFD = ERR; + + +int +strcmp_until(left, right, until) + char *left; + char *right; + int until; +{ + register int diff; + + while (*left && *left != until && *left == *right) { + left++; + right++; + } + + if ((*left=='\0' || *left == until) && + (*right=='\0' || *right == until)) { + diff = 0; + } else { + diff = *left - *right; + } + + return diff; +} + + +/* strdtb(s) - delete trailing blanks in string 's' and return new length + */ +int +strdtb(s) + char *s; +{ + char *x = s; + + /* scan forward to the null + */ + while (*x) + x++; + + /* scan backward to either the first character before the string, + * or the last non-blank in the string, whichever comes first. + */ + do {x--;} + while (x >= s && isspace(*x)); + + /* one character beyond where we stopped above is where the null + * goes. + */ + *++x = '\0'; + + /* the difference between the position of the null character and + * the position of the first character of the string is the length. + */ + return x - s; +} + + +int +set_debug_flags(flags) + char *flags; +{ + /* debug flags are of the form flag[,flag ...] + * + * if an error occurs, print a message to stdout and return FALSE. + * otherwise return TRUE after setting ERROR_FLAGS. + */ + +#if !DEBUGGING + + printf("this program was compiled without debugging enabled\n"); + return FALSE; + +#else /* DEBUGGING */ + + char *pc = flags; + + DebugFlags = 0; + + while (*pc) { + char **test; + int mask; + + /* try to find debug flag name in our list. + */ + for ( test = DebugFlagNames, mask = 1; + *test && strcmp_until(*test, pc, ','); + test++, mask <<= 1 + ) + ; + + if (!*test) { + fprintf(stderr, + "unrecognized debug flag <%s> <%s>\n", + flags, pc); + return FALSE; + } + + DebugFlags |= mask; + + /* skip to the next flag + */ + while (*pc && *pc != ',') + pc++; + if (*pc == ',') + pc++; + } + + if (DebugFlags) { + int flag; + + fprintf(stderr, "debug flags enabled:"); + + for (flag = 0; DebugFlagNames[flag]; flag++) + if (DebugFlags & (1 << flag)) + fprintf(stderr, " %s", DebugFlagNames[flag]); + fprintf(stderr, "\n"); + } + + return TRUE; + +#endif /* DEBUGGING */ +} + + +void +set_cron_uid() +{ +#if defined(BSD) || defined(POSIX) + if (seteuid(ROOT_UID) < OK) + err(ERROR_EXIT, "seteuid"); +#else + if (setuid(ROOT_UID) < OK) + err(ERROR_EXIT, "setuid"); +#endif +} + + +void +set_cron_cwd() +{ + struct stat sb; + + /* first check for CRONDIR ("/var/cron" or some such) + */ + if (stat(CRONDIR, &sb) < OK && errno == ENOENT) { + warn("%s", CRONDIR); + if (OK == mkdir(CRONDIR, 0700)) { + warnx("%s: created", CRONDIR); + stat(CRONDIR, &sb); + } else { + err(ERROR_EXIT, "%s: mkdir", CRONDIR); + } + } + if (!(sb.st_mode & S_IFDIR)) + err(ERROR_EXIT, "'%s' is not a directory, bailing out", CRONDIR); + if (chdir(CRONDIR) < OK) + err(ERROR_EXIT, "cannot chdir(%s), bailing out", CRONDIR); + + /* CRONDIR okay (now==CWD), now look at SPOOL_DIR ("tabs" or some such) + */ + if (stat(SPOOL_DIR, &sb) < OK && errno == ENOENT) { + warn("%s", SPOOL_DIR); + if (OK == mkdir(SPOOL_DIR, 0700)) { + warnx("%s: created", SPOOL_DIR); + stat(SPOOL_DIR, &sb); + } else { + err(ERROR_EXIT, "%s: mkdir", SPOOL_DIR); + } + } + if (!(sb.st_mode & S_IFDIR)) + err(ERROR_EXIT, "'%s' is not a directory, bailing out", SPOOL_DIR); +} + + +/* get_char(file) : like getc() but increment LineNumber on newlines + */ +int +get_char(file) + FILE *file; +{ + int ch; + + ch = getc(file); + if (ch == '\n') + Set_LineNum(LineNumber + 1) + return ch; +} + + +/* unget_char(ch, file) : like ungetc but do LineNumber processing + */ +void +unget_char(ch, file) + int ch; + FILE *file; +{ + ungetc(ch, file); + if (ch == '\n') + Set_LineNum(LineNumber - 1) +} + + +/* get_string(str, max, file, termstr) : like fgets() but + * (1) has terminator string which should include \n + * (2) will always leave room for the null + * (3) uses get_char() so LineNumber will be accurate + * (4) returns EOF or terminating character, whichever + */ +int +get_string(string, size, file, terms) + char *string; + int size; + FILE *file; + char *terms; +{ + int ch; + + while (EOF != (ch = get_char(file)) && !strchr(terms, ch)) { + if (size > 1) { + *string++ = (char) ch; + size--; + } + } + + if (size > 0) + *string = '\0'; + + return ch; +} + + +/* skip_comments(file) : read past comment (if any) + */ +void +skip_comments(file) + FILE *file; +{ + int ch; + + while (EOF != (ch = get_char(file))) { + /* ch is now the first character of a line. + */ + + while (ch == ' ' || ch == '\t') + ch = get_char(file); + + if (ch == EOF) + break; + + /* ch is now the first non-blank character of a line. + */ + + if (ch != '\n' && ch != '#') + break; + + /* ch must be a newline or comment as first non-blank + * character on a line. + */ + + while (ch != '\n' && ch != EOF) + ch = get_char(file); + + /* ch is now the newline of a line which we're going to + * ignore. + */ + } + if (ch != EOF) + unget_char(ch, file); +} + + +/* int in_file(char *string, FILE *file) + * return TRUE if one of the lines in file matches string exactly, + * FALSE otherwise. + */ +static int +in_file(char *string, FILE *file) +{ + char line[MAX_TEMPSTR]; + + rewind(file); + while (fgets(line, MAX_TEMPSTR, file)) { + if (line[0] != '\0') + if (line[strlen(line)-1] == '\n') + line[strlen(line)-1] = '\0'; + if (0 == strcmp(line, string)) + return TRUE; + } + return FALSE; +} + + +/* int allowed(char *username) + * returns TRUE if (ALLOW_FILE exists and user is listed) + * or (DENY_FILE exists and user is NOT listed) + * or (neither file exists but user=="root" so it's okay) + */ +int +allowed(username) + char *username; +{ + FILE *allow, *deny; + int isallowed; + + isallowed = FALSE; + + deny = NULL; +#if defined(ALLOW_FILE) && defined(DENY_FILE) + if ((allow = fopen(ALLOW_FILE, "r")) == NULL && errno != ENOENT) + goto out; + if ((deny = fopen(DENY_FILE, "r")) == NULL && errno != ENOENT) + goto out; + Debug(DMISC, ("allow/deny enabled, %d/%d\n", !!allow, !!deny)) +#else + allow = NULL; +#endif + + if (allow) + isallowed = in_file(username, allow); + else if (deny) + isallowed = !in_file(username, deny); + else { +#if defined(ALLOW_ONLY_ROOT) + isallowed = (strcmp(username, ROOT_USER) == 0); +#else + isallowed = TRUE; +#endif + } +out: if (allow) + fclose(allow); + if (deny) + fclose(deny); + return (isallowed); +} + + +void +log_it(username, xpid, event, detail) + char *username; + int xpid; + char *event; + char *detail; +{ +#if defined(LOG_FILE) || DEBUGGING + PID_T pid = xpid; +#endif +#if defined(LOG_FILE) + char *msg; + TIME_T now = time((TIME_T) 0); + register struct tm *t = localtime(&now); +#endif /*LOG_FILE*/ + +#if defined(SYSLOG) + static int syslog_open = 0; +#endif + +#if defined(LOG_FILE) + /* we assume that MAX_TEMPSTR will hold the date, time, &punctuation. + */ + msg = malloc(strlen(username) + + strlen(event) + + strlen(detail) + + MAX_TEMPSTR); + + if (msg == NULL) + warnx("failed to allocate memory for log message"); + else { + if (LogFD < OK) { + LogFD = open(LOG_FILE, O_WRONLY|O_APPEND|O_CREAT, 0600); + if (LogFD < OK) { + warn("can't open log file %s", LOG_FILE); + } else { + (void) fcntl(LogFD, F_SETFD, 1); + } + } + + /* we have to sprintf() it because fprintf() doesn't always + * write everything out in one chunk and this has to be + * atomically appended to the log file. + */ + sprintf(msg, "%s (%02d/%02d-%02d:%02d:%02d-%d) %s (%s)\n", + username, + t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min, + t->tm_sec, pid, event, detail); + + /* we have to run strlen() because sprintf() returns (char*) + * on old BSD. + */ + if (LogFD < OK || write(LogFD, msg, strlen(msg)) < OK) { + if (LogFD >= OK) + warn("%s", LOG_FILE); + warnx("can't write to log file"); + write(STDERR, msg, strlen(msg)); + } + + free(msg); + } +#endif /*LOG_FILE*/ + +#if defined(SYSLOG) + if (!syslog_open) { + /* we don't use LOG_PID since the pid passed to us by + * our client may not be our own. therefore we want to + * print the pid ourselves. + */ +# ifdef LOG_DAEMON + openlog(ProgramName, LOG_PID, LOG_CRON); +# else + openlog(ProgramName, LOG_PID); +# endif + syslog_open = TRUE; /* assume openlog success */ + } + + syslog(LOG_INFO, "(%s) %s (%s)\n", username, event, detail); + +#endif /*SYSLOG*/ + +#if DEBUGGING + if (DebugFlags) { + fprintf(stderr, "log_it: (%s %d) %s (%s)\n", + username, pid, event, detail); + } +#endif +} + + +void +log_close() { + if (LogFD != ERR) { + close(LogFD); + LogFD = ERR; + } +} + + +/* two warnings: + * (1) this routine is fairly slow + * (2) it returns a pointer to static storage + */ +char * +first_word(s, t) + register char *s; /* string we want the first word of */ + register char *t; /* terminators, implicitly including \0 */ +{ + static char retbuf[2][MAX_TEMPSTR + 1]; /* sure wish C had GC */ + static int retsel = 0; + register char *rb, *rp; + + /* select a return buffer */ + retsel = 1-retsel; + rb = &retbuf[retsel][0]; + rp = rb; + + /* skip any leading terminators */ + while (*s && (NULL != strchr(t, *s))) { + s++; + } + + /* copy until next terminator or full buffer */ + while (*s && (NULL == strchr(t, *s)) && (rp < &rb[MAX_TEMPSTR])) { + *rp++ = *s++; + } + + /* finish the return-string and return it */ + *rp = '\0'; + return rb; +} + + +/* warning: + * heavily ascii-dependent. + */ +static void +mkprint(register char *dst, register unsigned char *src, register int len) +{ + while (len-- > 0) + { + register unsigned char ch = *src++; + + if (ch < ' ') { /* control character */ + *dst++ = '^'; + *dst++ = ch + '@'; + } else if (ch < 0177) { /* printable */ + *dst++ = ch; + } else if (ch == 0177) { /* delete/rubout */ + *dst++ = '^'; + *dst++ = '?'; + } else { /* parity character */ + sprintf(dst, "\\%03o", ch); + dst += 4; + } + } + *dst = '\0'; +} + + +/* warning: + * returns a pointer to malloc'd storage, you must call free yourself. + */ +char * +mkprints(src, len) + register unsigned char *src; + register unsigned int len; +{ + register char *dst = malloc(len*4 + 1); + + if (dst != NULL) + mkprint(dst, src, len); + + return dst; +} + + +#ifdef MAIL_DATE +/* Sat, 27 Feb 93 11:44:51 CST + * 123456789012345678901234567 + */ +char * +arpadate(clock) + time_t *clock; +{ + time_t t = clock ?*clock :time(0L); + struct tm *tm = localtime(&t); + static char ret[32]; /* zone name might be >3 chars */ + + if (tm->tm_year >= 100) + tm->tm_year += 1900; + + (void) snprintf(ret, sizeof(ret), "%s, %2d %s %d %02d:%02d:%02d %s", + DowNames[tm->tm_wday], + tm->tm_mday, + MonthNames[tm->tm_mon], + tm->tm_year, + tm->tm_hour, + tm->tm_min, + tm->tm_sec, + TZONE(*tm)); + return ret; +} +#endif /*MAIL_DATE*/ + + +#ifdef HAVE_SAVED_UIDS +static int save_euid; +int swap_uids() { save_euid = geteuid(); return seteuid(getuid()); } +int swap_uids_back() { return seteuid(save_euid); } +#else /*HAVE_SAVED_UIDS*/ +int swap_uids() { return setreuid(geteuid(), getuid()); } +int swap_uids_back() { return swap_uids(); } +#endif /*HAVE_SAVED_UIDS*/ |
