/*	$OpenBSD: imsg-buffer.c,v 1.41 2026/07/30 17:55:33 claudio Exp $	*/

/*
 * Copyright (c) 2023 Claudio Jeker <claudio@openbsd.org>
 * Copyright (c) 2003, 2004 Henning Brauer <henning@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/socket.h>
#include <sys/uio.h>

#include <limits.h>
#include <errno.h>
#include <endian.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "imsg.h"

struct ibufqueue {
	TAILQ_HEAD(, ibuf)	bufs;
	uint32_t		queued;
};

struct msgbuf {
	struct ibufqueue	 bufs;
	struct ibufqueue	 rbufs;
	char			*rbuf;
	struct ibuf		*rpmsg;
	struct ibuf		*(*readhdr)(struct ibuf *, void *, int *);
	void			*rarg;
	size_t			 roff;
	size_t			 hdrsize;
};

static void	msgbuf_drain(struct msgbuf *, size_t);
static void	ibufq_init(struct ibufqueue *);

#define	IBUF_FD_MARK_ON_STACK	-2

struct ibuf *
ibuf_open(size_t len)
{
	struct ibuf	*buf;

	if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
		return (NULL);
	if (len > 0) {
		if ((buf->buf = calloc(len, 1)) == NULL) {
			free(buf);
			return (NULL);
		}
	}
	buf->size = buf->max = len;
	buf->fd = -1;

	return (buf);
}

struct ibuf *
ibuf_dynamic(size_t len, size_t max)
{
	struct ibuf	*buf;

	if (max == 0 || max < len) {
		errno = EINVAL;
		return (NULL);
	}

	if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
		return (NULL);
	if (len > 0) {
		if ((buf->buf = calloc(len, 1)) == NULL) {
			free(buf);
			return (NULL);
		}
	}
	buf->size = len;
	buf->max = max;
	buf->fd = -1;

	return (buf);
}

void *
ibuf_reserve(struct ibuf *buf, size_t len)
{
	void	*b;

	if (len > SIZE_MAX - buf->wpos) {
		errno = ERANGE;
		return (NULL);
	}
	if (buf->fd == IBUF_FD_MARK_ON_STACK) {
		/* can not grow stack buffers */
		errno = EINVAL;
		return (NULL);
	}

	if (buf->wpos + len > buf->size) {
		unsigned char	*nb;

		/* check if buffer is allowed to grow */
		if (buf->wpos + len > buf->max) {
			errno = ERANGE;
			return (NULL);
		}
		nb = realloc(buf->buf, buf->wpos + len);
		if (nb == NULL)
			return (NULL);
		memset(nb + buf->size, 0, buf->wpos + len - buf->size);
		buf->buf = nb;
		buf->size = buf->wpos + len;
	}

	b = buf->buf + buf->wpos;
	buf->wpos += len;
	return (b);
}

int
ibuf_add(struct ibuf *buf, const void *data, size_t len)
{
	void *b;

	if (len == 0)
		return (0);

	if ((b = ibuf_reserve(buf, len)) == NULL)
		return (-1);

	memcpy(b, data, len);
	return (0);
}

int
ibuf_add_ibuf(struct ibuf *buf, const struct ibuf *from)
{
	return ibuf_add(buf, ibuf_data(from), ibuf_size(from));
}

int
ibuf_add_n8(struct ibuf *buf, uint64_t value)
{
	uint8_t v;

	if (value > UINT8_MAX) {
		errno = EINVAL;
		return (-1);
	}
	v = value;
	return ibuf_add(buf, &v, sizeof(v));
}

int
ibuf_add_n16(struct ibuf *buf, uint64_t value)
{
	uint16_t v;

	if (value > UINT16_MAX) {
		errno = EINVAL;
		return (-1);
	}
	v = htobe16(value);
	return ibuf_add(buf, &v, sizeof(v));
}

int
ibuf_add_n32(struct ibuf *buf, uint64_t value)
{
	uint32_t v;

	if (value > UINT32_MAX) {
		errno = EINVAL;
		return (-1);
	}
	v = htobe32(value);
	return ibuf_add(buf, &v, sizeof(v));
}

