Annotation of embedaddon/libevent/buffer.c, revision 1.1
1.1 ! misho 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: #include "./log.h"
! 68:
! 69: struct evbuffer *
! 70: evbuffer_new(void)
! 71: {
! 72: struct evbuffer *buffer;
! 73:
! 74: buffer = calloc(1, sizeof(struct evbuffer));
! 75:
! 76: return (buffer);
! 77: }
! 78:
! 79: void
! 80: evbuffer_free(struct evbuffer *buffer)
! 81: {
! 82: if (buffer->orig_buffer != NULL)
! 83: free(buffer->orig_buffer);
! 84: free(buffer);
! 85: }
! 86:
! 87: /*
! 88: * This is a destructive add. The data from one buffer moves into
! 89: * the other buffer.
! 90: */
! 91:
! 92: #define SWAP(x,y) do { \
! 93: (x)->buffer = (y)->buffer; \
! 94: (x)->orig_buffer = (y)->orig_buffer; \
! 95: (x)->misalign = (y)->misalign; \
! 96: (x)->totallen = (y)->totallen; \
! 97: (x)->off = (y)->off; \
! 98: } while (0)
! 99:
! 100: int
! 101: evbuffer_add_buffer(struct evbuffer *outbuf, struct evbuffer *inbuf)
! 102: {
! 103: int res;
! 104:
! 105: /* Short cut for better performance */
! 106: if (outbuf->off == 0) {
! 107: struct evbuffer tmp;
! 108: size_t oldoff = inbuf->off;
! 109:
! 110: /* Swap them directly */
! 111: SWAP(&tmp, outbuf);
! 112: SWAP(outbuf, inbuf);
! 113: SWAP(inbuf, &tmp);
! 114:
! 115: /*
! 116: * Optimization comes with a price; we need to notify the
! 117: * buffer if necessary of the changes. oldoff is the amount
! 118: * of data that we transfered from inbuf to outbuf
! 119: */
! 120: if (inbuf->off != oldoff && inbuf->cb != NULL)
! 121: (*inbuf->cb)(inbuf, oldoff, inbuf->off, inbuf->cbarg);
! 122: if (oldoff && outbuf->cb != NULL)
! 123: (*outbuf->cb)(outbuf, 0, oldoff, outbuf->cbarg);
! 124:
! 125: return (0);
! 126: }
! 127:
! 128: res = evbuffer_add(outbuf, inbuf->buffer, inbuf->off);
! 129: if (res == 0) {
! 130: /* We drain the input buffer on success */
! 131: evbuffer_drain(inbuf, inbuf->off);
! 132: }
! 133:
! 134: return (res);
! 135: }
! 136:
! 137: int
! 138: evbuffer_add_vprintf(struct evbuffer *buf, const char *fmt, va_list ap)
! 139: {
! 140: char *buffer;
! 141: size_t space;
! 142: size_t oldoff = buf->off;
! 143: int sz;
! 144: va_list aq;
! 145:
! 146: /* make sure that at least some space is available */
! 147: evbuffer_expand(buf, 64);
! 148: for (;;) {
! 149: size_t used = buf->misalign + buf->off;
! 150: buffer = (char *)buf->buffer + buf->off;
! 151: assert(buf->totallen >= used);
! 152: space = buf->totallen - used;
! 153:
! 154: #ifndef va_copy
! 155: #define va_copy(dst, src) memcpy(&(dst), &(src), sizeof(va_list))
! 156: #endif
! 157: va_copy(aq, ap);
! 158:
! 159: sz = evutil_vsnprintf(buffer, space, fmt, aq);
! 160:
! 161: va_end(aq);
! 162:
! 163: if (sz < 0)
! 164: return (-1);
! 165: if ((size_t)sz < space) {
! 166: buf->off += sz;
! 167: if (buf->cb != NULL)
! 168: (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
! 169: return (sz);
! 170: }
! 171: if (evbuffer_expand(buf, sz + 1) == -1)
! 172: return (-1);
! 173:
! 174: }
! 175: /* NOTREACHED */
! 176: }
! 177:
! 178: int
! 179: evbuffer_add_printf(struct evbuffer *buf, const char *fmt, ...)
! 180: {
! 181: int res = -1;
! 182: va_list ap;
! 183:
! 184: va_start(ap, fmt);
! 185: res = evbuffer_add_vprintf(buf, fmt, ap);
! 186: va_end(ap);
! 187:
! 188: return (res);
! 189: }
! 190:
! 191: /* Reads data from an event buffer and drains the bytes read */
! 192:
! 193: int
! 194: evbuffer_remove(struct evbuffer *buf, void *data, size_t datlen)
! 195: {
! 196: size_t nread = datlen;
! 197: if (nread >= buf->off)
! 198: nread = buf->off;
! 199:
! 200: memcpy(data, buf->buffer, nread);
! 201: evbuffer_drain(buf, nread);
! 202:
! 203: return (nread);
! 204: }
! 205:
! 206: /*
! 207: * Reads a line terminated by either '\r\n', '\n\r' or '\r' or '\n'.
! 208: * The returned buffer needs to be freed by the called.
! 209: */
! 210:
! 211: char *
! 212: evbuffer_readline(struct evbuffer *buffer)
! 213: {
! 214: u_char *data = EVBUFFER_DATA(buffer);
! 215: size_t len = EVBUFFER_LENGTH(buffer);
! 216: char *line;
! 217: unsigned int i;
! 218:
! 219: for (i = 0; i < len; i++) {
! 220: if (data[i] == '\r' || data[i] == '\n')
! 221: break;
! 222: }
! 223:
! 224: if (i == len)
! 225: return (NULL);
! 226:
! 227: if ((line = malloc(i + 1)) == NULL) {
! 228: fprintf(stderr, "%s: out of memory\n", __func__);
! 229: return (NULL);
! 230: }
! 231:
! 232: memcpy(line, data, i);
! 233: line[i] = '\0';
! 234:
! 235: /*
! 236: * Some protocols terminate a line with '\r\n', so check for
! 237: * that, too.
! 238: */
! 239: if ( i < len - 1 ) {
! 240: char fch = data[i], sch = data[i+1];
! 241:
! 242: /* Drain one more character if needed */
! 243: if ( (sch == '\r' || sch == '\n') && sch != fch )
! 244: i += 1;
! 245: }
! 246:
! 247: evbuffer_drain(buffer, i + 1);
! 248:
! 249: return (line);
! 250: }
! 251:
! 252:
! 253: char *
! 254: evbuffer_readln(struct evbuffer *buffer, size_t *n_read_out,
! 255: enum evbuffer_eol_style eol_style)
! 256: {
! 257: u_char *data = EVBUFFER_DATA(buffer);
! 258: u_char *start_of_eol, *end_of_eol;
! 259: size_t len = EVBUFFER_LENGTH(buffer);
! 260: char *line;
! 261: unsigned int i, n_to_copy, n_to_drain;
! 262:
! 263: if (n_read_out)
! 264: *n_read_out = 0;
! 265:
! 266: /* depending on eol_style, set start_of_eol to the first character
! 267: * in the newline, and end_of_eol to one after the last character. */
! 268: switch (eol_style) {
! 269: case EVBUFFER_EOL_ANY:
! 270: for (i = 0; i < len; i++) {
! 271: if (data[i] == '\r' || data[i] == '\n')
! 272: break;
! 273: }
! 274: if (i == len)
! 275: return (NULL);
! 276: start_of_eol = data+i;
! 277: ++i;
! 278: for ( ; i < len; i++) {
! 279: if (data[i] != '\r' && data[i] != '\n')
! 280: break;
! 281: }
! 282: end_of_eol = data+i;
! 283: break;
! 284: case EVBUFFER_EOL_CRLF:
! 285: end_of_eol = memchr(data, '\n', len);
! 286: if (!end_of_eol)
! 287: return (NULL);
! 288: if (end_of_eol > data && *(end_of_eol-1) == '\r')
! 289: start_of_eol = end_of_eol - 1;
! 290: else
! 291: start_of_eol = end_of_eol;
! 292: end_of_eol++; /*point to one after the LF. */
! 293: break;
! 294: case EVBUFFER_EOL_CRLF_STRICT: {
! 295: u_char *cp = data;
! 296: while ((cp = memchr(cp, '\r', len-(cp-data)))) {
! 297: if (cp < data+len-1 && *(cp+1) == '\n')
! 298: break;
! 299: if (++cp >= data+len) {
! 300: cp = NULL;
! 301: break;
! 302: }
! 303: }
! 304: if (!cp)
! 305: return (NULL);
! 306: start_of_eol = cp;
! 307: end_of_eol = cp+2;
! 308: break;
! 309: }
! 310: case EVBUFFER_EOL_LF:
! 311: start_of_eol = memchr(data, '\n', len);
! 312: if (!start_of_eol)
! 313: return (NULL);
! 314: end_of_eol = start_of_eol + 1;
! 315: break;
! 316: default:
! 317: return (NULL);
! 318: }
! 319:
! 320: n_to_copy = start_of_eol - data;
! 321: n_to_drain = end_of_eol - data;
! 322:
! 323: if ((line = malloc(n_to_copy+1)) == NULL) {
! 324: event_warn("%s: out of memory\n", __func__);
! 325: return (NULL);
! 326: }
! 327:
! 328: memcpy(line, data, n_to_copy);
! 329: line[n_to_copy] = '\0';
! 330:
! 331: evbuffer_drain(buffer, n_to_drain);
! 332: if (n_read_out)
! 333: *n_read_out = (size_t)n_to_copy;
! 334:
! 335: return (line);
! 336: }
! 337:
! 338: /* Adds data to an event buffer */
! 339:
! 340: static void
! 341: evbuffer_align(struct evbuffer *buf)
! 342: {
! 343: memmove(buf->orig_buffer, buf->buffer, buf->off);
! 344: buf->buffer = buf->orig_buffer;
! 345: buf->misalign = 0;
! 346: }
! 347:
! 348: /* Expands the available space in the event buffer to at least datlen */
! 349:
! 350: int
! 351: evbuffer_expand(struct evbuffer *buf, size_t datlen)
! 352: {
! 353: size_t need = buf->misalign + buf->off + datlen;
! 354:
! 355: /* If we can fit all the data, then we don't have to do anything */
! 356: if (buf->totallen >= need)
! 357: return (0);
! 358:
! 359: /*
! 360: * If the misalignment fulfills our data needs, we just force an
! 361: * alignment to happen. Afterwards, we have enough space.
! 362: */
! 363: if (buf->misalign >= datlen) {
! 364: evbuffer_align(buf);
! 365: } else {
! 366: void *newbuf;
! 367: size_t length = buf->totallen;
! 368:
! 369: if (length < 256)
! 370: length = 256;
! 371: while (length < need)
! 372: length <<= 1;
! 373:
! 374: if (buf->orig_buffer != buf->buffer)
! 375: evbuffer_align(buf);
! 376: if ((newbuf = realloc(buf->buffer, length)) == NULL)
! 377: return (-1);
! 378:
! 379: buf->orig_buffer = buf->buffer = newbuf;
! 380: buf->totallen = length;
! 381: }
! 382:
! 383: return (0);
! 384: }
! 385:
! 386: int
! 387: evbuffer_add(struct evbuffer *buf, const void *data, size_t datlen)
! 388: {
! 389: size_t need = buf->misalign + buf->off + datlen;
! 390: size_t oldoff = buf->off;
! 391:
! 392: if (buf->totallen < need) {
! 393: if (evbuffer_expand(buf, datlen) == -1)
! 394: return (-1);
! 395: }
! 396:
! 397: memcpy(buf->buffer + buf->off, data, datlen);
! 398: buf->off += datlen;
! 399:
! 400: if (datlen && buf->cb != NULL)
! 401: (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
! 402:
! 403: return (0);
! 404: }
! 405:
! 406: void
! 407: evbuffer_drain(struct evbuffer *buf, size_t len)
! 408: {
! 409: size_t oldoff = buf->off;
! 410:
! 411: if (len >= buf->off) {
! 412: buf->off = 0;
! 413: buf->buffer = buf->orig_buffer;
! 414: buf->misalign = 0;
! 415: goto done;
! 416: }
! 417:
! 418: buf->buffer += len;
! 419: buf->misalign += len;
! 420:
! 421: buf->off -= len;
! 422:
! 423: done:
! 424: /* Tell someone about changes in this buffer */
! 425: if (buf->off != oldoff && buf->cb != NULL)
! 426: (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
! 427:
! 428: }
! 429:
! 430: /*
! 431: * Reads data from a file descriptor into a buffer.
! 432: */
! 433:
! 434: #define EVBUFFER_MAX_READ 4096
! 435:
! 436: int
! 437: evbuffer_read(struct evbuffer *buf, int fd, int howmuch)
! 438: {
! 439: u_char *p;
! 440: size_t oldoff = buf->off;
! 441: int n = EVBUFFER_MAX_READ;
! 442:
! 443: #if defined(FIONREAD)
! 444: #ifdef WIN32
! 445: long lng = n;
! 446: if (ioctlsocket(fd, FIONREAD, &lng) == -1 || (n=lng) <= 0) {
! 447: #else
! 448: if (ioctl(fd, FIONREAD, &n) == -1 || n <= 0) {
! 449: #endif
! 450: n = EVBUFFER_MAX_READ;
! 451: } else if (n > EVBUFFER_MAX_READ && n > howmuch) {
! 452: /*
! 453: * It's possible that a lot of data is available for
! 454: * reading. We do not want to exhaust resources
! 455: * before the reader has a chance to do something
! 456: * about it. If the reader does not tell us how much
! 457: * data we should read, we artifically limit it.
! 458: */
! 459: if ((size_t)n > buf->totallen << 2)
! 460: n = buf->totallen << 2;
! 461: if (n < EVBUFFER_MAX_READ)
! 462: n = EVBUFFER_MAX_READ;
! 463: }
! 464: #endif
! 465: if (howmuch < 0 || howmuch > n)
! 466: howmuch = n;
! 467:
! 468: /* If we don't have FIONREAD, we might waste some space here */
! 469: if (evbuffer_expand(buf, howmuch) == -1)
! 470: return (-1);
! 471:
! 472: /* We can append new data at this point */
! 473: p = buf->buffer + buf->off;
! 474:
! 475: #ifndef WIN32
! 476: n = read(fd, p, howmuch);
! 477: #else
! 478: n = recv(fd, p, howmuch, 0);
! 479: #endif
! 480: if (n == -1)
! 481: return (-1);
! 482: if (n == 0)
! 483: return (0);
! 484:
! 485: buf->off += n;
! 486:
! 487: /* Tell someone about changes in this buffer */
! 488: if (buf->off != oldoff && buf->cb != NULL)
! 489: (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
! 490:
! 491: return (n);
! 492: }
! 493:
! 494: int
! 495: evbuffer_write(struct evbuffer *buffer, int fd)
! 496: {
! 497: int n;
! 498:
! 499: #ifndef WIN32
! 500: n = write(fd, buffer->buffer, buffer->off);
! 501: #else
! 502: n = send(fd, buffer->buffer, buffer->off, 0);
! 503: #endif
! 504: if (n == -1)
! 505: return (-1);
! 506: if (n == 0)
! 507: return (0);
! 508: evbuffer_drain(buffer, n);
! 509:
! 510: return (n);
! 511: }
! 512:
! 513: u_char *
! 514: evbuffer_find(struct evbuffer *buffer, const u_char *what, size_t len)
! 515: {
! 516: u_char *search = buffer->buffer, *end = search + buffer->off;
! 517: u_char *p;
! 518:
! 519: while (search < end &&
! 520: (p = memchr(search, *what, end - search)) != NULL) {
! 521: if (p + len > end)
! 522: break;
! 523: if (memcmp(p, what, len) == 0)
! 524: return (p);
! 525: search = p + 1;
! 526: }
! 527:
! 528: return (NULL);
! 529: }
! 530:
! 531: void evbuffer_setcb(struct evbuffer *buffer,
! 532: void (*cb)(struct evbuffer *, size_t, size_t, void *),
! 533: void *cbarg)
! 534: {
! 535: buffer->cb = cb;
! 536: buffer->cbarg = cbarg;
! 537: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to buffer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent