xref: /freebsd/usr.sbin/cron/lib/misc.c (revision 71fe318b852b8dfb3e799cb12ef184750f7f8eac)
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 
18 #if !defined(lint) && !defined(LINT)
19 static const char rcsid[] =
20   "$FreeBSD$";
21 #endif
22 
23 /* vix 26jan87 [RCS has the rest of the log]
24  * vix 30dec86 [written]
25  */
26 
27 
28 #include "cron.h"
29 #if SYS_TIME_H
30 # include <sys/time.h>
31 #else
32 # include <time.h>
33 #endif
34 #include <sys/file.h>
35 #include <sys/stat.h>
36 #include <err.h>
37 #include <errno.h>
38 #include <string.h>
39 #include <fcntl.h>
40 #if defined(SYSLOG)
41 # include <syslog.h>
42 #endif
43 
44 
45 #if defined(LOG_DAEMON) && !defined(LOG_CRON)
46 #define LOG_CRON LOG_DAEMON
47 #endif
48 
49 
50 static int		LogFD = ERR;
51 
52 
53 int
54 strcmp_until(left, right, until)
55 	char	*left;
56 	char	*right;
57 	int	until;
58 {
59 	register int	diff;
60 
61 	while (*left && *left != until && *left == *right) {
62 		left++;
63 		right++;
64 	}
65 
66 	if ((*left=='\0' || *left == until) &&
67 	    (*right=='\0' || *right == until)) {
68 		diff = 0;
69 	} else {
70 		diff = *left - *right;
71 	}
72 
73 	return diff;
74 }
75 
76 
77 /* strdtb(s) - delete trailing blanks in string 's' and return new length
78  */
79 int
80 strdtb(s)
81 	char	*s;
82 {
83 	char	*x = s;
84 
85 	/* scan forward to the null
86 	 */
87 	while (*x)
88 		x++;
89 
90 	/* scan backward to either the first character before the string,
91 	 * or the last non-blank in the string, whichever comes first.
92 	 */
93 	do	{x--;}
94 	while (x >= s && isspace(*x));
95 
96 	/* one character beyond where we stopped above is where the null
97 	 * goes.
98 	 */
99 	*++x = '\0';
100 
101 	/* the difference between the position of the null character and
102 	 * the position of the first character of the string is the length.
103 	 */
104 	return x - s;
105 }
106 
107 
108 int
109 set_debug_flags(flags)
110 	char	*flags;
111 {
112 	/* debug flags are of the form    flag[,flag ...]
113 	 *
114 	 * if an error occurs, print a message to stdout and return FALSE.
115 	 * otherwise return TRUE after setting ERROR_FLAGS.
116 	 */
117 
118 #if !DEBUGGING
119 
120 	printf("this program was compiled without debugging enabled\n");
121 	return FALSE;
122 
123 #else /* DEBUGGING */
124 
125 	char	*pc = flags;
126 
127 	DebugFlags = 0;
128 
129 	while (*pc) {
130 		char	**test;
131 		int	mask;
132 
133 		/* try to find debug flag name in our list.
134 		 */
135 		for (	test = DebugFlagNames, mask = 1;
136 			*test && strcmp_until(*test, pc, ',');
137 			test++, mask <<= 1
138 		    )
139 			;
140 
141 		if (!*test) {
142 			fprintf(stderr,
143 				"unrecognized debug flag <%s> <%s>\n",
144 				flags, pc);
145 			return FALSE;
146 		}
147 
148 		DebugFlags |= mask;
149 
150 		/* skip to the next flag
151 		 */
152 		while (*pc && *pc != ',')
153 			pc++;
154 		if (*pc == ',')
155 			pc++;
156 	}
157 
158 	if (DebugFlags) {
159 		int	flag;
160 
161 		fprintf(stderr, "debug flags enabled:");
162 
163 		for (flag = 0;  DebugFlagNames[flag];  flag++)
164 			if (DebugFlags & (1 << flag))
165 				fprintf(stderr, " %s", DebugFlagNames[flag]);
166 		fprintf(stderr, "\n");
167 	}
168 
169 	return TRUE;
170 
171 #endif /* DEBUGGING */
172 }
173 
174 
175 void
176 set_cron_uid()
177 {
178 #if defined(BSD) || defined(POSIX)
179 	if (seteuid(ROOT_UID) < OK)
180 		err(ERROR_EXIT, "seteuid");
181 #else
182 	if (setuid(ROOT_UID) < OK)
183 		err(ERROR_EXIT, "setuid");
184 #endif
185 }
186 
187 
188 void
189 set_cron_cwd()
190 {
191 	struct stat	sb;
192 
193 	/* first check for CRONDIR ("/var/cron" or some such)
194 	 */
195 	if (stat(CRONDIR, &sb) < OK && errno == ENOENT) {
196 		warn("%s", CRONDIR);
197 		if (OK == mkdir(CRONDIR, 0700)) {
198 			warnx("%s: created", CRONDIR);
199 			stat(CRONDIR, &sb);
200 		} else {
201 			err(ERROR_EXIT, "%s: mkdir", CRONDIR);
202 		}
203 	}
204 	if (!(sb.st_mode & S_IFDIR))
205 		err(ERROR_EXIT, "'%s' is not a directory, bailing out", CRONDIR);
206 	if (chdir(CRONDIR) < OK)
207 		err(ERROR_EXIT, "cannot chdir(%s), bailing out", CRONDIR);
208 
209 	/* CRONDIR okay (now==CWD), now look at SPOOL_DIR ("tabs" or some such)
210 	 */
211 	if (stat(SPOOL_DIR, &sb) < OK && errno == ENOENT) {
212 		warn("%s", SPOOL_DIR);
213 		if (OK == mkdir(SPOOL_DIR, 0700)) {
214 			warnx("%s: created", SPOOL_DIR);
215 			stat(SPOOL_DIR, &sb);
216 		} else {
217 			err(ERROR_EXIT, "%s: mkdir", SPOOL_DIR);
218 		}
219 	}
220 	if (!(sb.st_mode & S_IFDIR))
221 		err(ERROR_EXIT, "'%s' is not a directory, bailing out", SPOOL_DIR);
222 }
223 
224 
225 /* acquire_daemonlock() - write our PID into /etc/cron.pid, unless
226  *	another daemon is already running, which we detect here.
227  *
228  * note: main() calls us twice; once before forking, once after.
229  *	we maintain static storage of the file pointer so that we
230  *	can rewrite our PID into the PIDFILE after the fork.
231  *
232  * it would be great if fflush() disassociated the file buffer.
233  */
234 void
235 acquire_daemonlock(closeflag)
236 	int closeflag;
237 {
238 	static	FILE	*fp = NULL;
239 
240 	if (closeflag && fp) {
241 		fclose(fp);
242 		fp = NULL;
243 		return;
244 	}
245 
246 	if (!fp) {
247 		char	pidfile[MAX_FNAME];
248 		char	buf[MAX_TEMPSTR];
249 		int	fd, otherpid;
250 
251 		(void) sprintf(pidfile, PIDFILE, PIDDIR);
252 		if ((-1 == (fd = open(pidfile, O_RDWR|O_CREAT, 0644)))
253 		    || (NULL == (fp = fdopen(fd, "r+")))
254 		    ) {
255 			sprintf(buf, "can't open or create %s: %s",
256 				pidfile, strerror(errno));
257 			log_it("CRON", getpid(), "DEATH", buf);
258 			errx(ERROR_EXIT, "%s", buf);
259 		}
260 
261 		if (flock(fd, LOCK_EX|LOCK_NB) < OK) {
262 			int save_errno = errno;
263 
264 			fscanf(fp, "%d", &otherpid);
265 			sprintf(buf, "can't lock %s, otherpid may be %d: %s",
266 				pidfile, otherpid, strerror(save_errno));
267 			log_it("CRON", getpid(), "DEATH", buf);
268 			errx(ERROR_EXIT, "%s", buf);
269 		}
270 
271 		(void) fcntl(fd, F_SETFD, 1);
272 	}
273 
274 	rewind(fp);
275 	fprintf(fp, "%d\n", getpid());
276 	fflush(fp);
277 	(void) ftruncate(fileno(fp), ftell(fp));
278 
279 	/* abandon fd and fp even though the file is open. we need to
280 	 * keep it open and locked, but we don't need the handles elsewhere.
281 	 */
282 }
283 
284 /* get_char(file) : like getc() but increment LineNumber on newlines
285  */
286 int
287 get_char(file)
288 	FILE	*file;
289 {
290 	int	ch;
291 
292 	ch = getc(file);
293 	if (ch == '\n')
294 		Set_LineNum(LineNumber + 1)
295 	return ch;
296 }
297 
298 
299 /* unget_char(ch, file) : like ungetc but do LineNumber processing
300  */
301 void
302 unget_char(ch, file)
303 	int	ch;
304 	FILE	*file;
305 {
306 	ungetc(ch, file);
307 	if (ch == '\n')
308 		Set_LineNum(LineNumber - 1)
309 }
310 
311 
312 /* get_string(str, max, file, termstr) : like fgets() but
313  *		(1) has terminator string which should include \n
314  *		(2) will always leave room for the null
315  *		(3) uses get_char() so LineNumber will be accurate
316  *		(4) returns EOF or terminating character, whichever
317  */
318 int
319 get_string(string, size, file, terms)
320 	char	*string;
321 	int	size;
322 	FILE	*file;
323 	char	*terms;
324 {
325 	int	ch;
326 
327 	while (EOF != (ch = get_char(file)) && !strchr(terms, ch)) {
328 		if (size > 1) {
329 			*string++ = (char) ch;
330 			size--;
331 		}
332 	}
333 
334 	if (size > 0)
335 		*string = '\0';
336 
337 	return ch;
338 }
339 
340 
341 /* skip_comments(file) : read past comment (if any)
342  */
343 void
344 skip_comments(file)
345 	FILE	*file;
346 {
347 	int	ch;
348 
349 	while (EOF != (ch = get_char(file))) {
350 		/* ch is now the first character of a line.
351 		 */
352 
353 		while (ch == ' ' || ch == '\t')
354 			ch = get_char(file);
355 
356 		if (ch == EOF)
357 			break;
358 
359 		/* ch is now the first non-blank character of a line.
360 		 */
361 
362 		if (ch != '\n' && ch != '#')
363 			break;
364 
365 		/* ch must be a newline or comment as first non-blank
366 		 * character on a line.
367 		 */
368 
369 		while (ch != '\n' && ch != EOF)
370 			ch = get_char(file);
371 
372 		/* ch is now the newline of a line which we're going to
373 		 * ignore.
374 		 */
375 	}
376 	if (ch != EOF)
377 		unget_char(ch, file);
378 }
379 
380 
381 /* int in_file(char *string, FILE *file)
382  *	return TRUE if one of the lines in file matches string exactly,
383  *	FALSE otherwise.
384  */
385 static int
386 in_file(string, file)
387 	char *string;
388 	FILE *file;
389 {
390 	char line[MAX_TEMPSTR];
391 
392 	rewind(file);
393 	while (fgets(line, MAX_TEMPSTR, file)) {
394 		if (line[0] != '\0')
395 			if (line[strlen(line)-1] == '\n')
396 				line[strlen(line)-1] = '\0';
397 		if (0 == strcmp(line, string))
398 			return TRUE;
399 	}
400 	return FALSE;
401 }
402 
403 
404 /* int allowed(char *username)
405  *	returns TRUE if (ALLOW_FILE exists and user is listed)
406  *	or (DENY_FILE exists and user is NOT listed)
407  *	or (neither file exists but user=="root" so it's okay)
408  */
409 int
410 allowed(username)
411 	char *username;
412 {
413 	FILE	*allow, *deny;
414 	int	isallowed;
415 
416 	isallowed = FALSE;
417 
418 #if defined(ALLOW_FILE) && defined(DENY_FILE)
419 	if ((allow = fopen(ALLOW_FILE, "r")) == NULL && errno != ENOENT)
420 		goto out;
421 	if ((deny = fopen(DENY_FILE, "r")) == NULL && errno != ENOENT)
422 		goto out;
423 	Debug(DMISC, ("allow/deny enabled, %d/%d\n", !!allow, !!deny))
424 #else
425 	allow = NULL;
426 	deny = NULL;
427 #endif
428 
429 	if (allow)
430 		isallowed = in_file(username, allow);
431 	else if (deny)
432 		isallowed = !in_file(username, deny);
433 	else {
434 #if defined(ALLOW_ONLY_ROOT)
435 		isallowed = (strcmp(username, ROOT_USER) == 0);
436 #else
437 		isallowed = TRUE;
438 #endif
439 	}
440 out:	if (allow)
441 		fclose(allow);
442 	if (deny)
443 		fclose(deny);
444 	return (isallowed);
445 }
446 
447 
448 void
449 log_it(username, xpid, event, detail)
450 	char	*username;
451 	int	xpid;
452 	char	*event;
453 	char	*detail;
454 {
455 	PID_T			pid = xpid;
456 #if defined(LOG_FILE)
457 	char			*msg;
458 	TIME_T			now = time((TIME_T) 0);
459 	register struct tm	*t = localtime(&now);
460 #endif /*LOG_FILE*/
461 
462 #if defined(SYSLOG)
463 	static int		syslog_open = 0;
464 #endif
465 
466 #if defined(LOG_FILE)
467 	/* we assume that MAX_TEMPSTR will hold the date, time, &punctuation.
468 	 */
469 	msg = malloc(strlen(username)
470 		     + strlen(event)
471 		     + strlen(detail)
472 		     + MAX_TEMPSTR);
473 
474 	if (msg == NULL)
475 		warnx("failed to allocate memory for log message");
476 	else {
477 		if (LogFD < OK) {
478 			LogFD = open(LOG_FILE, O_WRONLY|O_APPEND|O_CREAT, 0600);
479 			if (LogFD < OK) {
480 				warn("can't open log file %s", LOG_FILE);
481 			} else {
482 				(void) fcntl(LogFD, F_SETFD, 1);
483 			}
484 		}
485 
486 		/* we have to sprintf() it because fprintf() doesn't always
487 		 * write everything out in one chunk and this has to be
488 		 * atomically appended to the log file.
489 		 */
490 		sprintf(msg, "%s (%02d/%02d-%02d:%02d:%02d-%d) %s (%s)\n",
491 			username,
492 			t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min,
493 			t->tm_sec, pid, event, detail);
494 
495 		/* we have to run strlen() because sprintf() returns (char*)
496 		 * on old BSD.
497 		 */
498 		if (LogFD < OK || write(LogFD, msg, strlen(msg)) < OK) {
499 			if (LogFD >= OK)
500 				warn("%s", LOG_FILE);
501 			warnx("can't write to log file");
502 			write(STDERR, msg, strlen(msg));
503 		}
504 
505 		free(msg);
506 	}
507 #endif /*LOG_FILE*/
508 
509 #if defined(SYSLOG)
510 	if (!syslog_open) {
511 		/* we don't use LOG_PID since the pid passed to us by
512 		 * our client may not be our own.  therefore we want to
513 		 * print the pid ourselves.
514 		 */
515 # ifdef LOG_DAEMON
516 		openlog(ProgramName, LOG_PID, LOG_CRON);
517 # else
518 		openlog(ProgramName, LOG_PID);
519 # endif
520 		syslog_open = TRUE;		/* assume openlog success */
521 	}
522 
523 	syslog(LOG_INFO, "(%s) %s (%s)\n", username, event, detail);
524 
525 #endif /*SYSLOG*/
526 
527 #if DEBUGGING
528 	if (DebugFlags) {
529 		fprintf(stderr, "log_it: (%s %d) %s (%s)\n",
530 			username, pid, event, detail);
531 	}
532 #endif
533 }
534 
535 
536 void
537 log_close() {
538 	if (LogFD != ERR) {
539 		close(LogFD);
540 		LogFD = ERR;
541 	}
542 }
543 
544 
545 /* two warnings:
546  *	(1) this routine is fairly slow
547  *	(2) it returns a pointer to static storage
548  */
549 char *
550 first_word(s, t)
551 	register char *s;	/* string we want the first word of */
552 	register char *t;	/* terminators, implicitly including \0 */
553 {
554 	static char retbuf[2][MAX_TEMPSTR + 1];	/* sure wish C had GC */
555 	static int retsel = 0;
556 	register char *rb, *rp;
557 
558 	/* select a return buffer */
559 	retsel = 1-retsel;
560 	rb = &retbuf[retsel][0];
561 	rp = rb;
562 
563 	/* skip any leading terminators */
564 	while (*s && (NULL != strchr(t, *s))) {
565 		s++;
566 	}
567 
568 	/* copy until next terminator or full buffer */
569 	while (*s && (NULL == strchr(t, *s)) && (rp < &rb[MAX_TEMPSTR])) {
570 		*rp++ = *s++;
571 	}
572 
573 	/* finish the return-string and return it */
574 	*rp = '\0';
575 	return rb;
576 }
577 
578 
579 /* warning:
580  *	heavily ascii-dependent.
581  */
582 void
583 mkprint(dst, src, len)
584 	register char *dst;
585 	register unsigned char *src;
586 	register int len;
587 {
588 	while (len-- > 0)
589 	{
590 		register unsigned char ch = *src++;
591 
592 		if (ch < ' ') {			/* control character */
593 			*dst++ = '^';
594 			*dst++ = ch + '@';
595 		} else if (ch < 0177) {		/* printable */
596 			*dst++ = ch;
597 		} else if (ch == 0177) {	/* delete/rubout */
598 			*dst++ = '^';
599 			*dst++ = '?';
600 		} else {			/* parity character */
601 			sprintf(dst, "\\%03o", ch);
602 			dst += 4;
603 		}
604 	}
605 	*dst = '\0';
606 }
607 
608 
609 /* warning:
610  *	returns a pointer to malloc'd storage, you must call free yourself.
611  */
612 char *
613 mkprints(src, len)
614 	register unsigned char *src;
615 	register unsigned int len;
616 {
617 	register char *dst = malloc(len*4 + 1);
618 
619 	if (dst != NULL)
620 		mkprint(dst, src, len);
621 
622 	return dst;
623 }
624 
625 
626 #ifdef MAIL_DATE
627 /* Sat, 27 Feb 93 11:44:51 CST
628  * 123456789012345678901234567
629  */
630 char *
631 arpadate(clock)
632 	time_t *clock;
633 {
634 	time_t t = clock ?*clock :time(0L);
635 	struct tm *tm = localtime(&t);
636 	static char ret[32];	/* zone name might be >3 chars */
637 
638 	if (tm->tm_year >= 100)
639 		tm->tm_year += 1900;
640 
641 	(void) snprintf(ret, sizeof(ret), "%s, %2d %s %d %02d:%02d:%02d %s",
642 		       DowNames[tm->tm_wday],
643 		       tm->tm_mday,
644 		       MonthNames[tm->tm_mon],
645 		       tm->tm_year,
646 		       tm->tm_hour,
647 		       tm->tm_min,
648 		       tm->tm_sec,
649 		       TZONE(*tm));
650 	return ret;
651 }
652 #endif /*MAIL_DATE*/
653 
654 
655 #ifdef HAVE_SAVED_UIDS
656 static int save_euid;
657 int swap_uids() { save_euid = geteuid(); return seteuid(getuid()); }
658 int swap_uids_back() { return seteuid(save_euid); }
659 #else /*HAVE_SAVED_UIDS*/
660 int swap_uids() { return setreuid(geteuid(), getuid()); }
661 int swap_uids_back() { return swap_uids(); }
662 #endif /*HAVE_SAVED_UIDS*/
663