int
ibuf_add_n64(struct ibuf *buf, uint64_t value)
{
	value = htobe64(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)
{
	void *b;

	if (len == 0)
		return (0);

	if ((b = ibuf_reserve(buf, len)) == NULL)
		return (-1);
	memset(b, 0, len);
	return (0);
}

int
ibuf_add_strbuf(struct ibuf *buf, const char *str, size_t len)
{
	char *b;
	size_t n;

	if ((b = ibuf_reserve(buf, len)) == NULL)
		return (-1);

	n = strlcpy(b, str, len);
	if (n >= len) {
		/* also covers the case where len == 0 */
		errno = EOVERFLOW;
		return (-1);
	}
	memset(b + n, 0, len - n);
	return (0);
}

void *
ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
{
	/* 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 + buf->rpos + pos);
}

int
ibuf_set(struct ibuf *buf, size_t pos, const void *data, size_t len)
{
	void *b;

	if ((b = ibuf_seek(buf, pos, len)) == NULL)
		return (-1);

	if (len == 0)
		return (0);
	memcpy(b, data, len);
	return (0);
}

int
ibuf_set_n8(struct ibuf *buf, size_t pos, uint64_t value)
{
	uint8_t v;

	if (value > UINT8_MAX) {
		errno = EINVAL;
		return (-1);
	}
	v = value;
	return (ibuf_set(buf, pos, &v, sizeof(v)));
}

int
ibuf_set_n16(struct ibuf *buf, size_t pos, uint64_t value)
{
	uint16_t v;

	if (value > UINT16_MAX) {
		errno = EINVAL;
		return (-1);
	}
	v = htobe16(value);
	return (ibuf_set(buf, pos, &v, sizeof(v)));
}

int
ibuf_set_n32(struct ibuf *buf, size_t pos, uint64_t value)
{
	uint32_t v;

	if (value > UINT32_MAX) {
		errno = EINVAL;
		return (-1);
	}
	v = htobe32(value);
	return (ibuf_set(buf, pos, &v, sizeof(v)));
}

int
ibuf_set_n64(struct ibuf *buf, size_t pos, uint64_t value)
{
	value = htobe64(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)));
}

int
ibuf_set_maxsize(struct ibuf *buf, size_t max)
{
	if (buf->fd == IBUF_FD_MARK_ON_STACK) {
		/* can't fiddle with stack buffers */
		errno = EINVAL;
		return (-1);
	}
	if (max > buf->max) {	/* can only shrink the buffer */
		errno = ERANGE;
		return (-1);
	}
	if (buf->wpos > max) {	/* cannot shrink below current wpos */
		errno = ERANGE;
		return (-1);
	}
	if (buf->size > max) {	/* clear excess memory */
		explicit_bzero(buf->buf + max, buf->size - max);
		buf->size = max;
	}
	
	buf->max = max;
	return (0);
}

void *
ibuf_data(const struct ibuf *buf)
{
	return (buf->buf + buf->rpos);
}

size_t
ibuf_size(const struct ibuf *buf)
{
	return (buf->wpos - buf->rpos);
}

size_t
ibuf_left(const struct ibuf *buf)
{
	/* on stack buffers have no space left */
	if (buf->fd == IBUF_FD_MARK_ON_STACK)
		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->fd == IBUF_FD_MARK_ON_STACK) {
		/* only allow to truncate down for stack buffers */
		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)
{
	ibufq_push(&msgbuf->bufs, 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 = IBUF_FD_MARK_ON_STACK;
}

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_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_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);
}

char *
ibuf_get_string(struct ibuf *buf, size_t len)
{
	char *str;

	if (ibuf_size(buf) < len) {
		errno = EBADMSG;
		return (NULL);
	}

	str = strndup(ibuf_data(buf), len);
	if (str == NULL)
		return (NULL);
	buf->rpos += len;
	return (str);
}

int
ibuf_get_strbuf(struct ibuf *buf, char *str, size_t len)
{
	size_t n;

	if (len == 0) {
		errno = EINVAL;
		return (-1);
	}

	if (ibuf_get(buf, str, len) == -1)
		return -1;
	if ((n = strnlen(str, len)) == len) {
		str[len - 1] = '\0';	/* just to be safe */
		errno = EOVERFLOW;
		return -1;
	}
	/* clear rest of the buffer */
	memset(str + n, 0, len - n);

	return 0;
}

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)
{
	int save_errno = errno;

	if (buf == NULL)
		return;
	/* if buf lives on the stack abort before causing more harm */
	if (buf->fd == IBUF_FD_MARK_ON_STACK)
		abort();
	if (buf->fd >= 0)
		close(buf->fd);
	freezero(buf->buf, buf->size);
	free(buf);
	errno = save_errno;
}

int
ibuf_fd_avail(struct ibuf *buf)
{
	return (buf->fd >= 0);
}

