Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/smtpd/smtpd/../queue_ram.c	Lines:	0	152	0.0 %
Date:	2017-11-07	Branches:	0	64	0.0 %


/*	$OpenBSD: queue_ram.c,v 1.7 2015/01/20 17:37:54 deraadt Exp $	*/

/*
 * Copyright (c) 2012 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 <err.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"

struct qr_envelope {
	char		*buf;
	size_t		 len;
};

struct qr_message {
	char		*buf;
	size_t		 len;
	struct tree	 envelopes;
};

static struct tree messages;

static struct qr_message *
get_message(uint32_t msgid)
{
	struct qr_message	*msg;

        msg = tree_get(&messages, msgid);
        if (msg == NULL)
                log_warn("warn: queue-ram: message not found");

	return (msg);
}

static int
queue_ram_message_create(uint32_t *msgid)
{
	struct qr_message	*msg;

	msg = calloc(1, sizeof(*msg));
	if (msg == NULL) {
		log_warn("warn: queue-ram: calloc");
		return (0);
	}
	tree_init(&msg->envelopes);

	do {
		*msgid = queue_generate_msgid();
	} while (tree_check(&messages, *msgid));

	tree_xset(&messages, *msgid, msg);

	return (1);
}

static int
queue_ram_message_commit(uint32_t msgid, const char *path)
{
	struct qr_message	*msg;
	struct stat		 sb;
	size_t			 n;
	FILE			*f;
	int			 ret;

	if ((msg = tree_get(&messages, msgid)) == NULL) {
		log_warnx("warn: queue-ram: msgid not found");
		return (0);
	}

	f = fopen(path, "rb");
	if (f == NULL) {
		log_warn("warn: queue-ram: fopen: %s", path);
		return (0);
	}
	if (fstat(fileno(f), &sb) == -1) {
		log_warn("warn: queue-ram: fstat");
		fclose(f);
		return (0);
	}

	msg->len = sb.st_size;
	msg->buf = malloc(msg->len);
	if (msg->buf == NULL) {
		log_warn("warn: queue-ram: malloc");
		fclose(f);
		return (0);
	}

	ret = 0;
	n = fread(msg->buf, 1, msg->len, f);
	if (ferror(f))
		log_warn("warn: queue-ram: fread");
	else if ((off_t)n != sb.st_size)
		log_warnx("warn: queue-ram: bad read");
	else {
		ret = 1;
		stat_increment("queue.ram.message.size", msg->len);
	}
	fclose(f);

	return (ret);
}

static int
queue_ram_message_delete(uint32_t msgid)
{
	struct qr_message	*msg;
	struct qr_envelope	*evp;
	uint64_t		 evpid;

	if ((msg = tree_pop(&messages, msgid)) == NULL) {
		log_warnx("warn: queue-ram: not found");
		return (0);
	}
	while (tree_poproot(&messages, &evpid, (void**)&evp)) {
		stat_decrement("queue.ram.envelope.size", evp->len);
		free(evp->buf);
		free(evp);
	}
	stat_decrement("queue.ram.message.size", msg->len);
	free(msg->buf);
	free(msg);
	return (0);
}

static int
queue_ram_message_fd_r(uint32_t msgid)
{
	struct qr_message	*msg;
	size_t			 n;
	FILE			*f;
	int			 fd, fd2;

	if ((msg = tree_get(&messages, msgid)) == NULL) {
		log_warnx("warn: queue-ram: not found");
		return (-1);
	}

	fd = mktmpfile();
	if (fd == -1) {
		log_warn("warn: queue-ram: mktmpfile");
		return (-1);
	}

	fd2 = dup(fd);
	if (fd2 == -1) {
		log_warn("warn: queue-ram: dup");
		close(fd);
		return (-1);
	}
	f = fdopen(fd2, "w");
	if (f == NULL) {
		log_warn("warn: queue-ram: fdopen");
		close(fd);
		close(fd2);
		return (-1);
	}
	n = fwrite(msg->buf, 1, msg->len, f);
	if (n != msg->len) {
		log_warn("warn: queue-ram: write");
		close(fd);
		fclose(f);
		return (-1);
	}
	fclose(f);
	lseek(fd, 0, SEEK_SET);
	return (fd);
}

static int
queue_ram_message_corrupt(uint32_t msgid)
{
	return (queue_ram_message_delete(msgid));
}

static int
queue_ram_envelope_create(uint32_t msgid, const char *buf, size_t len,
    uint64_t *evpid)
{
	struct qr_envelope	*evp;
	struct qr_message	*msg;

	if ((msg = get_message(msgid)) == NULL)
		return (0);

	do {
		*evpid = queue_generate_evpid(msgid);
	} while (tree_check(&msg->envelopes, *evpid));
	evp = calloc(1, sizeof *evp);
	if (evp == NULL) {
		log_warn("warn: queue-ram: calloc");
		return (0);
	}
	evp->len = len;
	evp->buf = malloc(len);
	if (evp->buf == NULL) {
		log_warn("warn: queue-ram: malloc");
		free(evp);
		return (0);
	}
	memmove(evp->buf, buf, len);
	tree_xset(&msg->envelopes, *evpid, evp);
	stat_increment("queue.ram.envelope.size", len);
	return (1);
}

static int
queue_ram_envelope_delete(uint64_t evpid)
{
	struct qr_envelope	*evp;
	struct qr_message	*msg;

	if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
		return (0);

	if ((evp = tree_pop(&msg->envelopes, evpid)) == NULL) {
		log_warnx("warn: queue-ram: not found");
		return (0);
	}
	stat_decrement("queue.ram.envelope.size", evp->len);
	free(evp->buf);
	free(evp);
	if (tree_empty(&msg->envelopes)) {
		tree_xpop(&messages, evpid_to_msgid(evpid));
		stat_decrement("queue.ram.message.size", msg->len);
		free(msg->buf);
		free(msg);
	}
	return (1);
}

static int
queue_ram_envelope_update(uint64_t evpid, const char *buf, size_t len)
{
	struct qr_envelope	*evp;
	struct qr_message	*msg;
	void			*tmp;

	if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
		return (0);

	if ((evp = tree_get(&msg->envelopes, evpid)) == NULL) {
		log_warn("warn: queue-ram: not found");
		return (0);
	}
	tmp = malloc(len);
	if (tmp == NULL) {
		log_warn("warn: queue-ram: malloc");
		return (0);
	}
	memmove(tmp, buf, len);
	free(evp->buf);
	evp->len = len;
	evp->buf = tmp;
	stat_decrement("queue.ram.envelope.size", evp->len);
	stat_increment("queue.ram.envelope.size", len);
	return (1);
}

static int
queue_ram_envelope_load(uint64_t evpid, char *buf, size_t len)
{
	struct qr_envelope	*evp;
	struct qr_message	*msg;

	if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
		return (0);

	if ((evp = tree_get(&msg->envelopes, evpid)) == NULL) {
		log_warn("warn: queue-ram: not found");
		return (0);
	}
	if (len < evp->len) {
		log_warnx("warn: queue-ram: buffer too small");
		return (0);
	}
	memmove(buf, evp->buf, evp->len);
	return (evp->len);
}

static int
queue_ram_envelope_walk(uint64_t *evpid, char *buf, size_t len)
{
	return (-1);
}

static int
queue_ram_init(struct passwd *pw, int server, const char * conf)
{
	tree_init(&messages);

	queue_api_on_message_create(queue_ram_message_create);
	queue_api_on_message_commit(queue_ram_message_commit);
	queue_api_on_message_delete(queue_ram_message_delete);
	queue_api_on_message_fd_r(queue_ram_message_fd_r);
	queue_api_on_message_corrupt(queue_ram_message_corrupt);
	queue_api_on_envelope_create(queue_ram_envelope_create);
	queue_api_on_envelope_delete(queue_ram_envelope_delete);
	queue_api_on_envelope_update(queue_ram_envelope_update);
	queue_api_on_envelope_load(queue_ram_envelope_load);
	queue_api_on_envelope_walk(queue_ram_envelope_walk);

	return (1);
}

struct queue_backend	queue_backend_ram = {
	queue_ram_init,
};


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: queue_ram.c,v 1.7 2015/01/20 17:37:54 deraadt Exp $ */
2
3			/*
4			* Copyright (c) 2012 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 <err.h>
27			#include <errno.h>
28			#include <event.h>
29			#include <fcntl.h>
30			#include <imsg.h>
31			#include <inttypes.h>
32			#include <libgen.h>
33			#include <pwd.h>
34			#include <stdio.h>
35			#include <stdlib.h>
36			#include <string.h>
37			#include <time.h>
38			#include <unistd.h>
39			#include <limits.h>
40
41			#include "smtpd.h"
42			#include "log.h"
43
44			struct qr_envelope {
45			char *buf;
46			size_t len;
47			};
48
49			struct qr_message {
50			char *buf;
51			size_t len;
52			struct tree envelopes;
53			};
54
55			static struct tree messages;
56
57			static struct qr_message *
58			get_message(uint32_t msgid)
59			{
60			struct qr_message *msg;
61
62			msg = tree_get(&messages, msgid);
63			if (msg == NULL)
64			log_warn("warn: queue-ram: message not found");
65
66			return (msg);
67			}
68
69			static int
70			queue_ram_message_create(uint32_t *msgid)
71			{
72			struct qr_message *msg;
73
74			msg = calloc(1, sizeof(*msg));
75			if (msg == NULL) {
76			log_warn("warn: queue-ram: calloc");
77			return (0);
78			}
79			tree_init(&msg->envelopes);
80
81			do {
82			*msgid = queue_generate_msgid();
83			} while (tree_check(&messages, *msgid));
84
85			tree_xset(&messages, *msgid, msg);
86
87			return (1);
88			}
89
90			static int
91			queue_ram_message_commit(uint32_t msgid, const char *path)
92			{
93			struct qr_message *msg;
94			struct stat sb;
95			size_t n;
96			FILE *f;
97			int ret;
98
99			if ((msg = tree_get(&messages, msgid)) == NULL) {
100			log_warnx("warn: queue-ram: msgid not found");
101			return (0);
102			}
103
104			f = fopen(path, "rb");
105			if (f == NULL) {
106			log_warn("warn: queue-ram: fopen: %s", path);
107			return (0);
108			}
109			if (fstat(fileno(f), &sb) == -1) {
110			log_warn("warn: queue-ram: fstat");
111			fclose(f);
112			return (0);
113			}
114
115			msg->len = sb.st_size;
116			msg->buf = malloc(msg->len);
117			if (msg->buf == NULL) {
118			log_warn("warn: queue-ram: malloc");
119			fclose(f);
120			return (0);
121			}
122
123			ret = 0;
124			n = fread(msg->buf, 1, msg->len, f);
125			if (ferror(f))
126			log_warn("warn: queue-ram: fread");
127			else if ((off_t)n != sb.st_size)
128			log_warnx("warn: queue-ram: bad read");
129			else {
130			ret = 1;
131			stat_increment("queue.ram.message.size", msg->len);
132			}
133			fclose(f);
134
135			return (ret);
136			}
137
138			static int
139			queue_ram_message_delete(uint32_t msgid)
140			{
141			struct qr_message *msg;
142			struct qr_envelope *evp;
143			uint64_t evpid;
144
145			if ((msg = tree_pop(&messages, msgid)) == NULL) {
146			log_warnx("warn: queue-ram: not found");
147			return (0);
148			}
149			while (tree_poproot(&messages, &evpid, (void**)&evp)) {
150			stat_decrement("queue.ram.envelope.size", evp->len);
151			free(evp->buf);
152			free(evp);
153			}
154			stat_decrement("queue.ram.message.size", msg->len);
155			free(msg->buf);
156			free(msg);
157			return (0);
158			}
159
160			static int
161			queue_ram_message_fd_r(uint32_t msgid)
162			{
163			struct qr_message *msg;
164			size_t n;
165			FILE *f;
166			int fd, fd2;
167
168			if ((msg = tree_get(&messages, msgid)) == NULL) {
169			log_warnx("warn: queue-ram: not found");
170			return (-1);
171			}
172
173			fd = mktmpfile();
174			if (fd == -1) {
175			log_warn("warn: queue-ram: mktmpfile");
176			return (-1);
177			}
178
179			fd2 = dup(fd);
180			if (fd2 == -1) {
181			log_warn("warn: queue-ram: dup");
182			close(fd);
183			return (-1);
184			}
185			f = fdopen(fd2, "w");
186			if (f == NULL) {
187			log_warn("warn: queue-ram: fdopen");
188			close(fd);
189			close(fd2);
190			return (-1);
191			}
192			n = fwrite(msg->buf, 1, msg->len, f);
193			if (n != msg->len) {
194			log_warn("warn: queue-ram: write");
195			close(fd);
196			fclose(f);
197			return (-1);
198			}
199			fclose(f);
200			lseek(fd, 0, SEEK_SET);
201			return (fd);
202			}
203
204			static int
205			queue_ram_message_corrupt(uint32_t msgid)
206			{
207			return (queue_ram_message_delete(msgid));
208			}
209
210			static int
211			queue_ram_envelope_create(uint32_t msgid, const char *buf, size_t len,
212			uint64_t *evpid)
213			{
214			struct qr_envelope *evp;
215			struct qr_message *msg;
216
217			if ((msg = get_message(msgid)) == NULL)
218			return (0);
219
220			do {
221			*evpid = queue_generate_evpid(msgid);
222			} while (tree_check(&msg->envelopes, *evpid));
223			evp = calloc(1, sizeof *evp);
224			if (evp == NULL) {
225			log_warn("warn: queue-ram: calloc");
226			return (0);
227			}
228			evp->len = len;
229			evp->buf = malloc(len);
230			if (evp->buf == NULL) {
231			log_warn("warn: queue-ram: malloc");
232			free(evp);
233			return (0);
234			}
235			memmove(evp->buf, buf, len);
236			tree_xset(&msg->envelopes, *evpid, evp);
237			stat_increment("queue.ram.envelope.size", len);
238			return (1);
239			}
240
241			static int
242			queue_ram_envelope_delete(uint64_t evpid)
243			{
244			struct qr_envelope *evp;
245			struct qr_message *msg;
246
247			if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
248			return (0);
249
250			if ((evp = tree_pop(&msg->envelopes, evpid)) == NULL) {
251			log_warnx("warn: queue-ram: not found");
252			return (0);
253			}
254			stat_decrement("queue.ram.envelope.size", evp->len);
255			free(evp->buf);
256			free(evp);
257			if (tree_empty(&msg->envelopes)) {
258			tree_xpop(&messages, evpid_to_msgid(evpid));
259			stat_decrement("queue.ram.message.size", msg->len);
260			free(msg->buf);
261			free(msg);
262			}
263			return (1);
264			}
265
266			static int
267			queue_ram_envelope_update(uint64_t evpid, const char *buf, size_t len)
268			{
269			struct qr_envelope *evp;
270			struct qr_message *msg;
271			void *tmp;
272
273			if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
274			return (0);
275
276			if ((evp = tree_get(&msg->envelopes, evpid)) == NULL) {
277			log_warn("warn: queue-ram: not found");
278			return (0);
279			}
280			tmp = malloc(len);
281			if (tmp == NULL) {
282			log_warn("warn: queue-ram: malloc");
283			return (0);
284			}
285			memmove(tmp, buf, len);
286			free(evp->buf);
287			evp->len = len;
288			evp->buf = tmp;
289			stat_decrement("queue.ram.envelope.size", evp->len);
290			stat_increment("queue.ram.envelope.size", len);
291			return (1);
292			}
293
294			static int
295			queue_ram_envelope_load(uint64_t evpid, char *buf, size_t len)
296			{
297			struct qr_envelope *evp;
298			struct qr_message *msg;
299
300			if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
301			return (0);
302
303			if ((evp = tree_get(&msg->envelopes, evpid)) == NULL) {
304			log_warn("warn: queue-ram: not found");
305			return (0);
306			}
307			if (len < evp->len) {
308			log_warnx("warn: queue-ram: buffer too small");
309			return (0);
310			}
311			memmove(buf, evp->buf, evp->len);
312			return (evp->len);
313			}
314
315			static int
316			queue_ram_envelope_walk(uint64_t evpid, char buf, size_t len)
317			{
318			return (-1);
319			}
320
321			static int
322			queue_ram_init(struct passwd pw, int server, const char conf)
323			{
324			tree_init(&messages);
325
326			queue_api_on_message_create(queue_ram_message_create);
327			queue_api_on_message_commit(queue_ram_message_commit);
328			queue_api_on_message_delete(queue_ram_message_delete);
329			queue_api_on_message_fd_r(queue_ram_message_fd_r);
330			queue_api_on_message_corrupt(queue_ram_message_corrupt);
331			queue_api_on_envelope_create(queue_ram_envelope_create);
332			queue_api_on_envelope_delete(queue_ram_envelope_delete);
333			queue_api_on_envelope_update(queue_ram_envelope_update);
334			queue_api_on_envelope_load(queue_ram_envelope_load);
335			queue_api_on_envelope_walk(queue_ram_envelope_walk);
336
337			return (1);
338			}
339
340			struct queue_backend queue_backend_ram = {
341			queue_ram_init,
342			};