[people/ms/dma.git] / dma.c

/*
 * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Simon 'corecode' Schubert <corecode@fs.ei.tum.de>.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "dfcompat.h"

#include <sys/param.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <paths.h>
#include <pwd.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>

#include "dma.h"


static void deliver(struct qitem *);

struct aliases aliases = LIST_HEAD_INITIALIZER(aliases);
struct strlist tmpfs = SLIST_HEAD_INITIALIZER(tmpfs);
struct authusers authusers = LIST_HEAD_INITIALIZER(authusers);
char username[USERNAME_SIZE];
uid_t useruid;
const char *logident_base;
char errmsg[ERRMSG_SIZE];

static int daemonize = 1;

struct config config = {
	.smarthost	= NULL,
	.port		= 25,
	.aliases	= "/etc/aliases",
	.spooldir	= "/var/spool/dma",
	.authpath	= NULL,
	.certfile	= NULL,
	.features	= 0,
	.mailname	= NULL,
	.masquerade_host = NULL,
	.masquerade_user = NULL,
};


static void
sighup_handler(int signo)
{
	(void)signo;	/* so that gcc doesn't complain */
}

static char *
set_from(struct queue *queue, const char *osender)
{
	char *sender;

	if (osender) {
		sender = strdup(osender);
		if (sender == NULL)
			return (NULL);
	} else if (getenv("EMAIL") != NULL) {
		sender = strdup(getenv("EMAIL"));
		if (sender == NULL)
			return (NULL);
	} else {
		const char *from_user = username;
		const char *from_host = hostname();

		if (config.masquerade_user)
			from_user = config.masquerade_user;
		if (config.masquerade_host)
			from_host = config.masquerade_host;
		if (asprintf(&sender, "%s@%s", from_user, from_host) <= 0)
			return (NULL);
	}

	if (strchr(sender, '\n') != NULL) {
		errno = EINVAL;
		return (NULL);
	}

	queue->sender = sender;
	return (sender);
}

static int
read_aliases(void)
{
	yyin = fopen(config.aliases, "r");
	if (yyin == NULL) {
		/*
		 * Non-existing aliases file is not a fatal error
		 */
		if (errno == ENOENT)
			return (0);
		/* Other problems are. */
		return (-1);
	}
	if (yyparse())
		return (-1);	/* fatal error, probably malloc() */
	fclose(yyin);
	return (0);
}

static int
do_alias(struct queue *queue, const char *addr)
{
	struct alias *al;
        struct stritem *sit;
	int aliased = 0;

        LIST_FOREACH(al, &aliases, next) {
                if (strcmp(al->alias, addr) != 0)
                        continue;
		SLIST_FOREACH(sit, &al->dests, next) {
			if (add_recp(queue, sit->str, EXPAND_ADDR) != 0)
				return (-1);
		}
		aliased = 1;
        }

        return (aliased);
}

int
add_recp(struct queue *queue, const char *str, int expand)
{
	struct qitem *it, *tit;
	struct passwd *pw;
	char *host;
	int aliased = 0;

	it = calloc(1, sizeof(*it));
	if (it == NULL)
		return (-1);
	it->addr = strdup(str);
	if (it->addr == NULL)
		return (-1);

	it->sender = queue->sender;
	host = strrchr(it->addr, '@');
	if (host != NULL &&
	    (strcmp(host + 1, hostname()) == 0 ||
	     strcmp(host + 1, "localhost") == 0)) {
		*host = 0;
	}
	LIST_FOREACH(tit, &queue->queue, next) {
		/* weed out duplicate dests */
		if (strcmp(tit->addr, it->addr) == 0) {
			free(it->addr);
			free(it);
			return (0);
		}
	}
	LIST_INSERT_HEAD(&queue->queue, it, next);
	if (strrchr(it->addr, '@') == NULL) {
		it->remote = 0;
		if (expand) {
			aliased = do_alias(queue, it->addr);
			if (!aliased && expand == EXPAND_WILDCARD)
				aliased = do_alias(queue, "*");
			if (aliased < 0)
				return (-1);
			if (aliased) {
				LIST_REMOVE(it, next);
			} else {
				/* Local destination, check */
				pw = getpwnam(it->addr);
				if (pw == NULL)
					goto out;
				/* XXX read .forward */
				endpwent();
			}
		}
	} else {
		it->remote = 1;
	}

	return (0);

out:
	free(it->addr);
	free(it);
	return (-1);
}

