Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/smtpd/smtpd/../mproc.c	Lines:	0	249	0.0 %
Date:	2017-11-07	Branches:	0	97	0.0 %


/*	$OpenBSD: mproc.c,v 1.29 2017/03/17 20:57:57 eric Exp $	*/

/*
 * Copyright (c) 2012 Eric Faurot <eric@faurot.net>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/tree.h>
#include <sys/queue.h>
#include <sys/uio.h>

#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/nameser.h>

#include <err.h>
#include <errno.h>
#include <event.h>
#include <imsg.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <unistd.h>

#include "smtpd.h"
#include "log.h"

static void mproc_dispatch(int, short, void *);

static ssize_t imsg_read_nofd(struct imsgbuf *);

int
mproc_fork(struct mproc *p, const char *path, char *argv[])
{
	int sp[2];

	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, sp) < 0)
		return (-1);

	io_set_nonblocking(sp[0]);
	io_set_nonblocking(sp[1]);

	if ((p->pid = fork()) == -1)
		goto err;

	if (p->pid == 0) {
		/* child process */
		dup2(sp[0], STDIN_FILENO);
		if (closefrom(STDERR_FILENO + 1) < 0)
			exit(1);

		execv(path, argv);
		err(1, "execv: %s", path);
	}

	/* parent process */
	close(sp[0]);
	mproc_init(p, sp[1]);
	return (0);

err:
	log_warn("warn: Failed to start process %s, instance of %s", argv[0], path);
	close(sp[0]);
	close(sp[1]);
	return (-1);
}

void
mproc_init(struct mproc *p, int fd)
{
	imsg_init(&p->imsgbuf, fd);
}

void
mproc_clear(struct mproc *p)
{
	log_debug("debug: clearing p=%s, fd=%d, pid=%d", p->name, p->imsgbuf.fd, p->pid);

	event_del(&p->ev);
	close(p->imsgbuf.fd);
	imsg_clear(&p->imsgbuf);
}

void
mproc_enable(struct mproc *p)
{
	if (p->enable == 0) {
		log_trace(TRACE_MPROC, "mproc: %s -> %s: enabled",
		    proc_name(smtpd_process),
		    proc_name(p->proc));
		p->enable = 1;
	}
	mproc_event_add(p);
}

void
mproc_disable(struct mproc *p)
{
	if (p->enable == 1) {
		log_trace(TRACE_MPROC, "mproc: %s -> %s: disabled",
		    proc_name(smtpd_process),
		    proc_name(p->proc));
		p->enable = 0;
	}
	mproc_event_add(p);
}

void
mproc_event_add(struct mproc *p)
{
	short	events;

	if (p->enable)
		events = EV_READ;
	else
		events = 0;

	if (p->imsgbuf.w.queued)
		events |= EV_WRITE;

	if (p->events)
		event_del(&p->ev);

	p->events = events;
	if (events) {
		event_set(&p->ev, p->imsgbuf.fd, events, mproc_dispatch, p);
		event_add(&p->ev, NULL);
	}
}

static void
mproc_dispatch(int fd, short event, void *arg)
{
	struct mproc	*p = arg;
	struct imsg	 imsg;
	ssize_t		 n;

	p->events = 0;

	if (event & EV_READ) {

		if (p->proc == PROC_CLIENT)
			n = imsg_read_nofd(&p->imsgbuf);
		else
			n = imsg_read(&p->imsgbuf);

		switch (n) {
		case -1:
			if (errno == EAGAIN)
				break;
			log_warn("warn: %s -> %s: imsg_read",
			    proc_name(smtpd_process),  p->name);
			fatal("exiting");
			/* NOTREACHED */
		case 0:
			/* this pipe is dead, so remove the event handler */
			log_debug("debug: %s -> %s: pipe closed",
			    proc_name(smtpd_process),  p->name);
			p->handler(p, NULL);
			return;
		default:
			break;
		}
	}

	if (event & EV_WRITE) {
		n = msgbuf_write(&p->imsgbuf.w);
		if (n == 0 || (n == -1 && errno != EAGAIN)) {
			/* this pipe is dead, so remove the event handler */
			log_debug("debug: %s -> %s: pipe closed",
			    proc_name(smtpd_process),  p->name);
			p->handler(p, NULL);
			return;
		}
	}

	for (;;) {
		if ((n = imsg_get(&p->imsgbuf, &imsg)) == -1) {

			if (smtpd_process == PROC_CONTROL &&
			    p->proc == PROC_CLIENT) {
				log_warnx("warn: client sent invalid imsg "
				    "over control socket");
				p->handler(p, NULL);
				return;
			}
			log_warn("fatal: %s: error in imsg_get for %s",
			    proc_name(smtpd_process),  p->name);
			fatalx(NULL);
		}
		if (n == 0)
			break;

		p->handler(p, &imsg);

		imsg_free(&imsg);
	}

	mproc_event_add(p);
}

