1 /*	$OpenBSD: imsg-buffer.c,v 1.17 2023/10/24 14:05:23 claudio 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/socket.h>
21 #include <sys/uio.h>
22 
23 #include <limits.h>
24 #include <errno.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28 
29 #include "got_compat.h"
30 #include "imsg.h"
31 
32 static int	ibuf_realloc(struct ibuf *, size_t);
33 static void	ibuf_enqueue(struct msgbuf *, struct ibuf *);
34 static void	ibuf_dequeue(struct msgbuf *, struct ibuf *);
35 static void	msgbuf_drain(struct msgbuf *, size_t);
36 
37 struct ibuf *
38 ibuf_open(size_t len)
39 {
40 	struct ibuf	*buf;
41 
42 	if (len == 0) {
43 		errno = EINVAL;
44 		return (NULL);
45 	}
46 	if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
47 		return (NULL);
48 	if ((buf->buf = calloc(len, 1)) == NULL) {
49 		free(buf);
50 		return (NULL);
51 	}
52 	buf->size = buf->max = len;
53 	buf->fd = -1;
54 
55 	return (buf);
56 }
57 
58 struct ibuf *
59 ibuf_dynamic(size_t len, size_t max)
60 {
61 	struct ibuf	*buf;
62 
63 	if (max < len) {
64 		errno = EINVAL;
65 		return (NULL);
66 	}
67 
68 	if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
69 		return (NULL);
70 	if (len > 0) {
71 		if ((buf->buf = calloc(len, 1)) == NULL) {
72 			free(buf);
73 			return (NULL);
74 		}
75 	}
76 	buf->size = len;
77 	buf->max = max;
78 	buf->fd = -1;
79 
80 	return (buf);
81 }
82 
83 static int
84 ibuf_realloc(struct ibuf *buf, size_t len)
85 {
86 	unsigned char	*b;
87 
88 	/* on static buffers max is eq size and so the following fails */
89 	if (len > SIZE_MAX - buf->wpos || buf->wpos + len > buf->max) {
90 		errno = ERANGE;
91 		return (-1);
92 	}
93 
94 	b = recallocarray(buf->buf, buf->size, buf->wpos + len, 1);
95 	if (b == NULL)
96 		return (-1);
97 	buf->buf = b;
98 	buf->size = buf->wpos + len;
99 
100 	return (0);
101 }
102 
103 void *
104 ibuf_reserve(struct ibuf *buf, size_t len)
105 {
106 	void	*b;
107 
108 	if (len > SIZE_MAX - buf->wpos) {
109 		errno = ERANGE;
110 		return (NULL);
111 	}
112 
113 	if (buf->wpos + len > buf->size)
114 		if (ibuf_realloc(buf, len) == -1)
115 			return (NULL);
116 
117 	b = buf->buf + buf->wpos;
118 	buf->wpos += len;
119 	memset(b, 0, len);
120 	return (b);
121 }
122 
123 int
124 ibuf_add(struct ibuf *buf, const void *data, size_t len)
125 {
126 	void *b;
127 
128 	if ((b = ibuf_reserve(buf, len)) == NULL)
129 		return (-1);
130 
131 	memcpy(b, data, len);
132 	return (0);
133 }
134 
135 int
136 ibuf_add_buf(struct ibuf *buf, const struct ibuf *from)
137 {
138 	return ibuf_add(buf, from->buf, from->wpos);
139 }
140 
141 int
142 ibuf_add_n8(struct ibuf *buf, uint64_t value)
143 {
144 	uint8_t v;
145 
146 	if (value > UINT8_MAX) {
147 		errno = EINVAL;
148 		return (-1);
149 	}
150 	v = value;
151 	return ibuf_add(buf, &v, sizeof(v));
152 }
153 
154 int
155 ibuf_add_n16(struct ibuf *buf, uint64_t value)
156 {
157 	uint16_t v;
158 
159 	if (value > UINT16_MAX) {
160 		errno = EINVAL;
161 		return (-1);
162 	}
163 	v = htobe16(value);
164 	return ibuf_add(buf, &v, sizeof(v));
165 }
166 
167 int
168 ibuf_add_n32(struct ibuf *buf, uint64_t value)
169 {
170 	uint32_t v;
171 
172 	if (value > UINT32_MAX) {
173 		errno = EINVAL;
174 		return (-1);
175 	}
176 	v = htobe32(value);
177 	return ibuf_add(buf, &v, sizeof(v));
178 }
179 
180 int
181 ibuf_add_n64(struct ibuf *buf, uint64_t value)
182 {
183 	value = htobe64(value);
184 	return ibuf_add(buf, &value, sizeof(value));
185 }
186 
187 int
188 ibuf_add_zero(struct ibuf *buf, size_t len)
189 {
190 	void *b;
191 
192 	if ((b = ibuf_reserve(buf, len)) == NULL)
193 		return (-1);
194 	return (0);
195 }
196 
197 void *
198 ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
199 {
200 	/* only allowed to seek in already written parts */
201 	if (len > SIZE_MAX - pos || pos + len > buf->wpos) {
202 		errno = ERANGE;
203 		return (NULL);
204 	}
205 
206 	return (buf->buf + pos);
207 }
208 
209 int
210 ibuf_set(struct ibuf *buf, size_t pos, const void *data, size_t len)
211 {
212 	void *b;
213 
214 	if ((b = ibuf_seek(buf, pos, len)) == NULL)
215 		return (-1);
216 
217 	memcpy(b, data, len);
218 	return (0);
219 }
220 
221 int
222 ibuf_set_n8(struct ibuf *buf, size_t pos, uint64_t value)
223 {
224 	uint8_t v;
225 
226 	if (value > UINT8_MAX) {
227 		errno = EINVAL;
228 		return (-1);
229 	}
230 	v = value;
231 	return (ibuf_set(buf, pos, &v, sizeof(v)));
232 }
233 
234 int
235 ibuf_set_n16(struct ibuf *buf, size_t pos, uint64_t value)
236 {
237 	uint16_t v;
238 
239 	if (value > UINT16_MAX) {
240 		errno = EINVAL;
241 		return (-1);
242 	}
243 	v = htobe16(value);
244 	return (ibuf_set(buf, pos, &v, sizeof(v)));
245 }
246 
247 int
248 ibuf_set_n32(struct ibuf *buf, size_t pos, uint64_t value)
249 {
250 	uint32_t v;
251 
252 	if (value > UINT32_MAX) {
253 		errno = EINVAL;
254 		return (-1);
255 	}
256 	v = htobe32(value);
257 	return (ibuf_set(buf, pos, &v, sizeof(v)));
258 }
259 
260 int
261 ibuf_set_n64(struct ibuf *buf, size_t pos, uint64_t value)
262 {
263 	value = htobe64(value);
264 	return (ibuf_set(buf, pos, &value, sizeof(value)));
265 }
266 
267 void *
268 ibuf_data(struct ibuf *buf)
269 {
270 	return (buf->buf);
271 }
272 
273 size_t
274 ibuf_size(struct ibuf *buf)
275 {
276 	return (buf->wpos);
277 }
278 
279 size_t
280 ibuf_left(struct ibuf *buf)
281 {
282 	return (buf->max - buf->wpos);
283 }
284 
285 void
286 ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf)
287 {
288 	ibuf_enqueue(msgbuf, buf);
289 }
290 
291 void
292 ibuf_free(struct ibuf *buf)
293 {
294 	if (buf == NULL)
295 		return;
296 	if (buf->fd != -1)
297 		close(buf->fd);
298 	freezero(buf->buf, buf->size);
299 	free(buf);
300 }
301 
302 int
303 ibuf_fd_avail(struct ibuf *buf)
304 {
305 	return (buf->fd != -1);
306 }
307 
308 int
309 ibuf_fd_get(struct ibuf *buf)
310 {
311 	int fd;
312 
313 	fd = buf->fd;
314 	buf->fd = -1;
315 	return (fd);
316 }
317 
318 void
319 ibuf_fd_set(struct ibuf *buf, int fd)
320 {
321 	if (buf->fd != -1)
322 		close(buf->fd);
323 	buf->fd = fd;
324 }
325 
326 int
327 ibuf_write(struct msgbuf *msgbuf)
328 {
329 	struct iovec	 iov[IOV_MAX];
330 	struct ibuf	*buf;
331 	unsigned int	 i = 0;
332 	ssize_t	n;
333 
334 	memset(&iov, 0, sizeof(iov));
335 	TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
336 		if (i >= IOV_MAX)
337 			break;
338 		iov[i].iov_base = buf->buf + buf->rpos;
339 		iov[i].iov_len = buf->wpos - buf->rpos;
340 		i++;
341 	}
342 
343 again:
344 	if ((n = writev(msgbuf->fd, iov, i)) == -1) {
345 		if (errno == EINTR)
346 			goto again;
347 		if (errno == ENOBUFS)
348 			errno = EAGAIN;
349 		return (-1);
350 	}
351 
352 	if (n == 0) {			/* connection closed */
353 		errno = 0;
354 		return (0);
355 	}
356 
357 	msgbuf_drain(msgbuf, n);
358 
359 	return (1);
360 }
361 
362 void
363 msgbuf_init(struct msgbuf *msgbuf)
364 {
365 	msgbuf->queued = 0;
366 	msgbuf->fd = -1;
367 	TAILQ_INIT(&msgbuf->bufs);
368 }
369 
370 static void
371 msgbuf_drain(struct msgbuf *msgbuf, size_t n)
372 {
373 	struct ibuf	*buf, *next;
374 
375 	for (buf = TAILQ_FIRST(&msgbuf->bufs); buf != NULL && n > 0;
376 	    buf = next) {
377 		next = TAILQ_NEXT(buf, entry);
378 		if (n >= buf->wpos - buf->rpos) {
379 			n -= buf->wpos - buf->rpos;
380 			ibuf_dequeue(msgbuf, buf);
381 		} else {
382 			buf->rpos += n;
383 			n = 0;
384 		}
385 	}
386 }
387 
388 void
389 msgbuf_clear(struct msgbuf *msgbuf)
390 {
391 	struct ibuf	*buf;
392 
393 	while ((buf = TAILQ_FIRST(&msgbuf->bufs)) != NULL)
394 		ibuf_dequeue(msgbuf, buf);
395 }
396 
397 int
398 msgbuf_write(struct msgbuf *msgbuf)
399 {
400 	struct iovec	 iov[IOV_MAX];
401 	struct ibuf	*buf, *buf0 = NULL;
402 	unsigned int	 i = 0;
403 	ssize_t		 n;
404 	struct msghdr	 msg;
405 	struct cmsghdr	*cmsg;
406 	union {
407 		struct cmsghdr	hdr;
408 		char		buf[CMSG_SPACE(sizeof(int))];
409 	} cmsgbuf;
410 
411 	memset(&iov, 0, sizeof(iov));
412 	memset(&msg, 0, sizeof(msg));
413 	memset(&cmsgbuf, 0, sizeof(cmsgbuf));
414 	TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
415 		if (i >= IOV_MAX)
416 			break;
417 		if (i > 0 && buf->fd != -1)
418 			break;
419 		iov[i].iov_base = buf->buf + buf->rpos;
420 		iov[i].iov_len = buf->wpos - buf->rpos;
421 		i++;
422 		if (buf->fd != -1)
423 			buf0 = buf;
424 	}
425 
426 	msg.msg_iov = iov;
427 	msg.msg_iovlen = i;
428 
429 	if (buf0 != NULL) {
430 		msg.msg_control = (caddr_t)&cmsgbuf.buf;
431 		msg.msg_controllen = sizeof(cmsgbuf.buf);
432 		cmsg = CMSG_FIRSTHDR(&msg);
433 		cmsg->cmsg_len = CMSG_LEN(sizeof(int));
434 		cmsg->cmsg_level = SOL_SOCKET;
435 		cmsg->cmsg_type = SCM_RIGHTS;
436 		*(int *)CMSG_DATA(cmsg) = buf0->fd;
437 	}
438 
439 again:
440 	if ((n = sendmsg(msgbuf->fd, &msg, 0)) == -1) {
441 		if (errno == EINTR)
442 			goto again;
443 		if (errno == ENOBUFS)
444 			errno = EAGAIN;
445 		return (-1);
446 	}
447 
448 	if (n == 0) {			/* connection closed */
449 		errno = 0;
450 		return (0);
451 	}
452 
453 	/*
454 	 * assumption: fd got sent if sendmsg sent anything
455 	 * this works because fds are passed one at a time
456 	 */
457 	if (buf0 != NULL) {
458 		close(buf0->fd);
459 		buf0->fd = -1;
460 	}
461 
462 	msgbuf_drain(msgbuf, n);
463 
464 	return (1);
465 }
466 
467 static void
468 ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
469 {
470 	TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry);
471 	msgbuf->queued++;
472 }
473 
474 static void
475 ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
476 {
477 	TAILQ_REMOVE(&msgbuf->bufs, buf, entry);
478 
479 	msgbuf->queued--;
480 	ibuf_free(buf);
481 }