1 /*
2 * Copyright (c) 2002, 2003 Niels Provos <provos@citi.umich.edu>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #ifdef WIN32
33 #include <winsock2.h>
34 #include <windows.h>
35 #endif
36
37 #ifdef HAVE_VASPRINTF
38 /* If we have vasprintf, we need to define this before we include stdio.h. */
39 #define _GNU_SOURCE
40 #endif
41
42 #include <sys/types.h>
43
44 #ifdef HAVE_SYS_TIME_H
45 #include <sys/time.h>
46 #endif
47
48 #ifdef HAVE_SYS_IOCTL_H
49 #include <sys/ioctl.h>
50 #endif
51
52 #include <assert.h>
53 #include <errno.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <string.h>
57 #ifdef HAVE_STDARG_H
58 #include <stdarg.h>
59 #endif
60 #ifdef HAVE_UNISTD_H
61 #include <unistd.h>
62 #endif
63
64 #include "event.h"
65 #include "config.h"
66 #include "evutil.h"
67
68 struct evbuffer *
evbuffer_new(void)69 evbuffer_new(void)
70 {
71 struct evbuffer *buffer;
72
73 buffer = calloc(1, sizeof(struct evbuffer));
74
75 return (buffer);
76 }
77
78 void
evbuffer_free(struct evbuffer * buffer)79 evbuffer_free(struct evbuffer *buffer)
80 {
81 if (buffer->orig_buffer != NULL)
82 free(buffer->orig_buffer);
83 free(buffer);
84 }
85
86 /*
87 * This is a destructive add. The data from one buffer moves into
88 * the other buffer.
89 */
90
91 #define SWAP(x,y) do { \
92 (x)->buffer = (y)->buffer; \
93 (x)->orig_buffer = (y)->orig_buffer; \
94 (x)->misalign = (y)->misalign; \
95 (x)->totallen = (y)->totallen; \
96 (x)->off = (y)->off; \
97 } while (0)
98
99 int
evbuffer_add_buffer(struct evbuffer * outbuf,struct evbuffer * inbuf)100 evbuffer_add_buffer(struct evbuffer *outbuf, struct evbuffer *inbuf)
101 {
102 int res;
103
104 /* Short cut for better performance */
105 if (outbuf->off == 0) {
106 struct evbuffer tmp;
107 size_t oldoff = inbuf->off;
108
109 /* Swap them directly */
110 SWAP(&tmp, outbuf);
111 SWAP(outbuf, inbuf);
112 SWAP(inbuf, &tmp);
113
114 /*
115 * Optimization comes with a price; we need to notify the
116 * buffer if necessary of the changes. oldoff is the amount
117 * of data that we transfered from inbuf to outbuf
118 */
119 if (inbuf->off != oldoff && inbuf->cb != NULL)
120 (*inbuf->cb)(inbuf, oldoff, inbuf->off, inbuf->cbarg);
121 if (oldoff && outbuf->cb != NULL)
122 (*outbuf->cb)(outbuf, 0, oldoff, outbuf->cbarg);
123
124 return (0);
125 }
126
127 res = evbuffer_add(outbuf, inbuf->buffer, inbuf->off);
128 if (res == 0) {
129 /* We drain the input buffer on success */
130 evbuffer_drain(inbuf, inbuf->off);
131 }
132
133 return (res);
134 }
135
136 int
evbuffer_add_vprintf(struct evbuffer * buf,const char * fmt,va_list ap)137 evbuffer_add_vprintf(struct evbuffer *buf, const char *fmt, va_list ap)
138 {
139 char *buffer;
140 size_t space;
141 size_t oldoff = buf->off;
142 int sz;
143 va_list aq;
144
145 /* make sure that at least some space is available */
146 evbuffer_expand(buf, 64);
147 for (;;) {
148 size_t used = buf->misalign + buf->off;
149 buffer = (char *)buf->buffer + buf->off;
150 assert(buf->totallen >= used);
151 space = buf->totallen - used;
152
153 #ifndef va_copy
154 #define va_copy(dst, src) memcpy(&(dst), &(src), sizeof(va_list))
155 #endif
156 va_copy(aq, ap);
157
158 sz = evutil_vsnprintf(buffer, space, fmt, aq);
159
160 va_end(aq);
161
162 if (sz < 0)
163 return (-1);
164 if ((size_t)sz < space) {
165 buf->off += sz;
166 if (buf->cb != NULL)
167 (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
168 return (sz);
169 }
170 if (evbuffer_expand(buf, sz + 1) == -1)
171 return (-1);
172
173 }
174 /* NOTREACHED */
175 }
176
177 int
evbuffer_add_printf(struct evbuffer * buf,const char * fmt,...)178 evbuffer_add_printf(struct evbuffer *buf, const char *fmt, ...)
179 {
180 int res = -1;
181 va_list ap;
182
183 va_start(ap, fmt);
184 res = evbuffer_add_vprintf(buf, fmt, ap);
185 va_end(ap);
186
187 return (res);
188 }
189
190 /* Reads data from an event buffer and drains the bytes read */
191
192 int
evbuffer_remove(struct evbuffer * buf,void * data,size_t datlen)193 evbuffer_remove(struct evbuffer *buf, void *data, size_t datlen)
194 {
195 size_t nread = datlen;
196 if (nread >= buf->off)
197 nread = buf->off;
198
199 memcpy(data, buf->buffer, nread);
200 evbuffer_drain(buf, nread);
201
202 return (nread);
203 }
204
205 /*
206 * Reads a line terminated by either '\r\n', '\n\r' or '\r' or '\n'.
207 * The returned buffer needs to be freed by the called.
208 */
209
210 char *
evbuffer_readline(struct evbuffer * buffer)211 evbuffer_readline(struct evbuffer *buffer)
212 {
213 u_char *data = EVBUFFER_DATA(buffer);
214 size_t len = EVBUFFER_LENGTH(buffer);
215 char *line;
216 unsigned int i;
217
218 for (i = 0; i < len; i++) {
219 if (data[i] == '\r' || data[i] == '\n')
220 break;
221 }
222
223 if (i == len)
224 return (NULL);
225
226 if ((line = malloc(i + 1)) == NULL) {
227 fprintf(stderr, "%s: out of memory\n", __func__);
228 return (NULL);
229 }
230
231 memcpy(line, data, i);
232 line[i] = '\0';
233
234 /*
235 * Some protocols terminate a line with '\r\n', so check for
236 * that, too.
237 */
238 if ( i < len - 1 ) {
239 char fch = data[i], sch = data[i+1];
240
241 /* Drain one more character if needed */
242 if ( (sch == '\r' || sch == '\n') && sch != fch )
243 i += 1;
244 }
245
246 evbuffer_drain(buffer, i + 1);
247
248 return (line);
249 }
250
251 /* Adds data to an event buffer */
252
253 static void
evbuffer_align(struct evbuffer * buf)254 evbuffer_align(struct evbuffer *buf)
255 {
256 memmove(buf->orig_buffer, buf->buffer, buf->off);
257 buf->buffer = buf->orig_buffer;
258 buf->misalign = 0;
259 }
260
261 /* Expands the available space in the event buffer to at least datlen */
262
263 int
evbuffer_expand(struct evbuffer * buf,size_t datlen)264 evbuffer_expand(struct evbuffer *buf, size_t datlen)
265 {
266 size_t need = buf->misalign + buf->off + datlen;
267
268 /* If we can fit all the data, then we don't have to do anything */
269 if (buf->totallen >= need)
270 return (0);
271
272 /*
273 * If the misalignment fulfills our data needs, we just force an
274 * alignment to happen. Afterwards, we have enough space.
275 */
276 if (buf->misalign >= datlen) {
277 evbuffer_align(buf);
278 } else {
279 void *newbuf;
280 size_t length = buf->totallen;
281
282 if (length < 256)
283 length = 256;
284 while (length < need)
285 length <<= 1;
286
287 if (buf->orig_buffer != buf->buffer)
288 evbuffer_align(buf);
289 if ((newbuf = realloc(buf->buffer, length)) == NULL)
290 return (-1);
291
292 buf->orig_buffer = buf->buffer = newbuf;
293 buf->totallen = length;
294 }
295
296 return (0);
297 }
298
299 int
evbuffer_add(struct evbuffer * buf,const void * data,size_t datlen)300 evbuffer_add(struct evbuffer *buf, const void *data, size_t datlen)
301 {
302 size_t need = buf->misalign + buf->off + datlen;
303 size_t oldoff = buf->off;
304
305 if (buf->totallen < need) {
306 if (evbuffer_expand(buf, datlen) == -1)
307 return (-1);
308 }
309
310 memcpy(buf->buffer + buf->off, data, datlen);
311 buf->off += datlen;
312
313 if (datlen && buf->cb != NULL)
314 (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
315
316 return (0);
317 }
318
319 void
evbuffer_drain(struct evbuffer * buf,size_t len)320 evbuffer_drain(struct evbuffer *buf, size_t len)
321 {
322 size_t oldoff = buf->off;
323
324 if (len >= buf->off) {
325 buf->off = 0;
326 buf->buffer = buf->orig_buffer;
327 buf->misalign = 0;
328 goto done;
329 }
330
331 buf->buffer += len;
332 buf->misalign += len;
333
334 buf->off -= len;
335
336 done:
337 /* Tell someone about changes in this buffer */
338 if (buf->off != oldoff && buf->cb != NULL)
339 (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
340
341 }
342
343 /*
344 * Reads data from a file descriptor into a buffer.
345 */
346
347 #define EVBUFFER_MAX_READ 4096
348
349 int
evbuffer_read(struct evbuffer * buf,int fd,int howmuch)350 evbuffer_read(struct evbuffer *buf, int fd, int howmuch)
351 {
352 u_char *p;
353 size_t oldoff = buf->off;
354 int n = EVBUFFER_MAX_READ;
355
356 #if defined(FIONREAD)
357 #ifdef WIN32
358 long lng = n;
359 if (ioctlsocket(fd, FIONREAD, &lng) == -1 || (n=lng) <= 0) {
360 #else
361 if (ioctl(fd, FIONREAD, &n) == -1 || n <= 0) {
362 #endif
363 n = EVBUFFER_MAX_READ;
364 } else if (n > EVBUFFER_MAX_READ && n > howmuch) {
365 /*
366 * It's possible that a lot of data is available for
367 * reading. We do not want to exhaust resources
368 * before the reader has a chance to do something
369 * about it. If the reader does not tell us how much
370 * data we should read, we artifically limit it.
371 */
372 if ((size_t)n > buf->totallen << 2)
373 n = buf->totallen << 2;
374 if (n < EVBUFFER_MAX_READ)
375 n = EVBUFFER_MAX_READ;
376 }
377 #endif
378 if (howmuch < 0 || howmuch > n)
379 howmuch = n;
380
381 /* If we don't have FIONREAD, we might waste some space here */
382 if (evbuffer_expand(buf, howmuch) == -1)
383 return (-1);
384
385 /* We can append new data at this point */
386 p = buf->buffer + buf->off;
387
388 #ifndef WIN32
389 n = read(fd, p, howmuch);
390 #else
391 n = recv(fd, p, howmuch, 0);
392 #endif
393 if (n == -1)
394 return (-1);
395 if (n == 0)
396 return (0);
397
398 buf->off += n;
399
400 /* Tell someone about changes in this buffer */
401 if (buf->off != oldoff && buf->cb != NULL)
402 (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
403
404 return (n);
405 }
406
407 int
408 evbuffer_write(struct evbuffer *buffer, int fd)
409 {
410 int n;
411
412 #ifndef WIN32
413 n = write(fd, buffer->buffer, buffer->off);
414 #else
415 n = send(fd, buffer->buffer, buffer->off, 0);
416 #endif
417 if (n == -1)
418 return (-1);
419 if (n == 0)
420 return (0);
421 evbuffer_drain(buffer, n);
422
423 return (n);
424 }
425
426 u_char *
427 evbuffer_find(struct evbuffer *buffer, const u_char *what, size_t len)
428 {
429 u_char *search = buffer->buffer, *end = search + buffer->off;
430 u_char *p;
431
432 while (search < end &&
433 (p = memchr(search, *what, end - search)) != NULL) {
434 if (p + len > end)
435 break;
436 if (memcmp(p, what, len) == 0)
437 return (p);
438 search = p + 1;
439 }
440
441 return (NULL);
442 }
443
444 void evbuffer_setcb(struct evbuffer *buffer,
445 void (*cb)(struct evbuffer *, size_t, size_t, void *),
446 void *cbarg)
447 {
448 buffer->cb = cb;
449 buffer->cbarg = cbarg;
450 }
451