/* This should go into libutil */
static ssize_t
imsg_read_nofd(struct imsgbuf *ibuf)
{
	ssize_t	 n;
	char	*buf;
	size_t	 len;

	buf = ibuf->r.buf + ibuf->r.wpos;
	len = sizeof(ibuf->r.buf) - ibuf->r.wpos;

	while ((n = recv(ibuf->fd, buf, len, 0)) == -1) {
		if (errno != EINTR)
			return (n);
	}

	ibuf->r.wpos += n;
	return (n);
}

void
m_forward(struct mproc *p, struct imsg *imsg)
{
	imsg_compose(&p->imsgbuf, imsg->hdr.type, imsg->hdr.peerid,
	    imsg->hdr.pid, imsg->fd, imsg->data,
	    imsg->hdr.len - sizeof(imsg->hdr));

	if (imsg->hdr.type != IMSG_STAT_DECREMENT &&
	    imsg->hdr.type != IMSG_STAT_INCREMENT)
		log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s (forward)",
		    proc_name(smtpd_process),
		    proc_name(p->proc),
		    imsg->hdr.len - sizeof(imsg->hdr),
		    imsg_to_str(imsg->hdr.type));

	mproc_event_add(p);
}

void
m_compose(struct mproc *p, uint32_t type, uint32_t peerid, pid_t pid, int fd,
    void *data, size_t len)
{
	imsg_compose(&p->imsgbuf, type, peerid, pid, fd, data, len);

	if (type != IMSG_STAT_DECREMENT &&
	    type != IMSG_STAT_INCREMENT)
		log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
		    proc_name(smtpd_process),
		    proc_name(p->proc),
		    len,
		    imsg_to_str(type));

	mproc_event_add(p);
}

void
m_composev(struct mproc *p, uint32_t type, uint32_t peerid, pid_t pid,
    int fd, const struct iovec *iov, int n)
{
	size_t	len;
	int	i;

	imsg_composev(&p->imsgbuf, type, peerid, pid, fd, iov, n);

	len = 0;
	for (i = 0; i < n; i++)
		len += iov[i].iov_len;

	if (type != IMSG_STAT_DECREMENT &&
	    type != IMSG_STAT_INCREMENT)
		log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
		    proc_name(smtpd_process),
		    proc_name(p->proc),
		    len,
		    imsg_to_str(type));

	mproc_event_add(p);
}

void
m_create(struct mproc *p, uint32_t type, uint32_t peerid, pid_t pid, int fd)
{
	p->m_pos = 0;
	p->m_type = type;
	p->m_peerid = peerid;
	p->m_pid = pid;
	p->m_fd = fd;
}

void
m_add(struct mproc *p, const void *data, size_t len)
{
	size_t	 alloc;
	void	*tmp;

	if (p->m_pos + len + IMSG_HEADER_SIZE > MAX_IMSGSIZE) {
		log_warnx("warn: message to large");
		fatal(NULL);
	}

	alloc = p->m_alloc ? p->m_alloc : 128;
	while (p->m_pos + len > alloc)
		alloc *= 2;
	if (alloc != p->m_alloc) {
		log_trace(TRACE_MPROC, "mproc: %s -> %s: realloc %zu -> %zu",
		    proc_name(smtpd_process),
		    proc_name(p->proc),
		    p->m_alloc,
		    alloc);

		tmp = recallocarray(p->m_buf, p->m_alloc, alloc, 1);
		if (tmp == NULL)
			fatal("realloc");
		p->m_alloc = alloc;
		p->m_buf = tmp;
	}

	memmove(p->m_buf + p->m_pos, data, len);
	p->m_pos += len;
}

