xref: /dragonfly/usr.sbin/cron/crontab/crontab.c (revision 2d8a3be7) 
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  * From Id: crontab.c,v 2.13 1994/01/17 03:20:37 vixie Exp
18  * $FreeBSD: src/usr.sbin/cron/crontab/crontab.c,v 1.12.2.4 2001/06/16 03:18:37 peter Exp $
19  * $DragonFly: src/usr.sbin/cron/crontab/crontab.c,v 1.3 2003/11/03 19:31:36 eirikn Exp $
20  */
21 
22 /* crontab - install and manage per-user crontab files
23  * vix 02may87 [RCS has the rest of the log]
24  * vix 26jan87 [original]
25  */
26 
27 static char version[] = "$DragonFly: src/usr.sbin/cron/crontab/crontab.c,v 1.3 2003/11/03 19:31:36 eirikn Exp $";
28 
29 #define	MAIN_PROGRAM
30 
31 #include "cron.h"
32 #include <errno.h>
33 #include <fcntl.h>
34 #include <paths.h>
35 #include <sys/file.h>
36 #include <sys/stat.h>
37 #ifdef USE_UTIMES
38 # include <sys/time.h>
39 #else
40 # include <time.h>
41 # include <utime.h>
42 #endif
43 #if defined(POSIX)
44 # include <locale.h>
45 #endif
46 
47 
48 #define NHEADER_LINES 3
49 
50 
51 enum opt_t	{ opt_unknown, opt_list, opt_delete, opt_edit, opt_replace };
52 
53 #if DEBUGGING
54 static char	*Options[] = { "???", "list", "delete", "edit", "replace" };
55 #endif
56 
57 
58 static	PID_T		Pid;
59 static	char		User[MAX_UNAME], RealUser[MAX_UNAME];
60 static	char		Filename[MAX_FNAME];
61 static	FILE		*NewCrontab;
62 static	int		CheckErrorCount;
63 static	enum opt_t	Option;
64 static	struct passwd	*pw;
65 static	void		list_cmd(void),
66 			delete_cmd(void),
67 			edit_cmd(void),
68 			poke_daemon(void),
69 			check_error(char *),
70 			parse_args(int c, char *v[]);
71 static	int		replace_cmd(void);
72 
73 
74 static void
75 usage(msg)
76 	char *msg;
77 {
78 	fprintf(stderr, "crontab: usage error: %s\n", msg);
79 	fprintf(stderr, "%s\n%s\n",
80 		"usage: crontab [-u user] file",
81 		"       crontab [-u user] { -e | -l | -r }");
82 	exit(ERROR_EXIT);
83 }
84 
85 
86 int
87 main(argc, argv)
88 	int	argc;
89 	char	*argv[];
90 {
91 	int	exitstatus;
92 
93 	Pid = getpid();
94 	ProgramName = argv[0];
95 
96 #if defined(POSIX)
97 	setlocale(LC_ALL, "");
98 #endif
99 
100 #if defined(BSD)
101 	setlinebuf(stderr);
102 #endif
103 	parse_args(argc, argv);		/* sets many globals, opens a file */
104 	set_cron_uid();
105 	set_cron_cwd();
106 	if (!allowed(User)) {
107 		warnx("you (%s) are not allowed to use this program", User);
108 		log_it(RealUser, Pid, "AUTH", "crontab command not allowed");
109 		exit(ERROR_EXIT);
110 	}
111 	exitstatus = OK_EXIT;
112 	switch (Option) {
113 	case opt_list:		list_cmd();
114 				break;
115 	case opt_delete:	delete_cmd();
116 				break;
117 	case opt_edit:		edit_cmd();
118 				break;
119 	case opt_replace:	if (replace_cmd() < 0)
120 					exitstatus = ERROR_EXIT;
121 				break;
122 	case opt_unknown:
123 				break;
124 	}
125 	exit(0);
126 	/*NOTREACHED*/
127 }
128 
129 
130 static void
131 parse_args(argc, argv)
132 	int	argc;
133 	char	*argv[];
134 {
135 	int		argch;
136 
137 	if (!(pw = getpwuid(getuid())))
138 		errx(ERROR_EXIT, "your UID isn't in the passwd file, bailing out");
139 	(void) strncpy(User, pw->pw_name, (sizeof User)-1);
140 	User[(sizeof User)-1] = '\0';
141 	strcpy(RealUser, User);
142 	Filename[0] = '\0';
143 	Option = opt_unknown;
144 	while ((argch = getopt(argc, argv, "u:lerx:")) != -1) {
145 		switch (argch) {
146 		case 'x':
147 			if (!set_debug_flags(optarg))
148 				usage("bad debug option");
149 			break;
150 		case 'u':
151 			if (getuid() != ROOT_UID)
152 				errx(ERROR_EXIT, "must be privileged to use -u");
153 			if (!(pw = getpwnam(optarg)))
154 				errx(ERROR_EXIT, "user `%s' unknown", optarg);
155 			(void) strncpy(User, pw->pw_name, (sizeof User)-1);
156 			User[(sizeof User)-1] = '\0';
157 			break;
158 		case 'l':
159 			if (Option != opt_unknown)
160 				usage("only one operation permitted");
161 			Option = opt_list;
162 			break;
163 		case 'r':
164 			if (Option != opt_unknown)
165 				usage("only one operation permitted");
166 			Option = opt_delete;
167 			break;
168 		case 'e':
169 			if (Option != opt_unknown)
170 				usage("only one operation permitted");
171 			Option = opt_edit;
172 			break;
173 		default:
174 			usage("unrecognized option");
175 		}
176 	}
177 
178 	endpwent();
179 
180 	if (Option != opt_unknown) {
181 		if (argv[optind] != NULL) {
182 			usage("no arguments permitted after this option");
183 		}
184 	} else {
185 		if (argv[optind] != NULL) {
186 			Option = opt_replace;
187 			(void) strncpy (Filename, argv[optind], (sizeof Filename)-1);
188 			Filename[(sizeof Filename)-1] = '\0';
189 
190 		} else {
191 			usage("file name must be specified for replace");
192 		}
193 	}
194 
195 	if (Option == opt_replace) {
196 		/* we have to open the file here because we're going to
197 		 * chdir(2) into /var/cron before we get around to
198 		 * reading the file.
199 		 */
200 		if (!strcmp(Filename, "-")) {
201 			NewCrontab = stdin;
202 		} else {
203 			/* relinquish the setuid status of the binary during
204 			 * the open, lest nonroot users read files they should
205 			 * not be able to read.  we can't use access() here
206 			 * since there's a race condition.  thanks go out to
207 			 * Arnt Gulbrandsen <agulbra@pvv.unit.no> for spotting
208 			 * the race.
209 			 */
210 
211 			if (swap_uids() < OK)
212 				err(ERROR_EXIT, "swapping uids");
213 			if (!(NewCrontab = fopen(Filename, "r")))
214 				err(ERROR_EXIT, "%s", Filename);
215 			if (swap_uids() < OK)
216 				err(ERROR_EXIT, "swapping uids back");
217 		}
218 	}
219 
220 	Debug(DMISC, ("user=%s, file=%s, option=%s\n",
221 		      User, Filename, Options[(int)Option]))
222 }
223 
224 
225 static void
226 list_cmd() {
227 	char	n[MAX_FNAME];
228 	FILE	*f;
229 	int	ch, x;
230 
231 	log_it(RealUser, Pid, "LIST", User);
232 	(void) sprintf(n, CRON_TAB(User));
233 	if (!(f = fopen(n, "r"))) {
234 		if (errno == ENOENT)
235 			errx(ERROR_EXIT, "no crontab for %s", User);
236 		else
237 			err(ERROR_EXIT, "%s", n);
238 	}
239 
240 	/* file is open. copy to stdout, close.
241 	 */
242 	Set_LineNum(1)
243 
244 	/* ignore the top few comments since we probably put them there.
245 	 */
246 	for (x = 0;  x < NHEADER_LINES;  x++) {
247 		ch = get_char(f);
248 		if (EOF == ch)
249 			break;
250 		if ('#' != ch) {
251 			putchar(ch);
252 			break;
253 		}
254 		while (EOF != (ch = get_char(f)))
255 			if (ch == '\n')
256 				break;
257 		if (EOF == ch)
258 			break;
259 	}
260 
261 	while (EOF != (ch = get_char(f)))
262 		putchar(ch);
263 	fclose(f);
264 }
265 
266 
267 static void
268 delete_cmd() {
269 	char	n[MAX_FNAME];
270 	int ch, first;
271 
272 	if (isatty(STDIN_FILENO)) {
273 		(void)fprintf(stderr, "remove crontab for %s? ", User);
274 		first = ch = getchar();
275 		while (ch != '\n' && ch != EOF)
276 			ch = getchar();
277 		if (first != 'y' && first != 'Y')
278 			return;
279 	}
280 
281 	log_it(RealUser, Pid, "DELETE", User);
282 	(void) sprintf(n, CRON_TAB(User));
283 	if (unlink(n)) {
284 		if (errno == ENOENT)
285 			errx(ERROR_EXIT, "no crontab for %s", User);
286 		else
287 			err(ERROR_EXIT, "%s", n);
288 	}
289 	poke_daemon();
290 }
291 
292 
293 static void
294 check_error(msg)
295 	char	*msg;
296 {
297 	CheckErrorCount++;
298 	fprintf(stderr, "\"%s\":%d: %s\n", Filename, LineNumber-1, msg);
299 }
300 
301 
302 static void
303 edit_cmd() {
304 	char		n[MAX_FNAME], q[MAX_TEMPSTR], *editor;
305 	FILE		*f;
306 	int		ch, t, x;
307 	struct stat	statbuf, fsbuf;
308 	time_t		mtime;
309 	WAIT_T		waiter;
310 	PID_T		pid, xpid;
311 	mode_t		um;
312 
313 	log_it(RealUser, Pid, "BEGIN EDIT", User);
314 	(void) sprintf(n, CRON_TAB(User));
315 	if (!(f = fopen(n, "r"))) {
316 		if (errno != ENOENT)
317 			err(ERROR_EXIT, "%s", n);
318 		warnx("no crontab for %s - using an empty one", User);
319 		if (!(f = fopen(_PATH_DEVNULL, "r")))
320 			err(ERROR_EXIT, _PATH_DEVNULL);
321 	}
322 
323 	um = umask(077);
324 	(void) sprintf(Filename, "/tmp/crontab.XXXXXXXXXX");
325 	if ((t = mkstemp(Filename)) == -1) {
326 		warn("%s", Filename);
327 		(void) umask(um);
328 		goto fatal;
329 	}
330 	(void) umask(um);
331 #ifdef HAS_FCHOWN
332 	if (fchown(t, getuid(), getgid()) < 0) {
333 #else
334 	if (chown(Filename, getuid(), getgid()) < 0) {
335 #endif
336 		warn("fchown");
337 		goto fatal;
338 	}
339 	if (!(NewCrontab = fdopen(t, "r+"))) {
340 		warn("fdopen");
341 		goto fatal;
342 	}
343 
344 	Set_LineNum(1)
345 
346 	/* ignore the top few comments since we probably put them there.
347 	 */
348 	for (x = 0;  x < NHEADER_LINES;  x++) {
349 		ch = get_char(f);
350 		if (EOF == ch)
351 			break;
352 		if ('#' != ch) {
353 			putc(ch, NewCrontab);
354 			break;
355 		}
356 		while (EOF != (ch = get_char(f)))
357 			if (ch == '\n')
358 				break;
359 		if (EOF == ch)
360 			break;
361 	}
362 
363 	/* copy the rest of the crontab (if any) to the temp file.
364 	 */
365 	if (EOF != ch)
366 		while (EOF != (ch = get_char(f)))
367 			putc(ch, NewCrontab);
368 	fclose(f);
369 	if (fflush(NewCrontab))
370 		err(ERROR_EXIT, "%s", Filename);
371 	if (fstat(t, &fsbuf) < 0) {
372 		warn("unable to fstat temp file");
373 		goto fatal;
374 	}
375  again:
376 	if (stat(Filename, &statbuf) < 0) {
377 		warn("stat");
378  fatal:		unlink(Filename);
379 		exit(ERROR_EXIT);
380 	}
381 	if (statbuf.st_dev != fsbuf.st_dev || statbuf.st_ino != fsbuf.st_ino)
382 		errx(ERROR_EXIT, "temp file must be edited in place");
383 	mtime = statbuf.st_mtime;
384 
385 	if ((!(editor = getenv("VISUAL")))
386 	 && (!(editor = getenv("EDITOR")))
387 	    ) {
388 		editor = EDITOR;
389 	}
390 
391 	/* we still have the file open.  editors will generally rewrite the
392 	 * original file rather than renaming/unlinking it and starting a
393 	 * new one; even backup files are supposed to be made by copying
394 	 * rather than by renaming.  if some editor does not support this,
395 	 * then don't use it.  the security problems are more severe if we
396 	 * close and reopen the file around the edit.
397 	 */
398 
399 	switch (pid = fork()) {
400 	case -1:
401 		warn("fork");
402 		goto fatal;
403 	case 0:
404 		/* child */
405 		if (setuid(getuid()) < 0)
406 			err(ERROR_EXIT, "setuid(getuid())");
407 		if (chdir("/tmp") < 0)
408 			err(ERROR_EXIT, "chdir(/tmp)");
409 		if (strlen(editor) + strlen(Filename) + 2 >= MAX_TEMPSTR)
410 			errx(ERROR_EXIT, "editor or filename too long");
411 		execlp(editor, editor, Filename, NULL);
412 		err(ERROR_EXIT, "%s", editor);
413 		/*NOTREACHED*/
414 	default:
415 		/* parent */
416 		break;
417 	}
418 
419 	/* parent */
420 	{
421 	void (*f[4])();
422 	f[0] = signal(SIGHUP, SIG_IGN);
423 	f[1] = signal(SIGINT, SIG_IGN);
424 	f[2] = signal(SIGTERM, SIG_IGN);
425 	xpid = wait(&waiter);
426 	signal(SIGHUP, f[0]);
427 	signal(SIGINT, f[1]);
428 	signal(SIGTERM, f[2]);
429 	}
430 	if (xpid != pid) {
431 		warnx("wrong PID (%d != %d) from \"%s\"", xpid, pid, editor);
432 		goto fatal;
433 	}
434 	if (WIFEXITED(waiter) && WEXITSTATUS(waiter)) {
435 		warnx("\"%s\" exited with status %d", editor, WEXITSTATUS(waiter));
436 		goto fatal;
437 	}
438 	if (WIFSIGNALED(waiter)) {
439 		warnx("\"%s\" killed; signal %d (%score dumped)",
440 			editor, WTERMSIG(waiter), WCOREDUMP(waiter) ?"" :"no ");
441 		goto fatal;
442 	}
443 	if (stat(Filename, &statbuf) < 0) {
444 		warn("stat");
445 		goto fatal;
446 	}
447 	if (statbuf.st_dev != fsbuf.st_dev || statbuf.st_ino != fsbuf.st_ino)
448 		errx(ERROR_EXIT, "temp file must be edited in place");
449 	if (mtime == statbuf.st_mtime) {
450 		warnx("no changes made to crontab");
451 		goto remove;
452 	}
453 	warnx("installing new crontab");
454 	switch (replace_cmd()) {
455 	case 0:
456 		break;
457 	case -1:
458 		for (;;) {
459 			printf("Do you want to retry the same edit? ");
460 			fflush(stdout);
461 			q[0] = '\0';
462 			(void) fgets(q, sizeof q, stdin);
463 			switch (islower(q[0]) ? q[0] : tolower(q[0])) {
464 			case 'y':
465 				goto again;
466 			case 'n':
467 				goto abandon;
468 			default:
469 				fprintf(stderr, "Enter Y or N\n");
470 			}
471 		}
472 		/*NOTREACHED*/
473 	case -2:
474 	abandon:
475 		warnx("edits left in %s", Filename);
476 		goto done;
477 	default:
478 		warnx("panic: bad switch() in replace_cmd()");
479 		goto fatal;
480 	}
481  remove:
482 	unlink(Filename);
483  done:
484 	log_it(RealUser, Pid, "END EDIT", User);
485 }
486 
487 
488 /* returns	0	on success
489  *		-1	on syntax error
490  *		-2	on install error
491  */
492 static int
493 replace_cmd() {
494 	char	n[MAX_FNAME], envstr[MAX_ENVSTR], tn[MAX_FNAME];
495 	FILE	*tmp;
496 	int	ch, eof;
497 	entry	*e;
498 	time_t	now = time(NULL);
499 	char	**envp = env_init();
500 
501 	if (envp == NULL) {
502 		warnx("cannot allocate memory");
503 		return (-2);
504 	}
505 
506 	(void) sprintf(n, "tmp.%d", Pid);
507 	(void) sprintf(tn, CRON_TAB(n));
508 	if (!(tmp = fopen(tn, "w+"))) {
509 		warn("%s", tn);
510 		return (-2);
511 	}
512 
513 	/* write a signature at the top of the file.
514 	 *
515 	 * VERY IMPORTANT: make sure NHEADER_LINES agrees with this code.
516 	 */
517 	fprintf(tmp, "# DO NOT EDIT THIS FILE - edit the master and reinstall.\n");
518 	fprintf(tmp, "# (%s installed on %-24.24s)\n", Filename, ctime(&now));
519 	fprintf(tmp, "# (Cron version -- %s)\n", version);
520 
521 	/* copy the crontab to the tmp
522 	 */
523 	rewind(NewCrontab);
524 	Set_LineNum(1)
525 	while (EOF != (ch = get_char(NewCrontab)))
526 		putc(ch, tmp);
527 	ftruncate(fileno(tmp), ftell(tmp));
528 	fflush(tmp);  rewind(tmp);
529 
530 	if (ferror(tmp)) {
531 		warnx("error while writing new crontab to %s", tn);
532 		fclose(tmp);  unlink(tn);
533 		return (-2);
534 	}
535 
536 	/* check the syntax of the file being installed.
537 	 */
538 
539 	/* BUG: was reporting errors after the EOF if there were any errors
540 	 * in the file proper -- kludged it by stopping after first error.
541 	 *		vix 31mar87
542 	 */
543 	Set_LineNum(1 - NHEADER_LINES)
544 	CheckErrorCount = 0;  eof = FALSE;
545 	while (!CheckErrorCount && !eof) {
546 		switch (load_env(envstr, tmp)) {
547 		case ERR:
548 			eof = TRUE;
549 			break;
550 		case FALSE:
551 			e = load_entry(tmp, check_error, pw, envp);
552 			if (e)
553 				free(e);
554 			break;
555 		case TRUE:
556 			break;
557 		}
558 	}
559 
560 	if (CheckErrorCount != 0) {
561 		warnx("errors in crontab file, can't install");
562 		fclose(tmp);  unlink(tn);
563 		return (-1);
564 	}
565 
566 #ifdef HAS_FCHOWN
567 	if (fchown(fileno(tmp), ROOT_UID, -1) < OK)
568 #else
569 	if (chown(tn, ROOT_UID, -1) < OK)
570 #endif
571 	{
572 		warn("chown");
573 		fclose(tmp);  unlink(tn);
574 		return (-2);
575 	}
576 
577 #ifdef HAS_FCHMOD
578 	if (fchmod(fileno(tmp), 0600) < OK)
579 #else
580 	if (chmod(tn, 0600) < OK)
581 #endif
582 	{
583 		warn("chown");
584 		fclose(tmp);  unlink(tn);
585 		return (-2);
586 	}
587 
588 	if (fclose(tmp) == EOF) {
589 		warn("fclose");
590 		unlink(tn);
591 		return (-2);
592 	}
593 
594 	(void) sprintf(n, CRON_TAB(User));
595 	if (rename(tn, n)) {
596 		warn("error renaming %s to %s", tn, n);
597 		unlink(tn);
598 		return (-2);
599 	}
600 	log_it(RealUser, Pid, "REPLACE", User);
601 
602 	poke_daemon();
603 
604 	return (0);
605 }
606 
607 
608 static void
609 poke_daemon() {
610 #ifdef USE_UTIMES
611 	struct timeval tvs[2];
612 	struct timezone tz;
613 
614 	(void) gettimeofday(&tvs[0], &tz);
615 	tvs[1] = tvs[0];
616 	if (utimes(SPOOL_DIR, tvs) < OK) {
617 		warn("can't update mtime on spooldir %s", SPOOL_DIR);
618 		return;
619 	}
620 #else
621 	if (utime(SPOOL_DIR, NULL) < OK) {
622 		warn("can't update mtime on spooldir %s", SPOOL_DIR);
623 		return;
624 	}
625 #endif /*USE_UTIMES*/
626 }
627