[mirror_frr.git] / lib / imsg-buffer.c

/*	$OpenBSD$	*/

/*
 * 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 <zebra.h>

#include "openbsd-queue.h"
#include "imsg.h"

int	ibuf_realloc(struct ibuf *, size_t);
void	ibuf_enqueue(struct msgbuf *, struct ibuf *);
void	ibuf_dequeue(struct msgbuf *, struct ibuf *);

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

	if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
		return (NULL);
	if ((buf->buf = malloc(len)) == 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 < len)
		return (NULL);

	if ((buf = ibuf_open(len)) == NULL)
		return (NULL);

	if (max > 0)
		buf->max = max;

	return (buf);
}

int
ibuf_realloc(struct ibuf *buf, size_t len)
{
	u_char	*b;

	/* on static buffers max is eq size and so the following fails */
	if (buf->wpos + len > buf->max) {
		errno = ERANGE;
		return (-1);
	}

	b = realloc(buf->buf, buf->wpos + len);
	if (b == NULL)
		return (-1);
	buf->buf = b;
	buf->size = buf->wpos + len;

	return (0);
}

int
ibuf_add(struct ibuf *buf, const void *data, size_t len)
{
	if (buf->wpos + len > buf->size)
		if (ibuf_realloc(buf, len) == -1)
			return (-1);

	memcpy(buf->buf + buf->wpos, data, len);
	buf->wpos += len;
	return (0);
}

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

	if (buf->wpos + len > buf->size)
		if (ibuf_realloc(buf, len) == -1)
			return (NULL);

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

void *
ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
{
	/* only allowed to seek in already written parts */
	if (pos + len > buf->wpos)
		return (NULL);

	return (buf->buf + pos);
}

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

size_t
ibuf_left(struct ibuf *buf)
{
	return (buf->max - buf->wpos);
}

void
ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf)
{
	ibuf_enqueue(msgbuf, buf);
}

int
ibuf_write(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, entry) {
		if (i >= IOV_MAX)
			break;
		iov[i].iov_base = buf->buf + buf->rpos;
		iov[i].iov_len = buf->wpos - buf->rpos;
		i++;
	}

again:
	if ((n = writev(msgbuf->fd, iov, i)) == -1) {
		if (errno == EINTR)
			goto again;
		if (errno == ENOBUFS)
			errno = EAGAIN;
		return (-1);
	}

	if (n == 0) {			/* connection closed */
		errno = 0;
		return (0);
	}

	msgbuf_drain(msgbuf, n);

	return (1);
}

void
ibuf_free(struct ibuf *buf)
{
	if (buf == NULL)
		return;
	free(buf->buf);
	free(buf);
}

void
msgbuf_init(struct msgbuf *msgbuf)
{
	msgbuf->queued = 0;
	msgbuf->fd = -1;
	TAILQ_INIT(&msgbuf->bufs);
}

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

	for (buf = TAILQ_FIRST(&msgbuf->bufs); buf != NULL && n > 0;
	    buf = next) {
		next = TAILQ_NEXT(buf, entry);
		if (buf->rpos + n >= buf->wpos) {
			n -= buf->wpos - buf->rpos;
			ibuf_dequeue(msgbuf, buf);
		} else {
			buf->rpos += n;
			n = 0;
		}
	}
}

void
msgbuf_clear(struct msgbuf *msgbuf)
{
	struct ibuf	*buf;

	while ((buf = TAILQ_FIRST(&msgbuf->bufs)) != NULL)
		ibuf_dequeue(msgbuf, buf);
}

int
msgbuf_write(struct msgbuf *msgbuf)
{
	struct iovec	 iov[IOV_MAX];
	struct ibuf	*buf;
	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, entry) {
		if (i >= IOV_MAX)
			break;
		iov[i].iov_base = buf->buf + buf->rpos;
		iov[i].iov_len = buf->wpos - buf->rpos;
		i++;
		if (buf->fd != -1)
			break;
	}

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

	if (buf != NULL && buf->fd != -1) {
		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;
		memcpy(CMSG_DATA(cmsg), &buf->fd, sizeof(int));
	}

again:
	if ((n = sendmsg(msgbuf->fd, &msg, 0)) == -1) {
		if (errno == EINTR)
			goto again;
		if (errno == ENOBUFS)
			errno = EAGAIN;
		return (-1);
	}

	if (n == 0) {			/* connection closed */
		errno = 0;
		return (0);
	}

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

	msgbuf_drain(msgbuf, n);

	return (1);
}

void
ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
{
	TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry);
	msgbuf->queued++;
}

void
ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
{
	TAILQ_REMOVE(&msgbuf->bufs, buf, entry);

	if (buf->fd != -1)
		close(buf->fd);

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