void
m_close(struct mproc *p)
{
	if (imsg_compose(&p->imsgbuf, p->m_type, p->m_peerid, p->m_pid, p->m_fd,
	    p->m_buf, p->m_pos) == -1)
		fatal("imsg_compose");

	log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
		    proc_name(smtpd_process),
		    proc_name(p->proc),
		    p->m_pos,
		    imsg_to_str(p->m_type));

	mproc_event_add(p);
}

void
m_flush(struct mproc *p)
{
	if (imsg_compose(&p->imsgbuf, p->m_type, p->m_peerid, p->m_pid, p->m_fd,
	    p->m_buf, p->m_pos) == -1)
		fatal("imsg_compose");

	log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s (flush)",
	    proc_name(smtpd_process),
	    proc_name(p->proc),
	    p->m_pos,
	    imsg_to_str(p->m_type));

	p->m_pos = 0;

	imsg_flush(&p->imsgbuf);
}

static struct imsg * current;

static void
m_error(const char *error)
{
	char	buf[512];

	(void)snprintf(buf, sizeof buf, "%s: %s: %s",
	    proc_name(smtpd_process),
	    imsg_to_str(current->hdr.type),
	    error);
	fatalx("%s", buf);
}

void
m_msg(struct msg *m, struct imsg *imsg)
{
	current = imsg;
	m->pos = imsg->data;
	m->end = m->pos + (imsg->hdr.len - sizeof(imsg->hdr));
}

void
m_end(struct msg *m)
{
	if (m->pos != m->end)
		m_error("not at msg end");
}

int
m_is_eom(struct msg *m)
{
	return (m->pos == m->end);
}

static inline void
m_get(struct msg *m, void *dst, size_t sz)
{
	if (sz > MAX_IMSGSIZE ||
	    m->end - m->pos < (ssize_t)sz)
		fatalx("msg too short");

	memmove(dst, m->pos, sz);
	m->pos += sz;
}

void
m_add_int(struct mproc *m, int v)
{
	m_add(m, &v, sizeof(v));
};

void
m_add_u32(struct mproc *m, uint32_t u32)
{
	m_add(m, &u32, sizeof(u32));
};

void
m_add_size(struct mproc *m, size_t sz)
{
	m_add(m, &sz, sizeof(sz));
};

void
m_add_time(struct mproc *m, time_t v)
{
	m_add(m, &v, sizeof(v));
};

void
m_add_string(struct mproc *m, const char *v)
{
	m_add(m, v, strlen(v) + 1);
};

void
m_add_data(struct mproc *m, const void *v, size_t len)
{
	m_add_size(m, len);
	m_add(m, v, len);
};

void
m_add_id(struct mproc *m, uint64_t v)
{
	m_add(m, &v, sizeof(v));
}

void
m_add_evpid(struct mproc *m, uint64_t v)
{
	m_add(m, &v, sizeof(v));
}

void
m_add_msgid(struct mproc *m, uint32_t v)
{
	m_add(m, &v, sizeof(v));
}

void
m_add_sockaddr(struct mproc *m, const struct sockaddr *sa)
{
	m_add_size(m, sa->sa_len);
	m_add(m, sa, sa->sa_len);
}

void
m_add_mailaddr(struct mproc *m, const struct mailaddr *maddr)
{
	m_add(m, maddr, sizeof(*maddr));
}

void
m_add_envelope(struct mproc *m, const struct envelope *evp)
{
	char	buf[sizeof(*evp)];

	envelope_dump_buffer(evp, buf, sizeof(buf));
	m_add_evpid(m, evp->id);
	m_add_string(m, buf);
}

