diff --git a/usr.sbin/cron/lib/entry.c b/usr.sbin/cron/lib/entry.c index 9150a0d4ac56..ef05c14c2de3 100644 --- a/usr.sbin/cron/lib/entry.c +++ b/usr.sbin/cron/lib/entry.c @@ -1,567 +1,629 @@ /* 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 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 #ifdef LOGIN_CAP #include #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_cmd, e_timespec, e_username, e_group, e_mem #ifdef LOGIN_CAP , e_class #endif } ecode_e; static char get_list __P((bitstr_t *, int, int, char *[], int, FILE *)), get_range __P((bitstr_t *, int, int, char *[], int, FILE *)), get_number __P((int *, int, char *[], int, FILE *)); static int set_element __P((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 free(e->cmd); 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)(); 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->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)); } else if (!strcmp("monthly", cmd)) { Debug(DPARS, ("load_entry()...monthly shortcut\n")) 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)); } else if (!strcmp("weekly", cmd)) { Debug(DPARS, ("load_entry()...weekly shortcut\n")) 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_set(e->dow, 0); } else if (!strcmp("daily", cmd) || !strcmp("midnight", cmd)) { Debug(DPARS, ("load_entry()...daily shortcut\n")) 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->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 { 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")) 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 equivilent */ 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, *group; struct group *grp; 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); - } else + 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 (login_getclass(e->class) == NULL) { ecode = e_class; goto eof; } #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 } if (pw->pw_expire && time(NULL) >= pw->pw_expire) { ecode = e_username; goto eof; } 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; + } } + 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) { + env_free(e->envp); 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(\"%d\")", cmd); + env_free(e->envp); + 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(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 != '-') { /* 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) 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'; /* 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/misc.c b/usr.sbin/cron/lib/misc.c index eca9604bafc1..f8538ea3f346 100644 --- a/usr.sbin/cron/lib/misc.c +++ b/usr.sbin/cron/lib/misc.c @@ -1,648 +1,654 @@ /* 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 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 #else # include #endif #include #include #include #include #include #include #if defined(SYSLOG) # include #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); } /* acquire_daemonlock() - write our PID into /etc/cron.pid, unless * another daemon is already running, which we detect here. * * note: main() calls us twice; once before forking, once after. * we maintain static storage of the file pointer so that we * can rewrite our PID into the PIDFILE after the fork. * * it would be great if fflush() disassociated the file buffer. */ void acquire_daemonlock(closeflag) int closeflag; { static FILE *fp = NULL; if (closeflag && fp) { fclose(fp); fp = NULL; return; } if (!fp) { char pidfile[MAX_FNAME]; char buf[MAX_TEMPSTR]; int fd, otherpid; (void) sprintf(pidfile, PIDFILE, PIDDIR); if ((-1 == (fd = open(pidfile, O_RDWR|O_CREAT, 0644))) || (NULL == (fp = fdopen(fd, "r+"))) ) { sprintf(buf, "can't open or create %s: %s", pidfile, strerror(errno)); log_it("CRON", getpid(), "DEATH", buf); errx(ERROR_EXIT, "%s", buf); } if (flock(fd, LOCK_EX|LOCK_NB) < OK) { int save_errno = errno; fscanf(fp, "%d", &otherpid); sprintf(buf, "can't lock %s, otherpid may be %d: %s", pidfile, otherpid, strerror(save_errno)); log_it("CRON", getpid(), "DEATH", buf); errx(ERROR_EXIT, "%s", buf); } (void) fcntl(fd, F_SETFD, 1); } rewind(fp); fprintf(fp, "%d\n", getpid()); fflush(fp); (void) ftruncate(fileno(fp), ftell(fp)); /* abandon fd and fp even though the file is open. we need to * keep it open and locked, but we don't need the handles elsewhere. */ } /* 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(string, file) char *string; FILE *file; { char line[MAX_TEMPSTR]; rewind(file); while (fgets(line, MAX_TEMPSTR, file)) { if (line[0] != '\0') 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; { static int init = FALSE; static FILE *allow, *deny; if (!init) { init = TRUE; #if defined(ALLOW_FILE) && defined(DENY_FILE) allow = fopen(ALLOW_FILE, "r"); deny = fopen(DENY_FILE, "r"); Debug(DMISC, ("allow/deny enabled, %d/%d\n", !!allow, !!deny)) #else allow = NULL; deny = NULL; #endif } if (allow) return (in_file(username, allow)); if (deny) return (!in_file(username, deny)); #if defined(ALLOW_ONLY_ROOT) return (strcmp(username, ROOT_USER) == 0); #else return TRUE; #endif } void log_it(username, xpid, event, detail) char *username; int xpid; char *event; char *detail; { PID_T pid = xpid; #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 (LogFD < OK) { - LogFD = open(LOG_FILE, O_WRONLY|O_APPEND|O_CREAT, 0600); + if (msg == NULL) + warnx("failed to allocate memory for log message"); + else { if (LogFD < OK) { - warn("can't open log file %s", LOG_FILE); - } else { - (void) fcntl(LogFD, F_SETFD, 1); + 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 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)); - } + /* 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); + 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. */ void mkprint(dst, src, len) 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); - mkprint(dst, src, len); + 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*/