GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libutil/imsg-buffer.c Lines: 33 124 26.6 %
Date: 2017-11-13 Branches: 12 66 18.2 %

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