static struct qitem *
go_background(struct queue *queue)
{
	struct sigaction sa;
	struct qitem *it;
	pid_t pid;

	if (daemonize && daemon(0, 0) != 0) {
		syslog(LOG_ERR, "can not daemonize: %m");
		exit(1);
	}
	daemonize = 0;

	bzero(&sa, sizeof(sa));
	sa.sa_handler = SIG_IGN;
	sigaction(SIGCHLD, &sa, NULL);

	LIST_FOREACH(it, &queue->queue, next) {
		/* No need to fork for the last dest */
		if (LIST_NEXT(it, next) == NULL)
			goto retit;

		pid = fork();
		switch (pid) {
		case -1:
			syslog(LOG_ERR, "can not fork: %m");
			exit(1);
			break;

		case 0:
			/*
			 * Child:
			 *
			 * return and deliver mail
			 */
retit:
			/*
			 * If necessary, acquire the queue and * mail files.
			 * If this fails, we probably were raced by another
			 * process.
			 */
			setlogident("%s", it->queueid);
			if (acquirespool(it) < 0)
				exit(1);
			dropspool(queue, it);
			return (it);

		default:
			/*
			 * Parent:
			 *
			 * fork next child
			 */
			break;
		}
	}

	syslog(LOG_CRIT, "reached dead code");
	exit(1);
}

static void
deliver(struct qitem *it)
{
	int error;
	unsigned int backoff = MIN_RETRY;
	struct timeval now;
	struct stat st;

	snprintf(errmsg, sizeof(errmsg), "unknown bounce reason");

retry:
	syslog(LOG_INFO, "trying delivery");

	if (it->remote)
		error = deliver_remote(it);
	else
		error = deliver_local(it);

	switch (error) {
	case 0:
		delqueue(it);
		syslog(LOG_INFO, "delivery successful");
		exit(0);

	case 1:
		if (stat(it->queuefn, &st) != 0) {
			syslog(LOG_ERR, "lost queue file `%s'", it->queuefn);
			exit(1);
		}
		if (gettimeofday(&now, NULL) == 0 &&
		    (now.tv_sec - st.st_mtim.tv_sec > MAX_TIMEOUT)) {
			snprintf(errmsg, sizeof(errmsg),
				 "Could not deliver for the last %d seconds. Giving up.",
				 MAX_TIMEOUT);
			goto bounce;
		}
		if (sleep(backoff) == 0) {
			/* pick the next backoff between [1.5, 2.5) times backoff */
			backoff = backoff + backoff / 2 + random() % backoff;
			if (backoff > MAX_RETRY)
				backoff = MAX_RETRY;
		}
		goto retry;

	case -1:
	default:
		break;
	}

bounce:
	bounce(it, errmsg);
	/* NOTREACHED */
}

void
run_queue(struct queue *queue)
{
	struct qitem *it;

	if (LIST_EMPTY(&queue->queue))
		return;

	it = go_background(queue);
	deliver(it);
	/* NOTREACHED */
}

static void
show_queue(struct queue *queue)
{
	struct qitem *it;
	int locked = 0;	/* XXX */

	if (LIST_EMPTY(&queue->queue)) {
		printf("Mail queue is empty\n");
		return;
	}

	LIST_FOREACH(it, &queue->queue, next) {
		printf("ID\t: %s%s\n"
		       "From\t: %s\n"
		       "To\t: %s\n",
		       it->queueid,
		       locked ? "*" : "",
		       it->sender, it->addr);

		if (LIST_NEXT(it, next) != NULL)
			printf("--\n");
	}
}

/*
 * TODO:
 *
 * - alias processing
 * - use group permissions
 * - proper sysexit codes
 */

