1 /* Copyright 1988,1990,1993,1994 by Paul Vixie
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
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
17 * $FreeBSD: src/usr.sbin/cron/lib/misc.c,v 1.8.2.2 2002/04/28 22:45:53 dwmalone Exp $
18 * $DragonFly: src/usr.sbin/cron/lib/misc.c,v 1.2 2003/06/17 04:29:53 dillon Exp $
21 /* vix 26jan87 [RCS has the rest of the log]
22 * vix 30dec86 [written]
28 # include <sys/time.h>
43 #if defined(LOG_DAEMON) && !defined(LOG_CRON)
44 #define LOG_CRON LOG_DAEMON
48 static int LogFD = ERR;
52 strcmp_until(left, right, until)
59 while (*left && *left != until && *left == *right) {
64 if ((*left=='\0' || *left == until) &&
65 (*right=='\0' || *right == until)) {
68 diff = *left - *right;
75 /* strdtb(s) - delete trailing blanks in string 's' and return new length
83 /* scan forward to the null
88 /* scan backward to either the first character before the string,
89 * or the last non-blank in the string, whichever comes first.
92 while (x >= s && isspace(*x));
94 /* one character beyond where we stopped above is where the null
99 /* the difference between the position of the null character and
100 * the position of the first character of the string is the length.
107 set_debug_flags(flags)
110 /* debug flags are of the form flag[,flag ...]
112 * if an error occurs, print a message to stdout and return FALSE.
113 * otherwise return TRUE after setting ERROR_FLAGS.
118 printf("this program was compiled without debugging enabled\n");
121 #else /* DEBUGGING */
131 /* try to find debug flag name in our list.
133 for ( test = DebugFlagNames, mask = 1;
134 *test && strcmp_until(*test, pc, ',');
141 "unrecognized debug flag <%s> <%s>\n",
148 /* skip to the next flag
150 while (*pc && *pc != ',')
159 fprintf(stderr, "debug flags enabled:");
161 for (flag = 0; DebugFlagNames[flag]; flag++)
162 if (DebugFlags & (1 << flag))
163 fprintf(stderr, " %s", DebugFlagNames[flag]);
164 fprintf(stderr, "\n");
169 #endif /* DEBUGGING */
176 #if defined(BSD) || defined(POSIX)
177 if (seteuid(ROOT_UID) < OK)
178 err(ERROR_EXIT, "seteuid");
180 if (setuid(ROOT_UID) < OK)
181 err(ERROR_EXIT, "setuid");
191 /* first check for CRONDIR ("/var/cron" or some such)
193 if (stat(CRONDIR, &sb) < OK && errno == ENOENT) {
195 if (OK == mkdir(CRONDIR, 0700)) {
196 warnx("%s: created", CRONDIR);
199 err(ERROR_EXIT, "%s: mkdir", CRONDIR);
202 if (!(sb.st_mode & S_IFDIR))
203 err(ERROR_EXIT, "'%s' is not a directory, bailing out", CRONDIR);
204 if (chdir(CRONDIR) < OK)
205 err(ERROR_EXIT, "cannot chdir(%s), bailing out", CRONDIR);
207 /* CRONDIR okay (now==CWD), now look at SPOOL_DIR ("tabs" or some such)
209 if (stat(SPOOL_DIR, &sb) < OK && errno == ENOENT) {
210 warn("%s", SPOOL_DIR);
211 if (OK == mkdir(SPOOL_DIR, 0700)) {
212 warnx("%s: created", SPOOL_DIR);
213 stat(SPOOL_DIR, &sb);
215 err(ERROR_EXIT, "%s: mkdir", SPOOL_DIR);
218 if (!(sb.st_mode & S_IFDIR))
219 err(ERROR_EXIT, "'%s' is not a directory, bailing out", SPOOL_DIR);
223 /* acquire_daemonlock() - write our PID into /etc/cron.pid, unless
224 * another daemon is already running, which we detect here.
226 * note: main() calls us twice; once before forking, once after.
227 * we maintain static storage of the file pointer so that we
228 * can rewrite our PID into the PIDFILE after the fork.
230 * it would be great if fflush() disassociated the file buffer.
233 acquire_daemonlock(closeflag)
236 static FILE *fp = NULL;
238 if (closeflag && fp) {
245 char pidfile[MAX_FNAME];
246 char buf[MAX_TEMPSTR];
249 (void) sprintf(pidfile, PIDFILE, PIDDIR);
250 if ((-1 == (fd = open(pidfile, O_RDWR|O_CREAT, 0644)))
251 || (NULL == (fp = fdopen(fd, "r+")))
253 sprintf(buf, "can't open or create %s: %s",
254 pidfile, strerror(errno));
255 log_it("CRON", getpid(), "DEATH", buf);
256 errx(ERROR_EXIT, "%s", buf);
259 if (flock(fd, LOCK_EX|LOCK_NB) < OK) {
260 int save_errno = errno;
262 fscanf(fp, "%d", &otherpid);
263 sprintf(buf, "can't lock %s, otherpid may be %d: %s",
264 pidfile, otherpid, strerror(save_errno));
265 log_it("CRON", getpid(), "DEATH", buf);
266 errx(ERROR_EXIT, "%s", buf);
269 (void) fcntl(fd, F_SETFD, 1);
273 fprintf(fp, "%d\n", getpid());
275 (void) ftruncate(fileno(fp), ftell(fp));
277 /* abandon fd and fp even though the file is open. we need to
278 * keep it open and locked, but we don't need the handles elsewhere.
282 /* get_char(file) : like getc() but increment LineNumber on newlines
292 Set_LineNum(LineNumber + 1)
297 /* unget_char(ch, file) : like ungetc but do LineNumber processing
306 Set_LineNum(LineNumber - 1)
310 /* get_string(str, max, file, termstr) : like fgets() but
311 * (1) has terminator string which should include \n
312 * (2) will always leave room for the null
313 * (3) uses get_char() so LineNumber will be accurate
314 * (4) returns EOF or terminating character, whichever
317 get_string(string, size, file, terms)
325 while (EOF != (ch = get_char(file)) && !strchr(terms, ch)) {
327 *string++ = (char) ch;
339 /* skip_comments(file) : read past comment (if any)
347 while (EOF != (ch = get_char(file))) {
348 /* ch is now the first character of a line.
351 while (ch == ' ' || ch == '\t')
357 /* ch is now the first non-blank character of a line.
360 if (ch != '\n' && ch != '#')
363 /* ch must be a newline or comment as first non-blank
364 * character on a line.
367 while (ch != '\n' && ch != EOF)
370 /* ch is now the newline of a line which we're going to
375 unget_char(ch, file);
379 /* int in_file(char *string, FILE *file)
380 * return TRUE if one of the lines in file matches string exactly,
384 in_file(string, file)
388 char line[MAX_TEMPSTR];
391 while (fgets(line, MAX_TEMPSTR, file)) {
393 if (line[strlen(line)-1] == '\n')
394 line[strlen(line)-1] = '\0';
395 if (0 == strcmp(line, string))
402 /* int allowed(char *username)
403 * returns TRUE if (ALLOW_FILE exists and user is listed)
404 * or (DENY_FILE exists and user is NOT listed)
405 * or (neither file exists but user=="root" so it's okay)
411 static int init = FALSE;
412 static FILE *allow, *deny;
416 #if defined(ALLOW_FILE) && defined(DENY_FILE)
417 allow = fopen(ALLOW_FILE, "r");
418 deny = fopen(DENY_FILE, "r");
419 Debug(DMISC, ("allow/deny enabled, %d/%d\n", !!allow, !!deny))
427 return (in_file(username, allow));
429 return (!in_file(username, deny));
431 #if defined(ALLOW_ONLY_ROOT)
432 return (strcmp(username, ROOT_USER) == 0);
440 log_it(username, xpid, event, detail)
447 #if defined(LOG_FILE)
449 TIME_T now = time((TIME_T) 0);
450 register struct tm *t = localtime(&now);
454 static int syslog_open = 0;
457 #if defined(LOG_FILE)
458 /* we assume that MAX_TEMPSTR will hold the date, time, &punctuation.
460 msg = malloc(strlen(username)
466 warnx("failed to allocate memory for log message");
469 LogFD = open(LOG_FILE, O_WRONLY|O_APPEND|O_CREAT, 0600);
471 warn("can't open log file %s", LOG_FILE);
473 (void) fcntl(LogFD, F_SETFD, 1);
477 /* we have to sprintf() it because fprintf() doesn't always
478 * write everything out in one chunk and this has to be
479 * atomically appended to the log file.
481 sprintf(msg, "%s (%02d/%02d-%02d:%02d:%02d-%d) %s (%s)\n",
483 t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min,
484 t->tm_sec, pid, event, detail);
486 /* we have to run strlen() because sprintf() returns (char*)
489 if (LogFD < OK || write(LogFD, msg, strlen(msg)) < OK) {
491 warn("%s", LOG_FILE);
492 warnx("can't write to log file");
493 write(STDERR, msg, strlen(msg));
502 /* we don't use LOG_PID since the pid passed to us by
503 * our client may not be our own. therefore we want to
504 * print the pid ourselves.
507 openlog(ProgramName, LOG_PID, LOG_CRON);
509 openlog(ProgramName, LOG_PID);
511 syslog_open = TRUE; /* assume openlog success */
514 syslog(LOG_INFO, "(%s) %s (%s)\n", username, event, detail);
520 fprintf(stderr, "log_it: (%s %d) %s (%s)\n",
521 username, pid, event, detail);
537 * (1) this routine is fairly slow
538 * (2) it returns a pointer to static storage
542 register char *s; /* string we want the first word of */
543 register char *t; /* terminators, implicitly including \0 */
545 static char retbuf[2][MAX_TEMPSTR + 1]; /* sure wish C had GC */
546 static int retsel = 0;
547 register char *rb, *rp;
549 /* select a return buffer */
551 rb = &retbuf[retsel][0];
554 /* skip any leading terminators */
555 while (*s && (NULL != strchr(t, *s))) {
559 /* copy until next terminator or full buffer */
560 while (*s && (NULL == strchr(t, *s)) && (rp < &rb[MAX_TEMPSTR])) {
564 /* finish the return-string and return it */
571 * heavily ascii-dependent.
574 mkprint(dst, src, len)
576 register unsigned char *src;
581 register unsigned char ch = *src++;
583 if (ch < ' ') { /* control character */
586 } else if (ch < 0177) { /* printable */
588 } else if (ch == 0177) { /* delete/rubout */
591 } else { /* parity character */
592 sprintf(dst, "\\%03o", ch);
601 * returns a pointer to malloc'd storage, you must call free yourself.
605 register unsigned char *src;
606 register unsigned int len;
608 register char *dst = malloc(len*4 + 1);
611 mkprint(dst, src, len);
618 /* Sat, 27 Feb 93 11:44:51 CST
619 * 123456789012345678901234567
625 time_t t = clock ?*clock :time(0L);
626 struct tm *tm = localtime(&t);
627 static char ret[32]; /* zone name might be >3 chars */
629 if (tm->tm_year >= 100)
632 (void) snprintf(ret, sizeof(ret), "%s, %2d %s %d %02d:%02d:%02d %s",
633 DowNames[tm->tm_wday],
635 MonthNames[tm->tm_mon],
646 #ifdef HAVE_SAVED_UIDS
647 static int save_euid;
648 int swap_uids() { save_euid = geteuid(); return seteuid(getuid()); }
649 int swap_uids_back() { return seteuid(save_euid); }
650 #else /*HAVE_SAVED_UIDS*/
651 int swap_uids() { return setreuid(geteuid(), getuid()); }
652 int swap_uids_back() { return swap_uids(); }
653 #endif /*HAVE_SAVED_UIDS*/