op public repos

Blob

Date:: Sun Jan 7 18:58:26 2024 UTC
Message:: remove explicit #include endian.h unfortunately that's not portable. config.h will include the right stuff however.
Actions:: History | Blame | Raw File
1 /*	$OpenBSD: imsg-buffer.c,v 1.18 2023/12/12 15:47:41 claudio Exp $	*/
2 
3 /*
4  * Copyright (c) 2023 Claudio Jeker <claudio@openbsd.org>
5  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 #include "../config.h"
21 
22 #include <sys/types.h>
23 #include <sys/socket.h>
24 #include <sys/uio.h>
25 
26 #include <limits.h>
27 #include <errno.h>
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <unistd.h>
32 
33 #include "imsg.h"
34 
35 static int	ibuf_realloc(struct ibuf *, size_t);
36 static void	ibuf_enqueue(struct msgbuf *, struct ibuf *);
37 static void	ibuf_dequeue(struct msgbuf *, struct ibuf *);
38 static void	msgbuf_drain(struct msgbuf *, size_t);
39 
40 struct ibuf *
41 ibuf_open(size_t len)
42 {
43 	struct ibuf	*buf;
44 
45 	if (len == 0) {
46 		errno = EINVAL;
47 		return (NULL);
48 	}
49 	if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
50 		return (NULL);
51 	if ((buf->buf = calloc(len, 1)) == NULL) {
52 		free(buf);
53 		return (NULL);
54 	}
55 	buf->size = buf->max = len;
56 	buf->fd = -1;
57 
58 	return (buf);
59 }
60 
61 struct ibuf *
62 ibuf_dynamic(size_t len, size_t max)
63 {
64 	struct ibuf	*buf;
65 
66 	if (max == 0 || max < len) {
67 		errno = EINVAL;
68 		return (NULL);
69 	}
70 
71 	if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
72 		return (NULL);
73 	if (len > 0) {
74 		if ((buf->buf = calloc(len, 1)) == NULL) {
75 			free(buf);
76 			return (NULL);
77 		}
78 	}
79 	buf->size = len;
80 	buf->max = max;
81 	buf->fd = -1;
82 
83 	return (buf);
84 }
85 
86 static int
87 ibuf_realloc(struct ibuf *buf, size_t len)
88 {
89 	unsigned char	*b;
90 
91 	/* on static buffers max is eq size and so the following fails */
92 	if (len > SIZE_MAX - buf->wpos || buf->wpos + len > buf->max) {
93 		errno = ERANGE;
94 		return (-1);
95 	}
96 
97 	b = recallocarray(buf->buf, buf->size, buf->wpos + len, 1);
98 	if (b == NULL)
99 		return (-1);
100 	buf->buf = b;
101 	buf->size = buf->wpos + len;
102 
103 	return (0);
104 }
105 
106 void *
107 ibuf_reserve(struct ibuf *buf, size_t len)
108 {
109 	void	*b;
110 
111 	if (len > SIZE_MAX - buf->wpos || buf->max == 0) {
112 		errno = ERANGE;
113 		return (NULL);
114 	}
115 
116 	if (buf->wpos + len > buf->size)
117 		if (ibuf_realloc(buf, len) == -1)
118 			return (NULL);
119 
120 	b = buf->buf + buf->wpos;
121 	buf->wpos += len;
122 	return (b);
123 }
124 
125 int
126 ibuf_add(struct ibuf *buf, const void *data, size_t len)
127 {
128 	void *b;
129 
130 	if ((b = ibuf_reserve(buf, len)) == NULL)
131 		return (-1);
132 
133 	memcpy(b, data, len);
134 	return (0);
135 }
136 
137 int
138 ibuf_add_ibuf(struct ibuf *buf, const struct ibuf *from)
139 {
140 	return ibuf_add(buf, ibuf_data(from), ibuf_size(from));
141 }
142 
143 /* remove after tree is converted */
144 int
145 ibuf_add_buf(struct ibuf *buf, const struct ibuf *from)
146 {
147 	return ibuf_add_ibuf(buf, from);
148 }
149 
150 int
151 ibuf_add_n8(struct ibuf *buf, uint64_t value)
152 {
153 	uint8_t v;
154 
155 	if (value > UINT8_MAX) {
156 		errno = EINVAL;
157 		return (-1);
158 	}
159 	v = value;
160 	return ibuf_add(buf, &v, sizeof(v));
161 }
162 
163 int
164 ibuf_add_n16(struct ibuf *buf, uint64_t value)
165 {
166 	uint16_t v;
167 
168 	if (value > UINT16_MAX) {
169 		errno = EINVAL;
170 		return (-1);
171 	}
172 	v = htobe16(value);
173 	return ibuf_add(buf, &v, sizeof(v));
174 }
175 
176 int
177 ibuf_add_n32(struct ibuf *buf, uint64_t value)
178 {
179 	uint32_t v;
180 
181 	if (value > UINT32_MAX) {
182 		errno = EINVAL;
183 		return (-1);
184 	}
185 	v = htobe32(value);
186 	return ibuf_add(buf, &v, sizeof(v));
187 }
188 
189 int
190 ibuf_add_n64(struct ibuf *buf, uint64_t value)
191 {
192 	value = htobe64(value);
193 	return ibuf_add(buf, &value, sizeof(value));
194 }
195 
196 int
197 ibuf_add_h16(struct ibuf *buf, uint64_t value)
198 {
199 	uint16_t v;
200 
201 	if (value > UINT16_MAX) {
202 		errno = EINVAL;
203 		return (-1);
204 	}
205 	v = value;
206 	return ibuf_add(buf, &v, sizeof(v));
207 }
208 
209 int
210 ibuf_add_h32(struct ibuf *buf, uint64_t value)
211 {
212 	uint32_t v;
213 
214 	if (value > UINT32_MAX) {
215 		errno = EINVAL;
216 		return (-1);
217 	}
218 	v = value;
219 	return ibuf_add(buf, &v, sizeof(v));
220 }
221 
222 int
223 ibuf_add_h64(struct ibuf *buf, uint64_t value)
224 {
225 	return ibuf_add(buf, &value, sizeof(value));
226 }
227 
228 int
229 ibuf_add_zero(struct ibuf *buf, size_t len)
230 {
231 	void *b;
232 
233 	if ((b = ibuf_reserve(buf, len)) == NULL)
234 		return (-1);
235 	memset(b, 0, len);
236 	return (0);
237 }
238 
239 void *
240 ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
241 {
242 	/* only allow seeking between rpos and wpos */
243 	if (ibuf_size(buf) < pos || SIZE_MAX - pos < len ||
244 	    ibuf_size(buf) < pos + len) {
245 		errno = ERANGE;
246 		return (NULL);
247 	}
248 
249 	return (buf->buf + buf->rpos + pos);
250 }
251 
252 int
253 ibuf_set(struct ibuf *buf, size_t pos, const void *data, size_t len)
254 {
255 	void *b;
256 
257 	if ((b = ibuf_seek(buf, pos, len)) == NULL)
258 		return (-1);
259 
260 	memcpy(b, data, len);
261 	return (0);
262 }
263 
264 int
265 ibuf_set_n8(struct ibuf *buf, size_t pos, uint64_t value)
266 {
267 	uint8_t v;
268 
269 	if (value > UINT8_MAX) {
270 		errno = EINVAL;
271 		return (-1);
272 	}
273 	v = value;
274 	return (ibuf_set(buf, pos, &v, sizeof(v)));
275 }
276 
277 int
278 ibuf_set_n16(struct ibuf *buf, size_t pos, uint64_t value)
279 {
280 	uint16_t v;
281 
282 	if (value > UINT16_MAX) {
283 		errno = EINVAL;
284 		return (-1);
285 	}
286 	v = htobe16(value);
287 	return (ibuf_set(buf, pos, &v, sizeof(v)));
288 }
289 
290 int
291 ibuf_set_n32(struct ibuf *buf, size_t pos, uint64_t value)
292 {
293 	uint32_t v;
294 
295 	if (value > UINT32_MAX) {
296 		errno = EINVAL;
297 		return (-1);
298 	}
299 	v = htobe32(value);
300 	return (ibuf_set(buf, pos, &v, sizeof(v)));
301 }
302 
303 int
304 ibuf_set_n64(struct ibuf *buf, size_t pos, uint64_t value)
305 {
306 	value = htobe64(value);
307 	return (ibuf_set(buf, pos, &value, sizeof(value)));
308 }
309 
310 int
311 ibuf_set_h16(struct ibuf *buf, size_t pos, uint64_t value)
312 {
313 	uint16_t v;
314 
315 	if (value > UINT16_MAX) {
316 		errno = EINVAL;
317 		return (-1);
318 	}
319 	v = value;
320 	return (ibuf_set(buf, pos, &v, sizeof(v)));
321 }
322 
323 int
324 ibuf_set_h32(struct ibuf *buf, size_t pos, uint64_t value)
325 {
326 	uint32_t v;
327 
328 	if (value > UINT32_MAX) {
329 		errno = EINVAL;
330 		return (-1);
331 	}
332 	v = value;
333 	return (ibuf_set(buf, pos, &v, sizeof(v)));
334 }
335 
336 int
337 ibuf_set_h64(struct ibuf *buf, size_t pos, uint64_t value)
338 {
339 	return (ibuf_set(buf, pos, &value, sizeof(value)));
340 }
341 
342 void *
343 ibuf_data(const struct ibuf *buf)
344 {
345 	return (buf->buf + buf->rpos);
346 }
347 
348 size_t
349 ibuf_size(const struct ibuf *buf)
350 {
351 	return (buf->wpos - buf->rpos);
352 }
353 
354 size_t
355 ibuf_left(const struct ibuf *buf)
356 {
357 	if (buf->max == 0)
358 		return (0);
359 	return (buf->max - buf->wpos);
360 }
361 
362 int
363 ibuf_truncate(struct ibuf *buf, size_t len)
364 {
365 	if (ibuf_size(buf) >= len) {
366 		buf->wpos = buf->rpos + len;
367 		return (0);
368 	}
369 	if (buf->max == 0) {
370 		/* only allow to truncate down */
371 		errno = ERANGE;
372 		return (-1);
373 	}
374 	return ibuf_add_zero(buf, len - ibuf_size(buf));
375 }
376 
377 void
378 ibuf_rewind(struct ibuf *buf)
379 {
380 	buf->rpos = 0;
381 }
382 
383 void
384 ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf)
385 {
386 	ibuf_enqueue(msgbuf, buf);
387 }
388 
389 void
390 ibuf_from_buffer(struct ibuf *buf, void *data, size_t len)
391 {
392 	memset(buf, 0, sizeof(*buf));
393 	buf->buf = data;
394 	buf->size = buf->wpos = len;
395 	buf->fd = -1;
396 }
397 
398 void
399 ibuf_from_ibuf(struct ibuf *buf, const struct ibuf *from)
400 {
401 	ibuf_from_buffer(buf, ibuf_data(from), ibuf_size(from));
402 }
403 
404 int
405 ibuf_get(struct ibuf *buf, void *data, size_t len)
406 {
407 	if (ibuf_size(buf) < len) {
408 		errno = EBADMSG;
409 		return (-1);
410 	}
411 
412 	memcpy(data, ibuf_data(buf), len);
413 	buf->rpos += len;
414 	return (0);
415 }
416 
417 int
418 ibuf_get_ibuf(struct ibuf *buf, size_t len, struct ibuf *new)
419 {
420 	if (ibuf_size(buf) < len) {
421 		errno = EBADMSG;
422 		return (-1);
423 	}
424 
425 	ibuf_from_buffer(new, ibuf_data(buf), len);
426 	buf->rpos += len;
427 	return (0);
428 }
429 
430 int
431 ibuf_get_n8(struct ibuf *buf, uint8_t *value)
432 {
433 	return ibuf_get(buf, value, sizeof(*value));
434 }
435 
436 int
437 ibuf_get_n16(struct ibuf *buf, uint16_t *value)
438 {
439 	int rv;
440 
441 	rv = ibuf_get(buf, value, sizeof(*value));
442 	*value = be16toh(*value);
443 	return (rv);
444 }
445 
446 int
447 ibuf_get_n32(struct ibuf *buf, uint32_t *value)
448 {
449 	int rv;
450 
451 	rv = ibuf_get(buf, value, sizeof(*value));
452 	*value = be32toh(*value);
453 	return (rv);
454 }
455 
456 int
457 ibuf_get_n64(struct ibuf *buf, uint64_t *value)
458 {
459 	int rv;
460 
461 	rv = ibuf_get(buf, value, sizeof(*value));
462 	*value = be64toh(*value);
463 	return (rv);
464 }
465 
466 int
467 ibuf_get_h16(struct ibuf *buf, uint16_t *value)
468 {
469 	return ibuf_get(buf, value, sizeof(*value));
470 }
471 
472 int
473 ibuf_get_h32(struct ibuf *buf, uint32_t *value)
474 {
475 	return ibuf_get(buf, value, sizeof(*value));
476 }
477 
478 int
479 ibuf_get_h64(struct ibuf *buf, uint64_t *value)
480 {
481 	return ibuf_get(buf, value, sizeof(*value));
482 }
483 
484 int
485 ibuf_skip(struct ibuf *buf, size_t len)
486 {
487 	if (ibuf_size(buf) < len) {
488 		errno = EBADMSG;
489 		return (-1);
490 	}
491 
492 	buf->rpos += len;
493 	return (0);
494 }
495 
496 void
497 ibuf_free(struct ibuf *buf)
498 {
499 	if (buf == NULL)
500 		return;
501 	if (buf->max == 0)	/* if buf lives on the stack */
502 		abort();	/* abort before causing more harm */
503 	if (buf->fd != -1)
504 		close(buf->fd);
505 	freezero(buf->buf, buf->size);
506 	free(buf);
507 }
508 
509 int
510 ibuf_fd_avail(struct ibuf *buf)
511 {
512 	return (buf->fd != -1);
513 }
514 
515 int
516 ibuf_fd_get(struct ibuf *buf)
517 {
518 	int fd;
519 
520 	fd = buf->fd;
521 	buf->fd = -1;
522 	return (fd);
523 }
524 
525 void
526 ibuf_fd_set(struct ibuf *buf, int fd)
527 {
528 	if (buf->max == 0)	/* if buf lives on the stack */
529 		abort();	/* abort before causing more harm */
530 	if (buf->fd != -1)
531 		close(buf->fd);
532 	buf->fd = fd;
533 }
534 
535 int
536 ibuf_write(struct msgbuf *msgbuf)
537 {
538 	struct iovec	 iov[IOV_MAX];
539 	struct ibuf	*buf;
540 	unsigned int	 i = 0;
541 	ssize_t	n;
542 
543 	memset(&iov, 0, sizeof(iov));
544 	TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
545 		if (i >= IOV_MAX)
546 			break;
547 		iov[i].iov_base = ibuf_data(buf);
548 		iov[i].iov_len = ibuf_size(buf);
549 		i++;
550 	}
551 
552 again:
553 	if ((n = writev(msgbuf->fd, iov, i)) == -1) {
554 		if (errno == EINTR)
555 			goto again;
556 		if (errno == ENOBUFS)
557 			errno = EAGAIN;
558 		return (-1);
559 	}
560 
561 	if (n == 0) {			/* connection closed */
562 		errno = 0;
563 		return (0);
564 	}
565 
566 	msgbuf_drain(msgbuf, n);
567 
568 	return (1);
569 }
570 
571 void
572 msgbuf_init(struct msgbuf *msgbuf)
573 {
574 	msgbuf->queued = 0;
575 	msgbuf->fd = -1;
576 	TAILQ_INIT(&msgbuf->bufs);
577 }
578 
579 static void
580 msgbuf_drain(struct msgbuf *msgbuf, size_t n)
581 {
582 	struct ibuf	*buf, *next;
583 
584 	for (buf = TAILQ_FIRST(&msgbuf->bufs); buf != NULL && n > 0;
585 	    buf = next) {
586 		next = TAILQ_NEXT(buf, entry);
587 		if (n >= ibuf_size(buf)) {
588 			n -= ibuf_size(buf);
589 			ibuf_dequeue(msgbuf, buf);
590 		} else {
591 			buf->rpos += n;
592 			n = 0;
593 		}
594 	}
595 }
596 
597 void
598 msgbuf_clear(struct msgbuf *msgbuf)
599 {
600 	struct ibuf	*buf;
601 
602 	while ((buf = TAILQ_FIRST(&msgbuf->bufs)) != NULL)
603 		ibuf_dequeue(msgbuf, buf);
604 }
605 
606 int
607 msgbuf_write(struct msgbuf *msgbuf)
608 {
609 	struct iovec	 iov[IOV_MAX];
610 	struct ibuf	*buf, *buf0 = NULL;
611 	unsigned int	 i = 0;
612 	ssize_t		 n;
613 	struct msghdr	 msg;
614 	struct cmsghdr	*cmsg;
615 	union {
616 		struct cmsghdr	hdr;
617 		char		buf[CMSG_SPACE(sizeof(int))];
618 	} cmsgbuf;
619 
620 	memset(&iov, 0, sizeof(iov));
621 	memset(&msg, 0, sizeof(msg));
622 	memset(&cmsgbuf, 0, sizeof(cmsgbuf));
623 	TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
624 		if (i >= IOV_MAX)
625 			break;
626 		if (i > 0 && buf->fd != -1)
627 			break;
628 		iov[i].iov_base = ibuf_data(buf);
629 		iov[i].iov_len = ibuf_size(buf);
630 		i++;
631 		if (buf->fd != -1)
632 			buf0 = buf;
633 	}
634 
635 	msg.msg_iov = iov;
636 	msg.msg_iovlen = i;
637 
638 	if (buf0 != NULL) {
639 		msg.msg_control = (caddr_t)&cmsgbuf.buf;
640 		msg.msg_controllen = sizeof(cmsgbuf.buf);
641 		cmsg = CMSG_FIRSTHDR(&msg);
642 		cmsg->cmsg_len = CMSG_LEN(sizeof(int));
643 		cmsg->cmsg_level = SOL_SOCKET;
644 		cmsg->cmsg_type = SCM_RIGHTS;
645 		*(int *)CMSG_DATA(cmsg) = buf0->fd;
646 	}
647 
648 again:
649 	if ((n = sendmsg(msgbuf->fd, &msg, 0)) == -1) {
650 		if (errno == EINTR)
651 			goto again;
652 		if (errno == ENOBUFS)
653 			errno = EAGAIN;
654 		return (-1);
655 	}
656 
657 	if (n == 0) {			/* connection closed */
658 		errno = 0;
659 		return (0);
660 	}
661 
662 	/*
663 	 * assumption: fd got sent if sendmsg sent anything
664 	 * this works because fds are passed one at a time
665 	 */
666 	if (buf0 != NULL) {
667 		close(buf0->fd);
668 		buf0->fd = -1;
669 	}
670 
671 	msgbuf_drain(msgbuf, n);
672 
673 	return (1);
674 }
675 
676 uint32_t
677 msgbuf_queuelen(struct msgbuf *msgbuf)
678 {
679 	return (msgbuf->queued);
680 }
681 
682 static void
683 ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
684 {
685 	if (buf->max == 0)	/* if buf lives on the stack */
686 		abort();	/* abort before causing more harm */
687 	TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry);
688 	msgbuf->queued++;
689 }
690 
691 static void
692 ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
693 {
694 	TAILQ_REMOVE(&msgbuf->bufs, buf, entry);
695 	msgbuf->queued--;
696 	ibuf_free(buf);
697 }