int
ibuf_fd_get(struct ibuf *buf)
{
	int fd;

	/* negative fds are internal use and equivalent to -1 */
	if (buf->fd < 0)
		return (-1);
	fd = buf->fd;
	buf->fd = -1;
	return (fd);
}

void
ibuf_fd_set(struct ibuf *buf, int fd)
{
	/* if buf lives on the stack abort before causing more harm */
	if (buf->fd == IBUF_FD_MARK_ON_STACK)
		abort();
	if (buf->fd >= 0)
		close(buf->fd);
	buf->fd = -1;
	if (fd >= 0)
		buf->fd = fd;
}

struct msgbuf *
msgbuf_new(void)
{
	struct msgbuf *msgbuf;

	if ((msgbuf = calloc(1, sizeof(*msgbuf))) == NULL)
		return (NULL);
	ibufq_init(&msgbuf->bufs);
	ibufq_init(&msgbuf->rbufs);

	return msgbuf;
}

struct msgbuf *
msgbuf_new_reader(size_t hdrsz,
    struct ibuf *(*readhdr)(struct ibuf *, void *, int *), void *arg)
{
	struct msgbuf *msgbuf;
	char *buf;

	if (hdrsz == 0 || hdrsz > IBUF_READ_SIZE / 2) {
		errno = EINVAL;
		return (NULL);
	}

	if ((buf = malloc(IBUF_READ_SIZE)) == NULL)
		return (NULL);

	msgbuf = msgbuf_new();
	if (msgbuf == NULL) {
		free(buf);
		return (NULL);
	}

	msgbuf->rbuf = buf;
	msgbuf->hdrsize = hdrsz;
	msgbuf->readhdr = readhdr;
	msgbuf->rarg = arg;

	return (msgbuf);
}

void
msgbuf_free(struct msgbuf *msgbuf)
{
	if (msgbuf == NULL)
		return;
	msgbuf_clear(msgbuf);
	free(msgbuf->rbuf);
	free(msgbuf);
}

uint32_t
msgbuf_queuelen(struct msgbuf *msgbuf)
{
	return ibufq_queuelen(&msgbuf->bufs);
}

void
msgbuf_clear(struct msgbuf *msgbuf)
{
	/* write side */
	ibufq_flush(&msgbuf->bufs);

	/* read side */
	ibufq_flush(&msgbuf->rbufs);
	msgbuf->roff = 0;
	ibuf_free(msgbuf->rpmsg);
	msgbuf->rpmsg = NULL;
}

struct ibuf *
msgbuf_get(struct msgbuf *msgbuf)
{
	return ibufq_pop(&msgbuf->rbufs);
}

void
msgbuf_concat(struct msgbuf *msgbuf, struct ibufqueue *from)
{
	ibufq_concat(&msgbuf->bufs, from);
}

int
ibuf_write(int fd, struct msgbuf *msgbuf)
{
	struct iovec	 iov[IOV_MAX];
	struct ibuf	*buf;
	unsigned int	 i = 0;
	ssize_t	n;

	memset(&iov, 0, sizeof(iov));
	TAILQ_FOREACH(buf, &msgbuf->bufs.bufs, entry) {
		if (i >= IOV_MAX)
			break;
		iov[i].iov_base = ibuf_data(buf);
		iov[i].iov_len = ibuf_size(buf);
		i++;
	}
	if (i == 0)
		return (0);	/* nothing queued */

 again:
	if ((n = writev(fd, iov, i)) == -1) {
		if (errno == EINTR)
			goto again;
		if (errno == EAGAIN || errno == ENOBUFS)
			/* let's retry later again */
			return (0);
		return (-1);
	}

	msgbuf_drain(msgbuf, n);
	return (0);
}

