xref: /dragonfly/libexec/dma/dma.c (revision ae071d8d) 
1 /*
2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Simon 'corecode' Schubert <corecode@fs.ei.tum.de>.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 
35 #include "dfcompat.h"
36 
37 #include <sys/param.h>
38 #include <sys/types.h>
39 #include <sys/queue.h>
40 #include <sys/stat.h>
41 #include <sys/time.h>
42 #include <sys/wait.h>
43 
44 #include <dirent.h>
45 #include <err.h>
46 #include <errno.h>
47 #include <fcntl.h>
48 #include <inttypes.h>
49 #include <paths.h>
50 #include <pwd.h>
51 #include <signal.h>
52 #include <stdarg.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 #include <syslog.h>
57 #include <unistd.h>
58 
59 #include "dma.h"
60 
61 extern int yyparse(void);
62 static void deliver(struct qitem *);
63 
64 struct aliases aliases = LIST_HEAD_INITIALIZER(aliases);
65 struct strlist tmpfs = SLIST_HEAD_INITIALIZER(tmpfs);
66 struct authusers authusers = LIST_HEAD_INITIALIZER(authusers);
67 char username[USERNAME_SIZE];
68 uid_t useruid;
69 const char *logident_base;
70 char errmsg[ERRMSG_SIZE];
71 
72 static int daemonize = 1;
73 
74 struct config config = {
75 	.smarthost	= NULL,
76 	.port		= 25,
77 	.aliases	= "/etc/aliases",
78 	.spooldir	= "/var/spool/dma",
79 	.authpath	= NULL,
80 	.certfile	= NULL,
81 	.features	= 0,
82 	.mailname	= NULL,
83 	.masquerade_host = NULL,
84 	.masquerade_user = NULL,
85 };
86 
87 
88 static void
89 sighup_handler(int signo)
90 {
91 	(void)signo;	/* so that gcc doesn't complain */
92 }
93 
94 static char *
95 set_from(struct queue *queue, const char *osender)
96 {
97 	char *sender;
98 
99 	if (osender) {
100 		sender = strdup(osender);
101 		if (sender == NULL)
102 			return (NULL);
103 	} else if (getenv("EMAIL") != NULL) {
104 		sender = strdup(getenv("EMAIL"));
105 		if (sender == NULL)
106 			return (NULL);
107 	} else {
108 		const char *from_user = username;
109 		const char *from_host = hostname();
110 
111 		if (config.masquerade_user)
112 			from_user = config.masquerade_user;
113 		if (config.masquerade_host)
114 			from_host = config.masquerade_host;
115 		if (asprintf(&sender, "%s@%s", from_user, from_host) <= 0)
116 			return (NULL);
117 	}
118 
119 	if (strchr(sender, '\n') != NULL) {
120 		errno = EINVAL;
121 		return (NULL);
122 	}
123 
124 	queue->sender = sender;
125 	return (sender);
126 }
127 
128 static int
129 read_aliases(void)
130 {
131 	yyin = fopen(config.aliases, "r");
132 	if (yyin == NULL) {
133 		/*
134 		 * Non-existing aliases file is not a fatal error
135 		 */
136 		if (errno == ENOENT)
137 			return (0);
138 		/* Other problems are. */
139 		return (-1);
140 	}
141 	if (yyparse())
142 		return (-1);	/* fatal error, probably malloc() */
143 	fclose(yyin);
144 	return (0);
145 }
146 
147 static int
148 do_alias(struct queue *queue, const char *addr)
149 {
150 	struct alias *al;
151         struct stritem *sit;
152 	int aliased = 0;
153 
154         LIST_FOREACH(al, &aliases, next) {
155                 if (strcmp(al->alias, addr) != 0)
156                         continue;
157 		SLIST_FOREACH(sit, &al->dests, next) {
158 			if (add_recp(queue, sit->str, EXPAND_ADDR) != 0)
159 				return (-1);
160 		}
161 		aliased = 1;
162         }
163 
164         return (aliased);
165 }
166 
167 int
168 add_recp(struct queue *queue, const char *str, int expand)
169 {
170 	struct qitem *it, *tit;
171 	struct passwd *pw;
172 	char *host;
173 	int aliased = 0;
174 
175 	it = calloc(1, sizeof(*it));
176 	if (it == NULL)
177 		return (-1);
178 	it->addr = strdup(str);
179 	if (it->addr == NULL)
180 		return (-1);
181 
182 	it->sender = queue->sender;
183 	host = strrchr(it->addr, '@');
184 	if (host != NULL &&
185 	    (strcmp(host + 1, hostname()) == 0 ||
186 	     strcmp(host + 1, "localhost") == 0)) {
187 		*host = 0;
188 	}
189 	LIST_FOREACH(tit, &queue->queue, next) {
190 		/* weed out duplicate dests */
191 		if (strcmp(tit->addr, it->addr) == 0) {
192 			free(it->addr);
193 			free(it);
194 			return (0);
195 		}
196 	}
197 	LIST_INSERT_HEAD(&queue->queue, it, next);
198 	if (strrchr(it->addr, '@') == NULL) {
199 		it->remote = 0;
200 		if (expand) {
201 			aliased = do_alias(queue, it->addr);
202 			if (!aliased && expand == EXPAND_WILDCARD)
203 				aliased = do_alias(queue, "*");
204 			if (aliased < 0)
205 				return (-1);
206 			if (aliased) {
207 				LIST_REMOVE(it, next);
208 			} else {
209 				/* Local destination, check */
210 				pw = getpwnam(it->addr);
211 				if (pw == NULL)
212 					goto out;
213 				/* XXX read .forward */
214 				endpwent();
215 			}
216 		}
217 	} else {
218 		it->remote = 1;
219 	}
220 
221 	return (0);
222 
223 out:
224 	free(it->addr);
225 	free(it);
226 	return (-1);
227 }
228 
229 static struct qitem *
230 go_background(struct queue *queue)
231 {
232 	struct sigaction sa;
233 	struct qitem *it;
234 	pid_t pid;
235 
236 	if (daemonize && daemon(0, 0) != 0) {
237 		syslog(LOG_ERR, "can not daemonize: %m");
238 		exit(1);
239 	}
240 	daemonize = 0;
241 
242 	bzero(&sa, sizeof(sa));
243 	sa.sa_handler = SIG_IGN;
244 	sigaction(SIGCHLD, &sa, NULL);
245 
246 	LIST_FOREACH(it, &queue->queue, next) {
247 		/* No need to fork for the last dest */
248 		if (LIST_NEXT(it, next) == NULL)
249 			goto retit;
250 
251 		pid = fork();
252 		switch (pid) {
253 		case -1:
254 			syslog(LOG_ERR, "can not fork: %m");
255 			exit(1);
256 			break;
257 
258 		case 0:
259 			/*
260 			 * Child:
261 			 *
262 			 * return and deliver mail
263 			 */
264 retit:
265 			/*
266 			 * If necessary, acquire the queue and * mail files.
267 			 * If this fails, we probably were raced by another
268 			 * process.
269 			 */
270 			setlogident("%s", it->queueid);
271 			if (acquirespool(it) < 0)
272 				exit(1);
273 			dropspool(queue, it);
274 			return (it);
275 
276 		default:
277 			/*
278 			 * Parent:
279 			 *
280 			 * fork next child
281 			 */
282 			break;
283 		}
284 	}
285 
286 	syslog(LOG_CRIT, "reached dead code");
287 	exit(1);
288 }
289 
290 static void
291 deliver(struct qitem *it)
292 {
293 	int error;
294 	unsigned int backoff = MIN_RETRY;
295 	struct timeval now;
296 	struct stat st;
297 
298 	snprintf(errmsg, sizeof(errmsg), "unknown bounce reason");
299 
300 retry:
301 	syslog(LOG_INFO, "trying delivery");
302 
303 	if (it->remote)
304 		error = deliver_remote(it);
305 	else
306 		error = deliver_local(it);
307 
308 	switch (error) {
309 	case 0:
310 		delqueue(it);
311 		syslog(LOG_INFO, "delivery successful");
312 		exit(0);
313 
314 	case 1:
315 		if (stat(it->queuefn, &st) != 0) {
316 			syslog(LOG_ERR, "lost queue file `%s'", it->queuefn);
317 			exit(1);
318 		}
319 		if (gettimeofday(&now, NULL) == 0 &&
320 		    (now.tv_sec - st.st_mtim.tv_sec > MAX_TIMEOUT)) {
321 			snprintf(errmsg, sizeof(errmsg),
322 				 "Could not deliver for the last %d seconds. Giving up.",
323 				 MAX_TIMEOUT);
324 			goto bounce;
325 		}
326 		if (sleep(backoff) == 0) {
327 			/* pick the next backoff between [1.5, 2.5) times backoff */
328 			backoff = backoff + backoff / 2 + random() % backoff;
329 			if (backoff > MAX_RETRY)
330 				backoff = MAX_RETRY;
331 		}
332 		goto retry;
333 
334 	case -1:
335 	default:
336 		break;
337 	}
338 
339 bounce:
340 	bounce(it, errmsg);
341 	/* NOTREACHED */
342 }
343 
344 void
345 run_queue(struct queue *queue)
346 {
347 	struct qitem *it;
348 
349 	if (LIST_EMPTY(&queue->queue))
350 		return;
351 
352 	it = go_background(queue);
353 	deliver(it);
354 	/* NOTREACHED */
355 }
356 
357 static void
358 show_queue(struct queue *queue)
359 {
360 	struct qitem *it;
361 	int locked = 0;	/* XXX */
362 
363 	if (LIST_EMPTY(&queue->queue)) {
364 		printf("Mail queue is empty\n");
365 		return;
366 	}
367 
368 	LIST_FOREACH(it, &queue->queue, next) {
369 		printf("ID\t: %s%s\n"
370 		       "From\t: %s\n"
371 		       "To\t: %s\n",
372 		       it->queueid,
373 		       locked ? "*" : "",
374 		       it->sender, it->addr);
375 
376 		if (LIST_NEXT(it, next) != NULL)
377 			printf("--\n");
378 	}
379 }
380 
381 /*
382  * TODO:
383  *
384  * - alias processing
385  * - use group permissions
386  * - proper sysexit codes
387  */
388 
389 int
390 main(int argc, char **argv)
391 {
392 	struct sigaction act;
393 	char *sender = NULL;
394 	struct queue queue;
395 	int i, ch;
396 	int nodot = 0, doqueue = 0, showq = 0, queue_only = 0;
397 	int recp_from_header = 0;
398 
399 	set_username();
400 
401 	/*
402 	 * We never run as root.  If called by root, drop permissions
403 	 * to the mail user.
404 	 */
405 	if (geteuid() == 0 || getuid() == 0) {
406 		struct passwd *pw;
407 
408 		pw = getpwnam(DMA_ROOT_USER);
409 		if (pw == NULL)
410 			err(1, "cannot drop root privileges");
411 
412 		if (setuid(pw->pw_uid) != 0)
413 			err(1, "cannot drop root privileges");
414 
415 		if (geteuid() == 0 || getuid() == 0)
416 			errx(1, "cannot drop root privileges");
417 	}
418 
419 	atexit(deltmp);
420 	init_random();
421 
422 	bzero(&queue, sizeof(queue));
423 	LIST_INIT(&queue.queue);
424 
425 	if (strcmp(argv[0], "mailq") == 0) {
426 		argv++; argc--;
427 		showq = 1;
428 		if (argc != 0)
429 			errx(1, "invalid arguments");
430 		goto skipopts;
431 	}
432 
433 	opterr = 0;
434 	while ((ch = getopt(argc, argv, ":A:b:B:C:d:Df:F:h:iL:N:no:O:q:r:R:tUV:vX:")) != -1) {
435 		switch (ch) {
436 		case 'A':
437 			/* -AX is being ignored, except for -A{c,m} */
438 			if (optarg[0] == 'c' || optarg[0] == 'm') {
439 				break;
440 			}
441 			/* else FALLTRHOUGH */
442 		case 'b':
443 			/* -bX is being ignored, except for -bp */
444 			if (optarg[0] == 'p') {
445 				showq = 1;
446 				break;
447 			} else if (optarg[0] == 'q') {
448 				queue_only = 1;
449 				break;
450 			}
451 			/* else FALLTRHOUGH */
452 		case 'D':
453 			daemonize = 0;
454 			break;
455 		case 'L':
456 			logident_base = optarg;
457 			break;
458 		case 'f':
459 		case 'r':
460 			sender = optarg;
461 			break;
462 
463 		case 't':
464 			recp_from_header = 1;
465 			break;
466 
467 		case 'o':
468 			/* -oX is being ignored, except for -oi */
469 			if (optarg[0] != 'i')
470 				break;
471 			/* else FALLTRHOUGH */
472 		case 'O':
473 			break;
474 		case 'i':
475 			nodot = 1;
476 			break;
477 
478 		case 'q':
479 			doqueue = 1;
480 			break;
481 
482 		/* Ignored options */
483 		case 'B':
484 		case 'C':
485 		case 'd':
486 		case 'F':
487 		case 'h':
488 		case 'N':
489 		case 'n':
490 		case 'R':
491 		case 'U':
492 		case 'V':
493 		case 'v':
494 		case 'X':
495 			break;
496 
497 		case ':':
498 			if (optopt == 'q') {
499 				doqueue = 1;
500 				break;
501 			}
502 			/* FALLTHROUGH */
503 
504 		default:
505 			fprintf(stderr, "invalid argument: `-%c'\n", optopt);
506 			exit(1);
507 		}
508 	}
509 	argc -= optind;
510 	argv += optind;
511 	opterr = 1;
512 
513 	if (argc != 0 && (showq || doqueue))
514 		errx(1, "sending mail and queue operations are mutually exclusive");
515 
516 	if (showq + doqueue > 1)
517 		errx(1, "conflicting queue operations");
518 
519 skipopts:
520 	if (logident_base == NULL)
521 		logident_base = "dma";
522 	setlogident(NULL);
523 
524 	act.sa_handler = sighup_handler;
525 	act.sa_flags = 0;
526 	sigemptyset(&act.sa_mask);
527 	if (sigaction(SIGHUP, &act, NULL) != 0)
528 		syslog(LOG_WARNING, "can not set signal handler: %m");
529 
530 	parse_conf(CONF_PATH "/dma.conf");
531 
532 	if (config.authpath != NULL)
533 		parse_authfile(config.authpath);
534 
535 	if (showq) {
536 		if (load_queue(&queue) < 0)
537 			errlog(1, "can not load queue");
538 		show_queue(&queue);
539 		return (0);
540 	}
541 
542 	if (doqueue) {
543 		if (load_queue(&queue) < 0)
544 			errlog(1, "can not load queue");
545 		run_queue(&queue);
546 		return (0);
547 	}
548 
549 	if (read_aliases() != 0)
550 		errlog(1, "can not read aliases file `%s'", config.aliases);
551 
552 	if ((sender = set_from(&queue, sender)) == NULL)
553 		errlog(1, NULL);
554 
555 	if (newspoolf(&queue) != 0)
556 		errlog(1, "can not create temp file");
557 
558 	setlogident("%s", queue.id);
559 
560 	for (i = 0; i < argc; i++) {
561 		if (add_recp(&queue, argv[i], EXPAND_WILDCARD) != 0)
562 			errlogx(1, "invalid recipient `%s'", argv[i]);
563 	}
564 
565 	if (LIST_EMPTY(&queue.queue) && !recp_from_header)
566 		errlogx(1, "no recipients");
567 
568 	if (readmail(&queue, nodot, recp_from_header) != 0)
569 		errlog(1, "can not read mail");
570 
571 	if (LIST_EMPTY(&queue.queue))
572 		errlogx(1, "no recipients");
573 
574 	if (linkspool(&queue) != 0)
575 		errlog(1, "can not create spools");
576 
577 	/* From here on the mail is safe. */
578 
579 	if (config.features & DEFER || queue_only)
580 		return (0);
581 
582 	run_queue(&queue);
583 
584 	/* NOTREACHED */
585 	return (0);
586 }
587