1/*	$OpenBSD: imsg-buffer.c,v 1.7 2015/07/12 18:40:49 nicm Exp $	*/
2
3/*
4 * Copyright (c) 2003, 2004 Henning Brauer <henning@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/socket.h>
22#include <sys/uio.h>
23
24#include <limits.h>
25#include <errno.h>
26#include <stdlib.h>
27#include <string.h>
28#include <unistd.h>
29
30#include "imsg.h"
31
32int	ibuf_realloc(struct ibuf *, size_t);
33void	ibuf_enqueue(struct msgbuf *, struct ibuf *);
34void	ibuf_dequeue(struct msgbuf *, struct ibuf *);
35
36struct ibuf *
37ibuf_open(size_t len)
38{
39	struct ibuf	*buf;
40
41	if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
42		return (NULL);
43	if ((buf->buf = malloc(len)) == NULL) {
44		free(buf);
45		return (NULL);
46	}
47	buf->size = buf->max = len;
48	buf->fd = -1;
49
50	return (buf);
51}
52
53struct ibuf *
54ibuf_dynamic(size_t len, size_t max)
55{
56	struct ibuf	*buf;
57
58	if (max < len)
59		return (NULL);
60
61	if ((buf = ibuf_open(len)) == NULL)
62		return (NULL);
63
64	if (max > 0)
65		buf->max = max;
66
67	return (buf);
68}
69
70int
71ibuf_realloc(struct ibuf *buf, size_t len)
72{
73	u_char	*b;
74
75	/* on static buffers max is eq size and so the following fails */
76	if (buf->wpos + len > buf->max) {
77		errno = ERANGE;
78		return (-1);
79	}
80
81	b = realloc(buf->buf, buf->wpos + len);
82	if (b == NULL)
83		return (-1);
84	buf->buf = b;
85	buf->size = buf->wpos + len;
86
87	return (0);
88}
89
90int
91ibuf_add(struct ibuf *buf, const void *data, size_t len)
92{
93	if (buf->wpos + len > buf->size)
94		if (ibuf_realloc(buf, len) == -1)
95			return (-1);
96
97	memcpy(buf->buf + buf->wpos, data, len);
98	buf->wpos += len;
99	return (0);
100}
101
102void *
103ibuf_reserve(struct ibuf *buf, size_t len)
104{
105	void	*b;
106
107	if (buf->wpos + len > buf->size)
108		if (ibuf_realloc(buf, len) == -1)
109			return (NULL);
110
111	b = buf->buf + buf->wpos;
112	buf->wpos += len;
113	return (b);
114}
115
116void *
117ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
118{
119	/* only allowed to seek in already written parts */
120	if (pos + len > buf->wpos)
121		return (NULL);
122
123	return (buf->buf + pos);
124}
125
126size_t
127ibuf_size(struct ibuf *buf)
128{
129	return (buf->wpos);
130}
131
132size_t
133ibuf_left(struct ibuf *buf)
134{
135	return (buf->max - buf->wpos);
136}
137
138void
139ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf)
140{
141	ibuf_enqueue(msgbuf, buf);
142}
143
144int
145ibuf_write(struct msgbuf *msgbuf)
146{
147	struct iovec	 iov[IOV_MAX];
148	struct ibuf	*buf;
149	unsigned int	 i = 0;
150	ssize_t	n;
151
152	memset(&iov, 0, sizeof(iov));
153	TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
154		if (i >= IOV_MAX)
155			break;
156		iov[i].iov_base = buf->buf + buf->rpos;
157		iov[i].iov_len = buf->wpos - buf->rpos;
158		i++;
159	}
160
161again:
162	if ((n = writev(msgbuf->fd, iov, i)) == -1) {
163		if (errno == EINTR)
164			goto again;
165		if (errno == ENOBUFS)
166			errno = EAGAIN;
167		return (-1);
168	}
169
170	if (n == 0) {			/* connection closed */
171		errno = 0;
172		return (0);
173	}
174
175	msgbuf_drain(msgbuf, n);
176
177	return (1);
178}
179
180void
181ibuf_free(struct ibuf *buf)
182{
183	free(buf->buf);
184	free(buf);
185}
186
187void
188msgbuf_init(struct msgbuf *msgbuf)
189{
190	msgbuf->queued = 0;
191	msgbuf->fd = -1;
192	TAILQ_INIT(&msgbuf->bufs);
193}
194
195void
196msgbuf_drain(struct msgbuf *msgbuf, size_t n)
197{
198	struct ibuf	*buf, *next;
199
200	for (buf = TAILQ_FIRST(&msgbuf->bufs); buf != NULL && n > 0;
201	    buf = next) {
202		next = TAILQ_NEXT(buf, entry);
203		if (buf->rpos + n >= buf->wpos) {
204			n -= buf->wpos - buf->rpos;
205			ibuf_dequeue(msgbuf, buf);
206		} else {
207			buf->rpos += n;
208			n = 0;
209		}
210	}
211}
212
213void
214msgbuf_clear(struct msgbuf *msgbuf)
215{
216	struct ibuf	*buf;
217
218	while ((buf = TAILQ_FIRST(&msgbuf->bufs)) != NULL)
219		ibuf_dequeue(msgbuf, buf);
220}
221
222int
223msgbuf_write(struct msgbuf *msgbuf)
224{
225	struct iovec	 iov[IOV_MAX];
226	struct ibuf	*buf;
227	unsigned int	 i = 0;
228	ssize_t		 n;
229	struct msghdr	 msg;
230	struct cmsghdr	*cmsg;
231	union {
232		struct cmsghdr	hdr;
233		char		buf[CMSG_SPACE(sizeof(int))];
234	} cmsgbuf;
235
236	memset(&iov, 0, sizeof(iov));
237	memset(&msg, 0, sizeof(msg));
238	memset(&cmsgbuf, 0, sizeof(cmsgbuf));
239	TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
240		if (i >= IOV_MAX)
241			break;
242		iov[i].iov_base = buf->buf + buf->rpos;
243		iov[i].iov_len = buf->wpos - buf->rpos;
244		i++;
245		if (buf->fd != -1)
246			break;
247	}
248
249	msg.msg_iov = iov;
250	msg.msg_iovlen = i;
251
252	if (buf != NULL && buf->fd != -1) {
253		msg.msg_control = (caddr_t)&cmsgbuf.buf;
254		msg.msg_controllen = sizeof(cmsgbuf.buf);
255		cmsg = CMSG_FIRSTHDR(&msg);
256		cmsg->cmsg_len = CMSG_LEN(sizeof(int));
257		cmsg->cmsg_level = SOL_SOCKET;
258		cmsg->cmsg_type = SCM_RIGHTS;
259		*(int *)CMSG_DATA(cmsg) = buf->fd;
260	}
261
262again:
263	if ((n = sendmsg(msgbuf->fd, &msg, 0)) == -1) {
264		if (errno == EINTR)
265			goto again;
266		if (errno == ENOBUFS)
267			errno = EAGAIN;
268		return (-1);
269	}
270
271	if (n == 0) {			/* connection closed */
272		errno = 0;
273		return (0);
274	}
275
276	/*
277	 * assumption: fd got sent if sendmsg sent anything
278	 * this works because fds are passed one at a time
279	 */
280	if (buf != NULL && buf->fd != -1) {
281		close(buf->fd);
282		buf->fd = -1;
283	}
284
285	msgbuf_drain(msgbuf, n);
286
287	return (1);
288}
289
290void
291ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
292{
293	TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry);
294	msgbuf->queued++;
295}
296
297void
298ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
299{
300	TAILQ_REMOVE(&msgbuf->bufs, buf, entry);
301
302	if (buf->fd != -1)
303		close(buf->fd);
304
305	msgbuf->queued--;
306	ibuf_free(buf);
307}
308