int
msgbuf_write(int fd, struct msgbuf *msgbuf)
{
	struct iovec	 iov[IOV_MAX];
	struct ibuf	*buf, *buf0 = NULL;
	unsigned int	 i = 0;
	ssize_t		 n;
	struct msghdr	 msg;
	struct cmsghdr	*cmsg;
	union {
		struct cmsghdr	hdr;
		char		buf[CMSG_SPACE(sizeof(int))];
	} cmsgbuf;

	memset(&iov, 0, sizeof(iov));
	memset(&msg, 0, sizeof(msg));
	memset(&cmsgbuf, 0, sizeof(cmsgbuf));
	TAILQ_FOREACH(buf, &msgbuf->bufs.bufs, entry) {
		if (i >= IOV_MAX)
			break;
		if (i > 0 && buf->fd != -1)
			break;
		iov[i].iov_base = ibuf_data(buf);
		iov[i].iov_len = ibuf_size(buf);
		i++;
		if (buf->fd != -1)
			buf0 = buf;
	}

	if (i == 0)
		return (0);	/* nothing queued */

	msg.msg_iov = iov;
	msg.msg_iovlen = i;

	if (buf0 != NULL) {
		msg.msg_control = (caddr_t)&cmsgbuf.buf;
		msg.msg_controllen = sizeof(cmsgbuf.buf);
		cmsg = CMSG_FIRSTHDR(&msg);
		cmsg->cmsg_len = CMSG_LEN(sizeof(int));
		cmsg->cmsg_level = SOL_SOCKET;
		cmsg->cmsg_type = SCM_RIGHTS;
		*(int *)CMSG_DATA(cmsg) = buf0->fd;
	}

 again:
	if ((n = sendmsg(fd, &msg, 0)) == -1) {
		if (errno == EINTR)
			goto again;
		if (errno == EAGAIN || errno == ENOBUFS)
			/* let's retry later again */
			return (0);
		return (-1);
	}

	/*
	 * assumption: fd got sent if sendmsg sent anything
	 * this works because fds are passed one at a time
	 */
	if (buf0 != NULL) {
		close(buf0->fd);
		buf0->fd = -1;
	}

	msgbuf_drain(msgbuf, n);

	return (0);
}

static int
ibuf_read_process(struct msgbuf *msgbuf, int fd)
{
	struct ibuf rbuf, msg;
	ssize_t sz;

	ibuf_from_buffer(&rbuf, msgbuf->rbuf, msgbuf->roff);

	do {
		if (msgbuf->rpmsg == NULL) {
			if (ibuf_size(&rbuf) < msgbuf->hdrsize)
				break;
			/* get size from header */
			ibuf_from_buffer(&msg, ibuf_data(&rbuf),
			    msgbuf->hdrsize);
			if ((msgbuf->rpmsg = msgbuf->readhdr(&msg,
			    msgbuf->rarg, &fd)) == NULL)
				goto fail;
		}

		if (ibuf_left(msgbuf->rpmsg) <= ibuf_size(&rbuf))
			sz = ibuf_left(msgbuf->rpmsg);
		else
			sz = ibuf_size(&rbuf);

		/* neither call below can fail */
		if (ibuf_get_ibuf(&rbuf, sz, &msg) == -1 ||
		    ibuf_add_ibuf(msgbuf->rpmsg, &msg) == -1)
			goto fail;

		if (ibuf_left(msgbuf->rpmsg) == 0) {
			ibufq_push(&msgbuf->rbufs, msgbuf->rpmsg);
			msgbuf->rpmsg = NULL;
		}
	} while (ibuf_size(&rbuf) > 0);

	if (ibuf_size(&rbuf) > 0)
		memmove(msgbuf->rbuf, ibuf_data(&rbuf), ibuf_size(&rbuf));
	msgbuf->roff = ibuf_size(&rbuf);

	if (fd != -1)
		close(fd);
	return (1);

 fail:
	/* XXX how to properly clean up is unclear */
	if (fd != -1)
		close(fd);
	return (-1);
}

int
ibuf_read(int fd, struct msgbuf *msgbuf)
{
	struct iovec	iov;
	ssize_t		n;

	if (msgbuf->rbuf == NULL) {
		errno = EINVAL;
		return (-1);
	}

	iov.iov_base = msgbuf->rbuf + msgbuf->roff;
	iov.iov_len = IBUF_READ_SIZE - msgbuf->roff;

 again:
	if ((n = readv(fd, &iov, 1)) == -1) {
		if (errno == EINTR)
			goto again;
		if (errno == EAGAIN)
			/* let's retry later again */
			return (1);
		return (-1);
	}
	if (n == 0)	/* connection closed */
		return (0);

	msgbuf->roff += n;
	/* new data arrived, try to process it */
	return (ibuf_read_process(msgbuf, -1));
}

