Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/smtpd/smtpd/../queue_proc.c	Lines:	0	145	0.0 %
Date:	2017-11-07	Branches:	0	42	0.0 %


/*	$OpenBSD: queue_proc.c,v 1.6 2015/12/05 13:14:21 claudio Exp $	*/

/*
 * Copyright (c) 2013 Eric Faurot <eric@openbsd.org>
 *
 * 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/queue.h>
#include <sys/tree.h>
#include <sys/socket.h>
#include <sys/stat.h>

#include <ctype.h>
#include <errno.h>
#include <event.h>
#include <fcntl.h>
#include <imsg.h>
#include <inttypes.h>
#include <libgen.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <limits.h>

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

static struct imsgbuf	 ibuf;
static struct imsg	 imsg;
static size_t		 rlen;
static char		*rdata;

static void
queue_proc_call(void)
{
	ssize_t	n;

	if (imsg_flush(&ibuf) == -1) {
		log_warn("warn: queue-proc: imsg_flush");
		fatalx("queue-proc: exiting");
	}

	while (1) {
		if ((n = imsg_get(&ibuf, &imsg)) == -1) {
			log_warn("warn: queue-proc: imsg_get");
			break;
		}
		if (n) {
			rlen = imsg.hdr.len - IMSG_HEADER_SIZE;
			rdata = imsg.data;

			if (imsg.hdr.type != PROC_QUEUE_OK) {
				log_warnx("warn: queue-proc: bad response");
				break;
			}
			return;
		}

		if ((n = imsg_read(&ibuf)) == -1 && errno != EAGAIN) {
			log_warn("warn: queue-proc: imsg_read");
			break;
		}

		if (n == 0) {
			log_warnx("warn: queue-proc: pipe closed");
			break;
		}
	}

	fatalx("queue-proc: exiting");
}

static void
queue_proc_read(void *dst, size_t len)
{
	if (len > rlen) {
		log_warnx("warn: queue-proc: bad msg len");
		fatalx("queue-proc: exiting");
	}

	memmove(dst, rdata, len);
	rlen -= len;
	rdata += len;
}

static void
queue_proc_end(void)
{
	if (rlen) {
		log_warnx("warn: queue-proc: bogus data");
		fatalx("queue-proc: exiting");
	}
	imsg_free(&imsg);
}

/*
 * API
 */

static int
queue_proc_close(void)
{
	int	r;

	imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_CORRUPT, 0, 0, -1, NULL, 0);

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));
	queue_proc_end();

	return (r);
}

static int
queue_proc_message_create(uint32_t *msgid)
{
	int	r;

	imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_CREATE, 0, 0, -1, NULL, 0);

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));
	if (r == 1)
		queue_proc_read(msgid, sizeof(*msgid));
	queue_proc_end();

	return (r);
}

static int
queue_proc_message_commit(uint32_t msgid, const char *path)
{
	int	r, fd;

	fd = open(path, O_RDONLY);
	if (fd == -1) {
		log_warn("queue-proc: open: %s", path);
		return (0);
	}

	imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_COMMIT, 0, 0, fd, &msgid,
	    sizeof(msgid));

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));
	queue_proc_end();

	return (r);
}

static int
queue_proc_message_delete(uint32_t msgid)
{
	int	r;

	imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_DELETE, 0, 0, -1, &msgid,
	    sizeof(msgid));

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));
	queue_proc_end();

	return (r);
}

static int
queue_proc_message_fd_r(uint32_t msgid)
{
	imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_FD_R, 0, 0, -1, &msgid,
	    sizeof(msgid));

	queue_proc_call();
	queue_proc_end();

	return (imsg.fd);
}

static int
queue_proc_message_corrupt(uint32_t msgid)
{
	int	r;

	imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_CORRUPT, 0, 0, -1, &msgid,
	    sizeof(msgid));

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));
	queue_proc_end();

	return (r);
}

static int
queue_proc_envelope_create(uint32_t msgid, const char *buf, size_t len,
    uint64_t *evpid)
{
	struct ibuf	*b;
	int		 r;

	msgid = evpid_to_msgid(*evpid);
	b = imsg_create(&ibuf, PROC_QUEUE_ENVELOPE_CREATE, 0, 0,
	    sizeof(msgid) + len);
	if (imsg_add(b, &msgid, sizeof(msgid)) == -1 ||
	    imsg_add(b, buf, len) == -1)
		return (0);
	imsg_close(&ibuf, b);

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));
	if (r == 1)
		queue_proc_read(evpid, sizeof(*evpid));
	queue_proc_end();

	return (r);
}

