1 /*	$OpenBSD: iobuf.c,v 1.11 2019/06/12 17:42:53 eric Exp $	*/
2 /*
3  * Copyright (c) 2012 Eric Faurot <eric@openbsd.org>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #define _GNU_SOURCE 1
19 #define _BSD_SOURCE 1
20 
21 #include <sys/types.h>
22 #include <sys/socket.h>
23 #include <sys/uio.h>
24 
25 #include <errno.h>
26 #include <limits.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <unistd.h>
32 
33 #ifdef IO_TLS
34 #include <openssl/err.h>
35 #include <openssl/ssl.h>
36 #endif
37 
38 #include "openbsd-compat.h"
39 #include "iobuf.h"
40 
41 #define IOBUF_MAX	65536
42 #define IOBUFQ_MIN	4096
43 
44 struct ioqbuf	*ioqbuf_alloc(struct iobuf *, size_t);
45 void		 iobuf_drain(struct iobuf *, size_t);
46 
47 int
48 iobuf_init(struct iobuf *io, size_t size, size_t max)
49 {
50 	memset(io, 0, sizeof *io);
51 
52 	if (max == 0)
53 		max = IOBUF_MAX;
54 
55 	if (size == 0)
56 		size = max;
57 
58 	if (size > max)
59 		return (-1);
60 
61 	if ((io->buf = calloc(size, 1)) == NULL)
62 		return (-1);
63 
64 	io->size = size;
65 	io->max = max;
66 
67 	return (0);
68 }
69 
70 void
71 iobuf_clear(struct iobuf *io)
72 {
73 	struct ioqbuf	*q;
74 
75 	free(io->buf);
76 
77 	while ((q = io->outq)) {
78 		io->outq = q->next;
79 		free(q);
80 	}
81 
82 	memset(io, 0, sizeof (*io));
83 }
84 
85 void
86 iobuf_drain(struct iobuf *io, size_t n)
87 {
88 	struct	ioqbuf	*q;
89 	size_t		 left = n;
90 
91 	while ((q = io->outq) && left) {
92 		if ((q->wpos - q->rpos) > left) {
93 			q->rpos += left;
94 			left = 0;
95 		} else {
96 			left -= q->wpos - q->rpos;
97 			io->outq = q->next;
98 			free(q);
99 		}
100 	}
101 
102 	io->queued -= (n - left);
103 	if (io->outq == NULL)
104 		io->outqlast = NULL;
105 }
106 
107 int
108 iobuf_extend(struct iobuf *io, size_t n)
109 {
110 	char	*t;
111 
112 	if (n > io->max)
113 		return (-1);
114 
115 	if (io->max - io->size < n)
116 		return (-1);
117 
118 	t = recallocarray(io->buf, io->size, io->size + n, 1);
119 	if (t == NULL)
120 		return (-1);
121 
122 	io->size += n;
123 	io->buf = t;
124 
125 	return (0);
126 }
127 
128 size_t
129 iobuf_left(struct iobuf *io)
130 {
131 	return io->size - io->wpos;
132 }
133 
134 size_t
135 iobuf_space(struct iobuf *io)
136 {
137 	return io->size - (io->wpos - io->rpos);
138 }
139 
140 size_t
141 iobuf_len(struct iobuf *io)
142 {
143 	return io->wpos - io->rpos;
144 }
145 
146 char *
147 iobuf_data(struct iobuf *io)
148 {
149 	return io->buf + io->rpos;
150 }
151 
152 void
153 iobuf_drop(struct iobuf *io, size_t n)
154 {
155 	if (n >= iobuf_len(io)) {
156 		io->rpos = io->wpos = 0;
157 		return;
158 	}
159 
160 	io->rpos += n;
161 }
162 
163 char *
164 iobuf_getline(struct iobuf *iobuf, size_t *rlen)
165 {
166 	char	*buf;
167 	size_t	 len, i;
168 
169 	buf = iobuf_data(iobuf);
170 	len = iobuf_len(iobuf);
171 
172 	for (i = 0; i + 1 <= len; i++)
173 		if (buf[i] == '\n') {
174 			/* Note: the returned address points into the iobuf
175 			 * buffer.  We NUL-end it for convenience, and discard
176 			 * the data from the iobuf, so that the caller doesn't
177 			 * have to do it.  The data remains "valid" as long
178 			 * as the iobuf does not overwrite it, that is until
179 			 * the next call to iobuf_normalize() or iobuf_extend().
180 			 */
181 			iobuf_drop(iobuf, i + 1);
182 			len = (i && buf[i - 1] == '\r') ? i - 1 : i;
183 			buf[len] = '\0';
184 			if (rlen)
185 				*rlen = len;
186 			return (buf);
187 		}
188 
189 	return (NULL);
190 }
191 
192 void
193 iobuf_normalize(struct iobuf *io)
194 {
195 	if (io->rpos == 0)
196 		return;
197 
198 	if (io->rpos == io->wpos) {
199 		io->rpos = io->wpos = 0;
200 		return;
201 	}
202 
203 	memmove(io->buf, io->buf + io->rpos, io->wpos - io->rpos);
204 	io->wpos -= io->rpos;
205 	io->rpos = 0;
206 }
207 
208 ssize_t
209 iobuf_read(struct iobuf *io, int fd)
210 {
211 	ssize_t	n;
212 
213 	n = read(fd, io->buf + io->wpos, iobuf_left(io));
214 	if (n == -1) {
215 		/* XXX is this really what we want? */
216 		if (errno == EAGAIN || errno == EINTR)
217 			return (IOBUF_WANT_READ);
218 		return (IOBUF_ERROR);
219 	}
220 	if (n == 0)
221 		return (IOBUF_CLOSED);
222 
223 	io->wpos += n;
224 
225 	return (n);
226 }
227 
228 struct ioqbuf *
229 ioqbuf_alloc(struct iobuf *io, size_t len)
230 {
231 	struct ioqbuf   *q;
232 
233 	if (len < IOBUFQ_MIN)
234 		len = IOBUFQ_MIN;
235 
236 	if ((q = malloc(sizeof(*q) + len)) == NULL)
237 		return (NULL);
238 
239 	q->rpos = 0;
240 	q->wpos = 0;
241 	q->size = len;
242 	q->next = NULL;
243 	q->buf = (char *)(q) + sizeof(*q);
244 
245 	if (io->outqlast == NULL)
246 		io->outq = q;
247 	else
248 		io->outqlast->next = q;
249 	io->outqlast = q;
250 
251 	return (q);
252 }
253 
254 size_t
255 iobuf_queued(struct iobuf *io)
256 {
257 	return io->queued;
258 }
259 
260 void *
261 iobuf_reserve(struct iobuf *io, size_t len)
262 {
263 	struct ioqbuf	*q;
264 	void		*r;
265 
266 	if (len == 0)
267 		return (NULL);
268 
269 	if (((q = io->outqlast) == NULL) || q->size - q->wpos <= len) {
270 		if ((q = ioqbuf_alloc(io, len)) == NULL)
271 			return (NULL);
272 	}
273 
274 	r = q->buf + q->wpos;
275 	q->wpos += len;
276 	io->queued += len;
277 
278 	return (r);
279 }
280 
281 int
282 iobuf_queue(struct iobuf *io, const void *data, size_t len)
283 {
284 	void	*buf;
285 
286 	if (len == 0)
287 		return (0);
288 
289 	if ((buf = iobuf_reserve(io, len)) == NULL)
290 		return (-1);
291 
292 	memmove(buf, data, len);
293 
294 	return (len);
295 }
296 
297 int
298 iobuf_queuev(struct iobuf *io, const struct iovec *iov, int iovcnt)
299 {
300 	int	 i;
301 	size_t	 len = 0;
302 	char	*buf;
303 
304 	for (i = 0; i < iovcnt; i++)
305 		len += iov[i].iov_len;
306 
307 	if ((buf = iobuf_reserve(io, len)) == NULL)
308 		return (-1);
309 
310 	for (i = 0; i < iovcnt; i++) {
311 		if (iov[i].iov_len == 0)
312 			continue;
313 		memmove(buf, iov[i].iov_base, iov[i].iov_len);
314 		buf += iov[i].iov_len;
315 	}
316 
317 	return (0);
318 
319 }
320 
321 int
322 iobuf_fqueue(struct iobuf *io, const char *fmt, ...)
323 {
324 	va_list	ap;
325 	int	len;
326 
327 	va_start(ap, fmt);
328 	len = iobuf_vfqueue(io, fmt, ap);
329 	va_end(ap);
330 
331 	return (len);
332 }
333 
334 int
335 iobuf_vfqueue(struct iobuf *io, const char *fmt, va_list ap)
336 {
337 	char	*buf;
338 	int	 len;
339 
340 	len = vasprintf(&buf, fmt, ap);
341 
342 	if (len == -1)
343 		return (-1);
344 
345 	len = iobuf_queue(io, buf, len);
346 	free(buf);
347 
348 	return (len);
349 }
350 
351 ssize_t
352 iobuf_write(struct iobuf *io, int fd)
353 {
354 	struct iovec	 iov[IOV_MAX];
355 	struct ioqbuf	*q;
356 	int		 i;
357 	ssize_t		 n;
358 
359 	i = 0;
360 	for (q = io->outq; q ; q = q->next) {
361 		if (i >= IOV_MAX)
362 			break;
363 		iov[i].iov_base = q->buf + q->rpos;
364 		iov[i].iov_len = q->wpos - q->rpos;
365 		i++;
366 	}
367 
368 	n = writev(fd, iov, i);
369 	if (n == -1) {
370 		if (errno == EAGAIN || errno == EINTR)
371 			return (IOBUF_WANT_WRITE);
372 		if (errno == EPIPE)
373 			return (IOBUF_CLOSED);
374 		return (IOBUF_ERROR);
375 	}
376 
377 	iobuf_drain(io, n);
378 
379 	return (n);
380 }
381 
382 int
383 iobuf_flush(struct iobuf *io, int fd)
384 {
385 	ssize_t	s;
386 
387 	while (io->queued)
388 		if ((s = iobuf_write(io, fd)) < 0)
389 			return (s);
390 
391 	return (0);
392 }
393 
394 #ifdef IO_TLS
395 
396 int
397 iobuf_flush_tls(struct iobuf *io, void *tls)
398 {
399 	ssize_t	s;
400 
401 	while (io->queued)
402 		if ((s = iobuf_write_tls(io, tls)) < 0)
403 			return (s);
404 
405 	return (0);
406 }
407 
408 ssize_t
409 iobuf_write_tls(struct iobuf *io, void *tls)
410 {
411 	struct ioqbuf	*q;
412 	int		 r;
413 	ssize_t		 n;
414 
415 	q = io->outq;
416 	n = SSL_write(tls, q->buf + q->rpos, q->wpos - q->rpos);
417 	if (n <= 0) {
418 		switch ((r = SSL_get_error(tls, n))) {
419 		case SSL_ERROR_WANT_READ:
420 			return (IOBUF_WANT_READ);
421 		case SSL_ERROR_WANT_WRITE:
422 			return (IOBUF_WANT_WRITE);
423 		case SSL_ERROR_ZERO_RETURN: /* connection closed */
424 			return (IOBUF_CLOSED);
425 		case SSL_ERROR_SYSCALL:
426 			if (ERR_peek_last_error())
427 				return (IOBUF_TLSERROR);
428 			if (r == 0)
429 				errno = EPIPE;
430 			return (IOBUF_ERROR);
431 		default:
432 			return (IOBUF_TLSERROR);
433 		}
434 	}
435 	iobuf_drain(io, n);
436 
437 	return (n);
438 }
439 
440 ssize_t
441 iobuf_read_tls(struct iobuf *io, void *tls)
442 {
443 	ssize_t	n;
444 	int	r;
445 
446 	n = SSL_read(tls, io->buf + io->wpos, iobuf_left(io));
447 	if (n < 0) {
448 		switch ((r = SSL_get_error(tls, n))) {
449 		case SSL_ERROR_WANT_READ:
450 			return (IOBUF_WANT_READ);
451 		case SSL_ERROR_WANT_WRITE:
452 			return (IOBUF_WANT_WRITE);
453 		case SSL_ERROR_SYSCALL:
454 			if (ERR_peek_last_error())
455 				return (IOBUF_TLSERROR);
456 			if (r == 0)
457 				errno = EPIPE;
458 			return (IOBUF_ERROR);
459 		default:
460 			return (IOBUF_TLSERROR);
461 		}
462 	} else if (n == 0)
463 		return (IOBUF_CLOSED);
464 
465 	io->wpos += n;
466 
467 	return (n);
468 }
469 
470 #endif /* IO_TLS */