include/event2/event.h

Go to the documentation of this file.

/*
 * Copyright (c) 2000-2007 Niels Provos <provos@citi.umich.edu>
 * Copyright (c) 2007-2009 Niels Provos and Nick Mathewson
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef _EVENT2_EVENT_H_
#define _EVENT2_EVENT_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <event-config.h>
#ifdef _EVENT_HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef _EVENT_HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#include <stdio.h>

/* For int types. */
#include <event2/util.h>

#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#undef WIN32_LEAN_AND_MEAN
#endif

struct event_base;
struct event;
struct event_config;

struct event_base *event_base_new(void);

int event_reinit(struct event_base *base);

int event_base_dispatch(struct event_base *);

const char *event_base_get_method(struct event_base *);

const char **event_get_supported_methods(void);

struct event_config *event_config_new(void);

void event_config_free(struct event_config *cfg);

int event_config_avoid_method(struct event_config *cfg, const char *method);

enum event_method_feature {
    /* Require an event method that allows edge-triggered events with EV_ET. */
    EV_FEATURE_ET = 0x01,
    /* Require an event method where having one event triggered among
     * many is [approximately] an O(1) operation. This excludes (for
     * example) select and poll, which are approximately O(N) for N
     * equal to the total number of possible events. */
    EV_FEATURE_O1 = 0x02,
    /* Require an event method that allows file descriptors as well as
     * sockets. */
    EV_FEATURE_FDS = 0x04,
};

enum event_base_config_flag {
        EVENT_BASE_FLAG_NOLOCK = 0x01,
};

enum event_method_feature event_base_get_features(struct event_base *base);

int event_config_require_features(struct event_config *cfg,
                                  enum event_method_feature feature);

int event_config_set_flag(struct event_config *cfg,
    enum event_base_config_flag flag);

struct event_base *event_base_new_with_config(struct event_config *cfg);

void event_base_free(struct event_base *);

#define _EVENT_LOG_DEBUG 0
#define _EVENT_LOG_MSG   1
#define _EVENT_LOG_WARN  2
#define _EVENT_LOG_ERR   3
typedef void (*event_log_cb)(int severity, const char *msg);
void event_set_log_callback(event_log_cb cb);

int event_base_set(struct event_base *, struct event *);

#define EVLOOP_ONCE     0x01    
#define EVLOOP_NONBLOCK 0x02    


int event_base_loop(struct event_base *, int);

int event_base_loopexit(struct event_base *, const struct timeval *);

int event_base_loopbreak(struct event_base *);

/* Flags to pass to event_set(), event_new(), event_assign(),
 * event_pending(), and anything else with an argument of the form
 * "short events" */
#define EV_TIMEOUT      0x01
#define EV_READ         0x02
#define EV_WRITE        0x04
#define EV_SIGNAL       0x08

#define EV_PERSIST      0x10

#define EV_ET       0x20

#define evtimer_set(ev, cb, arg)        event_set(ev, -1, 0, cb, arg)
#define evtimer_assign(ev, b, cb, arg)  event_assign(ev, b, -1, 0, cb, arg)
#define evtimer_new(b, cb, arg)         event_new(b, -1, 0, cb, arg)

#define evtimer_add(ev, tv)             event_add(ev, tv)

#define evtimer_del(ev)                 event_del(ev)
#define evtimer_pending(ev, tv)         event_pending(ev, EV_TIMEOUT, tv)
#define evtimer_initialized(ev)         _event_initialized((ev), 0)

#define evsignal_add(ev, tv)            event_add(ev, tv)
#define evsignal_set(ev, x, cb, arg)    \
        event_set(ev, x, EV_SIGNAL|EV_PERSIST, cb, arg)
#define evsignal_assign(ev, b, x, cb, arg)                   \
        event_assign(ev, b, x, EV_SIGNAL|EV_PERSIST, cb, arg)
#define evsignal_new(b, x, cb, arg) \
        event_new(b, x, EV_SIGNAL|EV_PERSIST, cb, arg)
#define evsignal_del(ev)                event_del(ev)
#define evsignal_pending(ev, tv)        event_pending(ev, EV_SIGNAL, tv)
#define evsignal_initialized(ev)        _event_initialized((ev), 0)

void event_set(struct event *, evutil_socket_t, short, void (*)(evutil_socket_t, short, void *), void *);


void event_assign(struct event *, struct event_base *, evutil_socket_t, short, void (*)(evutil_socket_t, short, void *), void *);

struct event *event_new(struct event_base *, evutil_socket_t, short, void (*)(evutil_socket_t, short, void *), void *);

void event_free(struct event *);

int event_base_once(struct event_base *, evutil_socket_t, short, void (*)(evutil_socket_t, short, void *), void *, const struct timeval *);

int event_add(struct event *, const struct timeval *);

int event_del(struct event *);


void event_active(struct event *, int, short);


int event_pending(struct event *, short, struct timeval *);


#define event_initialized(ev)           _event_initialized((ev), 1)

int _event_initialized(struct event *, int check_fd);

#define event_get_signal(ev) ((int)event_get_fd(ev))

evutil_socket_t event_get_fd(struct event *ev);

#ifndef EVENT_FD
/* We haven't included event_struct.h, so define these as function calls
 * rather than as direct struct access.  If we include event_struct.h later,
 * these macros will be overridden. */
#define EVENT_FD(ev)            ((int)event_get_fd(ev))
#define EVENT_SIGNAL(ev)        ((int)event_get_fd(ev))
#endif

const char *event_get_version(void);

ev_uint32_t event_get_version_number(void);

#define LIBEVENT_VERSION _EVENT_VERSION

#define LIBEVENT_VERSION_NUMBER _EVENT_NUMERIC_VERSION

int     event_base_priority_init(struct event_base *, int);


int     event_priority_set(struct event *, int);

#ifndef _EVENT_DISABLE_MM_REPLACEMENT

void event_set_mem_functions(void *(*malloc_fn)(size_t sz),
                             void *(*realloc_fn)(void *ptr, size_t sz),
                             void (*free_fn)(void *ptr));
#endif

void event_base_dump_events(struct event_base *, FILE *);

#ifdef __cplusplus
}
#endif

#endif /* _EVENT2_EVENT_H_ */

---