static int
queue_proc_envelope_delete(uint64_t evpid)
{
	int	r;

	imsg_compose(&ibuf, PROC_QUEUE_ENVELOPE_DELETE, 0, 0, -1, &evpid,
	    sizeof(evpid));

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));
	queue_proc_end();

	return (r);
}

static int
queue_proc_envelope_update(uint64_t evpid, const char *buf, size_t len)
{
	struct ibuf	*b;
	int		 r;

	b = imsg_create(&ibuf, PROC_QUEUE_ENVELOPE_UPDATE, 0, 0,
	    len + sizeof(evpid));
	if (imsg_add(b, &evpid, sizeof(evpid)) == -1 ||
	    imsg_add(b, buf, len) == -1)
		return (0);
	imsg_close(&ibuf, b);

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));
	queue_proc_end();

	return (r);
}

static int
queue_proc_envelope_load(uint64_t evpid, char *buf, size_t len)
{
	int	r;

	imsg_compose(&ibuf, PROC_QUEUE_ENVELOPE_LOAD, 0, 0, -1, &evpid,
	    sizeof(evpid));

	queue_proc_call();

	if (rlen > len) {
		log_warnx("warn: queue-proc: buf too small");
		fatalx("queue-proc: exiting");
	}

	r = rlen;
	queue_proc_read(buf, rlen);
	queue_proc_end();

	return (r);
}

static int
queue_proc_envelope_walk(uint64_t *evpid, char *buf, size_t len)
{
	int	r;

	imsg_compose(&ibuf, PROC_QUEUE_ENVELOPE_WALK, 0, 0, -1, NULL, 0);

	queue_proc_call();
	queue_proc_read(&r, sizeof(r));

	if (r > 0) {
		queue_proc_read(evpid, sizeof(*evpid));
		if (rlen > len) {
			log_warnx("warn: queue-proc: buf too small");
			fatalx("queue-proc: exiting");
		}
		if (r != (int)rlen) {
			log_warnx("warn: queue-proc: len mismatch");
			fatalx("queue-proc: exiting");
		}
		queue_proc_read(buf, rlen);
	}
	queue_proc_end();

	return (r);
}

static int
queue_proc_init(struct passwd *pw, int server, const char *conf)
{
	uint32_t	version;
	int		fd;

	fd = fork_proc_backend("queue", conf, "queue-proc");
	if (fd == -1)
		fatalx("queue-proc: exiting");

	imsg_init(&ibuf, fd);

	version = PROC_QUEUE_API_VERSION;
	imsg_compose(&ibuf, PROC_QUEUE_INIT, 0, 0, -1,
	    &version, sizeof(version));

	queue_api_on_close(queue_proc_close);
	queue_api_on_message_create(queue_proc_message_create);
	queue_api_on_message_commit(queue_proc_message_commit);
	queue_api_on_message_delete(queue_proc_message_delete);
	queue_api_on_message_fd_r(queue_proc_message_fd_r);
	queue_api_on_message_corrupt(queue_proc_message_corrupt);
	queue_api_on_envelope_create(queue_proc_envelope_create);
	queue_api_on_envelope_delete(queue_proc_envelope_delete);
	queue_api_on_envelope_update(queue_proc_envelope_update);
	queue_api_on_envelope_load(queue_proc_envelope_load);
	queue_api_on_envelope_walk(queue_proc_envelope_walk);

	queue_proc_call();
	queue_proc_end();

	return (1);
}