int
main(int argc, char **argv)
{
	struct sigaction act;
	char *sender = NULL;
	struct queue queue;
	int i, ch;
	int nodot = 0, doqueue = 0, showq = 0, queue_only = 0;
	int recp_from_header = 0;

	set_username();

	/*
	 * We never run as root.  If called by root, drop permissions
	 * to the mail user.
	 */
	if (geteuid() == 0 || getuid() == 0) {
		struct passwd *pw;

		pw = getpwnam(DMA_ROOT_USER);
		if (pw == NULL)
			err(1, "cannot drop root privileges");

		if (setuid(pw->pw_uid) != 0)
			err(1, "cannot drop root privileges");

		if (geteuid() == 0 || getuid() == 0)
			errx(1, "cannot drop root privileges");
	}

	atexit(deltmp);
	init_random();

	bzero(&queue, sizeof(queue));
	LIST_INIT(&queue.queue);

	if (strcmp(argv[0], "mailq") == 0) {
		argv++; argc--;
		showq = 1;
		if (argc != 0)
			errx(1, "invalid arguments");
		goto skipopts;
	}

	opterr = 0;
	while ((ch = getopt(argc, argv, ":A:b:B:C:d:Df:F:h:iL:N:no:O:q:r:R:tUV:vX:")) != -1) {
		switch (ch) {
		case 'A':
			/* -AX is being ignored, except for -A{c,m} */
			if (optarg[0] == 'c' || optarg[0] == 'm') {
				break;
			}
			/* else FALLTRHOUGH */
		case 'b':
			/* -bX is being ignored, except for -bp */
			if (optarg[0] == 'p') {
				showq = 1;
				break;
			} else if (optarg[0] == 'q') {
				queue_only = 1;
				break;
			}
			/* else FALLTRHOUGH */
		case 'D':
			daemonize = 0;
			break;
		case 'L':
			logident_base = optarg;
			break;
		case 'f':
		case 'r':
			sender = optarg;
			break;

		case 't':
			recp_from_header = 1;
			break;

		case 'o':
			/* -oX is being ignored, except for -oi */
			if (optarg[0] != 'i')
				break;
			/* else FALLTRHOUGH */
		case 'O':
			break;
		case 'i':
			nodot = 1;
			break;

		case 'q':
			doqueue = 1;
			break;

		/* Ignored options */
		case 'B':
		case 'C':
		case 'd':
		case 'F':
		case 'h':
		case 'N':
		case 'n':
		case 'R':
		case 'U':
		case 'V':
		case 'v':
		case 'X':
			break;

		case ':':
			if (optopt == 'q') {
				doqueue = 1;
				break;
			}
			/* FALLTHROUGH */

		default:
			fprintf(stderr, "invalid argument: `-%c'\n", optopt);
			exit(1);
		}
	}
	argc -= optind;
	argv += optind;
	opterr = 1;

	if (argc != 0 && (showq || doqueue))
		errx(1, "sending mail and queue operations are mutually exclusive");

	if (showq + doqueue > 1)
		errx(1, "conflicting queue operations");

skipopts:
	if (logident_base == NULL)
		logident_base = "dma";
	setlogident(NULL);

	act.sa_handler = sighup_handler;
	act.sa_flags = 0;
	sigemptyset(&act.sa_mask);
	if (sigaction(SIGHUP, &act, NULL) != 0)
		syslog(LOG_WARNING, "can not set signal handler: %m");

	parse_conf(CONF_PATH "/dma.conf");

	if (config.authpath != NULL)
		parse_authfile(config.authpath);

	if (showq) {
		if (load_queue(&queue) < 0)
			errlog(1, "can not load queue");
		show_queue(&queue);
		return (0);
	}

	if (doqueue) {
		if (load_queue(&queue) < 0)
			errlog(1, "can not load queue");
		run_queue(&queue);
		return (0);
	}

	if (read_aliases() != 0)
		errlog(1, "can not read aliases file `%s'", config.aliases);

	if ((sender = set_from(&queue, sender)) == NULL)
		errlog(1, NULL);

	if (newspoolf(&queue) != 0)
		errlog(1, "can not create temp file");

	setlogident("%s", queue.id);

	for (i = 0; i < argc; i++) {
		if (add_recp(&queue, argv[i], EXPAND_WILDCARD) != 0)
			errlogx(1, "invalid recipient `%s'", argv[i]);
	}

	if (LIST_EMPTY(&queue.queue) && !recp_from_header)
		errlogx(1, "no recipients");

	if (readmail(&queue, nodot, recp_from_header) != 0)
		errlog(1, "can not read mail");

	if (LIST_EMPTY(&queue.queue))
		errlogx(1, "no recipients");

	if (linkspool(&queue) != 0)
		errlog(1, "can not create spools");

	/* From here on the mail is safe. */

	if (config.features & DEFER || queue_only)
		return (0);

	run_queue(&queue);

	/* NOTREACHED */
	return (0);
}
Commit	Line	Data
86e4d161 MS	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.
86e4d161 MS	33	*/
86e4d161 MS	34
9b921550 SS	35	#include "dfcompat.h"
9b921550 SS	36
86e4d161	37	#include <sys/param.h>
4dd56cbc	38	#include <sys/types.h>
86e4d161 MS	39	#include <sys/queue.h>
86e4d161 MS	40	#include <sys/stat.h>
9b921550	41	#include <sys/time.h>
c507d897	42	#include <sys/wait.h>
86e4d161	43
86e4d161 MS	44	#include <dirent.h>
	45	#include <err.h>
	46	#include <errno.h>
	47	#include <fcntl.h>
	48	#include <inttypes.h>
