From 4658a150149effd473292dfdbfd8b1bd80e363ac Mon Sep 17 00:00:00 2001 From: claudio Date: Tue, 12 Dec 2023 15:47:40 +0000 Subject: [PATCH] Extend imsg and ibuf API with useful getter methods For ibufs: - various getters for ibufs (ibuf_get* and ibuf_skip) - additional ibuf set/add functions that don't alter byte order - ibuf_truncate and ibuf_rewind - ibuf_from_buffer and ibuf_from_ibuf to populate a reader ibuf - a getter for the msgbuf queuelen For imsg: - various getters for imsg (especially imsg_get_data() which can be used in most cases as a simple one call api with all error checks). All the imsg.hdr fields can also be accessed by getters. - The imsg data is now actually an ibuf but the old imsg.data pointer is kept for now to not break every imsg application. - Introduce imsg_forward to simply forward a message from one channel to an other (used in the control socket code). Since this requires a major bump take the oportunity to also cleanup some function signatures to use size_t for length fields. Also internal data structures are removed from the public header. With and OK tb@ --- lib/libutil/Symbols.map | 36 +++++- lib/libutil/imsg-buffer.c | 255 +++++++++++++++++++++++++++++++++++--- lib/libutil/imsg.c | 172 ++++++++++++++++++++----- lib/libutil/imsg.h | 54 ++++++-- lib/libutil/shlib_version | 2 +- 5 files changed, 452 insertions(+), 67 deletions(-) diff --git a/lib/libutil/Symbols.map b/lib/libutil/Symbols.map index 00472fbb33f..c1bac13aa21 100644 --- a/lib/libutil/Symbols.map +++ b/lib/libutil/Symbols.map @@ -19,10 +19,14 @@ getrawpartition; ibuf_add; ibuf_add_buf; - ibuf_add_n8; + ibuf_add_ibuf; + ibuf_add_h16; + ibuf_add_h32; + ibuf_add_h64; ibuf_add_n16; ibuf_add_n32; ibuf_add_n64; + ibuf_add_n8; ibuf_add_zero; ibuf_close; ibuf_data; @@ -31,28 +35,53 @@ ibuf_fd_get; ibuf_fd_set; ibuf_free; + ibuf_from_buffer; + ibuf_from_ibuf; + ibuf_get; + ibuf_get_ibuf; + ibuf_get_h16; + ibuf_get_h32; + ibuf_get_h64; + ibuf_get_n16; + ibuf_get_n32; + ibuf_get_n64; + ibuf_get_n8; ibuf_left; ibuf_open; ibuf_reserve; + ibuf_rewind; ibuf_seek; ibuf_set; - ibuf_set_n8; + ibuf_set_h16; + ibuf_set_h32; + ibuf_set_h64; ibuf_set_n16; ibuf_set_n32; ibuf_set_n64; + ibuf_set_n8; ibuf_size; + ibuf_skip; + ibuf_truncate; ibuf_write; imsg_add; imsg_clear; imsg_close; imsg_compose; - imsg_composev; imsg_compose_ibuf; + imsg_composev; imsg_create; imsg_fd_overhead; imsg_flush; + imsg_forward; imsg_free; imsg_get; + imsg_get_ibuf; + imsg_get_data; + imsg_get_fd; + imsg_get_id; + imsg_get_len; + imsg_get_pid; + imsg_get_type; imsg_init; imsg_read; isduid; @@ -64,6 +93,7 @@ logwtmp; msgbuf_clear; msgbuf_init; + msgbuf_queuelen; msgbuf_write; ober_add_bitstring; ober_add_boolean; diff --git a/lib/libutil/imsg-buffer.c b/lib/libutil/imsg-buffer.c index e54904226eb..0708f486ee1 100644 --- a/lib/libutil/imsg-buffer.c +++ b/lib/libutil/imsg-buffer.c @@ -1,6 +1,7 @@ -/* $OpenBSD: imsg-buffer.c,v 1.17 2023/10/24 14:05:23 claudio Exp $ */ +/* $OpenBSD: imsg-buffer.c,v 1.18 2023/12/12 15:47:41 claudio Exp $ */ /* + * Copyright (c) 2023 Claudio Jeker * Copyright (c) 2003, 2004 Henning Brauer * * Permission to use, copy, modify, and distribute this software for any @@ -24,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -61,7 +63,7 @@ ibuf_dynamic(size_t len, size_t max) { struct ibuf *buf; - if (max < len) { + if (max == 0 || max < len) { errno = EINVAL; return (NULL); } @@ -106,7 +108,7 @@ ibuf_reserve(struct ibuf *buf, size_t len) { void *b; - if (len > SIZE_MAX - buf->wpos) { + if (len > SIZE_MAX - buf->wpos || buf->max == 0) { errno = ERANGE; return (NULL); } @@ -117,7 +119,6 @@ ibuf_reserve(struct ibuf *buf, size_t len) b = buf->buf + buf->wpos; buf->wpos += len; - memset(b, 0, len); return (b); } @@ -133,10 +134,17 @@ ibuf_add(struct ibuf *buf, const void *data, size_t len) return (0); } +int +ibuf_add_ibuf(struct ibuf *buf, const struct ibuf *from) +{ + return ibuf_add(buf, ibuf_data(from), ibuf_size(from)); +} + +/* remove after tree is converted */ int ibuf_add_buf(struct ibuf *buf, const struct ibuf *from) { - return ibuf_add(buf, from->buf, from->wpos); + return ibuf_add_ibuf(buf, from); } int @@ -185,6 +193,38 @@ ibuf_add_n64(struct ibuf *buf, uint64_t value) return ibuf_add(buf, &value, sizeof(value)); } +int +ibuf_add_h16(struct ibuf *buf, uint64_t value) +{ + uint16_t v; + + if (value > UINT16_MAX) { + errno = EINVAL; + return (-1); + } + v = value; + return ibuf_add(buf, &v, sizeof(v)); +} + +int +ibuf_add_h32(struct ibuf *buf, uint64_t value) +{ + uint32_t v; + + if (value > UINT32_MAX) { + errno = EINVAL; + return (-1); + } + v = value; + return ibuf_add(buf, &v, sizeof(v)); +} + +int +ibuf_add_h64(struct ibuf *buf, uint64_t value) +{ + return ibuf_add(buf, &value, sizeof(value)); +} + int ibuf_add_zero(struct ibuf *buf, size_t len) { @@ -192,19 +232,21 @@ ibuf_add_zero(struct ibuf *buf, size_t len) if ((b = ibuf_reserve(buf, len)) == NULL) return (-1); + memset(b, 0, len); return (0); } void * ibuf_seek(struct ibuf *buf, size_t pos, size_t len) { - /* only allowed to seek in already written parts */ - if (len > SIZE_MAX - pos || pos + len > buf->wpos) { + /* only allow seeking between rpos and wpos */ + if (ibuf_size(buf) < pos || SIZE_MAX - pos < len || + ibuf_size(buf) < pos + len) { errno = ERANGE; return (NULL); } - return (buf->buf + pos); + return (buf->buf + buf->rpos + pos); } int @@ -265,35 +307,199 @@ ibuf_set_n64(struct ibuf *buf, size_t pos, uint64_t value) return (ibuf_set(buf, pos, &value, sizeof(value))); } +int +ibuf_set_h16(struct ibuf *buf, size_t pos, uint64_t value) +{ + uint16_t v; + + if (value > UINT16_MAX) { + errno = EINVAL; + return (-1); + } + v = value; + return (ibuf_set(buf, pos, &v, sizeof(v))); +} + +int +ibuf_set_h32(struct ibuf *buf, size_t pos, uint64_t value) +{ + uint32_t v; + + if (value > UINT32_MAX) { + errno = EINVAL; + return (-1); + } + v = value; + return (ibuf_set(buf, pos, &v, sizeof(v))); +} + +int +ibuf_set_h64(struct ibuf *buf, size_t pos, uint64_t value) +{ + return (ibuf_set(buf, pos, &value, sizeof(value))); +} + void * -ibuf_data(struct ibuf *buf) +ibuf_data(const struct ibuf *buf) { - return (buf->buf); + return (buf->buf + buf->rpos); } size_t -ibuf_size(struct ibuf *buf) +ibuf_size(const struct ibuf *buf) { - return (buf->wpos); + return (buf->wpos - buf->rpos); } size_t -ibuf_left(struct ibuf *buf) +ibuf_left(const struct ibuf *buf) { + if (buf->max == 0) + return (0); return (buf->max - buf->wpos); } +int +ibuf_truncate(struct ibuf *buf, size_t len) +{ + if (ibuf_size(buf) >= len) { + buf->wpos = buf->rpos + len; + return (0); + } + if (buf->max == 0) { + /* only allow to truncate down */ + errno = ERANGE; + return (-1); + } + return ibuf_add_zero(buf, len - ibuf_size(buf)); +} + +void +ibuf_rewind(struct ibuf *buf) +{ + buf->rpos = 0; +} + void ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf) { ibuf_enqueue(msgbuf, buf); } +void +ibuf_from_buffer(struct ibuf *buf, void *data, size_t len) +{ + memset(buf, 0, sizeof(*buf)); + buf->buf = data; + buf->size = buf->wpos = len; + buf->fd = -1; +} + +void +ibuf_from_ibuf(struct ibuf *buf, const struct ibuf *from) +{ + ibuf_from_buffer(buf, ibuf_data(from), ibuf_size(from)); +} + +int +ibuf_get(struct ibuf *buf, void *data, size_t len) +{ + if (ibuf_size(buf) < len) { + errno = EBADMSG; + return (-1); + } + + memcpy(data, ibuf_data(buf), len); + buf->rpos += len; + return (0); +} + +int +ibuf_get_ibuf(struct ibuf *buf, size_t len, struct ibuf *new) +{ + if (ibuf_size(buf) < len) { + errno = EBADMSG; + return (-1); + } + + ibuf_from_buffer(new, ibuf_data(buf), len); + buf->rpos += len; + return (0); +} + +int +ibuf_get_n8(struct ibuf *buf, uint8_t *value) +{ + return ibuf_get(buf, value, sizeof(*value)); +} + +int +ibuf_get_n16(struct ibuf *buf, uint16_t *value) +{ + int rv; + + rv = ibuf_get(buf, value, sizeof(*value)); + *value = be16toh(*value); + return (rv); +} + +int +ibuf_get_n32(struct ibuf *buf, uint32_t *value) +{ + int rv; + + rv = ibuf_get(buf, value, sizeof(*value)); + *value = be32toh(*value); + return (rv); +} + +int +ibuf_get_n64(struct ibuf *buf, uint64_t *value) +{ + int rv; + + rv = ibuf_get(buf, value, sizeof(*value)); + *value = be64toh(*value); + return (rv); +} + +int +ibuf_get_h16(struct ibuf *buf, uint16_t *value) +{ + return ibuf_get(buf, value, sizeof(*value)); +} + +int +ibuf_get_h32(struct ibuf *buf, uint32_t *value) +{ + return ibuf_get(buf, value, sizeof(*value)); +} + +int +ibuf_get_h64(struct ibuf *buf, uint64_t *value) +{ + return ibuf_get(buf, value, sizeof(*value)); +} + +int +ibuf_skip(struct ibuf *buf, size_t len) +{ + if (ibuf_size(buf) < len) { + errno = EBADMSG; + return (-1); + } + + buf->rpos += len; + return (0); +} + void ibuf_free(struct ibuf *buf) { if (buf == NULL) return; + if (buf->max == 0) /* if buf lives on the stack */ + abort(); /* abort before causing more harm */ if (buf->fd != -1) close(buf->fd); freezero(buf->buf, buf->size); @@ -319,6 +525,8 @@ ibuf_fd_get(struct ibuf *buf) void ibuf_fd_set(struct ibuf *buf, int fd) { + if (buf->max == 0) /* if buf lives on the stack */ + abort(); /* abort before causing more harm */ if (buf->fd != -1) close(buf->fd); buf->fd = fd; @@ -336,8 +544,8 @@ ibuf_write(struct msgbuf *msgbuf) TAILQ_FOREACH(buf, &msgbuf->bufs, entry) { if (i >= IOV_MAX) break; - iov[i].iov_base = buf->buf + buf->rpos; - iov[i].iov_len = buf->wpos - buf->rpos; + iov[i].iov_base = ibuf_data(buf); + iov[i].iov_len = ibuf_size(buf); i++; } @@ -376,8 +584,8 @@ msgbuf_drain(struct msgbuf *msgbuf, size_t n) for (buf = TAILQ_FIRST(&msgbuf->bufs); buf != NULL && n > 0; buf = next) { next = TAILQ_NEXT(buf, entry); - if (n >= buf->wpos - buf->rpos) { - n -= buf->wpos - buf->rpos; + if (n >= ibuf_size(buf)) { + n -= ibuf_size(buf); ibuf_dequeue(msgbuf, buf); } else { buf->rpos += n; @@ -417,8 +625,8 @@ msgbuf_write(struct msgbuf *msgbuf) break; if (i > 0 && buf->fd != -1) break; - iov[i].iov_base = buf->buf + buf->rpos; - iov[i].iov_len = buf->wpos - buf->rpos; + iov[i].iov_base = ibuf_data(buf); + iov[i].iov_len = ibuf_size(buf); i++; if (buf->fd != -1) buf0 = buf; @@ -465,9 +673,17 @@ again: return (1); } +uint32_t +msgbuf_queuelen(struct msgbuf *msgbuf) +{ + return (msgbuf->queued); +} + static void ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf) { + if (buf->max == 0) /* if buf lives on the stack */ + abort(); /* abort before causing more harm */ TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry); msgbuf->queued++; } @@ -476,7 +692,6 @@ static void ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf) { TAILQ_REMOVE(&msgbuf->bufs, buf, entry); - msgbuf->queued--; ibuf_free(buf); } diff --git a/lib/libutil/imsg.c b/lib/libutil/imsg.c index b6cc37ee1b7..0aff226bfc9 100644 --- a/lib/libutil/imsg.c +++ b/lib/libutil/imsg.c @@ -1,6 +1,7 @@ -/* $OpenBSD: imsg.c,v 1.22 2023/11/18 07:14:13 claudio Exp $ */ +/* $OpenBSD: imsg.c,v 1.23 2023/12/12 15:47:41 claudio Exp $ */ /* + * Copyright (c) 2023 Claudio Jeker * Copyright (c) 2003, 2004 Henning Brauer * * Permission to use, copy, modify, and distribute this software for any @@ -28,6 +29,11 @@ #include "imsg.h" +struct imsg_fd { + TAILQ_ENTRY(imsg_fd) entry; + int fd; +}; + int imsg_fd_overhead = 0; static int imsg_dequeue_fd(struct imsgbuf *); @@ -123,6 +129,7 @@ fail: ssize_t imsg_get(struct imsgbuf *imsgbuf, struct imsg *imsg) { + struct imsg m; size_t av, left, datalen; av = imsgbuf->r.wpos; @@ -130,42 +137,108 @@ imsg_get(struct imsgbuf *imsgbuf, struct imsg *imsg) if (IMSG_HEADER_SIZE > av) return (0); - memcpy(&imsg->hdr, imsgbuf->r.buf, sizeof(imsg->hdr)); - if (imsg->hdr.len < IMSG_HEADER_SIZE || - imsg->hdr.len > MAX_IMSGSIZE) { + memcpy(&m.hdr, imsgbuf->r.buf, sizeof(m.hdr)); + if (m.hdr.len < IMSG_HEADER_SIZE || + m.hdr.len > MAX_IMSGSIZE) { errno = ERANGE; return (-1); } - if (imsg->hdr.len > av) + if (m.hdr.len > av) return (0); - datalen = imsg->hdr.len - IMSG_HEADER_SIZE; - imsgbuf->r.rptr = imsgbuf->r.buf + IMSG_HEADER_SIZE; - if (datalen == 0) - imsg->data = NULL; - else if ((imsg->data = malloc(datalen)) == NULL) - return (-1); - if (imsg->hdr.flags & IMSGF_HASFD) - imsg->fd = imsg_dequeue_fd(imsgbuf); - else - imsg->fd = -1; + m.fd = -1; + m.buf = NULL; + m.data = NULL; + + datalen = m.hdr.len - IMSG_HEADER_SIZE; + imsgbuf->r.rptr = imsgbuf->r.buf + IMSG_HEADER_SIZE; + if (datalen != 0) { + if ((m.buf = ibuf_open(datalen)) == NULL) + return (-1); + if (ibuf_add(m.buf, imsgbuf->r.rptr, datalen) == -1) { + /* this should never fail */ + ibuf_free(m.buf); + return (-1); + } + m.data = ibuf_data(m.buf); + } - if (datalen != 0) - memcpy(imsg->data, imsgbuf->r.rptr, datalen); + if (m.hdr.flags & IMSGF_HASFD) + m.fd = imsg_dequeue_fd(imsgbuf); - if (imsg->hdr.len < av) { - left = av - imsg->hdr.len; - memmove(&imsgbuf->r.buf, imsgbuf->r.buf + imsg->hdr.len, left); + if (m.hdr.len < av) { + left = av - m.hdr.len; + memmove(&imsgbuf->r.buf, imsgbuf->r.buf + m.hdr.len, left); imsgbuf->r.wpos = left; } else imsgbuf->r.wpos = 0; + *imsg = m; return (datalen + IMSG_HEADER_SIZE); } +int +imsg_get_ibuf(struct imsg *imsg, struct ibuf *ibuf) +{ + if (imsg->buf == NULL) { + errno = EBADMSG; + return (-1); + } + return ibuf_get_ibuf(imsg->buf, ibuf_size(imsg->buf), ibuf); +} + +int +imsg_get_data(struct imsg *imsg, void *data, size_t len) +{ + if (len == 0) { + errno = EINVAL; + return (-1); + } + if (imsg->buf == NULL || ibuf_size(imsg->buf) != len) { + errno = EBADMSG; + return (-1); + } + return ibuf_get(imsg->buf, data, len); +} + +int +imsg_get_fd(struct imsg *imsg) +{ + int fd = imsg->fd; + + imsg->fd = -1; + return fd; +} + +uint32_t +imsg_get_id(struct imsg *imsg) +{ + return (imsg->hdr.peerid); +} + +size_t +imsg_get_len(struct imsg *imsg) +{ + if (imsg->buf == NULL) + return 0; + return ibuf_size(imsg->buf); +} + +pid_t +imsg_get_pid(struct imsg *imsg) +{ + return (imsg->hdr.pid); +} + +uint32_t +imsg_get_type(struct imsg *imsg) +{ + return (imsg->hdr.type); +} + int imsg_compose(struct imsgbuf *imsgbuf, uint32_t type, uint32_t id, pid_t pid, - int fd, const void *data, uint16_t datalen) + int fd, const void *data, size_t datalen) { struct ibuf *wbuf; @@ -186,7 +259,8 @@ imsg_composev(struct imsgbuf *imsgbuf, uint32_t type, uint32_t id, pid_t pid, int fd, const struct iovec *iov, int iovcnt) { struct ibuf *wbuf; - int i, datalen = 0; + int i; + size_t datalen = 0; for (i = 0; i < iovcnt; i++) datalen += iov[i].iov_len; @@ -204,11 +278,15 @@ imsg_composev(struct imsgbuf *imsgbuf, uint32_t type, uint32_t id, pid_t pid, return (1); } +/* + * Enqueue imsg with payload from ibuf buf. fd passing is not possible + * with this function. + */ int imsg_compose_ibuf(struct imsgbuf *imsgbuf, uint32_t type, uint32_t id, pid_t pid, struct ibuf *buf) { - struct ibuf *wbuf = NULL; + struct ibuf *hdrbuf = NULL; struct imsg_hdr hdr; int save_errno; @@ -224,26 +302,60 @@ imsg_compose_ibuf(struct imsgbuf *imsgbuf, uint32_t type, uint32_t id, if ((hdr.pid = pid) == 0) hdr.pid = imsgbuf->pid; - if ((wbuf = ibuf_open(IMSG_HEADER_SIZE)) == NULL) + if ((hdrbuf = ibuf_open(IMSG_HEADER_SIZE)) == NULL) goto fail; - if (imsg_add(wbuf, &hdr, sizeof(hdr)) == -1) + if (imsg_add(hdrbuf, &hdr, sizeof(hdr)) == -1) goto fail; - ibuf_close(&imsgbuf->w, wbuf); + ibuf_close(&imsgbuf->w, hdrbuf); ibuf_close(&imsgbuf->w, buf); return (1); fail: save_errno = errno; ibuf_free(buf); - ibuf_free(wbuf); + ibuf_free(hdrbuf); errno = save_errno; return (-1); } +/* + * Forward imsg to another channel. Any attached fd is closed. + */ +int +imsg_forward(struct imsgbuf *imsgbuf, struct imsg *msg) +{ + struct ibuf *wbuf; + size_t len = 0; + + if (msg->fd != -1) { + close(msg->fd); + msg->fd = -1; + } + + if (msg->buf != NULL) { + ibuf_rewind(msg->buf); + len = ibuf_size(msg->buf); + } + + if ((wbuf = imsg_create(imsgbuf, msg->hdr.type, msg->hdr.peerid, + msg->hdr.pid, len)) == NULL) + return (-1); + + if (msg->buf != NULL) { + if (ibuf_add_buf(wbuf, msg->buf) == -1) { + ibuf_free(wbuf); + return (-1); + } + } + + imsg_close(imsgbuf, wbuf); + return (1); +} + struct ibuf * imsg_create(struct imsgbuf *imsgbuf, uint32_t type, uint32_t id, pid_t pid, - uint16_t datalen) + size_t datalen) { struct ibuf *wbuf; struct imsg_hdr hdr; @@ -269,7 +381,7 @@ imsg_create(struct imsgbuf *imsgbuf, uint32_t type, uint32_t id, pid_t pid, } int -imsg_add(struct ibuf *msg, const void *data, uint16_t datalen) +imsg_add(struct ibuf *msg, const void *data, size_t datalen) { if (datalen) if (ibuf_add(msg, data, datalen) == -1) { @@ -297,7 +409,7 @@ imsg_close(struct imsgbuf *imsgbuf, struct ibuf *msg) void imsg_free(struct imsg *imsg) { - freezero(imsg->data, imsg->hdr.len - IMSG_HEADER_SIZE); + ibuf_free(imsg->buf); } static int diff --git a/lib/libutil/imsg.h b/lib/libutil/imsg.h index fb516e30287..dd47b1889da 100644 --- a/lib/libutil/imsg.h +++ b/lib/libutil/imsg.h @@ -1,6 +1,7 @@ -/* $OpenBSD: imsg.h,v 1.7 2023/06/19 17:19:50 claudio Exp $ */ +/* $OpenBSD: imsg.h,v 1.8 2023/12/12 15:47:41 claudio Exp $ */ /* + * Copyright (c) 2023 Claudio Jeker * Copyright (c) 2006, 2007 Pierre-Yves Ritschard * Copyright (c) 2006, 2007, 2008 Reyk Floeter * Copyright (c) 2003, 2004 Henning Brauer @@ -21,7 +22,7 @@ #ifndef _IMSG_H_ #define _IMSG_H_ -#include +#include #define IBUF_READ_SIZE 65535 #define IMSG_HEADER_SIZE sizeof(struct imsg_hdr) @@ -49,11 +50,7 @@ struct ibuf_read { size_t wpos; }; -struct imsg_fd { - TAILQ_ENTRY(imsg_fd) entry; - int fd; -}; - +struct imsg_fd; struct imsgbuf { TAILQ_HEAD(, imsg_fd) fds; struct ibuf_read r; @@ -76,6 +73,7 @@ struct imsg { struct imsg_hdr hdr; int fd; void *data; + struct ibuf *buf; }; struct iovec; @@ -85,11 +83,15 @@ struct ibuf *ibuf_open(size_t); struct ibuf *ibuf_dynamic(size_t, size_t); int ibuf_add(struct ibuf *, const void *, size_t); int ibuf_add_buf(struct ibuf *, const struct ibuf *); +int ibuf_add_ibuf(struct ibuf *, const struct ibuf *); int ibuf_add_zero(struct ibuf *, size_t); int ibuf_add_n8(struct ibuf *, uint64_t); int ibuf_add_n16(struct ibuf *, uint64_t); int ibuf_add_n32(struct ibuf *, uint64_t); int ibuf_add_n64(struct ibuf *, uint64_t); +int ibuf_add_h16(struct ibuf *, uint64_t); +int ibuf_add_h32(struct ibuf *, uint64_t); +int ibuf_add_h64(struct ibuf *, uint64_t); void *ibuf_reserve(struct ibuf *, size_t); void *ibuf_seek(struct ibuf *, size_t, size_t); int ibuf_set(struct ibuf *, size_t, const void *, size_t); @@ -97,10 +99,27 @@ int ibuf_set_n8(struct ibuf *, size_t, uint64_t); int ibuf_set_n16(struct ibuf *, size_t, uint64_t); int ibuf_set_n32(struct ibuf *, size_t, uint64_t); int ibuf_set_n64(struct ibuf *, size_t, uint64_t); -void *ibuf_data(struct ibuf *); -size_t ibuf_size(struct ibuf *); -size_t ibuf_left(struct ibuf *); +int ibuf_set_h16(struct ibuf *, size_t, uint64_t); +int ibuf_set_h32(struct ibuf *, size_t, uint64_t); +int ibuf_set_h64(struct ibuf *, size_t, uint64_t); +void *ibuf_data(const struct ibuf *); +size_t ibuf_size(const struct ibuf *); +size_t ibuf_left(const struct ibuf *); +int ibuf_truncate(struct ibuf *, size_t); +void ibuf_rewind(struct ibuf *); void ibuf_close(struct msgbuf *, struct ibuf *); +void ibuf_from_buffer(struct ibuf *, void *, size_t); +void ibuf_from_ibuf(struct ibuf *, const struct ibuf *); +int ibuf_get(struct ibuf *, void *, size_t); +int ibuf_get_ibuf(struct ibuf *, size_t, struct ibuf *); +int ibuf_get_n8(struct ibuf *, uint8_t *); +int ibuf_get_n16(struct ibuf *, uint16_t *); +int ibuf_get_n32(struct ibuf *, uint32_t *); +int ibuf_get_n64(struct ibuf *, uint64_t *); +int ibuf_get_h16(struct ibuf *, uint16_t *); +int ibuf_get_h32(struct ibuf *, uint32_t *); +int ibuf_get_h64(struct ibuf *, uint64_t *); +int ibuf_skip(struct ibuf *, size_t); void ibuf_free(struct ibuf *); int ibuf_fd_avail(struct ibuf *); int ibuf_fd_get(struct ibuf *); @@ -108,20 +127,29 @@ void ibuf_fd_set(struct ibuf *, int); int ibuf_write(struct msgbuf *); void msgbuf_init(struct msgbuf *); void msgbuf_clear(struct msgbuf *); +uint32_t msgbuf_queuelen(struct msgbuf *); int msgbuf_write(struct msgbuf *); /* imsg.c */ void imsg_init(struct imsgbuf *, int); ssize_t imsg_read(struct imsgbuf *); ssize_t imsg_get(struct imsgbuf *, struct imsg *); +int imsg_get_ibuf(struct imsg *, struct ibuf *); +int imsg_get_data(struct imsg *, void *, size_t); +int imsg_get_fd(struct imsg *); +uint32_t imsg_get_id(struct imsg *); +size_t imsg_get_len(struct imsg *); +pid_t imsg_get_pid(struct imsg *); +uint32_t imsg_get_type(struct imsg *); +int imsg_forward(struct imsgbuf *, struct imsg *); int imsg_compose(struct imsgbuf *, uint32_t, uint32_t, pid_t, int, - const void *, uint16_t); + const void *, size_t); int imsg_composev(struct imsgbuf *, uint32_t, uint32_t, pid_t, int, const struct iovec *, int); int imsg_compose_ibuf(struct imsgbuf *, uint32_t, uint32_t, pid_t, struct ibuf *); -struct ibuf *imsg_create(struct imsgbuf *, uint32_t, uint32_t, pid_t, uint16_t); -int imsg_add(struct ibuf *, const void *, uint16_t); +struct ibuf *imsg_create(struct imsgbuf *, uint32_t, uint32_t, pid_t, size_t); +int imsg_add(struct ibuf *, const void *, size_t); void imsg_close(struct imsgbuf *, struct ibuf *); void imsg_free(struct imsg *); int imsg_flush(struct imsgbuf *); diff --git a/lib/libutil/shlib_version b/lib/libutil/shlib_version index ffdd3d2d569..94727e17b3a 100644 --- a/lib/libutil/shlib_version +++ b/lib/libutil/shlib_version @@ -1,2 +1,2 @@ -major=17 +major=18 minor=0 -- 2.20.1