struct queue_backend	queue_backend_proc = {
	queue_proc_init,
};


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: queue_proc.c,v 1.6 2015/12/05 13:14:21 claudio Exp $ */
2
3			/*
4			* Copyright (c) 2013 Eric Faurot <eric@openbsd.org>
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/queue.h>
21			#include <sys/tree.h>
22			#include <sys/socket.h>
23			#include <sys/stat.h>
24
25			#include <ctype.h>
26			#include <errno.h>
27			#include <event.h>
28			#include <fcntl.h>
29			#include <imsg.h>
30			#include <inttypes.h>
31			#include <libgen.h>
32			#include <pwd.h>
33			#include <stdio.h>
34			#include <stdlib.h>
35			#include <string.h>
36			#include <time.h>
37			#include <unistd.h>
38			#include <limits.h>
39
40			#include "smtpd.h"
41			#include "log.h"
42
43			static struct imsgbuf ibuf;
44			static struct imsg imsg;
45			static size_t rlen;
46			static char *rdata;
47
48			static void
49			queue_proc_call(void)
50			{
51			ssize_t n;
52
53			if (imsg_flush(&ibuf) == -1) {
54			log_warn("warn: queue-proc: imsg_flush");
55			fatalx("queue-proc: exiting");
56			}
57
58			while (1) {
59			if ((n = imsg_get(&ibuf, &imsg)) == -1) {
60			log_warn("warn: queue-proc: imsg_get");
61			break;
62			}
63			if (n) {
64			rlen = imsg.hdr.len - IMSG_HEADER_SIZE;
65			rdata = imsg.data;
66
67			if (imsg.hdr.type != PROC_QUEUE_OK) {
68			log_warnx("warn: queue-proc: bad response");
69			break;
70			}
71			return;
72			}
73
74			if ((n = imsg_read(&ibuf)) == -1 && errno != EAGAIN) {
75			log_warn("warn: queue-proc: imsg_read");
76			break;
77			}
78
79			if (n == 0) {
80			log_warnx("warn: queue-proc: pipe closed");
81			break;
82			}
83			}
84
85			fatalx("queue-proc: exiting");
86			}
87
88			static void
89			queue_proc_read(void *dst, size_t len)
90			{
91			if (len > rlen) {
92			log_warnx("warn: queue-proc: bad msg len");
93			fatalx("queue-proc: exiting");
94			}
95
96			memmove(dst, rdata, len);
97			rlen -= len;
98			rdata += len;
99			}
100
101			static void
102			queue_proc_end(void)
103			{
104			if (rlen) {
105			log_warnx("warn: queue-proc: bogus data");
106			fatalx("queue-proc: exiting");
107			}
108			imsg_free(&imsg);
109			}
110
111			/*
112			* API
113			*/
114
115			static int
116			queue_proc_close(void)
117			{
118			int r;
119
120			imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_CORRUPT, 0, 0, -1, NULL, 0);
121
122			queue_proc_call();
123			queue_proc_read(&r, sizeof(r));
124			queue_proc_end();
125
126			return (r);
127			}
128
129			static int
130			queue_proc_message_create(uint32_t *msgid)
131			{
132			int r;
133
134			imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_CREATE, 0, 0, -1, NULL, 0);
135
136			queue_proc_call();
137			queue_proc_read(&r, sizeof(r));
138			if (r == 1)
139			queue_proc_read(msgid, sizeof(*msgid));
140			queue_proc_end();
141
142			return (r);
143			}
144
145			static int
146			queue_proc_message_commit(uint32_t msgid, const char *path)
147			{
148			int r, fd;
149
150			fd = open(path, O_RDONLY);
151			if (fd == -1) {
152			log_warn("queue-proc: open: %s", path);
153			return (0);
154			}
155
156			imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_COMMIT, 0, 0, fd, &msgid,
157			sizeof(msgid));
158
159			queue_proc_call();
160			queue_proc_read(&r, sizeof(r));
161			queue_proc_end();
162
163			return (r);
164			}
165
166			static int
167			queue_proc_message_delete(uint32_t msgid)
168			{
169			int r;
170
171			imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_DELETE, 0, 0, -1, &msgid,
172			sizeof(msgid));
173
174			queue_proc_call();
175			queue_proc_read(&r, sizeof(r));
176			queue_proc_end();
177
178			return (r);
179			}
180
181			static int
182			queue_proc_message_fd_r(uint32_t msgid)
183			{
184			imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_FD_R, 0, 0, -1, &msgid,
185			sizeof(msgid));
186
187			queue_proc_call();
188			queue_proc_end();
189
190			return (imsg.fd);
191			}
192
193			static int
194			queue_proc_message_corrupt(uint32_t msgid)
195			{
196			int r;
197
198			imsg_compose(&ibuf, PROC_QUEUE_MESSAGE_CORRUPT, 0, 0, -1, &msgid,
199			sizeof(msgid));
200
201			queue_proc_call();
202			queue_proc_read(&r, sizeof(r));
203			queue_proc_end();
204
205			return (r);
206			}
207
208			static int
209			queue_proc_envelope_create(uint32_t msgid, const char *buf, size_t len,
210			uint64_t *evpid)
211			{
212			struct ibuf *b;
213			int r;
214
215			msgid = evpid_to_msgid(*evpid);
216			b = imsg_create(&ibuf, PROC_QUEUE_ENVELOPE_CREATE, 0, 0,
217			sizeof(msgid) + len);
218			if (imsg_add(b, &msgid, sizeof(msgid)) == -1 \|\|
219			imsg_add(b, buf, len) == -1)
220			return (0);
221			imsg_close(&ibuf, b);
222
223			queue_proc_call();
224			queue_proc_read(&r, sizeof(r));
225			if (r == 1)
226			queue_proc_read(evpid, sizeof(*evpid));
227			queue_proc_end();
228
229			return (r);
230			}
231
232			static int
233			queue_proc_envelope_delete(uint64_t evpid)
234			{
235			int r;
236
237			imsg_compose(&ibuf, PROC_QUEUE_ENVELOPE_DELETE, 0, 0, -1, &evpid,
238			sizeof(evpid));
239
240			queue_proc_call();
241			queue_proc_read(&r, sizeof(r));
242			queue_proc_end();
243
244			return (r);
245			}
246
247			static int
248			queue_proc_envelope_update(uint64_t evpid, const char *buf, size_t len)
249			{
250			struct ibuf *b;
251			int r;
252
253			b = imsg_create(&ibuf, PROC_QUEUE_ENVELOPE_UPDATE, 0, 0,
254			len + sizeof(evpid));
255			if (imsg_add(b, &evpid, sizeof(evpid)) == -1 \|\|
256			imsg_add(b, buf, len) == -1)
257			return (0);
258			imsg_close(&ibuf, b);
259
260			queue_proc_call();
261			queue_proc_read(&r, sizeof(r));
262			queue_proc_end();
263
264			return (r);
265			}
266
267			static int
268			queue_proc_envelope_load(uint64_t evpid, char *buf, size_t len)
269			{
270			int r;
271
272			imsg_compose(&ibuf, PROC_QUEUE_ENVELOPE_LOAD, 0, 0, -1, &evpid,
273			sizeof(evpid));
274
275			queue_proc_call();
276
277			if (rlen > len) {
278			log_warnx("warn: queue-proc: buf too small");
279			fatalx("queue-proc: exiting");
280			}
281
282			r = rlen;
283			queue_proc_read(buf, rlen);
284			queue_proc_end();
285
286			return (r);
287			}
288
289			static int
290			queue_proc_envelope_walk(uint64_t evpid, char buf, size_t len)
291			{
292			int r;
293
294			imsg_compose(&ibuf, PROC_QUEUE_ENVELOPE_WALK, 0, 0, -1, NULL, 0);
295
296			queue_proc_call();
297			queue_proc_read(&r, sizeof(r));
298
299			if (r > 0) {
300			queue_proc_read(evpid, sizeof(*evpid));
301			if (rlen > len) {
302			log_warnx("warn: queue-proc: buf too small");
303			fatalx("queue-proc: exiting");
304			}
305			if (r != (int)rlen) {
306			log_warnx("warn: queue-proc: len mismatch");
307			fatalx("queue-proc: exiting");
308			}
309			queue_proc_read(buf, rlen);
310			}
311			queue_proc_end();
312
313			return (r);
314			}
315
316			static int
317			queue_proc_init(struct passwd pw, int server, const char conf)
318			{
319			uint32_t version;
320			int fd;
321
322			fd = fork_proc_backend("queue", conf, "queue-proc");
323			if (fd == -1)
324			fatalx("queue-proc: exiting");
325
326			imsg_init(&ibuf, fd);
327
328			version = PROC_QUEUE_API_VERSION;
329			imsg_compose(&ibuf, PROC_QUEUE_INIT, 0, 0, -1,
330			&version, sizeof(version));
331
332			queue_api_on_close(queue_proc_close);
333			queue_api_on_message_create(queue_proc_message_create);
334			queue_api_on_message_commit(queue_proc_message_commit);
335			queue_api_on_message_delete(queue_proc_message_delete);
336			queue_api_on_message_fd_r(queue_proc_message_fd_r);
337			queue_api_on_message_corrupt(queue_proc_message_corrupt);
338			queue_api_on_envelope_create(queue_proc_envelope_create);
339			queue_api_on_envelope_delete(queue_proc_envelope_delete);
340			queue_api_on_envelope_update(queue_proc_envelope_update);
341			queue_api_on_envelope_load(queue_proc_envelope_load);
342			queue_api_on_envelope_walk(queue_proc_envelope_walk);
343
344			queue_proc_call();
345			queue_proc_end();
346
347			return (1);
348			}
349
350			struct queue_backend queue_backend_proc = {
351			queue_proc_init,
352			};