86e4d161 MS	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
e0a95d28	62	static void deliver(struct qitem *);
86e4d161 MS	63
86e4d161 MS	64	struct aliases aliases = LIST_HEAD_INITIALIZER(aliases);
fd1de51a	65	struct strlist tmpfs = SLIST_HEAD_INITIALIZER(tmpfs);
86e4d161	66	struct authusers authusers = LIST_HEAD_INITIALIZER(authusers);
249ee966	67	char username[USERNAME_SIZE];
75fdf182	68	uid_t useruid;
de13a881	69	const char *logident_base;
249ee966	70	char errmsg[ERRMSG_SIZE];
86e4d161	71
87bdbc01	72	static int daemonize = 1;
dd561a09	73
a0c4afa6 SS	74	struct config config = {
	75	.smarthost = NULL,
	76	.port = 25,
db93ed9b	77	.aliases = "/etc/aliases",
a0c4afa6	78	.spooldir = "/var/spool/dma",
a0c4afa6 SS	79	.authpath = NULL,
	80	.certfile = NULL,
	81	.features = 0,
	82	.mailname = NULL,
5bc72de8 SS	83	.masquerade_host = NULL,
5bc72de8 SS	84	.masquerade_user = NULL,
a0c4afa6 SS	85	};
	86
	87
247523d6 SS	88	static void
	89	sighup_handler(int signo)
	90	{
	91	(void)signo; /* so that gcc doesn't complain */
	92	}
	93