int
msgbuf_read(int fd, struct msgbuf *msgbuf)
{
	struct msghdr		 msg;
	struct cmsghdr		*cmsg;
	union {
		struct cmsghdr hdr;
		char	buf[CMSG_SPACE(sizeof(int) * 1)];
	} cmsgbuf;
	struct iovec		 iov;
	ssize_t			 n;
	int			 fdpass = -1;

	if (msgbuf->rbuf == NULL) {
		errno = EINVAL;
		return (-1);
	}

	memset(&msg, 0, sizeof(msg));
	memset(&cmsgbuf, 0, sizeof(cmsgbuf));

	iov.iov_base = msgbuf->rbuf + msgbuf->roff;
	iov.iov_len = IBUF_READ_SIZE - msgbuf->roff;
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = &cmsgbuf.buf;
	msg.msg_controllen = sizeof(cmsgbuf.buf);

again:
	if ((n = recvmsg(fd, &msg, 0)) == -1) {
		if (errno == EINTR)
			goto again;
		if (errno == EMSGSIZE) {
			/*
			 * Not enough fd slots: fd passing failed, retry
			 * to receive the message without fd.
			 * imsg_get_fd() will return -1 in that case.
			 */
			msg.msg_control = NULL;
			msg.msg_controllen = 0;
			goto again;
		}
		if (errno == EAGAIN) {
			/* let's retry later again */
			return (1);
		}
		return (-1);
	}
	if (n == 0)	/* connection closed */
		return (0);

	msgbuf->roff += n;

	for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
	    cmsg = CMSG_NXTHDR(&msg, cmsg)) {
		if (cmsg->cmsg_level == SOL_SOCKET &&
		    cmsg->cmsg_type == SCM_RIGHTS) {
			int i, j, f;

			/*
			 * We only accept one file descriptor.  Due to C
			 * padding rules, our control buffer might contain
			 * more than one fd, and we must close them.
			 */
			j = ((char *)cmsg + cmsg->cmsg_len -
			    (char *)CMSG_DATA(cmsg)) / sizeof(int);
			for (i = 0; i < j; i++) {
				f = ((int *)CMSG_DATA(cmsg))[i];
				if (i == 0)
					fdpass = f;
				else
					close(f);
			}
		}
		/* we do not handle other ctl data level */
	}

	/* new data arrived, try to process it */
	return (ibuf_read_process(msgbuf, fdpass));
}

static void
msgbuf_drain(struct msgbuf *msgbuf, size_t n)
{
	struct ibuf	*buf;

	while ((buf = TAILQ_FIRST(&msgbuf->bufs.bufs)) != NULL) {
		if (n >= ibuf_size(buf)) {
			n -= ibuf_size(buf);
			TAILQ_REMOVE(&msgbuf->bufs.bufs, buf, entry);
			msgbuf->bufs.queued--;
			ibuf_free(buf);
		} else {
			buf->rpos += n;
			return;
		}
	}
}

static void
ibufq_init(struct ibufqueue *bufq)
{
	TAILQ_INIT(&bufq->bufs);
	bufq->queued = 0;
}

struct ibufqueue *
ibufq_new(void)
{
	struct ibufqueue *bufq;

	if ((bufq = calloc(1, sizeof(*bufq))) == NULL)
		return NULL;
	ibufq_init(bufq);
	return bufq;
}

void
ibufq_free(struct ibufqueue *bufq)
{
	if (bufq == NULL)
		return;
	ibufq_flush(bufq);
	free(bufq);
}

struct ibuf *
ibufq_pop(struct ibufqueue *bufq)
{
	struct ibuf *buf;

	if ((buf = TAILQ_FIRST(&bufq->bufs)) == NULL)
		return NULL;
	TAILQ_REMOVE(&bufq->bufs, buf, entry);
	bufq->queued--;
	return buf;
}

void
ibufq_push(struct ibufqueue *bufq, struct ibuf *buf)
{
	/* if buf lives on the stack abort before causing more harm */
	if (buf->fd == IBUF_FD_MARK_ON_STACK)
		abort();
	TAILQ_INSERT_TAIL(&bufq->bufs, buf, entry);
	bufq->queued++;
}

uint32_t
ibufq_queuelen(struct ibufqueue *bufq)
{
	return (bufq->queued);
}

void
ibufq_concat(struct ibufqueue *to, struct ibufqueue *from)
{
	to->queued += from->queued;
	TAILQ_CONCAT(&to->bufs, &from->bufs, entry);
	from->queued = 0;
}

void
ibufq_flush(struct ibufqueue *bufq)
{
	struct ibuf *buf;

	while ((buf = TAILQ_FIRST(&bufq->bufs)) != NULL) {
		TAILQ_REMOVE(&bufq->bufs, buf, entry);
		ibuf_free(buf);
	}
	bufq->queued = 0;
}
