EIC code displayed by LXR master/​include/​event2/​event.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:57:12

 /*
  * Copyright (c) 2000-2007 Niels Provos <provos@citi.umich.edu>
  * Copyright (c) 2007-2012 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_INCLUDED_
 #define EVENT2_EVENT_H_INCLUDED_
 
 /**
    @mainpage
 
   @section intro Introduction
 
   Libevent is an event notification library for developing scalable network
   servers.  The Libevent API provides a mechanism to execute a callback
   function when a specific event occurs on a file descriptor or after a
   timeout has been reached. Furthermore, Libevent also support callbacks due
   to signals or regular timeouts.
 
   Libevent is meant to replace the event loop found in event driven network
   servers. An application just needs to call event_base_dispatch() and then add or
   remove events dynamically without having to change the event loop.
 
 
   Currently, Libevent supports /dev/poll, kqueue(2), select(2), poll(2),
   epoll(4), and evports. The internal event mechanism is completely
   independent of the exposed event API, and a simple update of Libevent can
   provide new functionality without having to redesign the applications. As a
   result, Libevent allows for portable application development and provides
   the most scalable event notification mechanism available on an operating
   system.  Libevent can also be used for multithreaded programs.  Libevent
   should compile on Linux, *BSD, Mac OS X, Solaris and, Windows.
 
   @section usage Standard usage
 
   Every program that uses Libevent must include the <event2/event.h>
   header, and pass the -levent flag to the linker.  (You can instead link
   -levent_core if you only want the main event and buffered IO-based code,
   and don't want to link any protocol code.)
 
   @section setup Library setup
 
   Before you call any other Libevent functions, you need to set up the
   library.  If you're going to use Libevent from multiple threads in a
   multithreaded application, you need to initialize thread support --
   typically by using evthread_use_pthreads() or
   evthread_use_windows_threads().  See <event2/thread.h> for more
   information.
 
   This is also the point where you can replace Libevent's memory
   management functions with event_set_mem_functions, and enable debug mode
   with event_enable_debug_mode().
 
   @section base Creating an event base
 
   Next, you need to create an event_base structure, using event_base_new()
   or event_base_new_with_config().  The event_base is responsible for
   keeping track of which events are "pending" (that is to say, being
   watched to see if they become active) and which events are "active".
   Every event is associated with a single event_base.
 
   @section event Event notification
 
   For each file descriptor that you wish to monitor, you must create an
   event structure with event_new().  (You may also declare an event
   structure and call event_assign() to initialize the members of the
   structure.)  To enable notification, you add the structure to the list
   of monitored events by calling event_add().  The event structure must
   remain allocated as long as it is active, so it should generally be
   allocated on the heap.
 
   @section loop Dispatching events.
 
   Finally, you call event_base_dispatch() to loop and dispatch events.
   You can also use event_base_loop() for more fine-grained control.
 
   Currently, only one thread can be dispatching a given event_base at a
   time.  If you want to run events in multiple threads at once, you can
   either have a single event_base whose events add work to a work queue,
   or you can create multiple event_base objects.
 
   @section bufferevent I/O Buffers
 
   Libevent provides a buffered I/O abstraction on top of the regular event
   callbacks. This abstraction is called a bufferevent. A bufferevent
   provides input and output buffers that get filled and drained
   automatically. The user of a buffered event no longer deals directly
   with the I/O, but instead is reading from input and writing to output
   buffers.
 
   Once initialized via bufferevent_socket_new(), the bufferevent structure
   can be used repeatedly with bufferevent_enable() and
   bufferevent_disable().  Instead of reading and writing directly to a
   socket, you would call bufferevent_read() and bufferevent_write().
 
   When read enabled the bufferevent will try to read from the file descriptor
   and call the read callback. The write callback is executed whenever the
   output buffer is drained below the write low watermark, which is 0 by
   default.
 
   See <event2/bufferevent*.h> for more information.
 
   @section timers Timers
 
   Libevent can also be used to create timers that invoke a callback after a
   certain amount of time has expired. The evtimer_new() macro returns
   an event struct to use as a timer. To activate the timer, call
   evtimer_add(). Timers can be deactivated by calling evtimer_del().
   (These macros are thin wrappers around event_new(), event_add(),
   and event_del(); you can also use those instead.)
 
   @section evdns Asynchronous DNS resolution
 
   Libevent provides an asynchronous DNS resolver that should be used instead
   of the standard DNS resolver functions.  See the <event2/dns.h>
   functions for more detail.
 
   @section evhttp Event-driven HTTP servers
 
   Libevent provides a very simple event-driven HTTP server that can be
   embedded in your program and used to service HTTP requests.
 
   To use this capability, you need to include the <event2/http.h> header in your
   program.  See that header for more information.
 
   @section evrpc A framework for RPC servers and clients
 
   Libevent provides a framework for creating RPC servers and clients.  It
   takes care of marshaling and unmarshaling all data structures.
 
   @section api API Reference
 
   To browse the complete documentation of the libevent API, click on any of
   the following links.
 
   event2/event.h
   The primary libevent header
 
   event2/thread.h
   Functions for use by multithreaded programs
 
   event2/buffer.h and event2/bufferevent.h
   Buffer management for network reading and writing
 
   event2/util.h
   Utility functions for portable nonblocking network code
 
   event2/dns.h
   Asynchronous DNS resolution
 
   event2/http.h
   An embedded libevent-based HTTP server
 
   event2/rpc.h
   A framework for creating RPC servers and clients
 
  */
 
 /** @file event2/event.h
 
   Core functions for waiting for and receiving events, and using event bases.
 */
 
 #include <event2/visibility.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #include <event2/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>
 
 /**
  * Structure to hold information and state for a Libevent dispatch loop.
  *
  * The event_base lies at the center of Libevent; every application will
  * have one.  It keeps track of all pending and active events, and
  * notifies your application of the active ones.
  *
  * This is an opaque structure; you can allocate one using
  * event_base_new() or event_base_new_with_config().
  *
  * @see event_base_new(), event_base_free(), event_base_loop(),
  *    event_base_new_with_config()
  */
 struct event_base
 #ifdef EVENT_IN_DOXYGEN_
 {/*Empty body so that doxygen will generate documentation here.*/}
 #endif
 ;
 
 /**
  * @struct event
  *
  * Structure to represent a single event.
  *
  * An event can have some underlying condition it represents: a socket
  * becoming readable or writeable (or both), or a signal becoming raised.
  * (An event that represents no underlying condition is still useful: you
  * can use one to implement a timer, or to communicate between threads.)
  *
  * Generally, you can create events with event_new(), then make them
  * pending with event_add().  As your event_base runs, it will run the
  * callbacks of an events whose conditions are triggered.  When you no
  * longer want the event, free it with event_free().
  *
  * In more depth:
  *
  * An event may be "pending" (one whose condition we are watching),
  * "active" (one whose condition has triggered and whose callback is about
  * to run), neither, or both.  Events come into existence via
  * event_assign() or event_new(), and are then neither active nor pending.
  *
  * To make an event pending, pass it to event_add().  When doing so, you
  * can also set a timeout for the event.
  *
  * Events become active during an event_base_loop() call when either their
  * condition has triggered, or when their timeout has elapsed.  You can
  * also activate an event manually using event_active().  The even_base
  * loop will run the callbacks of active events; after it has done so, it
  * marks them as no longer active.
  *
  * You can make an event non-pending by passing it to event_del().  This
  * also makes the event non-active.
  *
  * Events can be "persistent" or "non-persistent".  A non-persistent event
  * becomes non-pending as soon as it is triggered: thus, it only runs at
  * most once per call to event_add().  A persistent event remains pending
  * even when it becomes active: you'll need to event_del() it manually in
  * order to make it non-pending.  When a persistent event with a timeout
  * becomes active, its timeout is reset: this means you can use persistent
  * events to implement periodic timeouts.
  *
  * This should be treated as an opaque structure; you should never read or
  * write any of its fields directly.  For backward compatibility with old
  * code, it is defined in the event2/event_struct.h header; including this
  * header may make your code incompatible with other versions of Libevent.
  *
  * @see event_new(), event_free(), event_assign(), event_get_assignment(),
  *    event_add(), event_del(), event_active(), event_pending(),
  *    event_get_fd(), event_get_base(), event_get_events(),
  *    event_get_callback(), event_get_callback_arg(),
  *    event_priority_set()
  */
 struct event
 #ifdef EVENT_IN_DOXYGEN_
 {/*Empty body so that doxygen will generate documentation here.*/}
 #endif
 ;
 
 /**
  * Configuration for an event_base.
  *
  * There are many options that can be used to alter the behavior and
  * implementation of an event_base.  To avoid having to pass them all in a
  * complex many-argument constructor, we provide an abstract data type
  * where you set up configuration information before passing it to
  * event_base_new_with_config().
  *
  * @see event_config_new(), event_config_free(), event_base_new_with_config(),
  *   event_config_avoid_method(), event_config_require_features(),
  *   event_config_set_flag(), event_config_set_num_cpus_hint()
  */
 struct event_config
 #ifdef EVENT_IN_DOXYGEN_
 {/*Empty body so that doxygen will generate documentation here.*/}
 #endif
 ;
 
 /**
  * Enable some relatively expensive debugging checks in Libevent that
  * would normally be turned off.  Generally, these checks cause code that
  * would otherwise crash mysteriously to fail earlier with an assertion
  * failure.  Note that this method MUST be called before any events or
  * event_bases have been created.
  *
  * Debug mode can currently catch the following errors:
  *    An event is re-assigned while it is added
  *    Any function is called on a non-assigned event
  *
  * Note that debugging mode uses memory to track every event that has been
  * initialized (via event_assign, event_set, or event_new) but not yet
  * released (via event_free or event_debug_unassign).  If you want to use
  * debug mode, and you find yourself running out of memory, you will need
  * to use event_debug_unassign to explicitly stop tracking events that
  * are no longer considered set-up.
  *
  * @see event_debug_unassign()
  */
 EVENT2_EXPORT_SYMBOL
 void event_enable_debug_mode(void);
 
 /**
  * When debugging mode is enabled, informs Libevent that an event should no
  * longer be considered as assigned. When debugging mode is not enabled, does
  * nothing.
  *
  * This function must only be called on a non-added event.
  *
  * @see event_enable_debug_mode()
  */
 EVENT2_EXPORT_SYMBOL
 void event_debug_unassign(struct event *);
 
 /**
  * Create and return a new event_base to use with the rest of Libevent.
  *
  * @return a new event_base on success, or NULL on failure.
  *
  * @see event_base_free(), event_base_new_with_config()
  */
 EVENT2_EXPORT_SYMBOL
 struct event_base *event_base_new(void);
 
 /**
   Reinitialize the event base after a fork
 
   Some event mechanisms do not survive across fork.   The event base needs
   to be reinitialized with the event_reinit() function.
 
   @param base the event base that needs to be re-initialized
   @return 0 if successful, or -1 if some events could not be re-added.
   @see event_base_new()
 */
 EVENT2_EXPORT_SYMBOL
 int event_reinit(struct event_base *base);
 
 /**
    Event dispatching loop
 
   This loop will run the event base until either there are no more pending or
   active, or until something calls event_base_loopbreak() or
   event_base_loopexit().
 
   @param base the event_base structure returned by event_base_new() or
      event_base_new_with_config()
   @return 0 if successful, -1 if an error occurred, or 1 if we exited because
      no events were pending or active.
   @see event_base_loop()
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_dispatch(struct event_base *);
 
 /**
  Get the kernel event notification mechanism used by Libevent.
 
  @param eb the event_base structure returned by event_base_new()
  @return a string identifying the kernel event mechanism (kqueue, epoll, etc.)
  */
 EVENT2_EXPORT_SYMBOL
 const char *event_base_get_method(const struct event_base *);
 
 /**
    Gets all event notification mechanisms supported by Libevent.
 
    This functions returns the event mechanism in order preferred by
    Libevent.  Note that this list will include all backends that
    Libevent has compiled-in support for, and will not necessarily check
    your OS to see whether it has the required resources.
 
    @return an array with pointers to the names of support methods.
      The end of the array is indicated by a NULL pointer.  If an
      error is encountered NULL is returned.
 */
 EVENT2_EXPORT_SYMBOL
 const char **event_get_supported_methods(void);
 
 /** Query the current monotonic time from a the timer for a struct
  * event_base.
  */
 EVENT2_EXPORT_SYMBOL
 int event_gettime_monotonic(struct event_base *base, struct timeval *tp);
 
 /**
    @name event type flag
 
    Flags to pass to event_base_get_num_events() to specify the kinds of events
    we want to aggregate counts for
 */
 /**@{*/
 /** count the number of active events, which have been triggered.*/
 #define EVENT_BASE_COUNT_ACTIVE                1U
 /** count the number of virtual events, which is used to represent an internal
  * condition, other than a pending event, that keeps the loop from exiting. */
 #define EVENT_BASE_COUNT_VIRTUAL       2U
 /** count the number of events which have been added to event base, including
  * internal events. */
 #define EVENT_BASE_COUNT_ADDED         4U
 /**@}*/
 
 /**
    Gets the number of events in event_base, as specified in the flags.
 
    Since event base has some internal events added to make some of its
    functionalities work, EVENT_BASE_COUNT_ADDED may return more than the
    number of events you added using event_add().
 
    If you pass EVENT_BASE_COUNT_ACTIVE and EVENT_BASE_COUNT_ADDED together, an
    active event will be counted twice. However, this might not be the case in
    future libevent versions.  The return value is an indication of the work
    load, but the user shouldn't rely on the exact value as this may change in
    the future.
 
    @param eb the event_base structure returned by event_base_new()
    @param flags a bitwise combination of the kinds of events to aggregate
        counts for
    @return the number of events specified in the flags
 */
 EVENT2_EXPORT_SYMBOL
 int event_base_get_num_events(struct event_base *, unsigned int);
 
 /**
   Get the maximum number of events in a given event_base as specified in the
   flags.
 
   @param eb the event_base structure returned by event_base_new()
   @param flags a bitwise combination of the kinds of events to aggregate
          counts for
   @param clear option used to reset the maximum count.
   @return the number of events specified in the flags
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_get_max_events(struct event_base *, unsigned int, int);
 
 /**
    Allocates a new event configuration object.
 
    The event configuration object can be used to change the behavior of
    an event base.
 
    @return an event_config object that can be used to store configuration, or
      NULL if an error is encountered.
    @see event_base_new_with_config(), event_config_free(), event_config
 */
 EVENT2_EXPORT_SYMBOL
 struct event_config *event_config_new(void);
 
 /**
    Deallocates all memory associated with an event configuration object
 
    @param cfg the event configuration object to be freed.
 */
 EVENT2_EXPORT_SYMBOL
 void event_config_free(struct event_config *cfg);
 
 /**
    Enters an event method that should be avoided into the configuration.
 
    This can be used to avoid event mechanisms that do not support certain
    file descriptor types, or for debugging to avoid certain event
    mechanisms.  An application can make use of multiple event bases to
    accommodate incompatible file descriptor types.
 
    @param cfg the event configuration object
    @param method the name of the event method to avoid
    @return 0 on success, -1 on failure.
 */
 EVENT2_EXPORT_SYMBOL
 int event_config_avoid_method(struct event_config *cfg, const char *method);
 
 /**
    A flag used to describe which features an event_base (must) provide.
 
    Because of OS limitations, not every Libevent backend supports every
    possible feature.  You can use this type with
    event_config_require_features() to tell Libevent to only proceed if your
    event_base implements a given feature, and you can receive this type from
    event_base_get_features() to see which features are available.
 */
 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,
     /** Require an event method that allows you to use EV_CLOSED to detect
      * connection close without the necessity of reading all the pending data.
      *
      * Methods that do support EV_CLOSED may not be able to provide support on
      * all kernel versions.
      **/
     EV_FEATURE_EARLY_CLOSE = 0x08
 };
 
 /**
    A flag passed to event_config_set_flag().
 
     These flags change the behavior of an allocated event_base.
 
     @see event_config_set_flag(), event_base_new_with_config(),
        event_method_feature
  */
 enum event_base_config_flag {
     /** Do not allocate a lock for the event base, even if we have
         locking set up.
 
         Setting this option will make it unsafe and nonfunctional to call
         functions on the base concurrently from multiple threads.
     */
     EVENT_BASE_FLAG_NOLOCK = 0x01,
     /** Do not check the EVENT_* environment variables when configuring
         an event_base  */
     EVENT_BASE_FLAG_IGNORE_ENV = 0x02,
     /** Windows only: enable the IOCP dispatcher at startup
 
         If this flag is set then bufferevent_socket_new() and
         evconn_listener_new() will use IOCP-backed implementations
         instead of the usual select-based one on Windows.
      */
     EVENT_BASE_FLAG_STARTUP_IOCP = 0x04,
     /** Instead of checking the current time every time the event loop is
         ready to run timeout callbacks, check after each timeout callback.
      */
     EVENT_BASE_FLAG_NO_CACHE_TIME = 0x08,
 
     /** If we are using the epoll backend, this flag says that it is
         safe to use Libevent's internal change-list code to batch up
         adds and deletes in order to try to do as few syscalls as
         possible.  Setting this flag can make your code run faster, but
         it may trigger a Linux bug: it is not safe to use this flag
         if you have any fds cloned by dup() or its variants.  Doing so
         will produce strange and hard-to-diagnose bugs.
 
         This flag can also be activated by setting the
         EVENT_EPOLL_USE_CHANGELIST environment variable.
 
         This flag has no effect if you wind up using a backend other than
         epoll.
      */
     EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST = 0x10,
 
     /** Ordinarily, Libevent implements its time and timeout code using
         the fastest monotonic timer that we have.  If this flag is set,
         however, we use less efficient more precise timer, assuming one is
         present.
      */
     EVENT_BASE_FLAG_PRECISE_TIMER = 0x20
 };
 
 /**
    Return a bitmask of the features implemented by an event base.  This
    will be a bitwise OR of one or more of the values of
    event_method_feature
 
    @see event_method_feature
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_get_features(const struct event_base *base);
 
 /**
    Enters a required event method feature that the application demands.
 
    Note that not every feature or combination of features is supported
    on every platform.  Code that requests features should be prepared
    to handle the case where event_base_new_with_config() returns NULL, as in:
    <pre>
      event_config_require_features(cfg, EV_FEATURE_ET);
      base = event_base_new_with_config(cfg);
      if (base == NULL) {
        // We can't get edge-triggered behavior here.
        event_config_require_features(cfg, 0);
        base = event_base_new_with_config(cfg);
      }
    </pre>
 
    @param cfg the event configuration object
    @param feature a bitfield of one or more event_method_feature values.
           Replaces values from previous calls to this function.
    @return 0 on success, -1 on failure.
    @see event_method_feature, event_base_new_with_config()
 */
 EVENT2_EXPORT_SYMBOL
 int event_config_require_features(struct event_config *cfg, int feature);
 
 /**
  * Sets one or more flags to configure what parts of the eventual event_base
  * will be initialized, and how they'll work.
  *
  * @see event_base_config_flags, event_base_new_with_config()
  **/
 EVENT2_EXPORT_SYMBOL
 int event_config_set_flag(struct event_config *cfg, int flag);
 
 /**
  * Records a hint for the number of CPUs in the system. This is used for
  * tuning thread pools, etc, for optimal performance.  In Libevent 2.0,
  * it is only on Windows, and only when IOCP is in use.
  *
  * @param cfg the event configuration object
  * @param cpus the number of cpus
  * @return 0 on success, -1 on failure.
  */
 EVENT2_EXPORT_SYMBOL
 int event_config_set_num_cpus_hint(struct event_config *cfg, int cpus);
 
 /**
  * Record an interval and/or a number of callbacks after which the event base
  * should check for new events.  By default, the event base will run as many
  * events are as activated at the highest activated priority before checking
  * for new events.  If you configure it by setting max_interval, it will check
  * the time after each callback, and not allow more than max_interval to
  * elapse before checking for new events.  If you configure it by setting
  * max_callbacks to a value >= 0, it will run no more than max_callbacks
  * callbacks before checking for new events.
  *
  * This option can decrease the latency of high-priority events, and
  * avoid priority inversions where multiple low-priority events keep us from
  * polling for high-priority events, but at the expense of slightly decreasing
  * the throughput.  Use it with caution!
  *
  * @param cfg The event_base configuration object.
  * @param max_interval An interval after which Libevent should stop running
  *     callbacks and check for more events, or NULL if there should be
  *     no such interval.
  * @param max_callbacks A number of callbacks after which Libevent should
  *     stop running callbacks and check for more events, or -1 if there
  *     should be no such limit.
  * @param min_priority A priority below which max_interval and max_callbacks
  *     should not be enforced.  If this is set to 0, they are enforced
  *     for events of every priority; if it's set to 1, they're enforced
  *     for events of priority 1 and above, and so on.
  * @return 0 on success, -1 on failure.
  **/
 EVENT2_EXPORT_SYMBOL
 int event_config_set_max_dispatch_interval(struct event_config *cfg,
     const struct timeval *max_interval, int max_callbacks,
     int min_priority);
 
 /**
   Initialize the event API.
 
   Use event_base_new_with_config() to initialize a new event base, taking
   the specified configuration under consideration.  The configuration object
   can currently be used to avoid certain event notification mechanisms.
 
   @param cfg the event configuration object
   @return an initialized event_base that can be used to registering events,
      or NULL if no event base can be created with the requested event_config.
   @see event_base_new(), event_base_free(), event_init(), event_assign()
 */
 EVENT2_EXPORT_SYMBOL
 struct event_base *event_base_new_with_config(const struct event_config *);
 
 /**
   Deallocate all memory associated with an event_base, and free the base.
 
   Note that this function will not close any fds or free any memory passed
   to event_new as the argument to callback.
 
   If there are any pending finalizer callbacks, this function will invoke
   them.
 
   @param eb an event_base to be freed
  */
 EVENT2_EXPORT_SYMBOL
 void event_base_free(struct event_base *);
 
 /**
    As event_base_free, but do not run finalizers.
  */
 EVENT2_EXPORT_SYMBOL
 void event_base_free_nofinalize(struct event_base *);
 
 /** @name Log severities
  */
 /**@{*/
 #define EVENT_LOG_DEBUG 0
 #define EVENT_LOG_MSG   1
 #define EVENT_LOG_WARN  2
 #define EVENT_LOG_ERR   3
 /**@}*/
 
 /* Obsolete names: these are deprecated, but older programs might use them.
  * They violate the reserved-identifier namespace. */
 #define _EVENT_LOG_DEBUG EVENT_LOG_DEBUG
 #define _EVENT_LOG_MSG EVENT_LOG_MSG
 #define _EVENT_LOG_WARN EVENT_LOG_WARN
 #define _EVENT_LOG_ERR EVENT_LOG_ERR
 
 /**
   A callback function used to intercept Libevent's log messages.
 
   @see event_set_log_callback
  */
 typedef void (*event_log_cb)(int severity, const char *msg);
 /**
   Redirect Libevent's log messages.
 
   @param cb a function taking two arguments: an integer severity between
      EVENT_LOG_DEBUG and EVENT_LOG_ERR, and a string.  If cb is NULL,
      then the default log is used.
 
   NOTE: The function you provide *must not* call any other libevent
   functionality.  Doing so can produce undefined behavior.
   */
 EVENT2_EXPORT_SYMBOL
 void event_set_log_callback(event_log_cb cb);
 
 /**
    A function to be called if Libevent encounters a fatal internal error.
 
    @see event_set_fatal_callback
  */
 typedef void (*event_fatal_cb)(int err);
 
 /**
  Override Libevent's behavior in the event of a fatal internal error.
 
  By default, Libevent will call exit(1) if a programming error makes it
  impossible to continue correct operation.  This function allows you to supply
  another callback instead.  Note that if the function is ever invoked,
  something is wrong with your program, or with Libevent: any subsequent calls
  to Libevent may result in undefined behavior.
 
  Libevent will (almost) always log an EVENT_LOG_ERR message before calling
  this function; look at the last log message to see why Libevent has died.
  */
 EVENT2_EXPORT_SYMBOL
 void event_set_fatal_callback(event_fatal_cb cb);
 
 #define EVENT_DBG_ALL 0xffffffffu
 #define EVENT_DBG_NONE 0
 
 /**
  Turn on debugging logs and have them sent to the default log handler.
 
  This is a global setting; if you are going to call it, you must call this
  before any calls that create an event-base.  You must call it before any
  multithreaded use of Libevent.
 
  Debug logs are verbose.
 
  @param which Controls which debug messages are turned on.  This option is
    unused for now; for forward compatibility, you must pass in the constant
    "EVENT_DBG_ALL" to turn debugging logs on, or "EVENT_DBG_NONE" to turn
    debugging logs off.
  */
 EVENT2_EXPORT_SYMBOL
 void event_enable_debug_logging(ev_uint32_t which);
 
 /**
   Associate a different event base with an event.
 
   The event to be associated must not be currently active or pending.
 
   @param eb the event base
   @param ev the event
   @return 0 on success, -1 on failure.
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_set(struct event_base *, struct event *);
 
 /** @name Loop flags
 
     These flags control the behavior of event_base_loop().
  */
 /**@{*/
 /** Block until we have an active event, then exit once all active events
  * have had their callbacks run. */
 #define EVLOOP_ONCE 0x01
 /** Do not block: see which events are ready now, run the callbacks
  * of the highest-priority ones, then exit. */
 #define EVLOOP_NONBLOCK 0x02
 /** Do not exit the loop because we have no pending events.  Instead, keep
  * running until event_base_loopexit() or event_base_loopbreak() makes us
  * stop.
  */
 #define EVLOOP_NO_EXIT_ON_EMPTY 0x04
 /**@}*/
 
 /**
   Wait for events to become active, and run their callbacks.
 
   This is a more flexible version of event_base_dispatch().
 
   By default, this loop will run the event base until either there are no more
   pending or active events, or until something calls event_base_loopbreak() or
   event_base_loopexit().  You can override this behavior with the 'flags'
   argument.
 
   @param eb the event_base structure returned by event_base_new() or
      event_base_new_with_config()
   @param flags any combination of EVLOOP_ONCE | EVLOOP_NONBLOCK
   @return 0 if successful, -1 if an error occurred, or 1 if we exited because
      no events were pending or active.
   @see event_base_loopexit(), event_base_dispatch(), EVLOOP_ONCE,
      EVLOOP_NONBLOCK
   */
 EVENT2_EXPORT_SYMBOL
 int event_base_loop(struct event_base *, int);
 
 /**
   Exit the event loop after the specified time
 
   The next event_base_loop() iteration after the given timer expires will
   complete normally (handling all queued events) then exit without
   blocking for events again.
 
   Subsequent invocations of event_base_loop() will proceed normally.
 
   @param eb the event_base structure returned by event_init()
   @param tv the amount of time after which the loop should terminate,
     or NULL to exit after running all currently active events.
   @return 0 if successful, or -1 if an error occurred
   @see event_base_loopbreak()
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_loopexit(struct event_base *, const struct timeval *);
 
 /**
   Abort the active event_base_loop() immediately.
 
   event_base_loop() will abort the loop after the next event is completed;
   event_base_loopbreak() is typically invoked from this event's callback.
   This behavior is analogous to the "break;" statement.
 
   Subsequent invocations of event_base_loop() will proceed normally.
 
   @param eb the event_base structure returned by event_init()
   @return 0 if successful, or -1 if an error occurred
   @see event_base_loopexit()
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_loopbreak(struct event_base *);
 
 /**
   Tell the active event_base_loop() to scan for new events immediately.
 
   Calling this function makes the currently active event_base_loop()
   start the loop over again (scanning for new events) after the current
   event callback finishes.  If the event loop is not running, this
   function has no effect.
 
   event_base_loopbreak() is typically invoked from this event's callback.
   This behavior is analogous to the "continue;" statement.
 
   Subsequent invocations of event loop will proceed normally.
 
   @param eb the event_base structure returned by event_init()
   @return 0 if successful, or -1 if an error occurred
   @see event_base_loopbreak()
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_loopcontinue(struct event_base *);
 
 /**
   Checks if the event loop was told to exit by event_base_loopexit().
 
   This function will return true for an event_base at every point after
   event_loopexit() is called, until the event loop is next entered.
 
   @param eb the event_base structure returned by event_init()
   @return true if event_base_loopexit() was called on this event base,
     or 0 otherwise
   @see event_base_loopexit()
   @see event_base_got_break()
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_got_exit(struct event_base *);
 
 /**
   Checks if the event loop was told to abort immediately by event_base_loopbreak().
 
   This function will return true for an event_base at every point after
   event_base_loopbreak() is called, until the event loop is next entered.
 
   @param eb the event_base structure returned by event_init()
   @return true if event_base_loopbreak() was called on this event base,
     or 0 otherwise
   @see event_base_loopbreak()
   @see event_base_got_exit()
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_got_break(struct event_base *);
 
 /**
  * @name event flags
  *
  * Flags to pass to event_new(), event_assign(), event_pending(), and
  * anything else with an argument of the form "short events"
  */
 /**@{*/
 /** Indicates that a timeout has occurred.  It's not necessary to pass
  * this flag to event_for new()/event_assign() to get a timeout. */
 #define EV_TIMEOUT  0x01
 /** Wait for a socket or FD to become readable */
 #define EV_READ     0x02
 /** Wait for a socket or FD to become writeable */
 #define EV_WRITE    0x04
 /** Wait for a POSIX signal to be raised*/
 #define EV_SIGNAL   0x08
 /**
  * Persistent event: won't get removed automatically when activated.
  *
  * When a persistent event with a timeout becomes activated, its timeout
  * is reset to 0.
  */
 #define EV_PERSIST  0x10
 /** Select edge-triggered behavior, if supported by the backend. */
 #define EV_ET       0x20
 /**
  * If this option is provided, then event_del() will not block in one thread
  * while waiting for the event callback to complete in another thread.
  *
  * To use this option safely, you may need to use event_finalize() or
  * event_free_finalize() in order to safely tear down an event in a
  * multithreaded application.  See those functions for more information.
  **/
 #define EV_FINALIZE     0x40
 /**
  * Detects connection close events.  You can use this to detect when a
  * connection has been closed, without having to read all the pending data
  * from a connection.
  *
  * Not all backends support EV_CLOSED.  To detect or require it, use the
  * feature flag EV_FEATURE_EARLY_CLOSE.
  **/
 #define EV_CLOSED   0x80
 /**@}*/
 
 /**
    @name evtimer_* macros
 
    Aliases for working with one-shot timer events
    If you need EV_PERSIST timer use event_*() functions.
  */
 /**@{*/
 #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)
 /**@}*/
 
 /**
    @name evsignal_* macros
 
    Aliases for working with signal events
  */
 /**@{*/
 #define evsignal_add(ev, tv)        event_add((ev), (tv))
 #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)
 /**@}*/
 
 /**
    @name evuser_* macros
 
    Aliases for working with user-triggered events
    If you need EV_PERSIST event use event_*() functions.
  */
 /**@{*/
 #define evuser_new(b, cb, arg)      event_new((b), -1, 0, (cb), (arg))
 #define evuser_del(ev)          event_del(ev)
 #define evuser_pending(ev, tv)      event_pending((ev), 0, (tv))
 #define evuser_initialized(ev)      event_initialized(ev)
 #define evuser_trigger(ev)      event_active((ev), 0, 0)
 /**@}*/
 
 /**
    A callback function for an event.
 
    It receives three arguments:
 
    @param fd An fd or signal
    @param events One or more EV_* flags
    @param arg A user-supplied argument.
 
    @see event_new()
  */
 typedef void (*event_callback_fn)(evutil_socket_t, short, void *);
 
 /**
   Return a value used to specify that the event itself must be used as the callback argument.
 
   The function event_new() takes a callback argument which is passed
   to the event's callback function. To specify that the argument to be
   passed to the callback function is the event that event_new() returns,
   pass in the return value of event_self_cbarg() as the callback argument
   for event_new().
 
   For example:
   <pre>
       struct event *ev = event_new(base, sock, events, callback, %event_self_cbarg());
   </pre>
 
   For consistency with event_new(), it is possible to pass the return value
   of this function as the callback argument for event_assign() &ndash; this
   achieves the same result as passing the event in directly.
 
   @return a value to be passed as the callback argument to event_new() or
   event_assign().
   @see event_new(), event_assign()
  */
 EVENT2_EXPORT_SYMBOL
 void *event_self_cbarg(void);
 
 /**
   Allocate and assign a new event structure, ready to be added.
 
   The function event_new() returns a new event that can be used in
   future calls to event_add() and event_del().  The fd and events
   arguments determine which conditions will trigger the event; the
   callback and callback_arg arguments tell Libevent what to do when the
   event becomes active.
 
   If events contains one of EV_READ, EV_WRITE, or EV_READ|EV_WRITE, then
   fd is a file descriptor or socket that should get monitored for
   readiness to read, readiness to write, or readiness for either operation
   (respectively).  If events contains EV_SIGNAL, then fd is a signal
   number to wait for.  If events contains none of those flags, then the
   event can be triggered only by a timeout or by manual activation with
   event_active(): In this case, fd must be -1.
 
   The EV_PERSIST flag can also be passed in the events argument: it makes
   event_add() persistent until event_del() is called.
 
   The EV_ET flag is compatible with EV_READ and EV_WRITE, and supported
   only by certain backends.  It tells Libevent to use edge-triggered
   events.
 
   The EV_TIMEOUT flag has no effect here.
 
   It is okay to have multiple events all listening on the same fds; but
   they must either all be edge-triggered, or all not be edge triggered.
 
   When the event becomes active, the event loop will run the provided
   callback function, with three arguments.  The first will be the provided
   fd value.  The second will be a bitfield of the events that triggered:
   EV_READ, EV_WRITE, or EV_SIGNAL.  Here the EV_TIMEOUT flag indicates
   that a timeout occurred, and EV_ET indicates that an edge-triggered
   event occurred.  The third event will be the callback_arg pointer that
   you provide.
 
   @param base the event base to which the event should be attached.
   @param fd the file descriptor or signal to be monitored, or -1.
   @param events desired events to monitor: bitfield of EV_READ, EV_WRITE,
       EV_SIGNAL, EV_PERSIST, EV_ET.
   @param callback callback function to be invoked when the event occurs
   @param callback_arg an argument to be passed to the callback function
 
   @return a newly allocated struct event that must later be freed with
     event_free() or NULL if an error occurred.
   @see event_free(), event_add(), event_del(), event_assign()
  */
 EVENT2_EXPORT_SYMBOL
 struct event *event_new(struct event_base *, evutil_socket_t, short, event_callback_fn, void *);
 
 
 /**
   Prepare a new, already-allocated event structure to be added.
 
   The function event_assign() prepares the event structure ev to be used
   in future calls to event_add() and event_del().  Unlike event_new(), it
   doesn't allocate memory itself: it requires that you have already
   allocated a struct event, probably on the heap.  Doing this will
   typically make your code depend on the size of the event structure, and
   thereby create incompatibility with future versions of Libevent.
 
   The easiest way to avoid this problem is just to use event_new() and
   event_free() instead.
 
   A slightly harder way to future-proof your code is to use
   event_get_struct_event_size() to determine the required size of an event
   at runtime.
 
   Note that it is NOT safe to call this function on an event that is
   active or pending.  Doing so WILL corrupt internal data structures in
   Libevent, and lead to strange, hard-to-diagnose bugs.  You _can_ use
   event_assign to change an existing event, but only if it is not active
   or pending!
 
   The arguments for this function, and the behavior of the events that it
   makes, are as for event_new().
 
   @param ev an event struct to be modified
   @param base the event base to which ev should be attached.
   @param fd the file descriptor to be monitored
   @param events desired events to monitor; can be EV_READ and/or EV_WRITE
   @param callback callback function to be invoked when the event occurs
   @param callback_arg an argument to be passed to the callback function
 
   @return 0 if success, or -1 on invalid arguments.
 
   @see event_new(), event_add(), event_del(), event_base_once(),
     event_get_struct_event_size()
   */
 EVENT2_EXPORT_SYMBOL
 int event_assign(struct event *, struct event_base *, evutil_socket_t, short, event_callback_fn, void *);
 
 /**
    Deallocate a struct event * returned by event_new().
 
    If the event is pending or active, this function makes it non-pending
    and non-active first.
  */
 EVENT2_EXPORT_SYMBOL
 void event_free(struct event *);
 
 /**
  * Callback type for event_finalize and event_free_finalize().
  **/
 typedef void (*event_finalize_callback_fn)(struct event *, void *);
 /**
    @name Finalization functions
 
    These functions are used to safely tear down an event in a multithreaded
    application.  If you construct your events with EV_FINALIZE to avoid
    deadlocks, you will need a way to remove an event in the certainty that
    it will definitely not be running its callback when you deallocate it
    and its callback argument.
 
    To do this, call one of event_finalize() or event_free_finalize with
    0 for its first argument, the event to tear down as its second argument,
    and a callback function as its third argument.  The callback will be
    invoked as part of the event loop, with the event's priority.
 
    After you call a finalizer function, event_add() and event_active() will
    no longer work on the event, and event_del() will produce a no-op. You
    must not try to change the event's fields with event_assign() or
    event_set() while the finalize callback is in progress.  Once the
    callback has been invoked, you should treat the event structure as
    containing uninitialized memory.
 
    The event_free_finalize() function frees the event after it's finalized;
    event_finalize() does not.
 
    A finalizer callback must not make events pending or active.  It must not
    add events, activate events, or attempt to "resuscitate" the event being
    finalized in any way.
 
    @return 0 on success, -1 on failure.
  */
 /**@{*/
 EVENT2_EXPORT_SYMBOL
 int event_finalize(unsigned, struct event *, event_finalize_callback_fn);
 EVENT2_EXPORT_SYMBOL
 int event_free_finalize(unsigned, struct event *, event_finalize_callback_fn);
 /**@}*/
 
 /**
   Schedule a one-time event
 
   The function event_base_once() is similar to event_new().  However, it
   schedules a callback to be called exactly once, and does not require the
   caller to prepare an event structure.
 
   Note that in Libevent 2.0 and earlier, if the event is never triggered, the
   internal memory used to hold it will never be freed.  In Libevent 2.1,
   the internal memory will get freed by event_base_free() if the event
   is never triggered.  The 'arg' value, however, will not get freed in either
   case--you'll need to free that on your own if you want it to go away.
 
   @param base an event_base
   @param fd a file descriptor to monitor, or -1 for no fd.
   @param events event(s) to monitor; can be any of EV_READ |
          EV_WRITE, or EV_TIMEOUT
   @param callback callback function to be invoked when the event occurs
   @param arg an argument to be passed to the callback function
   @param timeout the maximum amount of time to wait for the event. NULL
          makes an EV_READ/EV_WRITE event make forever; NULL makes an
         EV_TIMEOUT event success immediately.
   @return 0 if successful, or -1 if an error occurred
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_once(struct event_base *, evutil_socket_t, short, event_callback_fn, void *, const struct timeval *);
 
 /**
   Add an event to the set of pending events.
 
   The function event_add() schedules the execution of the event 'ev' when the
   condition specified by event_assign() or event_new() occurs, or when the time
   specified in timeout has elapsed.  If a timeout is NULL, no timeout
   occurs and the function will only be
   called if a matching event occurs.  The event in the
   ev argument must be already initialized by event_assign() or event_new()
   and may not be used
   in calls to event_assign() until it is no longer pending.
 
   If the event in the ev argument already has a scheduled timeout, calling
   event_add() replaces the old timeout with the new one if tv is non-NULL.
 
   @param ev an event struct initialized via event_assign() or event_new()
   @param timeout the maximum amount of time to wait for the event, or NULL
          to wait forever
   @return 0 if successful, or -1 if an error occurred
   @see event_del(), event_assign(), event_new()
   */
 EVENT2_EXPORT_SYMBOL
 int event_add(struct event *ev, const struct timeval *timeout);
 
 /**
    Remove a timer from a pending event without removing the event itself.
 
    If the event has a scheduled timeout, this function unschedules it but
    leaves the event otherwise pending.
 
    @param ev an event struct initialized via event_assign() or event_new()
    @return 0 on success, or -1 if an error occurred.
 */
 EVENT2_EXPORT_SYMBOL
 int event_remove_timer(struct event *ev);
 
 /**
   Remove an event from the set of monitored events.
 
   The function event_del() will cancel the event in the argument ev.  If the
   event has already executed or has never been added the call will have no
   effect.
 
   @param ev an event struct to be removed from the working set
   @return 0 if successful, or -1 if an error occurred
   @see event_add()
  */
 EVENT2_EXPORT_SYMBOL
 int event_del(struct event *);
 
 /**
    As event_del(), but never blocks while the event's callback is running
    in another thread, even if the event was constructed without the
    EV_FINALIZE flag.
  */
 EVENT2_EXPORT_SYMBOL
 int event_del_noblock(struct event *ev);
 /**
    As event_del(), but always blocks while the event's callback is running
    in another thread, even if the event was constructed with the
    EV_FINALIZE flag.
  */
 EVENT2_EXPORT_SYMBOL
 int event_del_block(struct event *ev);
 
 /**
   Make an event active.
 
   You can use this function on a pending or a non-pending event to make it
   active, so that its callback will be run by event_base_dispatch() or
   event_base_loop().
 
   One common use in multithreaded programs is to wake the thread running
   event_base_loop() from another thread.
 
   @param ev an event to make active.
   @param res a set of flags to pass to the event's callback.
   @param ncalls an obsolete argument: this is ignored.
  **/
 EVENT2_EXPORT_SYMBOL
 void event_active(struct event *ev, int res, short ncalls);
 
 /**
   Checks if a specific event is pending or scheduled.
 
   @param ev an event struct previously passed to event_add()
   @param events the requested event type; any of EV_TIMEOUT|EV_READ|
          EV_WRITE|EV_SIGNAL
   @param tv if this field is not NULL, and the event has a timeout,
          this field is set to hold the time at which the timeout will
      expire.
 
   @return true if the event is pending on any of the events in 'what', (that
   is to say, it has been added), or 0 if the event is not added.
  */
 EVENT2_EXPORT_SYMBOL
 int event_pending(const struct event *ev, short events, struct timeval *tv);
 
 /**
    If called from within the callback for an event, returns that event.
 
    The behavior of this function is not defined when called from outside the
    callback function for an event.
  */
 EVENT2_EXPORT_SYMBOL
 struct event *event_base_get_running_event(struct event_base *base);
 
 /**
   Test if an event structure might be initialized.
 
   The event_initialized() function can be used to check if an event has been
   initialized.
 
   Warning: This function is only useful for distinguishing a zeroed-out
     piece of memory from an initialized event, it can easily be confused by
     uninitialized memory.  Thus, it should ONLY be used to distinguish an
     initialized event from zero.
 
   @param ev an event structure to be tested
   @return 1 if the structure might be initialized, or 0 if it has not been
           initialized
  */
 EVENT2_EXPORT_SYMBOL
 int event_initialized(const struct event *ev);
 
 /**
    Get the signal number assigned to a signal event
 */
 #define event_get_signal(ev) ((int)event_get_fd(ev))
 
 /**
    Get the socket or signal assigned to an event, or -1 if the event has
    no socket.
 */
 EVENT2_EXPORT_SYMBOL
 evutil_socket_t event_get_fd(const struct event *ev);
 
 /**
    Get the event_base associated with an event.
 */
 EVENT2_EXPORT_SYMBOL
 struct event_base *event_get_base(const struct event *ev);
 
 /**
    Return the events (EV_READ, EV_WRITE, etc) assigned to an event.
 */
 EVENT2_EXPORT_SYMBOL
 short event_get_events(const struct event *ev);
 
 /**
    Return the callback assigned to an event.
 */
 EVENT2_EXPORT_SYMBOL
 event_callback_fn event_get_callback(const struct event *ev);
 
 /**
    Return the callback argument assigned to an event.
 */
 EVENT2_EXPORT_SYMBOL
 void *event_get_callback_arg(const struct event *ev);
 
 /**
    Return the priority of an event.
    @see event_priority_init(), event_get_priority()
 */
 EVENT2_EXPORT_SYMBOL
 int event_get_priority(const struct event *ev);
 
 /**
    Extract _all_ of arguments given to construct a given event.  The
    event_base is copied into *base_out, the fd is copied into *fd_out, and so
    on.
 
    If any of the "_out" arguments is NULL, it will be ignored.
  */
 EVENT2_EXPORT_SYMBOL
 void event_get_assignment(const struct event *event,
     struct event_base **base_out, evutil_socket_t *fd_out, short *events_out,
     event_callback_fn *callback_out, void **arg_out);
 
 /**
    Return the size of struct event that the Libevent library was compiled
    with.
 
    This will be NO GREATER than sizeof(struct event) if you're running with
    the same version of Libevent that your application was built with, but
    otherwise might not.
 
    Note that it might be SMALLER than sizeof(struct event) if some future
    version of Libevent adds extra padding to the end of struct event.
    We might do this to help ensure ABI-compatibility between different
    versions of Libevent.
  */
 EVENT2_EXPORT_SYMBOL
 size_t event_get_struct_event_size(void);
 
 /**
    Get the Libevent version.
 
    Note that this will give you the version of the library that you're
    currently linked against, not the version of the headers that you've
    compiled against.
 
    @return a string containing the version number of Libevent
 */
 EVENT2_EXPORT_SYMBOL
 const char *event_get_version(void);
 
 /**
    Return a numeric representation of Libevent's version.
 
    Note that this will give you the version of the library that you're
    currently linked against, not the version of the headers you've used to
    compile.
 
    The format uses one byte each for the major, minor, and patchlevel parts of
    the version number.  The low-order byte is unused.  For example, version
    2.0.1-alpha has a numeric representation of 0x02000100
 */
 EVENT2_EXPORT_SYMBOL
 ev_uint32_t event_get_version_number(void);
 
 /** As event_get_version, but gives the version of Libevent's headers. */
 #define LIBEVENT_VERSION EVENT__VERSION
 /** As event_get_version_number, but gives the version number of Libevent's
  * headers. */
 #define LIBEVENT_VERSION_NUMBER EVENT__NUMERIC_VERSION
 
 /** Largest number of priorities that Libevent can support. */
 #define EVENT_MAX_PRIORITIES 256
 /**
   Set the number of different event priorities
 
   By default Libevent schedules all active events with the same priority.
   However, some time it is desirable to process some events with a higher
   priority than others.  For that reason, Libevent supports strict priority
   queues.  Active events with a lower priority are always processed before
   events with a higher priority.
 
   The number of different priorities can be set initially with the
   event_base_priority_init() function.  This function should be called
   before the first call to event_base_dispatch().  The
   event_priority_set() function can be used to assign a priority to an
   event.  By default, Libevent assigns the middle priority to all events
   unless their priority is explicitly set.
 
   Note that urgent-priority events can starve less-urgent events: after
   running all urgent-priority callbacks, Libevent checks for more urgent
   events again, before running less-urgent events.  Less-urgent events
   will not have their callbacks run until there are no events more urgent
   than them that want to be active.
 
   @param eb the event_base structure returned by event_base_new()
   @param npriorities the maximum number of priorities
   @return 0 if successful, or -1 if an error occurred
   @see event_priority_set()
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_priority_init(struct event_base *, int);
 
 /**
   Get the number of different event priorities.
 
   @param eb the event_base structure returned by event_base_new()
   @return Number of different event priorities
   @see event_base_priority_init()
 */
 EVENT2_EXPORT_SYMBOL
 int event_base_get_npriorities(struct event_base *eb);
 
 /**
   Assign a priority to an event.
 
   @param ev an event struct
   @param priority the new priority to be assigned
   @return 0 if successful, or -1 if an error occurred
   @see event_priority_init(), event_get_priority()
   */
 EVENT2_EXPORT_SYMBOL
 int event_priority_set(struct event *, int);
 
 /**
    Prepare an event_base to use a large number of timeouts with the same
    duration.
 
    Libevent's default scheduling algorithm is optimized for having a large
    number of timeouts with their durations more or less randomly
    distributed.  But if you have a large number of timeouts that all have
    the same duration (for example, if you have a large number of
    connections that all have a 10-second timeout), then you can improve
    Libevent's performance by telling Libevent about it.
 
    To do this, call this function with the common duration.  It will return a
    pointer to a different, opaque timeout value.  (Don't depend on its actual
    contents!)  When you use this timeout value in event_add(), Libevent will
    schedule the event more efficiently.
 
    (This optimization probably will not be worthwhile until you have thousands
    or tens of thousands of events with the same timeout.)
  */
 EVENT2_EXPORT_SYMBOL
 const struct timeval *event_base_init_common_timeout(struct event_base *base,
     const struct timeval *duration);
 
 #if !defined(EVENT__DISABLE_MM_REPLACEMENT) || defined(EVENT_IN_DOXYGEN_)
 /**
  Override the functions that Libevent uses for memory management.
 
  Usually, Libevent uses the standard libc functions malloc, realloc, and
  free to allocate memory.  Passing replacements for those functions to
  event_set_mem_functions() overrides this behavior.
 
  Note that all memory returned from Libevent will be allocated by the
  replacement functions rather than by malloc() and realloc().  Thus, if you
  have replaced those functions, it will not be appropriate to free() memory
  that you get from Libevent.  Instead, you must use the free_fn replacement
  that you provided.
 
  Note also that if you are going to call this function, you should do so
  before any call to any Libevent function that does allocation.
  Otherwise, those functions will allocate their memory using malloc(), but
  then later free it using your provided free_fn.
 
  @param malloc_fn A replacement for malloc.
  @param realloc_fn A replacement for realloc
  @param free_fn A replacement for free.
  **/
 EVENT2_EXPORT_SYMBOL
 void event_set_mem_functions(
     void *(*malloc_fn)(size_t sz),
     void *(*realloc_fn)(void *ptr, size_t sz),
     void (*free_fn)(void *ptr));
 /** This definition is present if Libevent was built with support for
     event_set_mem_functions() */
 #define EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
 #endif
 
 /**
    Writes a human-readable description of all inserted and/or active
    events to a provided stdio stream.
 
    This is intended for debugging; its format is not guaranteed to be the same
    between libevent versions.
 
    @param base An event_base on which to scan the events.
    @param output A stdio file to write on.
  */
 EVENT2_EXPORT_SYMBOL
 void event_base_dump_events(struct event_base *, FILE *);
 
 
 /**
    Activates all pending events for the given fd and event mask.
 
    This function activates pending events only.  Events which have not been
    added will not become active.
 
    @param base the event_base on which to activate the events.
    @param fd An fd to active events on.
    @param events One or more of EV_{READ,WRITE,TIMEOUT}.
  */
 EVENT2_EXPORT_SYMBOL
 void event_base_active_by_fd(struct event_base *base, evutil_socket_t fd, short events);
 
 /**
    Activates all pending signals with a given signal number
 
    This function activates pending events only.  Events which have not been
    added will not become active.
 
    @param base the event_base on which to activate the events.
    @param fd The signal to active events on.
  */
 EVENT2_EXPORT_SYMBOL
 void event_base_active_by_signal(struct event_base *base, int sig);
 
 /**
  * Callback for iterating events in an event base via event_base_foreach_event
  */
 typedef int (*event_base_foreach_event_cb)(const struct event_base *, const struct event *, void *);
 
 /**
    Iterate over all added or active events events in an event loop, and invoke
    a given callback on each one.
 
    The callback must not call any function that modifies the event base, that
    modifies any event in the event base, or that adds or removes any event to
    the event base.  Doing so is unsupported and will lead to undefined
    behavior -- likely, to crashes.
 
    event_base_foreach_event() holds a lock on the event_base() for the whole
    time it's running: slow callbacks are not advisable.
 
    Note that Libevent adds some events of its own to make pieces of its
    functionality work.  You must not assume that the only events you'll
    encounter will be the ones you added yourself.
 
    The callback function must return 0 to continue iteration, or some other
    integer to stop iterating.
 
    @param base An event_base on which to scan the events.
    @param fn   A callback function to receive the events.
    @param arg  An argument passed to the callback function.
    @return 0 if we iterated over every event, or the value returned by the
       callback function if the loop exited early.
 */
 EVENT2_EXPORT_SYMBOL
 int event_base_foreach_event(struct event_base *base, event_base_foreach_event_cb fn, void *arg);
 
 
 /** Sets 'tv' to the current time (as returned by gettimeofday()),
     looking at the cached value in 'base' if possible, and calling
     gettimeofday() or clock_gettime() as appropriate if there is no
     cached time.
 
     Generally, this value will only be cached while actually
     processing event callbacks, and may be very inaccurate if your
     callbacks take a long time to execute.
 
     Returns 0 on success, negative on failure.
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_gettimeofday_cached(struct event_base *base,
     struct timeval *tv);
 
 /** Update cached_tv in the 'base' to the current time
  *
  * You can use this function is useful for selectively increasing
  * the accuracy of the cached time value in 'base' during callbacks
  * that take a long time to execute.
  *
  * This function has no effect if the base is currently not in its
  * event loop, or if timeval caching is disabled via
  * EVENT_BASE_FLAG_NO_CACHE_TIME.
  *
  * @return 0 on success, -1 on failure
  */
 EVENT2_EXPORT_SYMBOL
 int event_base_update_cache_time(struct event_base *base);
 
 /** Release up all globally-allocated resources allocated by Libevent.
 
     This function does not free developer-controlled resources like
     event_bases, events, bufferevents, listeners, and so on.  It only releases
     resources like global locks that there is no other way to free.
 
     It is not actually necessary to call this function before exit: every
     resource that it frees would be released anyway on exit.  It mainly exists
     so that resource-leak debugging tools don't see Libevent as holding
     resources at exit.
 
     You should only call this function when no other Libevent functions will
     be invoked -- e.g., when cleanly exiting a program.
  */
 EVENT2_EXPORT_SYMBOL
 void libevent_global_shutdown(void);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* EVENT2_EVENT_H_INCLUDED_ */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team