86e4d161	94	static char *
057afad5	95	set_from(struct queue queue, const char osender)
86e4d161	96	{
86e4d161 MS	97	char *sender;
86e4d161 MS	98
86e4d161 MS	99	if (osender) {
	100	sender = strdup(osender);
	101	if (sender == NULL)
e0a95d28	102	return (NULL);
09a2b07e SS	103	} else if (getenv("EMAIL") != NULL) {
	104	sender = strdup(getenv("EMAIL"));
	105	if (sender == NULL)
	106	return (NULL);
86e4d161	107	} else {
5bc72de8 SS	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)
e0a95d28	116	return (NULL);
86e4d161 MS	117	}
	118
	119	if (strchr(sender, '\n') != NULL) {
	120	errno = EINVAL;
e0a95d28	121	return (NULL);
86e4d161 MS	122	}
86e4d161 MS	123
057afad5	124	queue->sender = sender;
e0a95d28	125	return (sender);
86e4d161 MS	126	}
	127
	128	static int
	129	read_aliases(void)
	130	{
a0c4afa6 SS	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	}
86e4d161	141	if (yyparse())
e0a95d28	142	return (-1); /* fatal error, probably malloc() */
86e4d161	143	fclose(yyin);
e0a95d28	144	return (0);
86e4d161 MS	145	}
86e4d161 MS	146
a803c7a6 SS	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
fd1de51a	167	int
057afad5	168	add_recp(struct queue queue, const char str, int expand)
86e4d161 MS	169	{
86e4d161 MS	170	struct qitem it, tit;
86e4d161 MS	171	struct passwd *pw;
	172	char *host;
	173	int aliased = 0;
	174
	175	it = calloc(1, sizeof(*it));
	176	if (it == NULL)
e0a95d28	177	return (-1);
86e4d161 MS	178	it->addr = strdup(str);
86e4d161 MS	179	if (it->addr == NULL)
e0a95d28	180	return (-1);
86e4d161	181
057afad5	182	it->sender = queue->sender;
86e4d161 MS	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);
e0a95d28	194	return (0);
86e4d161 MS	195	}
	196	}
	197	LIST_INSERT_HEAD(&queue->queue, it, next);
	198	if (strrchr(it->addr, '@') == NULL) {
e0a95d28	199	it->remote = 0;
86e4d161	200	if (expand) {
a803c7a6 SS	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);
86e4d161 MS	206	if (aliased) {
	207	LIST_REMOVE(it, next);
	208	} else {
e0a95d28	209	/* Local destination, check */
86e4d161 MS	210	pw = getpwnam(it->addr);
	211	if (pw == NULL)
	212	goto out;
8d291e4d	213	/* XXX read .forward */
e0a95d28	214	endpwent();
86e4d161 MS	215	}
	216	}
	217	} else {
e0a95d28	218	it->remote = 1;
86e4d161 MS	219	}
86e4d161 MS	220
e0a95d28	221	return (0);
86e4d161 MS	222
	223	out:
	224	free(it->addr);
	225	free(it);