void
m_add_params(struct mproc *m, struct dict *d)
{
	const char *key;
	char *value;
	void *iter;

	if (d == NULL) {
		m_add_size(m, 0);
		return;
	}
	m_add_size(m, dict_count(d));
	iter = NULL;
	while (dict_iter(d, &iter, &key, (void **)&value)) {
		m_add_string(m, key);
		m_add_string(m, value);
	}
}

void
m_get_int(struct msg *m, int *i)
{
	m_get(m, i, sizeof(*i));
}

void
m_get_u32(struct msg *m, uint32_t *u32)
{
	m_get(m, u32, sizeof(*u32));
}

void
m_get_size(struct msg *m, size_t *sz)
{
	m_get(m, sz, sizeof(*sz));
}

void
m_get_time(struct msg *m, time_t *t)
{
	m_get(m, t, sizeof(*t));
}

void
m_get_string(struct msg *m, const char **s)
{
	uint8_t	*end;

	if (m->pos >= m->end)
		m_error("msg too short");

	end = memchr(m->pos, 0, m->end - m->pos);
	if (end == NULL)
		m_error("unterminated string");

	*s = m->pos;
	m->pos = end + 1;
}

void
m_get_data(struct msg *m, const void **data, size_t *sz)
{
	m_get_size(m, sz);

	if (m->pos + *sz > m->end)
		m_error("msg too short");

	*data = m->pos;
	m->pos += *sz;
}

void
m_get_evpid(struct msg *m, uint64_t *evpid)
{
	m_get(m, evpid, sizeof(*evpid));
}

void
m_get_msgid(struct msg *m, uint32_t *msgid)
{
	m_get(m, msgid, sizeof(*msgid));
}

void
m_get_id(struct msg *m, uint64_t *id)
{
	m_get(m, id, sizeof(*id));
}

void
m_get_sockaddr(struct msg *m, struct sockaddr *sa)
{
	size_t len;

	m_get_size(m, &len);
	m_get(m, sa, len);
}

void
m_get_mailaddr(struct msg *m, struct mailaddr *maddr)
{
	m_get(m, maddr, sizeof(*maddr));
}

void
m_get_envelope(struct msg *m, struct envelope *evp)
{
	uint64_t	 evpid;
	const char	*buf;

	m_get_evpid(m, &evpid);
	m_get_string(m, &buf);

	if (!envelope_load_buffer(evp, buf, strlen(buf)))
		fatalx("failed to retrieve envelope");
	evp->id = evpid;
}

void
m_get_params(struct msg *m, struct dict *d)
{
	size_t	c;
	const char *key;
	const char *value;
	char *tmp;

	dict_init(d);

	m_get_size(m, &c);

	for (; c; c--) {
		m_get_string(m, &key);
		m_get_string(m, &value);
		if ((tmp = strdup(value)) == NULL)
			fatal("m_get_params");
		dict_set(d, key, tmp);
	}
}

