event.h

Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2000-2007 Niels Provos <provos@citi.umich.edu>
00003  * All rights reserved.
00004  *
00005  * Redistribution and use in source and binary forms, with or without
00006  * modification, are permitted provided that the following conditions
00007  * are met:
00008  * 1. Redistributions of source code must retain the above copyright
00009  *    notice, this list of conditions and the following disclaimer.
00010  * 2. Redistributions in binary form must reproduce the above copyright
00011  *    notice, this list of conditions and the following disclaimer in the
00012  *    documentation and/or other materials provided with the distribution.
00013  * 3. The name of the author may not be used to endorse or promote products
00014  *    derived from this software without specific prior written permission.
00015  *
00016  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
00017  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
00018  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
00019  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
00020  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
00021  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00022  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00023  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00024  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
00025  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00026  */
00027 #ifndef _EVENT_H_
00028 #define _EVENT_H_
00029 
00158 #ifdef __cplusplus
00159 extern "C" {
00160 #endif
00161 
00162 #include <event-config.h>
00163 #ifdef _EVENT_HAVE_SYS_TYPES_H
00164 #include <sys/types.h>
00165 #endif
00166 #ifdef _EVENT_HAVE_SYS_TIME_H
00167 #include <sys/time.h>
00168 #endif
00169 #ifdef _EVENT_HAVE_STDINT_H
00170 #include <stdint.h>
00171 #endif
00172 #include <stdarg.h>
00173 
00174 /* For int types. */
00175 #include <evutil.h>
00176 
00177 #ifdef WIN32
00178 #define WIN32_LEAN_AND_MEAN
00179 #include <windows.h>
00180 #undef WIN32_LEAN_AND_MEAN
00181 typedef unsigned char u_char;
00182 typedef unsigned short u_short;
00183 #endif
00184 
00185 #define EVLIST_TIMEOUT  0x01
00186 #define EVLIST_INSERTED 0x02
00187 #define EVLIST_SIGNAL   0x04
00188 #define EVLIST_ACTIVE   0x08
00189 #define EVLIST_INTERNAL 0x10
00190 #define EVLIST_INIT     0x80
00191 
00192 /* EVLIST_X_ Private space: 0x1000-0xf000 */
00193 #define EVLIST_ALL      (0xf000 | 0x9f)
00194 
00195 #define EV_TIMEOUT      0x01
00196 #define EV_READ         0x02
00197 #define EV_WRITE        0x04
00198 #define EV_SIGNAL       0x08
00199 #define EV_PERSIST      0x10    /* Persistant event */
00200 
00201 /* Fix so that ppl dont have to run with <sys/queue.h> */
00202 #ifndef TAILQ_ENTRY
00203 #define _EVENT_DEFINED_TQENTRY
00204 #define TAILQ_ENTRY(type)                                               \
00205 struct {                                                                \
00206         struct type *tqe_next;  /* next element */                      \
00207         struct type **tqe_prev; /* address of previous next element */  \
00208 }
00209 #endif /* !TAILQ_ENTRY */
00210 
00211 struct event_base;
00212 #ifndef EVENT_NO_STRUCT
00213 struct event {
00214         TAILQ_ENTRY (event) ev_next;
00215         TAILQ_ENTRY (event) ev_active_next;
00216         TAILQ_ENTRY (event) ev_signal_next;
00217         unsigned int min_heap_idx;      /* for managing timeouts */
00218 
00219         struct event_base *ev_base;
00220 
00221         int ev_fd;
00222         short ev_events;
00223         short ev_ncalls;
00224         short *ev_pncalls;      /* Allows deletes in callback */
00225 
00226         struct timeval ev_timeout;
00227 
00228         int ev_pri;             /* smaller numbers are higher priority */
00229 
00230         void (*ev_callback)(int, short, void *arg);
00231         void *ev_arg;
00232 
00233         int ev_res;             /* result passed to event callback */
00234         int ev_flags;
00235 };
00236 #else
00237 struct event;
00238 #endif
00239 
00240 #define EVENT_SIGNAL(ev)        (int)(ev)->ev_fd
00241 #define EVENT_FD(ev)            (int)(ev)->ev_fd
00242 
00243 /*
00244  * Key-Value pairs.  Can be used for HTTP headers but also for
00245  * query argument parsing.
00246  */
00247 struct evkeyval {
00248         TAILQ_ENTRY(evkeyval) next;
00249 
00250         char *key;
00251         char *value;
00252 };
00253 
00254 #ifdef _EVENT_DEFINED_TQENTRY
00255 #undef TAILQ_ENTRY
00256 struct event_list;
00257 struct evkeyvalq;
00258 #undef _EVENT_DEFINED_TQENTRY
00259 #else
00260 TAILQ_HEAD (event_list, event);
00261 TAILQ_HEAD (evkeyvalq, evkeyval);
00262 #endif /* _EVENT_DEFINED_TQENTRY */
00263 
00273 struct event_base *event_base_new(void);
00274 
00284 struct event_base *event_init(void);
00285 
00296 int event_reinit(struct event_base *base);
00297 
00307 int event_dispatch(void);
00308 
00309 
00316 int event_base_dispatch(struct event_base *);
00317 
00318 
00325 const char *event_base_get_method(struct event_base *);
00326         
00327         
00336 void event_base_free(struct event_base *);
00337 
00338 
00339 #define _EVENT_LOG_DEBUG 0
00340 #define _EVENT_LOG_MSG   1
00341 #define _EVENT_LOG_WARN  2
00342 #define _EVENT_LOG_ERR   3
00343 typedef void (*event_log_cb)(int severity, const char *msg);
00351 void event_set_log_callback(event_log_cb cb);
00352 
00359 int event_base_set(struct event_base *, struct event *);
00360 
00365 #define EVLOOP_ONCE     0x01    
00366 #define EVLOOP_NONBLOCK 0x02    
00368 
00369 
00379 int event_loop(int);
00380 
00392 int event_base_loop(struct event_base *, int);
00393 
00407 int event_loopexit(const struct timeval *);
00408 
00409 
00424 int event_base_loopexit(struct event_base *, const struct timeval *);
00425 
00438 int event_loopbreak(void);
00439 
00453 int event_base_loopbreak(struct event_base *);
00454 
00455 
00462 #define evtimer_add(ev, tv)             event_add(ev, tv)
00463 
00464 
00472 #define evtimer_set(ev, cb, arg)        event_set(ev, -1, 0, cb, arg)
00473 
00474 
00480 #define evtimer_del(ev)                 event_del(ev)
00481 #define evtimer_pending(ev, tv)         event_pending(ev, EV_TIMEOUT, tv)
00482 #define evtimer_initialized(ev)         ((ev)->ev_flags & EVLIST_INIT)
00483 
00490 #define timeout_add(ev, tv)             event_add(ev, tv)
00491 
00492 
00500 #define timeout_set(ev, cb, arg)        event_set(ev, -1, 0, cb, arg)
00501 
00502 
00508 #define timeout_del(ev)                 event_del(ev)
00509 
00510 #define timeout_pending(ev, tv)         event_pending(ev, EV_TIMEOUT, tv)
00511 #define timeout_initialized(ev)         ((ev)->ev_flags & EVLIST_INIT)
00512 
00513 #define signal_add(ev, tv)              event_add(ev, tv)
00514 #define signal_set(ev, x, cb, arg)      \
00515         event_set(ev, x, EV_SIGNAL|EV_PERSIST, cb, arg)
00516 #define signal_del(ev)                  event_del(ev)
00517 #define signal_pending(ev, tv)          event_pending(ev, EV_SIGNAL, tv)
00518 #define signal_initialized(ev)          ((ev)->ev_flags & EVLIST_INIT)
00519 
00546 void event_set(struct event *, int, short, void (*)(int, short, void *), void *);
00547 
00566 int event_once(int, short, void (*)(int, short, void *), void *,
00567     const struct timeval *);
00568 
00569 
00588 int event_base_once(struct event_base *base, int fd, short events,
00589     void (*callback)(int, short, void *), void *arg,
00590     const struct timeval *timeout);
00591 
00592 
00611 int event_add(struct event *ev, const struct timeval *timeout);
00612 
00613 
00625 int event_del(struct event *);
00626 
00627 void event_active(struct event *, int, short);
00628 
00629 
00641 int event_pending(struct event *ev, short event, struct timeval *tv);
00642 
00643 
00654 #ifdef WIN32
00655 #define event_initialized(ev)           ((ev)->ev_flags & EVLIST_INIT && (ev)->ev_fd != (int)INVALID_HANDLE_VALUE)
00656 #else
00657 #define event_initialized(ev)           ((ev)->ev_flags & EVLIST_INIT)
00658 #endif
00659 
00660 
00666 const char *event_get_version(void);
00667 
00668 
00674 const char *event_get_method(void);
00675 
00676 
00697 int     event_priority_init(int);
00698 
00699 
00710 int     event_base_priority_init(struct event_base *, int);
00711 
00712 
00721 int     event_priority_set(struct event *, int);
00722 
00723 
00724 /* These functions deal with buffering input and output */
00725 
00726 struct evbuffer {
00727         u_char *buffer;
00728         u_char *orig_buffer;
00729 
00730         size_t misalign;
00731         size_t totallen;
00732         size_t off;
00733 
00734         void (*cb)(struct evbuffer *, size_t, size_t, void *);
00735         void *cbarg;
00736 };
00737 
00738 /* Just for error reporting - use other constants otherwise */
00739 #define EVBUFFER_READ           0x01
00740 #define EVBUFFER_WRITE          0x02
00741 #define EVBUFFER_EOF            0x10
00742 #define EVBUFFER_ERROR          0x20
00743 #define EVBUFFER_TIMEOUT        0x40
00744 
00745 struct bufferevent;
00746 typedef void (*evbuffercb)(struct bufferevent *, void *);
00747 typedef void (*everrorcb)(struct bufferevent *, short what, void *);
00748 
00749 struct event_watermark {
00750         size_t low;
00751         size_t high;
00752 };
00753 
00754 #ifndef EVENT_NO_STRUCT
00755 struct bufferevent {
00756         struct event_base *ev_base;
00757 
00758         struct event ev_read;
00759         struct event ev_write;
00760 
00761         struct evbuffer *input;
00762         struct evbuffer *output;
00763 
00764         struct event_watermark wm_read;
00765         struct event_watermark wm_write;
00766 
00767         evbuffercb readcb;
00768         evbuffercb writecb;
00769         everrorcb errorcb;
00770         void *cbarg;
00771 
00772         int timeout_read;       /* in seconds */
00773         int timeout_write;      /* in seconds */
00774 
00775         short enabled;  /* events that are currently enabled */
00776 };
00777 #endif
00778 
00813 struct bufferevent *bufferevent_new(int fd,
00814     evbuffercb readcb, evbuffercb writecb, everrorcb errorcb, void *cbarg);
00815 
00816 
00825 int bufferevent_base_set(struct event_base *base, struct bufferevent *bufev);
00826 
00827 
00835 int bufferevent_priority_set(struct bufferevent *bufev, int pri);
00836 
00837 
00843 void bufferevent_free(struct bufferevent *bufev);
00844 
00845 
00860 void bufferevent_setcb(struct bufferevent *bufev,
00861     evbuffercb readcb, evbuffercb writecb, everrorcb errorcb, void *cbarg);
00862 
00869 void bufferevent_setfd(struct bufferevent *bufev, int fd);
00870 
00884 int bufferevent_write(struct bufferevent *bufev,
00885     const void *data, size_t size);
00886 
00887 
00897 int bufferevent_write_buffer(struct bufferevent *bufev, struct evbuffer *buf);
00898 
00899 
00910 size_t bufferevent_read(struct bufferevent *bufev, void *data, size_t size);
00911 
00920 int bufferevent_enable(struct bufferevent *bufev, short event);
00921 
00922 
00931 int bufferevent_disable(struct bufferevent *bufev, short event);
00932 
00933 
00941 void bufferevent_settimeout(struct bufferevent *bufev,
00942     int timeout_read, int timeout_write);
00943 
00944 
00961 void bufferevent_setwatermark(struct bufferevent *bufev, short events,
00962     size_t lowmark, size_t highmark);
00963 
00964 #define EVBUFFER_LENGTH(x)      (x)->off
00965 #define EVBUFFER_DATA(x)        (x)->buffer
00966 #define EVBUFFER_INPUT(x)       (x)->input
00967 #define EVBUFFER_OUTPUT(x)      (x)->output
00968 
00969 
00976 struct evbuffer *evbuffer_new(void);
00977 
00978 
00984 void evbuffer_free(struct evbuffer *);
00985 
00986 
00996 int evbuffer_expand(struct evbuffer *, size_t);
00997 
00998 
01006 int evbuffer_add(struct evbuffer *, const void *, size_t);
01007 
01008 
01009 
01018 int evbuffer_remove(struct evbuffer *, void *, size_t);
01019 
01020 
01030 char *evbuffer_readline(struct evbuffer *);
01031 
01032 
01043 int evbuffer_add_buffer(struct evbuffer *, struct evbuffer *);
01044 
01045 
01054 int evbuffer_add_printf(struct evbuffer *, const char *fmt, ...)
01055 #ifdef __GNUC__
01056   __attribute__((format(printf, 2, 3)))
01057 #endif
01058 ;
01059 
01060 
01069 int evbuffer_add_vprintf(struct evbuffer *, const char *fmt, va_list ap);
01070 
01071 
01078 void evbuffer_drain(struct evbuffer *, size_t);
01079 
01080 
01091 int evbuffer_write(struct evbuffer *, int);
01092 
01093 
01103 int evbuffer_read(struct evbuffer *, int, int);
01104 
01105 
01114 u_char *evbuffer_find(struct evbuffer *, const u_char *, size_t);
01115 
01123 void evbuffer_setcb(struct evbuffer *, void (*)(struct evbuffer *, size_t, size_t, void *), void *);
01124 
01125 /*
01126  * Marshaling tagged data - We assume that all tags are inserted in their
01127  * numeric order - so that unknown tags will always be higher than the
01128  * known ones - and we can just ignore the end of an event buffer.
01129  */
01130 
01131 void evtag_init(void);
01132 
01133 void evtag_marshal(struct evbuffer *evbuf, ev_uint32_t tag, const void *data,
01134     ev_uint32_t len);
01135 
01146 void encode_int(struct evbuffer *evbuf, ev_uint32_t number);
01147 
01148 void evtag_marshal_int(struct evbuffer *evbuf, ev_uint32_t tag,
01149     ev_uint32_t integer);
01150 
01151 void evtag_marshal_string(struct evbuffer *buf, ev_uint32_t tag,
01152     const char *string);
01153 
01154 void evtag_marshal_timeval(struct evbuffer *evbuf, ev_uint32_t tag,
01155     struct timeval *tv);
01156 
01157 int evtag_unmarshal(struct evbuffer *src, ev_uint32_t *ptag,
01158     struct evbuffer *dst);
01159 int evtag_peek(struct evbuffer *evbuf, ev_uint32_t *ptag);
01160 int evtag_peek_length(struct evbuffer *evbuf, ev_uint32_t *plength);
01161 int evtag_payload_length(struct evbuffer *evbuf, ev_uint32_t *plength);
01162 int evtag_consume(struct evbuffer *evbuf);
01163 
01164 int evtag_unmarshal_int(struct evbuffer *evbuf, ev_uint32_t need_tag,
01165     ev_uint32_t *pinteger);
01166 
01167 int evtag_unmarshal_fixed(struct evbuffer *src, ev_uint32_t need_tag,
01168     void *data, size_t len);
01169 
01170 int evtag_unmarshal_string(struct evbuffer *evbuf, ev_uint32_t need_tag,
01171     char **pstring);
01172 
01173 int evtag_unmarshal_timeval(struct evbuffer *evbuf, ev_uint32_t need_tag,
01174     struct timeval *ptv);
01175 
01176 #ifdef __cplusplus
01177 }
01178 #endif
01179 
01180 #endif /* _EVENT_H_ */

Generated on Thu Feb 11 14:06:55 2010 for libevent by  doxygen 1.4.7