e0a95d28	226	return (-1);
86e4d161 MS	227	}
86e4d161 MS	228
e0a95d28 MS	229	static struct qitem *
e0a95d28 MS	230	go_background(struct queue *queue)
86e4d161 MS	231	{
	232	struct sigaction sa;
	233	struct qitem *it;
	234	pid_t pid;
	235
	236	if (daemonize && daemon(0, 0) != 0) {
e0a95d28	237	syslog(LOG_ERR, "can not daemonize: %m");
86e4d161 MS	238	exit(1);
	239	}
	240	daemonize = 0;
e0a95d28	241
86e4d161	242	bzero(&sa, sizeof(sa));
86e4d161 MS	243	sa.sa_handler = SIG_IGN;
	244	sigaction(SIGCHLD, &sa, NULL);
	245
94389971	246	LIST_FOREACH(it, &queue->queue, next) {
e0a95d28	247	/* No need to fork for the last dest */
87bdbc01 SS	248	if (LIST_NEXT(it, next) == NULL)
87bdbc01 SS	249	goto retit;
e0a95d28	250
86e4d161 MS	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	*/
87bdbc01 SS	264	retit:
87bdbc01 SS	265	/*
9aec6ad8	266	* If necessary, acquire the queue and * mail files.
87bdbc01 SS	267	* If this fails, we probably were raced by another
	268	* process.
	269	*/
4d5af2b0	270	setlogident("%s", it->queueid);
9aec6ad8	271	if (acquirespool(it) < 0)
87bdbc01 SS	272	exit(1);
87bdbc01 SS	273	dropspool(queue, it);
e0a95d28	274	return (it);
86e4d161 MS	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
86e4d161	290	static void
e0a95d28	291	deliver(struct qitem *it)
86e4d161 MS	292	{
86e4d161 MS	293	int error;
f54b5114	294	unsigned int backoff = MIN_RETRY;
86e4d161 MS	295	struct timeval now;
	296	struct stat st;
	297
249ee966 SS	298	snprintf(errmsg, sizeof(errmsg), "unknown bounce reason");
249ee966 SS	299
86e4d161	300	retry:
4d5af2b0	301	syslog(LOG_INFO, "trying delivery");
86e4d161	302
e0a95d28	303	if (it->remote)
249ee966	304	error = deliver_remote(it);
e0a95d28	305	else
249ee966	306	error = deliver_local(it);
86e4d161 MS	307
	308	switch (error) {
	309	case 0:
fd1de51a	310	delqueue(it);
4d5af2b0	311	syslog(LOG_INFO, "delivery successful");
86e4d161 MS	312	exit(0);
	313
	314	case 1:
	315	if (stat(it->queuefn, &st) != 0) {
4d5af2b0	316	syslog(LOG_ERR, "lost queue file `%s'", it->queuefn);
86e4d161 MS	317	exit(1);
	318	}
	319	if (gettimeofday(&now, NULL) == 0 &&
2fbb30b2	320	(now.tv_sec - st.st_mtim.tv_sec > MAX_TIMEOUT)) {
249ee966	321	snprintf(errmsg, sizeof(errmsg),
e0a95d28	322	"Could not deliver for the last %d seconds. Giving up.",
a43346d5	323	MAX_TIMEOUT);
86e4d161 MS	324	goto bounce;
86e4d161 MS	325	}
0de88752 SS	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	}
86e4d161 MS	332	goto retry;
	333
	334	case -1:
	335	default:
	336	break;
	337	}
	338
	339	bounce:
e0a95d28	340	bounce(it, errmsg);
86e4d161 MS	341	/* NOTREACHED */
	342	}
	343
28be0b96	344	void
86e4d161 MS	345	run_queue(struct queue *queue)
86e4d161 MS	346	{
e0a95d28 MS	347	struct qitem *it;
e0a95d28 MS	348
86e4d161 MS	349	if (LIST_EMPTY(&queue->queue))
	350	return;
	351
e0a95d28 MS	352	it = go_background(queue);
e0a95d28 MS	353	deliver(it);
86e4d161 MS	354	/* NOTREACHED */
	355	}
	356
	357	static void
	358	show_queue(struct queue *queue)
	359	{
	360	struct qitem *it;
87bdbc01	361	int locked = 0; /* XXX */
86e4d161 MS	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) {
5896fefc SS	369	printf("ID\t: %s%s\n"
5896fefc SS	370	"From\t: %s\n"
553ab44c	371	"To\t: %s\n",
5896fefc	372	it->queueid,
87bdbc01	373	locked ? "*" : "",
5896fefc	374	it->sender, it->addr);
553ab44c SS	375
	376	if (LIST_NEXT(it, next) != NULL)
	377	printf("--\n");
86e4d161 MS	378	}
	379	}
	380
	381	/*
	382	* TODO:
	383	*
	384	* - alias processing
	385	* - use group permissions
	386	* - proper sysexit codes
	387	*/
	388
e0a95d28 MS	389	int
e0a95d28 MS	390	main(int argc, char **argv)
86e4d161	391	{
247523d6	392	struct sigaction act;
86e4d161	393	char *sender = NULL;
86e4d161	394	struct queue queue;
86e4d161	395	int i, ch;
bca4c72a	396	int nodot = 0, doqueue = 0, showq = 0, queue_only = 0;
f734c0ae	397	int recp_from_header = 0;
86e4d161	398
75fdf182 SS	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
86e4d161	419	atexit(deltmp);
ee613428	420	init_random();
6f5efe4f SS	421
6f5efe4f SS	422	bzero(&queue, sizeof(queue));
86e4d161	423	LIST_INIT(&queue.queue);
86e4d161	424
0f779ba6 SS	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
87fa1cc5	433	opterr = 0;
f734c0ae	434	while ((ch = getopt(argc, argv, ":A:b:B:C:d:Df:F:h:iL:N:no:O:q:r:R:tUV:vX:")) != -1) {
86e4d161 MS	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;
bca4c72a SS	447	} else if (optarg[0] == 'q') {
	448	queue_only = 1;
	449	break;
86e4d161 MS	450	}
	451	/* else FALLTRHOUGH */
	452	case 'D':
	453	daemonize = 0;
	454	break;
	455	case 'L':
4d5af2b0	456	logident_base = optarg;
86e4d161 MS	457	break;
	458	case 'f':
	459	case 'r':
	460	sender = optarg;
	461	break;
	462
f734c0ae SS	463	case 't':
	464	recp_from_header = 1;
	465	break;
	466
86e4d161 MS	467	case 'o':
	468	/* -oX is being ignored, except for -oi */
	469	if (optarg[0] != 'i')
	470	break;
	471	/* else FALLTRHOUGH */
87fa1cc5 MS	472	case 'O':
87fa1cc5 MS	473	break;
86e4d161 MS	474	case 'i':
	475	nodot = 1;
	476	break;
	477
	478	case 'q':
	479	doqueue = 1;
	480	break;
	481
b6bb4e2d SS	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
f514a0d9 SS	497	case ':':
	498	if (optopt == 'q') {
	499	doqueue = 1;
	500	break;
	501	}
	502	/* FALLTHROUGH */
	503
86e4d161	504	default:
f514a0d9	505	fprintf(stderr, "invalid argument: `-%c'\n", optopt);
86e4d161 MS	506	exit(1);
	507	}
	508	}
	509	argc -= optind;
	510	argv += optind;