void
m_clear_params(struct dict *d)
{
	char *value;

	while (dict_poproot(d, (void **)&value))
		free(value);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: mproc.c,v 1.29 2017/03/17 20:57:57 eric Exp $ */
2
3			/*
4			* Copyright (c) 2012 Eric Faurot <eric@faurot.net>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <sys/types.h>
20			#include <sys/socket.h>
21			#include <sys/tree.h>
22			#include <sys/queue.h>
23			#include <sys/uio.h>
24
25			#include <netinet/in.h>
26			#include <arpa/inet.h>
27			#include <arpa/nameser.h>
28
29			#include <err.h>
30			#include <errno.h>
31			#include <event.h>
32			#include <imsg.h>
33			#include <stdio.h>
34			#include <stdlib.h>
35			#include <limits.h>
36			#include <string.h>
37			#include <unistd.h>
38
39			#include "smtpd.h"
40			#include "log.h"
41
42			static void mproc_dispatch(int, short, void *);
43
44			static ssize_t imsg_read_nofd(struct imsgbuf *);
45
46			int
47			mproc_fork(struct mproc p, const char path, char *argv[])
48			{
49			int sp[2];
50
51			if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, sp) < 0)
52			return (-1);
53
54			io_set_nonblocking(sp[0]);
55			io_set_nonblocking(sp[1]);
56
57			if ((p->pid = fork()) == -1)
58			goto err;
59
60			if (p->pid == 0) {
61			/* child process */
62			dup2(sp[0], STDIN_FILENO);
63			if (closefrom(STDERR_FILENO + 1) < 0)
64			exit(1);
65
66			execv(path, argv);
67			err(1, "execv: %s", path);
68			}
69
70			/* parent process */
71			close(sp[0]);
72			mproc_init(p, sp[1]);
73			return (0);
74
75			err:
76			log_warn("warn: Failed to start process %s, instance of %s", argv[0], path);
77			close(sp[0]);
78			close(sp[1]);
79			return (-1);
80			}
81
82			void
83			mproc_init(struct mproc *p, int fd)
84			{
85			imsg_init(&p->imsgbuf, fd);
86			}
87
88			void
89			mproc_clear(struct mproc *p)
90			{
91			log_debug("debug: clearing p=%s, fd=%d, pid=%d", p->name, p->imsgbuf.fd, p->pid);
92
93			event_del(&p->ev);
94			close(p->imsgbuf.fd);
95			imsg_clear(&p->imsgbuf);
96			}
97
98			void
99			mproc_enable(struct mproc *p)
100			{
101			if (p->enable == 0) {
102			log_trace(TRACE_MPROC, "mproc: %s -> %s: enabled",
103			proc_name(smtpd_process),
104			proc_name(p->proc));
105			p->enable = 1;
106			}
107			mproc_event_add(p);
108			}
109
110			void
111			mproc_disable(struct mproc *p)
112			{
113			if (p->enable == 1) {
114			log_trace(TRACE_MPROC, "mproc: %s -> %s: disabled",
115			proc_name(smtpd_process),
116			proc_name(p->proc));
117			p->enable = 0;
118			}
119			mproc_event_add(p);
120			}
121
122			void
123			mproc_event_add(struct mproc *p)
124			{
125			short events;
126
127			if (p->enable)
128			events = EV_READ;
129			else
130			events = 0;
131
132			if (p->imsgbuf.w.queued)
133			events \|= EV_WRITE;
134
135			if (p->events)
136			event_del(&p->ev);
137
138			p->events = events;
139			if (events) {
140			event_set(&p->ev, p->imsgbuf.fd, events, mproc_dispatch, p);
141			event_add(&p->ev, NULL);
142			}
143			}
144
145			static void
146			mproc_dispatch(int fd, short event, void *arg)
147			{
148			struct mproc *p = arg;
149			struct imsg imsg;
150			ssize_t n;
151
152			p->events = 0;
153
154			if (event & EV_READ) {
155
156			if (p->proc == PROC_CLIENT)
157			n = imsg_read_nofd(&p->imsgbuf);
158			else
159			n = imsg_read(&p->imsgbuf);
160
161			switch (n) {
162			case -1:
163			if (errno == EAGAIN)
164			break;
165			log_warn("warn: %s -> %s: imsg_read",
166			proc_name(smtpd_process), p->name);
167			fatal("exiting");
168			/* NOTREACHED */
169			case 0:
170			/* this pipe is dead, so remove the event handler */
171			log_debug("debug: %s -> %s: pipe closed",
172			proc_name(smtpd_process), p->name);
173			p->handler(p, NULL);
174			return;
175			default:
176			break;
177			}
178			}
179
180			if (event & EV_WRITE) {
181			n = msgbuf_write(&p->imsgbuf.w);
182			if (n == 0 \|\| (n == -1 && errno != EAGAIN)) {
183			/* this pipe is dead, so remove the event handler */
184			log_debug("debug: %s -> %s: pipe closed",
185			proc_name(smtpd_process), p->name);
186			p->handler(p, NULL);
187			return;
188			}
189			}
190
191			for (;;) {
192			if ((n = imsg_get(&p->imsgbuf, &imsg)) == -1) {
193
194			if (smtpd_process == PROC_CONTROL &&
195			p->proc == PROC_CLIENT) {
196			log_warnx("warn: client sent invalid imsg "
197			"over control socket");
198			p->handler(p, NULL);
199			return;
200			}
201			log_warn("fatal: %s: error in imsg_get for %s",
202			proc_name(smtpd_process), p->name);
203			fatalx(NULL);
204			}
205			if (n == 0)
206			break;
207
208			p->handler(p, &imsg);
209
210			imsg_free(&imsg);
211			}
212
213			mproc_event_add(p);
214			}
215
216			/* This should go into libutil */
217			static ssize_t
218			imsg_read_nofd(struct imsgbuf *ibuf)
219			{
220			ssize_t n;
221			char *buf;
222			size_t len;
223
224			buf = ibuf->r.buf + ibuf->r.wpos;
225			len = sizeof(ibuf->r.buf) - ibuf->r.wpos;
226
227			while ((n = recv(ibuf->fd, buf, len, 0)) == -1) {
228			if (errno != EINTR)
229			return (n);
230			}
231
232			ibuf->r.wpos += n;
233			return (n);
234			}
235
236			void
237			m_forward(struct mproc p, struct imsg imsg)
238			{
239			imsg_compose(&p->imsgbuf, imsg->hdr.type, imsg->hdr.peerid,
240			imsg->hdr.pid, imsg->fd, imsg->data,
241			imsg->hdr.len - sizeof(imsg->hdr));
242
243			if (imsg->hdr.type != IMSG_STAT_DECREMENT &&
244			imsg->hdr.type != IMSG_STAT_INCREMENT)
245			log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s (forward)",
246			proc_name(smtpd_process),
247			proc_name(p->proc),
248			imsg->hdr.len - sizeof(imsg->hdr),
249			imsg_to_str(imsg->hdr.type));
250
251			mproc_event_add(p);
252			}
253
254			void
255			m_compose(struct mproc *p, uint32_t type, uint32_t peerid, pid_t pid, int fd,
256			void *data, size_t len)
257			{
258			imsg_compose(&p->imsgbuf, type, peerid, pid, fd, data, len);
259
260			if (type != IMSG_STAT_DECREMENT &&
261			type != IMSG_STAT_INCREMENT)
262			log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
263			proc_name(smtpd_process),
264			proc_name(p->proc),
265			len,
266			imsg_to_str(type));
267
268			mproc_event_add(p);
269			}
270
271			void
272			m_composev(struct mproc *p, uint32_t type, uint32_t peerid, pid_t pid,
273			int fd, const struct iovec *iov, int n)
274			{
275			size_t len;
276			int i;
277
278			imsg_composev(&p->imsgbuf, type, peerid, pid, fd, iov, n);
279
280			len = 0;
281			for (i = 0; i < n; i++)
282			len += iov[i].iov_len;
283
284			if (type != IMSG_STAT_DECREMENT &&
285			type != IMSG_STAT_INCREMENT)
286			log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
287			proc_name(smtpd_process),
288			proc_name(p->proc),
289			len,
290			imsg_to_str(type));
291
292			mproc_event_add(p);
293			}
294
295			void
296			m_create(struct mproc *p, uint32_t type, uint32_t peerid, pid_t pid, int fd)
297			{
298			p->m_pos = 0;
299			p->m_type = type;
300			p->m_peerid = peerid;
301			p->m_pid = pid;
302			p->m_fd = fd;
303			}
304
305			void
306			m_add(struct mproc p, const void data, size_t len)
307			{
308			size_t alloc;
309			void *tmp;
310
311			if (p->m_pos + len + IMSG_HEADER_SIZE > MAX_IMSGSIZE) {
312			log_warnx("warn: message to large");
313			fatal(NULL);
314			}
315
316			alloc = p->m_alloc ? p->m_alloc : 128;
317			while (p->m_pos + len > alloc)
318			alloc *= 2;
319			if (alloc != p->m_alloc) {
320			log_trace(TRACE_MPROC, "mproc: %s -> %s: realloc %zu -> %zu",
321			proc_name(smtpd_process),
322			proc_name(p->proc),
323			p->m_alloc,
324			alloc);
325
326			tmp = recallocarray(p->m_buf, p->m_alloc, alloc, 1);
327			if (tmp == NULL)
328			fatal("realloc");
329			p->m_alloc = alloc;
330			p->m_buf = tmp;
331			}
332
333			memmove(p->m_buf + p->m_pos, data, len);
334			p->m_pos += len;
335			}
336
337			void
338			m_close(struct mproc *p)
339			{
340			if (imsg_compose(&p->imsgbuf, p->m_type, p->m_peerid, p->m_pid, p->m_fd,
341			p->m_buf, p->m_pos) == -1)
342			fatal("imsg_compose");
343
344			log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
345			proc_name(smtpd_process),
346			proc_name(p->proc),
347			p->m_pos,
348			imsg_to_str(p->m_type));
349
350			mproc_event_add(p);
351			}
352
353			void
354			m_flush(struct mproc *p)
355			{
356			if (imsg_compose(&p->imsgbuf, p->m_type, p->m_peerid, p->m_pid, p->m_fd,
357			p->m_buf, p->m_pos) == -1)
358			fatal("imsg_compose");
359
360			log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s (flush)",
361			proc_name(smtpd_process),
362			proc_name(p->proc),
363			p->m_pos,
364			imsg_to_str(p->m_type));
365
366			p->m_pos = 0;
367
368			imsg_flush(&p->imsgbuf);
369			}
370
371			static struct imsg * current;
372
373			static void
374			m_error(const char *error)
375			{
376			char buf[512];
377
378			(void)snprintf(buf, sizeof buf, "%s: %s: %s",
379			proc_name(smtpd_process),
380			imsg_to_str(current->hdr.type),
381			error);
382			fatalx("%s", buf);
383			}
384
385			void
386			m_msg(struct msg m, struct imsg imsg)
387			{
388			current = imsg;
389			m->pos = imsg->data;
390			m->end = m->pos + (imsg->hdr.len - sizeof(imsg->hdr));
391			}
392
393			void
394			m_end(struct msg *m)
395			{
396			if (m->pos != m->end)
397			m_error("not at msg end");
398			}
399
400			int
401			m_is_eom(struct msg *m)
402			{
403			return (m->pos == m->end);
404			}
405
406			static inline void
407			m_get(struct msg m, void dst, size_t sz)
408			{
409			if (sz > MAX_IMSGSIZE \|\|
410			m->end - m->pos < (ssize_t)sz)
411			fatalx("msg too short");
412
413			memmove(dst, m->pos, sz);
414			m->pos += sz;
415			}
416
417			void
418			m_add_int(struct mproc *m, int v)
419			{
420			m_add(m, &v, sizeof(v));
421			};
422
423			void
424			m_add_u32(struct mproc *m, uint32_t u32)
425			{
426			m_add(m, &u32, sizeof(u32));
427			};
428
429			void
430			m_add_size(struct mproc *m, size_t sz)
431			{
432			m_add(m, &sz, sizeof(sz));
433			};
434
435			void
436			m_add_time(struct mproc *m, time_t v)
437			{
438			m_add(m, &v, sizeof(v));
439			};
440
441			void
442			m_add_string(struct mproc m, const char v)
443			{
444			m_add(m, v, strlen(v) + 1);
445			};
446
447			void
448			m_add_data(struct mproc m, const void v, size_t len)
449			{
450			m_add_size(m, len);
451			m_add(m, v, len);
452			};
453
454			void
455			m_add_id(struct mproc *m, uint64_t v)
456			{
457			m_add(m, &v, sizeof(v));
458			}
459
460			void
461			m_add_evpid(struct mproc *m, uint64_t v)
462			{
463			m_add(m, &v, sizeof(v));
464			}
465
466			void
467			m_add_msgid(struct mproc *m, uint32_t v)
468			{
469			m_add(m, &v, sizeof(v));
470			}
471
472			void
473			m_add_sockaddr(struct mproc m, const struct sockaddr sa)
474			{
475			m_add_size(m, sa->sa_len);
476			m_add(m, sa, sa->sa_len);
477			}
478
479			void
480			m_add_mailaddr(struct mproc m, const struct mailaddr maddr)
481			{
482			m_add(m, maddr, sizeof(*maddr));
483			}
484
485			void
486			m_add_envelope(struct mproc m, const struct envelope evp)
487			{
488			char buf[sizeof(*evp)];
489
490			envelope_dump_buffer(evp, buf, sizeof(buf));
491			m_add_evpid(m, evp->id);
492			m_add_string(m, buf);
493			}
494
495			void
496			m_add_params(struct mproc m, struct dict d)
497			{
498			const char *key;
499			char *value;
500			void *iter;
501
502			if (d == NULL) {
503			m_add_size(m, 0);
504			return;
505			}
506			m_add_size(m, dict_count(d));
507			iter = NULL;
508			while (dict_iter(d, &iter, &key, (void **)&value)) {
509			m_add_string(m, key);
510			m_add_string(m, value);
511			}
512			}
513
514			void
515			m_get_int(struct msg m, int i)
516			{
517			m_get(m, i, sizeof(*i));
518			}
519
520			void
521			m_get_u32(struct msg m, uint32_t u32)
522			{
523			m_get(m, u32, sizeof(*u32));
524			}
525
526			void
527			m_get_size(struct msg m, size_t sz)
528			{
529			m_get(m, sz, sizeof(*sz));
530			}
531
532			void
533			m_get_time(struct msg m, time_t t)
534			{
535			m_get(m, t, sizeof(*t));
536			}
537
538			void
539			m_get_string(struct msg m, const char *s)
540			{
541			uint8_t *end;
542
543			if (m->pos >= m->end)
544			m_error("msg too short");
545
546			end = memchr(m->pos, 0, m->end - m->pos);
547			if (end == NULL)
548			m_error("unterminated string");
549
550			*s = m->pos;
551			m->pos = end + 1;
552			}
553
554			void
555			m_get_data(struct msg m, const void data, size_t sz)
556			{
557			m_get_size(m, sz);
558
559			if (m->pos + *sz > m->end)
560			m_error("msg too short");
561
562			*data = m->pos;
563			m->pos += *sz;
564			}
565
566			void
567			m_get_evpid(struct msg m, uint64_t evpid)
568			{
569			m_get(m, evpid, sizeof(*evpid));
570			}
571
572			void
573			m_get_msgid(struct msg m, uint32_t msgid)
574			{
575			m_get(m, msgid, sizeof(*msgid));
576			}
577
578			void
579			m_get_id(struct msg m, uint64_t id)
580			{
581			m_get(m, id, sizeof(*id));
582			}
583
584			void
585			m_get_sockaddr(struct msg m, struct sockaddr sa)
586			{
587			size_t len;
588
589			m_get_size(m, &len);
590			m_get(m, sa, len);
591			}
592
593			void
594			m_get_mailaddr(struct msg m, struct mailaddr maddr)
595			{
596			m_get(m, maddr, sizeof(*maddr));
597			}
598
599			void
600			m_get_envelope(struct msg m, struct envelope evp)
601			{
602			uint64_t evpid;
603			const char *buf;
604
605			m_get_evpid(m, &evpid);
606			m_get_string(m, &buf);
607
608			if (!envelope_load_buffer(evp, buf, strlen(buf)))
609			fatalx("failed to retrieve envelope");
610			evp->id = evpid;
611			}
612
613			void
614			m_get_params(struct msg m, struct dict d)
615			{
616			size_t c;
617			const char *key;
618			const char *value;
619			char *tmp;
620
621			dict_init(d);
622
623			m_get_size(m, &c);
624
625			for (; c; c--) {
626			m_get_string(m, &key);
627			m_get_string(m, &value);
628			if ((tmp = strdup(value)) == NULL)
629			fatal("m_get_params");
630			dict_set(d, key, tmp);
631			}
632			}
633
634			void
635			m_clear_params(struct dict *d)
636			{
637			char *value;
638
639			while (dict_poproot(d, (void **)&value))
640			free(value);
641			}