167ecd4f3SMax Laier /*
267ecd4f3SMax Laier * Copyright (c) 2002, 2003 Niels Provos <provos@citi.umich.edu>
367ecd4f3SMax Laier * All rights reserved.
467ecd4f3SMax Laier *
567ecd4f3SMax Laier * Redistribution and use in source and binary forms, with or without
667ecd4f3SMax Laier * modification, are permitted provided that the following conditions
767ecd4f3SMax Laier * are met:
867ecd4f3SMax Laier * 1. Redistributions of source code must retain the above copyright
967ecd4f3SMax Laier * notice, this list of conditions and the following disclaimer.
1067ecd4f3SMax Laier * 2. Redistributions in binary form must reproduce the above copyright
1167ecd4f3SMax Laier * notice, this list of conditions and the following disclaimer in the
1267ecd4f3SMax Laier * documentation and/or other materials provided with the distribution.
1367ecd4f3SMax Laier * 3. The name of the author may not be used to endorse or promote products
1467ecd4f3SMax Laier * derived from this software without specific prior written permission.
1567ecd4f3SMax Laier *
1667ecd4f3SMax Laier * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
1767ecd4f3SMax Laier * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
1867ecd4f3SMax Laier * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
1967ecd4f3SMax Laier * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
2067ecd4f3SMax Laier * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
2167ecd4f3SMax Laier * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2267ecd4f3SMax Laier * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
2367ecd4f3SMax Laier * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
2467ecd4f3SMax Laier * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
2567ecd4f3SMax Laier * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2667ecd4f3SMax Laier */
2767ecd4f3SMax Laier
2867ecd4f3SMax Laier #ifdef HAVE_CONFIG_H
2967ecd4f3SMax Laier #include "config.h"
3067ecd4f3SMax Laier #endif
3167ecd4f3SMax Laier
3267ecd4f3SMax Laier #ifdef HAVE_VASPRINTF
3367ecd4f3SMax Laier /* If we have vasprintf, we need to define this before we include stdio.h. */
3467ecd4f3SMax Laier #define _GNU_SOURCE
3567ecd4f3SMax Laier #endif
3667ecd4f3SMax Laier
3767ecd4f3SMax Laier #include <sys/types.h>
3867ecd4f3SMax Laier
3967ecd4f3SMax Laier #ifdef HAVE_SYS_TIME_H
4067ecd4f3SMax Laier #include <sys/time.h>
4167ecd4f3SMax Laier #endif
4267ecd4f3SMax Laier
4367ecd4f3SMax Laier #ifdef HAVE_SYS_IOCTL_H
4467ecd4f3SMax Laier #include <sys/ioctl.h>
4567ecd4f3SMax Laier #endif
4667ecd4f3SMax Laier
4767ecd4f3SMax Laier #include <errno.h>
4867ecd4f3SMax Laier #include <stdio.h>
4967ecd4f3SMax Laier #include <stdlib.h>
5067ecd4f3SMax Laier #include <string.h>
5167ecd4f3SMax Laier #ifdef HAVE_STDARG_H
5267ecd4f3SMax Laier #include <stdarg.h>
5367ecd4f3SMax Laier #endif
5467ecd4f3SMax Laier #ifdef HAVE_UNISTD_H
5567ecd4f3SMax Laier #include <unistd.h>
5667ecd4f3SMax Laier #endif
5767ecd4f3SMax Laier
5867ecd4f3SMax Laier #include "event.h"
5967ecd4f3SMax Laier
6067ecd4f3SMax Laier struct evbuffer *
evbuffer_new(void)6167ecd4f3SMax Laier evbuffer_new(void)
6267ecd4f3SMax Laier {
6367ecd4f3SMax Laier struct evbuffer *buffer;
6467ecd4f3SMax Laier
6567ecd4f3SMax Laier buffer = calloc(1, sizeof(struct evbuffer));
6667ecd4f3SMax Laier
6767ecd4f3SMax Laier return (buffer);
6867ecd4f3SMax Laier }
6967ecd4f3SMax Laier
7067ecd4f3SMax Laier void
evbuffer_free(struct evbuffer * buffer)7167ecd4f3SMax Laier evbuffer_free(struct evbuffer *buffer)
7267ecd4f3SMax Laier {
7367ecd4f3SMax Laier if (buffer->orig_buffer != NULL)
7467ecd4f3SMax Laier free(buffer->orig_buffer);
7567ecd4f3SMax Laier free(buffer);
7667ecd4f3SMax Laier }
7767ecd4f3SMax Laier
7867ecd4f3SMax Laier /*
7967ecd4f3SMax Laier * This is a destructive add. The data from one buffer moves into
8067ecd4f3SMax Laier * the other buffer.
8167ecd4f3SMax Laier */
8267ecd4f3SMax Laier
8367ecd4f3SMax Laier #define SWAP(x,y) do { \
8467ecd4f3SMax Laier (x)->buffer = (y)->buffer; \
8567ecd4f3SMax Laier (x)->orig_buffer = (y)->orig_buffer; \
8667ecd4f3SMax Laier (x)->misalign = (y)->misalign; \
8767ecd4f3SMax Laier (x)->totallen = (y)->totallen; \
8867ecd4f3SMax Laier (x)->off = (y)->off; \
8967ecd4f3SMax Laier } while (0)
9067ecd4f3SMax Laier
9167ecd4f3SMax Laier int
evbuffer_add_buffer(struct evbuffer * outbuf,struct evbuffer * inbuf)9267ecd4f3SMax Laier evbuffer_add_buffer(struct evbuffer *outbuf, struct evbuffer *inbuf)
9367ecd4f3SMax Laier {
9467ecd4f3SMax Laier int res;
9567ecd4f3SMax Laier
9667ecd4f3SMax Laier /* Short cut for better performance */
9767ecd4f3SMax Laier if (outbuf->off == 0) {
9867ecd4f3SMax Laier struct evbuffer tmp;
9967ecd4f3SMax Laier size_t oldoff = inbuf->off;
10067ecd4f3SMax Laier
10167ecd4f3SMax Laier /* Swap them directly */
10267ecd4f3SMax Laier SWAP(&tmp, outbuf);
10367ecd4f3SMax Laier SWAP(outbuf, inbuf);
10467ecd4f3SMax Laier SWAP(inbuf, &tmp);
10567ecd4f3SMax Laier
10667ecd4f3SMax Laier /*
10767ecd4f3SMax Laier * Optimization comes with a price; we need to notify the
10867ecd4f3SMax Laier * buffer if necessary of the changes. oldoff is the amount
10967ecd4f3SMax Laier * of data that we tranfered from inbuf to outbuf
11067ecd4f3SMax Laier */
11167ecd4f3SMax Laier if (inbuf->off != oldoff && inbuf->cb != NULL)
11267ecd4f3SMax Laier (*inbuf->cb)(inbuf, oldoff, inbuf->off, inbuf->cbarg);
11367ecd4f3SMax Laier if (oldoff && outbuf->cb != NULL)
11467ecd4f3SMax Laier (*outbuf->cb)(outbuf, 0, oldoff, outbuf->cbarg);
11567ecd4f3SMax Laier
11667ecd4f3SMax Laier return (0);
11767ecd4f3SMax Laier }
11867ecd4f3SMax Laier
11967ecd4f3SMax Laier res = evbuffer_add(outbuf, inbuf->buffer, inbuf->off);
12067ecd4f3SMax Laier if (res == 0) {
12167ecd4f3SMax Laier /* We drain the input buffer on success */
12267ecd4f3SMax Laier evbuffer_drain(inbuf, inbuf->off);
12367ecd4f3SMax Laier }
12467ecd4f3SMax Laier
12567ecd4f3SMax Laier return (res);
12667ecd4f3SMax Laier }
12767ecd4f3SMax Laier
12867ecd4f3SMax Laier int
evbuffer_add_vprintf(struct evbuffer * buf,const char * fmt,va_list ap)12967ecd4f3SMax Laier evbuffer_add_vprintf(struct evbuffer *buf, const char *fmt, va_list ap)
13067ecd4f3SMax Laier {
13167ecd4f3SMax Laier char *buffer;
13267ecd4f3SMax Laier size_t space;
13367ecd4f3SMax Laier size_t oldoff = buf->off;
13467ecd4f3SMax Laier int sz;
13567ecd4f3SMax Laier va_list aq;
13667ecd4f3SMax Laier
13767ecd4f3SMax Laier for (;;) {
13867ecd4f3SMax Laier buffer = (char *)buf->buffer + buf->off;
13967ecd4f3SMax Laier space = buf->totallen - buf->misalign - buf->off;
14067ecd4f3SMax Laier
14167ecd4f3SMax Laier #ifndef va_copy
14267ecd4f3SMax Laier #define va_copy(dst, src) memcpy(&(dst), &(src), sizeof(va_list))
14367ecd4f3SMax Laier #endif
14467ecd4f3SMax Laier va_copy(aq, ap);
14567ecd4f3SMax Laier
14667ecd4f3SMax Laier #ifdef WIN32
14767ecd4f3SMax Laier sz = vsnprintf(buffer, space - 1, fmt, aq);
14867ecd4f3SMax Laier buffer[space - 1] = '\0';
14967ecd4f3SMax Laier #else
15067ecd4f3SMax Laier sz = vsnprintf(buffer, space, fmt, aq);
15167ecd4f3SMax Laier #endif
15267ecd4f3SMax Laier
15367ecd4f3SMax Laier va_end(aq);
15467ecd4f3SMax Laier
15567ecd4f3SMax Laier if (sz == -1)
15667ecd4f3SMax Laier return (-1);
15767ecd4f3SMax Laier if (sz < space) {
15867ecd4f3SMax Laier buf->off += sz;
15967ecd4f3SMax Laier if (buf->cb != NULL)
16067ecd4f3SMax Laier (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
16167ecd4f3SMax Laier return (sz);
16267ecd4f3SMax Laier }
16367ecd4f3SMax Laier if (evbuffer_expand(buf, sz + 1) == -1)
16467ecd4f3SMax Laier return (-1);
16567ecd4f3SMax Laier
16667ecd4f3SMax Laier }
16767ecd4f3SMax Laier /* NOTREACHED */
16867ecd4f3SMax Laier }
16967ecd4f3SMax Laier
17067ecd4f3SMax Laier int
evbuffer_add_printf(struct evbuffer * buf,const char * fmt,...)17167ecd4f3SMax Laier evbuffer_add_printf(struct evbuffer *buf, const char *fmt, ...)
17267ecd4f3SMax Laier {
17367ecd4f3SMax Laier int res = -1;
17467ecd4f3SMax Laier va_list ap;
17567ecd4f3SMax Laier
17667ecd4f3SMax Laier va_start(ap, fmt);
17767ecd4f3SMax Laier res = evbuffer_add_vprintf(buf, fmt, ap);
17867ecd4f3SMax Laier va_end(ap);
17967ecd4f3SMax Laier
18067ecd4f3SMax Laier return (res);
18167ecd4f3SMax Laier }
18267ecd4f3SMax Laier
18367ecd4f3SMax Laier /* Reads data from an event buffer and drains the bytes read */
18467ecd4f3SMax Laier
18567ecd4f3SMax Laier int
evbuffer_remove(struct evbuffer * buf,void * data,size_t datlen)18667ecd4f3SMax Laier evbuffer_remove(struct evbuffer *buf, void *data, size_t datlen)
18767ecd4f3SMax Laier {
18867ecd4f3SMax Laier size_t nread = datlen;
18967ecd4f3SMax Laier if (nread >= buf->off)
19067ecd4f3SMax Laier nread = buf->off;
19167ecd4f3SMax Laier
19267ecd4f3SMax Laier memcpy(data, buf->buffer, nread);
19367ecd4f3SMax Laier evbuffer_drain(buf, nread);
19467ecd4f3SMax Laier
19567ecd4f3SMax Laier return (nread);
19667ecd4f3SMax Laier }
19767ecd4f3SMax Laier
19867ecd4f3SMax Laier /*
19967ecd4f3SMax Laier * Reads a line terminated by either '\r\n', '\n\r' or '\r' or '\n'.
20067ecd4f3SMax Laier * The returned buffer needs to be freed by the called.
20167ecd4f3SMax Laier */
20267ecd4f3SMax Laier
20367ecd4f3SMax Laier char *
evbuffer_readline(struct evbuffer * buffer)20467ecd4f3SMax Laier evbuffer_readline(struct evbuffer *buffer)
20567ecd4f3SMax Laier {
20667ecd4f3SMax Laier u_char *data = EVBUFFER_DATA(buffer);
20767ecd4f3SMax Laier size_t len = EVBUFFER_LENGTH(buffer);
20867ecd4f3SMax Laier char *line;
20967ecd4f3SMax Laier unsigned int i;
21067ecd4f3SMax Laier
21167ecd4f3SMax Laier for (i = 0; i < len; i++) {
21267ecd4f3SMax Laier if (data[i] == '\r' || data[i] == '\n')
21367ecd4f3SMax Laier break;
21467ecd4f3SMax Laier }
21567ecd4f3SMax Laier
21667ecd4f3SMax Laier if (i == len)
21767ecd4f3SMax Laier return (NULL);
21867ecd4f3SMax Laier
21967ecd4f3SMax Laier if ((line = malloc(i + 1)) == NULL) {
22067ecd4f3SMax Laier fprintf(stderr, "%s: out of memory\n", __func__);
22167ecd4f3SMax Laier evbuffer_drain(buffer, i);
22267ecd4f3SMax Laier return (NULL);
22367ecd4f3SMax Laier }
22467ecd4f3SMax Laier
22567ecd4f3SMax Laier memcpy(line, data, i);
22667ecd4f3SMax Laier line[i] = '\0';
22767ecd4f3SMax Laier
22867ecd4f3SMax Laier /*
22967ecd4f3SMax Laier * Some protocols terminate a line with '\r\n', so check for
23067ecd4f3SMax Laier * that, too.
23167ecd4f3SMax Laier */
23267ecd4f3SMax Laier if ( i < len - 1 ) {
23367ecd4f3SMax Laier char fch = data[i], sch = data[i+1];
23467ecd4f3SMax Laier
23567ecd4f3SMax Laier /* Drain one more character if needed */
23667ecd4f3SMax Laier if ( (sch == '\r' || sch == '\n') && sch != fch )
23767ecd4f3SMax Laier i += 1;
23867ecd4f3SMax Laier }
23967ecd4f3SMax Laier
24067ecd4f3SMax Laier evbuffer_drain(buffer, i + 1);
24167ecd4f3SMax Laier
24267ecd4f3SMax Laier return (line);
24367ecd4f3SMax Laier }
24467ecd4f3SMax Laier
24567ecd4f3SMax Laier /* Adds data to an event buffer */
24667ecd4f3SMax Laier
24767ecd4f3SMax Laier static inline void
evbuffer_align(struct evbuffer * buf)24867ecd4f3SMax Laier evbuffer_align(struct evbuffer *buf)
24967ecd4f3SMax Laier {
25067ecd4f3SMax Laier memmove(buf->orig_buffer, buf->buffer, buf->off);
25167ecd4f3SMax Laier buf->buffer = buf->orig_buffer;
25267ecd4f3SMax Laier buf->misalign = 0;
25367ecd4f3SMax Laier }
25467ecd4f3SMax Laier
25567ecd4f3SMax Laier /* Expands the available space in the event buffer to at least datlen */
25667ecd4f3SMax Laier
25767ecd4f3SMax Laier int
evbuffer_expand(struct evbuffer * buf,size_t datlen)25867ecd4f3SMax Laier evbuffer_expand(struct evbuffer *buf, size_t datlen)
25967ecd4f3SMax Laier {
26067ecd4f3SMax Laier size_t need = buf->misalign + buf->off + datlen;
26167ecd4f3SMax Laier
26267ecd4f3SMax Laier /* If we can fit all the data, then we don't have to do anything */
26367ecd4f3SMax Laier if (buf->totallen >= need)
26467ecd4f3SMax Laier return (0);
26567ecd4f3SMax Laier
26667ecd4f3SMax Laier /*
26767ecd4f3SMax Laier * If the misalignment fulfills our data needs, we just force an
26867ecd4f3SMax Laier * alignment to happen. Afterwards, we have enough space.
26967ecd4f3SMax Laier */
27067ecd4f3SMax Laier if (buf->misalign >= datlen) {
27167ecd4f3SMax Laier evbuffer_align(buf);
27267ecd4f3SMax Laier } else {
27367ecd4f3SMax Laier void *newbuf;
27467ecd4f3SMax Laier size_t length = buf->totallen;
27567ecd4f3SMax Laier
27667ecd4f3SMax Laier if (length < 256)
27767ecd4f3SMax Laier length = 256;
27867ecd4f3SMax Laier while (length < need)
27967ecd4f3SMax Laier length <<= 1;
28067ecd4f3SMax Laier
28167ecd4f3SMax Laier if (buf->orig_buffer != buf->buffer)
28267ecd4f3SMax Laier evbuffer_align(buf);
28367ecd4f3SMax Laier if ((newbuf = realloc(buf->buffer, length)) == NULL)
28467ecd4f3SMax Laier return (-1);
28567ecd4f3SMax Laier
28667ecd4f3SMax Laier buf->orig_buffer = buf->buffer = newbuf;
28767ecd4f3SMax Laier buf->totallen = length;
28867ecd4f3SMax Laier }
28967ecd4f3SMax Laier
29067ecd4f3SMax Laier return (0);
29167ecd4f3SMax Laier }
29267ecd4f3SMax Laier
29367ecd4f3SMax Laier int
evbuffer_add(struct evbuffer * buf,const void * data,size_t datlen)29467ecd4f3SMax Laier evbuffer_add(struct evbuffer *buf, const void *data, size_t datlen)
29567ecd4f3SMax Laier {
29667ecd4f3SMax Laier size_t need = buf->misalign + buf->off + datlen;
29767ecd4f3SMax Laier size_t oldoff = buf->off;
29867ecd4f3SMax Laier
29967ecd4f3SMax Laier if (buf->totallen < need) {
30067ecd4f3SMax Laier if (evbuffer_expand(buf, datlen) == -1)
30167ecd4f3SMax Laier return (-1);
30267ecd4f3SMax Laier }
30367ecd4f3SMax Laier
30467ecd4f3SMax Laier memcpy(buf->buffer + buf->off, data, datlen);
30567ecd4f3SMax Laier buf->off += datlen;
30667ecd4f3SMax Laier
30767ecd4f3SMax Laier if (datlen && buf->cb != NULL)
30867ecd4f3SMax Laier (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
30967ecd4f3SMax Laier
31067ecd4f3SMax Laier return (0);
31167ecd4f3SMax Laier }
31267ecd4f3SMax Laier
31367ecd4f3SMax Laier void
evbuffer_drain(struct evbuffer * buf,size_t len)31467ecd4f3SMax Laier evbuffer_drain(struct evbuffer *buf, size_t len)
31567ecd4f3SMax Laier {
31667ecd4f3SMax Laier size_t oldoff = buf->off;
31767ecd4f3SMax Laier
31867ecd4f3SMax Laier if (len >= buf->off) {
31967ecd4f3SMax Laier buf->off = 0;
32067ecd4f3SMax Laier buf->buffer = buf->orig_buffer;
32167ecd4f3SMax Laier buf->misalign = 0;
32267ecd4f3SMax Laier goto done;
32367ecd4f3SMax Laier }
32467ecd4f3SMax Laier
32567ecd4f3SMax Laier buf->buffer += len;
32667ecd4f3SMax Laier buf->misalign += len;
32767ecd4f3SMax Laier
32867ecd4f3SMax Laier buf->off -= len;
32967ecd4f3SMax Laier
33067ecd4f3SMax Laier done:
33167ecd4f3SMax Laier /* Tell someone about changes in this buffer */
33267ecd4f3SMax Laier if (buf->off != oldoff && buf->cb != NULL)
33367ecd4f3SMax Laier (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
33467ecd4f3SMax Laier
33567ecd4f3SMax Laier }
33667ecd4f3SMax Laier
33767ecd4f3SMax Laier /*
33867ecd4f3SMax Laier * Reads data from a file descriptor into a buffer.
33967ecd4f3SMax Laier */
34067ecd4f3SMax Laier
34167ecd4f3SMax Laier #define EVBUFFER_MAX_READ 4096
34267ecd4f3SMax Laier
34367ecd4f3SMax Laier int
evbuffer_read(struct evbuffer * buf,int fd,int howmuch)34467ecd4f3SMax Laier evbuffer_read(struct evbuffer *buf, int fd, int howmuch)
34567ecd4f3SMax Laier {
34667ecd4f3SMax Laier u_char *p;
34767ecd4f3SMax Laier size_t oldoff = buf->off;
34867ecd4f3SMax Laier int n = EVBUFFER_MAX_READ;
34967ecd4f3SMax Laier #ifdef WIN32
35067ecd4f3SMax Laier DWORD dwBytesRead;
35167ecd4f3SMax Laier #endif
35267ecd4f3SMax Laier
35367ecd4f3SMax Laier #ifdef FIONREAD
35467ecd4f3SMax Laier if (ioctl(fd, FIONREAD, &n) == -1 || n == 0) {
35567ecd4f3SMax Laier n = EVBUFFER_MAX_READ;
35667ecd4f3SMax Laier } else if (n > EVBUFFER_MAX_READ && n > howmuch) {
35767ecd4f3SMax Laier /*
35867ecd4f3SMax Laier * It's possible that a lot of data is available for
35967ecd4f3SMax Laier * reading. We do not want to exhaust resources
36067ecd4f3SMax Laier * before the reader has a chance to do something
36167ecd4f3SMax Laier * about it. If the reader does not tell us how much
36267ecd4f3SMax Laier * data we should read, we artifically limit it.
36367ecd4f3SMax Laier */
36467ecd4f3SMax Laier if (n > buf->totallen << 2)
36567ecd4f3SMax Laier n = buf->totallen << 2;
36667ecd4f3SMax Laier if (n < EVBUFFER_MAX_READ)
36767ecd4f3SMax Laier n = EVBUFFER_MAX_READ;
36867ecd4f3SMax Laier }
36967ecd4f3SMax Laier #endif
37067ecd4f3SMax Laier if (howmuch < 0 || howmuch > n)
37167ecd4f3SMax Laier howmuch = n;
37267ecd4f3SMax Laier
37367ecd4f3SMax Laier /* If we don't have FIONREAD, we might waste some space here */
37467ecd4f3SMax Laier if (evbuffer_expand(buf, howmuch) == -1)
37567ecd4f3SMax Laier return (-1);
37667ecd4f3SMax Laier
37767ecd4f3SMax Laier /* We can append new data at this point */
37867ecd4f3SMax Laier p = buf->buffer + buf->off;
37967ecd4f3SMax Laier
38067ecd4f3SMax Laier #ifndef WIN32
38167ecd4f3SMax Laier n = read(fd, p, howmuch);
38267ecd4f3SMax Laier if (n == -1)
38367ecd4f3SMax Laier return (-1);
38467ecd4f3SMax Laier if (n == 0)
38567ecd4f3SMax Laier return (0);
38667ecd4f3SMax Laier #else
38767ecd4f3SMax Laier n = ReadFile((HANDLE)fd, p, howmuch, &dwBytesRead, NULL);
38867ecd4f3SMax Laier if (n == 0)
38967ecd4f3SMax Laier return (-1);
39067ecd4f3SMax Laier if (dwBytesRead == 0)
39167ecd4f3SMax Laier return (0);
39267ecd4f3SMax Laier n = dwBytesRead;
39367ecd4f3SMax Laier #endif
39467ecd4f3SMax Laier
39567ecd4f3SMax Laier buf->off += n;
39667ecd4f3SMax Laier
39767ecd4f3SMax Laier /* Tell someone about changes in this buffer */
39867ecd4f3SMax Laier if (buf->off != oldoff && buf->cb != NULL)
39967ecd4f3SMax Laier (*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
40067ecd4f3SMax Laier
40167ecd4f3SMax Laier return (n);
40267ecd4f3SMax Laier }
40367ecd4f3SMax Laier
40467ecd4f3SMax Laier int
evbuffer_write(struct evbuffer * buffer,int fd)40567ecd4f3SMax Laier evbuffer_write(struct evbuffer *buffer, int fd)
40667ecd4f3SMax Laier {
40767ecd4f3SMax Laier int n;
40867ecd4f3SMax Laier #ifdef WIN32
40967ecd4f3SMax Laier DWORD dwBytesWritten;
41067ecd4f3SMax Laier #endif
41167ecd4f3SMax Laier
41267ecd4f3SMax Laier #ifndef WIN32
41367ecd4f3SMax Laier n = write(fd, buffer->buffer, buffer->off);
41467ecd4f3SMax Laier if (n == -1)
41567ecd4f3SMax Laier return (-1);
41667ecd4f3SMax Laier if (n == 0)
41767ecd4f3SMax Laier return (0);
41867ecd4f3SMax Laier #else
41967ecd4f3SMax Laier n = WriteFile((HANDLE)fd, buffer->buffer, buffer->off, &dwBytesWritten, NULL);
42067ecd4f3SMax Laier if (n == 0)
42167ecd4f3SMax Laier return (-1);
42267ecd4f3SMax Laier if (dwBytesWritten == 0)
42367ecd4f3SMax Laier return (0);
42467ecd4f3SMax Laier n = dwBytesWritten;
42567ecd4f3SMax Laier #endif
42667ecd4f3SMax Laier evbuffer_drain(buffer, n);
42767ecd4f3SMax Laier
42867ecd4f3SMax Laier return (n);
42967ecd4f3SMax Laier }
43067ecd4f3SMax Laier
43167ecd4f3SMax Laier u_char *
evbuffer_find(struct evbuffer * buffer,const u_char * what,size_t len)43267ecd4f3SMax Laier evbuffer_find(struct evbuffer *buffer, const u_char *what, size_t len)
43367ecd4f3SMax Laier {
43467ecd4f3SMax Laier size_t remain = buffer->off;
43567ecd4f3SMax Laier u_char *search = buffer->buffer;
43667ecd4f3SMax Laier u_char *p;
43767ecd4f3SMax Laier
43867ecd4f3SMax Laier while ((p = memchr(search, *what, remain)) != NULL) {
43967ecd4f3SMax Laier remain = buffer->off - (size_t)(search - buffer->buffer);
44067ecd4f3SMax Laier if (remain < len)
44167ecd4f3SMax Laier break;
44267ecd4f3SMax Laier if (memcmp(p, what, len) == 0)
44367ecd4f3SMax Laier return (p);
44467ecd4f3SMax Laier search = p + 1;
44567ecd4f3SMax Laier }
44667ecd4f3SMax Laier
44767ecd4f3SMax Laier return (NULL);
44867ecd4f3SMax Laier }
44967ecd4f3SMax Laier
evbuffer_setcb(struct evbuffer * buffer,void (* cb)(struct evbuffer *,size_t,size_t,void *),void * cbarg)45067ecd4f3SMax Laier void evbuffer_setcb(struct evbuffer *buffer,
45167ecd4f3SMax Laier void (*cb)(struct evbuffer *, size_t, size_t, void *),
45267ecd4f3SMax Laier void *cbarg)
45367ecd4f3SMax Laier {
45467ecd4f3SMax Laier buffer->cb = cb;
45567ecd4f3SMax Laier buffer->cbarg = cbarg;
45667ecd4f3SMax Laier }
457