87fa1cc5	511	opterr = 1;
86e4d161	512
8d291e4d SS	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
0f779ba6	519	skipopts:
4d5af2b0 SS	520	if (logident_base == NULL)
	521	logident_base = "dma";
	522	setlogident(NULL);
4602c807	523
247523d6 SS	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
d84c3daa	530	parse_conf(CONF_PATH "/dma.conf");
86e4d161	531
a0c4afa6 SS	532	if (config.authpath != NULL)
a0c4afa6 SS	533	parse_authfile(config.authpath);
86e4d161 MS	534
86e4d161 MS	535	if (showq) {
6f5efe4f	536	if (load_queue(&queue) < 0)
de13a881	537	errlog(1, "can not load queue");
6f5efe4f	538	show_queue(&queue);
e0a95d28	539	return (0);
86e4d161 MS	540	}
	541
	542	if (doqueue) {
6f5efe4f	543	if (load_queue(&queue) < 0)
de13a881	544	errlog(1, "can not load queue");
6f5efe4f	545	run_queue(&queue);
e0a95d28	546	return (0);
86e4d161 MS	547	}
86e4d161 MS	548
e0a95d28	549	if (read_aliases() != 0)
a0c4afa6	550	errlog(1, "can not read aliases file `%s'", config.aliases);
86e4d161	551
057afad5	552	if ((sender = set_from(&queue, sender)) == NULL)
de13a881	553	errlog(1, NULL);
86e4d161	554
f734c0ae SS	555	if (newspoolf(&queue) != 0)
	556	errlog(1, "can not create temp file");
	557
	558	setlogident("%s", queue.id);
	559
86e4d161	560	for (i = 0; i < argc; i++) {
a803c7a6	561	if (add_recp(&queue, argv[i], EXPAND_WILDCARD) != 0)
de13a881	562	errlogx(1, "invalid recipient `%s'", argv[i]);
86e4d161 MS	563	}
86e4d161 MS	564
f734c0ae	565	if (LIST_EMPTY(&queue.queue) && !recp_from_header)
de13a881	566	errlogx(1, "no recipients");
86e4d161	567
f734c0ae	568	if (readmail(&queue, nodot, recp_from_header) != 0)
de13a881	569	errlog(1, "can not read mail");
86e4d161	570
f734c0ae SS	571	if (LIST_EMPTY(&queue.queue))
	572	errlogx(1, "no recipients");
	573
057afad5	574	if (linkspool(&queue) != 0)
de13a881	575	errlog(1, "can not create spools");
86e4d161 MS	576
	577	/* From here on the mail is safe. */
	578
a0c4afa6	579	if (config.features & DEFER \|\| queue_only)
e0a95d28	580	return (0);
86e4d161	581
28be0b96	582	run_queue(&queue);
86e4d161 MS	583
86e4d161 MS	584	/* NOTREACHED */
e0a95d28	585	return (0);
94389971	586	}