I would appreciate any donations. Wishlist or send e-mail type donations to maekawa AT daemon-systems.org.

Thank you.


event2/event.h(3)          Library Functions Manual          event2/event.h(3)



NAME
       event2/event.h - Core functions for waiting for and receiving events,
       and using event bases.


SYNOPSIS
       #include <event2/visibility.h>
       #include <event2/event-config.h>
       #include <stdio.h>
       #include <event2/util.h>


   Data Structures
           struct event
           Structure to represent a single event.  struct event_base
           Structure to hold information and state for a Libevent dispatch
           loop.  struct event_config
           Configuration for an event_base.

   Macros
           #define _EVENT_LOG_DEBUG   EVENT_LOG_DEBUG
           #define _EVENT_LOG_ERR   EVENT_LOG_ERR
           #define _EVENT_LOG_MSG   EVENT_LOG_MSG
           #define _EVENT_LOG_WARN   EVENT_LOG_WARN
           #define EVENT_DBG_ALL   0xffffffffu
           #define EVENT_DBG_NONE   0
           #define event_get_signal(ev)   ((int)event_get_fd(ev))
           Get the signal number assigned to a signal event.  #define
           EVENT_MAX_PRIORITIES   256
           Largest number of priorities that Libevent can support.  #define
           EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
           This definition is present if Libevent was built with support for
           event_set_mem_functions()  #define LIBEVENT_VERSION
           EVENT__VERSION
           As event_get_version, but gives the version of Libevent's headers.
           #define LIBEVENT_VERSION_NUMBER   EVENT__NUMERIC_VERSION
           As event_get_version_number, but gives the version number of
           Libevent's headers.

       event type flag
       Flags to pass to event_base_get_num_events() to specify the kinds of
       events we want to aggregate counts for

               #define EVENT_BASE_COUNT_ACTIVE   1U
               count the number of active events, which have been triggered.
               #define EVENT_BASE_COUNT_VIRTUAL   2U
               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_ADDED   4U
               count the number of events which have been added to event base,
               including internal events.

       Log severities

               #define EVENT_LOG_DEBUG   0
               #define EVENT_LOG_MSG   1
               #define EVENT_LOG_WARN   2
               #define EVENT_LOG_ERR   3

       Loop flags
       These flags control the behavior of event_base_loop().

               #define EVLOOP_ONCE   0x01
               Block until we have an active event, then exit once all active
               events have had their callbacks run.  #define EVLOOP_NONBLOCK
               0x02
               Do not block: see which events are ready now, run the callbacks
               of the highest-priority ones, then exit.  #define
               EVLOOP_NO_EXIT_ON_EMPTY   0x04
               Do not exit the loop because we have no pending events.

       event flags
       Flags to pass to event_new(), event_assign(), event_pending(), and
       anything else with an argument of the form 'short events'

               #define EV_TIMEOUT   0x01
               Indicates that a timeout has occurred.  #define EV_READ   0x02
               Wait for a socket or FD to become readable.  #define EV_WRITE
               0x04
               Wait for a socket or FD to become writeable.  #define EV_SIGNAL
               0x08
               Wait for a POSIX signal to be raised.  #define EV_PERSIST
               0x10
               Persistent event: won't get removed automatically when
               activated.  #define EV_ET   0x20
               Select edge-triggered behavior, if supported by the backend.
               #define EV_FINALIZE   0x40
               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.  #define EV_CLOSED   0x80
               Detects connection close events.

       evtimer_* macros
       Aliases for working with one-shot timer events

               #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)

       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)

   Typedefs
           typedef int(* event_base_foreach_event_cb) (const struct event_base
           *, const struct event *, void *)
           Callback for iterating events in an event base via
           event_base_foreach_event.  typedef void(* event_callback_fn)
           (evutil_socket_t, short, void *)
           A callback function for an event.  typedef void(* event_fatal_cb)
           (int err)
           A function to be called if Libevent encounters a fatal internal
           error.  typedef void(* event_finalize_callback_fn) (struct event *,
           void *)
           Callback type for event_finalize and event_free_finalize().
           typedef void(* event_log_cb) (int severity, const char *msg)
           A callback function used to intercept Libevent's log messages.

   Enumerations
           enum event_base_config_flag { EVENT_BASE_FLAG_NOLOCK = 0x01,
           EVENT_BASE_FLAG_IGNORE_ENV = 0x02, EVENT_BASE_FLAG_STARTUP_IOCP =
           0x04, EVENT_BASE_FLAG_NO_CACHE_TIME = 0x08,
           EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST = 0x10,
           EVENT_BASE_FLAG_PRECISE_TIMER = 0x20 } A flag passed to
           event_config_set_flag(). "
           enum event_method_feature { EV_FEATURE_ET = 0x01, EV_FEATURE_O1 =
           0x02, EV_FEATURE_FDS = 0x04, EV_FEATURE_EARLY_CLOSE = 0x08 } A flag
           used to describe which features an event_base (must) provide. "

   Functions
           EVENT2_EXPORT_SYMBOL void event_active (struct event *ev, int res,
           short ncalls)
           Make an event active.  EVENT2_EXPORT_SYMBOL int event_add (struct
           event *ev, const struct timeval *timeout)
           Add an event to the set of pending events.  EVENT2_EXPORT_SYMBOL
           int event_assign (struct event *, struct event_base *,
           evutil_socket_t, short, event_callback_fn, void *)
           Prepare a new, already-allocated event structure to be added.
           EVENT2_EXPORT_SYMBOL void event_base_active_by_fd (struct
           event_base *base, evutil_socket_t fd, short events)
           Activates all pending events for the given fd and event mask.
           EVENT2_EXPORT_SYMBOL void event_base_active_by_signal (struct
           event_base *base, int sig)
           Activates all pending signals with a given signal number.
           EVENT2_EXPORT_SYMBOL int event_base_dispatch (struct event_base *)
           Event dispatching loop.  EVENT2_EXPORT_SYMBOL void
           event_base_dump_events (struct event_base *, FILE *)
           Writes a human-readable description of all inserted and/or active
           events to a provided stdio stream.  EVENT2_EXPORT_SYMBOL int
           event_base_foreach_event (struct event_base *base,
           event_base_foreach_event_cb fn, void *arg)
           Iterate over all added or active events events in an event loop,
           and invoke a given callback on each one.  EVENT2_EXPORT_SYMBOL void
           event_base_free (struct event_base *)
           Deallocate all memory associated with an event_base, and free the
           base.  EVENT2_EXPORT_SYMBOL void event_base_free_nofinalize (struct
           event_base *)
           As event_free, but do not run finalizers.  EVENT2_EXPORT_SYMBOL int
           event_base_get_features (const struct event_base *base)
           Return a bitmask of the features implemented by an event base.
           EVENT2_EXPORT_SYMBOL int event_base_get_max_events (struct
           event_base *, unsigned int, int)
           Get the maximum number of events in a given event_base as specified
           in the flags.  EVENT2_EXPORT_SYMBOL const char *
           event_base_get_method (const struct event_base *)
           Get the kernel event notification mechanism used by Libevent.
           EVENT2_EXPORT_SYMBOL int event_base_get_npriorities (struct
           event_base *eb)
           Get the number of different event priorities.  EVENT2_EXPORT_SYMBOL
           int event_base_get_num_events (struct event_base *, unsigned int)
           Gets the number of events in event_base, as specified in the flags.
           EVENT2_EXPORT_SYMBOL struct event * event_base_get_running_event
           (struct event_base *base)
           If called from within the callback for an event, returns that
           event.  EVENT2_EXPORT_SYMBOL int event_base_gettimeofday_cached
           (struct event_base *base, struct timeval *tv)
           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.  EVENT2_EXPORT_SYMBOL int event_base_got_break (struct
           event_base *)
           Checks if the event loop was told to abort immediately by
           event_base_loopbreak().  EVENT2_EXPORT_SYMBOL int
           event_base_got_exit (struct event_base *)
           Checks if the event loop was told to exit by event_base_loopexit().
           EVENT2_EXPORT_SYMBOL const struct timeval *
           event_base_init_common_timeout (struct event_base *base, const
           struct timeval *duration)
           Prepare an event_base to use a large number of timeouts with the
           same duration.  EVENT2_EXPORT_SYMBOL int event_base_loop (struct
           event_base *, int)
           Wait for events to become active, and run their callbacks.
           EVENT2_EXPORT_SYMBOL int event_base_loopbreak (struct event_base *)
           Abort the active event_base_loop() immediately.
           EVENT2_EXPORT_SYMBOL int event_base_loopcontinue (struct event_base
           *)
           Tell the active event_base_loop() to scan for new events
           immediately.  EVENT2_EXPORT_SYMBOL int event_base_loopexit (struct
           event_base *, const struct timeval *)
           Exit the event loop after the specified time.  EVENT2_EXPORT_SYMBOL
           struct event_base * event_base_new (void)
           Create and return a new event_base to use with the rest of
           Libevent.  EVENT2_EXPORT_SYMBOL struct event_base *
           event_base_new_with_config (const struct event_config *)
           Initialize the event API.  EVENT2_EXPORT_SYMBOL int event_base_once
           (struct event_base *, evutil_socket_t, short, event_callback_fn,
           void *, const struct timeval *)
           Schedule a one-time event.  EVENT2_EXPORT_SYMBOL int
           event_base_priority_init (struct event_base *, int)
           Set the number of different event priorities.  EVENT2_EXPORT_SYMBOL
           int event_base_set (struct event_base *, struct event *)
           Associate a different event base with an event.
           EVENT2_EXPORT_SYMBOL int event_base_update_cache_time (struct
           event_base *base)
           Update cached_tv in the 'base' to the current time.
           EVENT2_EXPORT_SYMBOL int event_config_avoid_method (struct
           event_config *cfg, const char *method)
           Enters an event method that should be avoided into the
           configuration.  EVENT2_EXPORT_SYMBOL void event_config_free (struct
           event_config *cfg)
           Deallocates all memory associated with an event configuration
           object.  EVENT2_EXPORT_SYMBOL struct event_config *
           event_config_new (void)
           Allocates a new event configuration object.  EVENT2_EXPORT_SYMBOL
           int event_config_require_features (struct event_config *cfg, int
           feature)
           Enters a required event method feature that the application
           demands.  EVENT2_EXPORT_SYMBOL int event_config_set_flag (struct
           event_config *cfg, int flag)
           Sets one or more flags to configure what parts of the eventual
           event_base will be initialized, and how they'll work.
           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)
           Record an interval and/or a number of callbacks after which the
           event base should check for new events.  EVENT2_EXPORT_SYMBOL int
           event_config_set_num_cpus_hint (struct event_config *cfg, int cpus)
           Records a hint for the number of CPUs in the system.
           EVENT2_EXPORT_SYMBOL void event_debug_unassign (struct event *)
           When debugging mode is enabled, informs Libevent that an event
           should no longer be considered as assigned.  EVENT2_EXPORT_SYMBOL
           int event_del (struct event *)
           Remove an event from the set of monitored events.
           EVENT2_EXPORT_SYMBOL int event_del_block (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_noblock
           (struct event *ev)
           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 void
           event_enable_debug_logging (ev_uint32_t which)
           Turn on debugging logs and have them sent to the default log
           handler.  EVENT2_EXPORT_SYMBOL void event_enable_debug_mode (void)
           Enable some relatively expensive debugging checks in Libevent that
           would normally be turned off.  EVENT2_EXPORT_SYMBOL void event_free
           (struct event *)
           Deallocate a struct event * returned by event_new().
           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)
           Extract all of arguments given to construct a given event.
           EVENT2_EXPORT_SYMBOL struct event_base * event_get_base (const
           struct event *ev)
           Get the event_base associated with an event.  EVENT2_EXPORT_SYMBOL
           event_callback_fn event_get_callback (const struct event *ev)
           Return the callback assigned to an event.  EVENT2_EXPORT_SYMBOL
           void * event_get_callback_arg (const struct event *ev)
           Return the callback argument assigned to an event.
           EVENT2_EXPORT_SYMBOL short event_get_events (const struct event
           *ev)
           Return the events (EV_READ, EV_WRITE, etc) assigned to an event.
           EVENT2_EXPORT_SYMBOL evutil_socket_t event_get_fd (const struct
           event *ev)
           Get the socket or signal assigned to an event, or -1 if the event
           has no socket.  EVENT2_EXPORT_SYMBOL int event_get_priority (const
           struct event *ev)
           Return the priority of an event.  EVENT2_EXPORT_SYMBOL size_t
           event_get_struct_event_size (void)
           Return the size of struct event that the Libevent library was
           compiled with.  EVENT2_EXPORT_SYMBOL const char **
           event_get_supported_methods (void)
           Gets all event notification mechanisms supported by Libevent.
           EVENT2_EXPORT_SYMBOL const char * event_get_version (void)
           Get the Libevent version.  EVENT2_EXPORT_SYMBOL ev_uint32_t
           event_get_version_number (void)
           Return a numeric representation of Libevent's version.
           EVENT2_EXPORT_SYMBOL int event_gettime_monotonic (struct event_base
           *base, struct timeval *tp)
           Query the current monotonic time from a the timer for a struct
           event_base.  EVENT2_EXPORT_SYMBOL int event_initialized (const
           struct event *ev)
           Test if an event structure might be initialized.
           EVENT2_EXPORT_SYMBOL struct event * event_new (struct event_base *,
           evutil_socket_t, short, event_callback_fn, void *)
           Allocate and asssign a new event structure, ready to be added.
           EVENT2_EXPORT_SYMBOL int event_pending (const struct event *ev,
           short events, struct timeval *tv)
           Checks if a specific event is pending or scheduled.
           EVENT2_EXPORT_SYMBOL int event_priority_set (struct event *, int)
           Assign a priority to an event.  EVENT2_EXPORT_SYMBOL int
           event_reinit (struct event_base *base)
           Reinitialize the event base after a fork.  EVENT2_EXPORT_SYMBOL int
           event_remove_timer (struct event *ev)
           Remove a timer from a pending event without removing the event
           itself.  EVENT2_EXPORT_SYMBOL void * event_self_cbarg (void)
           Return a value used to specify that the event itself must be used
           as the callback argument.  EVENT2_EXPORT_SYMBOL void
           event_set_fatal_callback (event_fatal_cb cb)
           Override Libevent's behavior in the event of a fatal internal
           error.  EVENT2_EXPORT_SYMBOL void event_set_log_callback
           (event_log_cb cb)
           Redirect Libevent's log messages.  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))
           Override the functions that Libevent uses for memory management.
           EVENT2_EXPORT_SYMBOL void libevent_global_shutdown (void)
           Release up all globally-allocated resources allocated by Libevent.

       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 'resucitate' the event
       being finalized in any way.

       THIS IS AN EXPERIMENTAL API. IT MIGHT CHANGE BEFORE THE LIBEVENT 2.1
       SERIES BECOMES STABLE.

       Returns:
           0 on succes, -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)

Detailed Description
       Core functions for waiting for and receiving events, and using event
       bases.



Macro Definition Documentation
   #define EV_CLOSED   0x80
       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_ET   0x20
       Select edge-triggered behavior, if supported by the backend.

   #define EV_FINALIZE   0x40
       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.

       THIS IS AN EXPERIMENTAL API. IT MIGHT CHANGE BEFORE THE LIBEVENT 2.1
       SERIES BECOMES STABLE.

   #define EV_PERSIST   0x10
       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_TIMEOUT   0x01
       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 EVENT_BASE_COUNT_ACTIVE   1U
       count the number of active events, which have been triggered.

   #define EVENT_BASE_COUNT_ADDED   4U
       count the number of events which have been added to event base,
       including internal events.

   #define EVENT_BASE_COUNT_VIRTUAL   2U
       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_MAX_PRIORITIES   256
       Largest number of priorities that Libevent can support.

   #define EVLOOP_NO_EXIT_ON_EMPTY   0x04
       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_NONBLOCK   0x02
       Do not block: see which events are ready now, run the callbacks of the
       highest-priority ones, then exit.

   #define EVLOOP_ONCE   0x01
       Block until we have an active event, then exit once all active events
       have had their callbacks run.

   #define LIBEVENT_VERSION   EVENT__VERSION
       As event_get_version, but gives the version of Libevent's headers.

   #define LIBEVENT_VERSION_NUMBER   EVENT__NUMERIC_VERSION
       As event_get_version_number, but gives the version number of Libevent's
       headers.

Typedef Documentation
   typedef void(* event_callback_fn) (evutil_socket_t, short, void *)
       A callback function for an event. It receives three arguments:

       Parameters:
           fd An fd or signal
           events One or more EV_* flags
           arg A user-supplied argument.

       See also:
           event_new()


   typedef void(* event_fatal_cb) (int err)
       A function to be called if Libevent encounters a fatal internal error.

       See also:
           event_set_fatal_callback


   typedef void(* event_finalize_callback_fn) (struct event *, void *)
       Callback type for event_finalize and event_free_finalize(). THIS IS AN
       EXPERIMENTAL API. IT MIGHT CHANGE BEFORE THE LIBEVENT 2.1 SERIES
       BECOMES STABLE.

   typedef void(* event_log_cb) (int severity, const char *msg)
       A callback function used to intercept Libevent's log messages.

       See also:
           event_set_log_callback


Enumeration Type Documentation
   enum event_base_config_flag
       A flag passed to event_config_set_flag(). These flags change the
       behavior of an allocated event_base.

       See also:
           event_config_set_flag(), event_base_new_with_config(),
           event_method_feature


       Enumerator

       EVENT_BASE_FLAG_NOLOCK
              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_IGNORE_ENV
              Do not check the EVENT_* environment variables when configuring
              an event_base.

       EVENT_BASE_FLAG_STARTUP_IOCP
              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_NO_CACHE_TIME
              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_EPOLL_USE_CHANGELIST
              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_PRECISE_TIMER
              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.

   enum event_method_feature
       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.

       Enumerator

       EV_FEATURE_ET
              Require an event method that allows edge-triggered events with
              EV_ET.

       EV_FEATURE_O1
              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_FDS
              Require an event method that allows file descriptors as well as
              sockets.

       EV_FEATURE_EARLY_CLOSE
              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.

Function Documentation
   EVENT2_EXPORT_SYMBOL void event_active (struct event * ev, int res, short
       ncalls)
       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.

       Parameters:
           ev an event to make active.
           res a set of flags to pass to the event's callback.
           ncalls an obsolete argument: this is ignored.


   EVENT2_EXPORT_SYMBOL int event_add (struct event * ev, const struct timeval
       * timeout)
       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 elapesed. If atimeout 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.

       Parameters:
           ev an event struct initialized via event_assign() or event_new()
           timeout the maximum amount of time to wait for the event, or NULL
           to wait forever

       Returns:
           0 if successful, or -1 if an error occurred

       See also:
           event_del(), event_assign(), event_new()


   EVENT2_EXPORT_SYMBOL int event_assign (struct event *, 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().

       Parameters:
           ev an event struct to be modified
           base the event base to which ev should be attached.
           fd the file descriptor to be monitored
           events desired events to monitor; can be EV_READ and/or EV_WRITE
           callback callback function to be invoked when the event occurs
           callback_arg an argument to be passed to the callback function

       Returns:
           0 if success, or -1 on invalid arguments.

       See also:
           event_new(), event_add(), event_del(), event_base_once(),
           event_get_struct_event_size()


   EVENT2_EXPORT_SYMBOL void event_base_active_by_fd (struct event_base *
       base, evutil_socket_t fd, short events)
       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.

       Parameters:
           base the event_base on which to activate the events.
           fd An fd to active events on.
           events One or more of EV_{READ,WRITE}.


   EVENT2_EXPORT_SYMBOL void event_base_active_by_signal (struct event_base *
       base, int sig)
       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.

       Parameters:
           base the event_base on which to activate the events.
           fd The signal to active events on.


   EVENT2_EXPORT_SYMBOL int event_base_dispatch (struct event_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().

       Parameters:
           base the event_base structure returned by event_base_new() or
           event_base_new_with_config()

       Returns:
           0 if successful, -1 if an error occurred, or 1 if we exited because
           no events were pending or active.

       See also:
           event_base_loop()


   EVENT2_EXPORT_SYMBOL void event_base_dump_events (struct event_base *, FILE
       *)
       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.

       Parameters:
           base An event_base on which to scan the events.
           output A stdio file to write on.


   EVENT2_EXPORT_SYMBOL int event_base_foreach_event (struct event_base *
       base, event_base_foreach_event_cb fn, void * arg)
       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.

       Parameters:
           base An event_base on which to scan the events.
           fn A callback function to receive the events.
           arg An argument passed to the callback function.

       Returns:
           0 if we iterated over every event, or the value returned by the
           callback function if the loop exited early.


   EVENT2_EXPORT_SYMBOL void event_base_free (struct event_base *)
       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.

       Parameters:
           eb an event_base to be freed


   EVENT2_EXPORT_SYMBOL void event_base_free_nofinalize (struct event_base *)
       As event_free, but do not run finalizers. THIS IS AN EXPERIMENTAL API.
       IT MIGHT CHANGE BEFORE THE LIBEVENT 2.1 SERIES BECOMES STABLE.

   EVENT2_EXPORT_SYMBOL int event_base_get_features (const struct event_base *
       base)
       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 also:
           event_method_feature


   EVENT2_EXPORT_SYMBOL int event_base_get_max_events (struct event_base *,
       unsigned int, int)
       Get the maximum number of events in a given event_base as specified in
       the flags.

       Parameters:
           eb the event_base structure returned by event_base_new()
           flags a bitwise combination of the kinds of events to aggregate
           counts for
           clear option used to reset the maximum count.

       Returns:
           the number of events specified in the flags


   EVENT2_EXPORT_SYMBOL const char* event_base_get_method (const struct
       event_base *)
       Get the kernel event notification mechanism used by Libevent.

       Parameters:
           eb the event_base structure returned by event_base_new()

       Returns:
           a string identifying the kernel event mechanism (kqueue, epoll,
           etc.)


   EVENT2_EXPORT_SYMBOL int event_base_get_npriorities (struct event_base *
       eb)
       Get the number of different event priorities.

       Parameters:
           eb the event_base structure returned by event_base_new()

       Returns:
           Number of different event priorities

       See also:
           event_base_priority_init()


   EVENT2_EXPORT_SYMBOL int event_base_get_num_events (struct event_base *,
       unsigned int)
       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.

       Parameters:
           eb the event_base structure returned by event_base_new()
           flags a bitwise combination of the kinds of events to aggregate
           counts for

       Returns:
           the number of events specified in the flags


   EVENT2_EXPORT_SYMBOL struct event* event_base_get_running_event (struct
       event_base * base)
       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 int event_base_gettimeofday_cached (struct event_base
       * base, struct timeval * tv)
       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 inaccuate if your callbacks take a
       long time to execute.

       Returns 0 on success, negative on failure.

   EVENT2_EXPORT_SYMBOL int event_base_got_break (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.

       Parameters:
           eb the event_base structure returned by event_init()

       Returns:
           true if event_base_loopbreak() was called on this event base, or 0
           otherwise

       See also:
           event_base_loopbreak()

           event_base_got_exit()


   EVENT2_EXPORT_SYMBOL int event_base_got_exit (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.

       Parameters:
           eb the event_base structure returned by event_init()

       Returns:
           true if event_base_loopexit() was called on this event base, or 0
           otherwise

       See also:
           event_base_loopexit()

           event_base_got_break()


   EVENT2_EXPORT_SYMBOL const struct timeval* event_base_init_common_timeout
       (struct event_base * base, const struct timeval * duration)
       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 int event_base_loop (struct event_base *, int)
       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.

       Parameters:
           eb the event_base structure returned by event_base_new() or
           event_base_new_with_config()
           flags any combination of EVLOOP_ONCE | EVLOOP_NONBLOCK

       Returns:
           0 if successful, -1 if an error occurred, or 1 if we exited because
           no events were pending or active.

       See also:
           event_base_loopexit(), event_base_dispatch(), EVLOOP_ONCE,
           EVLOOP_NONBLOCK


   EVENT2_EXPORT_SYMBOL int event_base_loopbreak (struct event_base *)
       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.

       Parameters:
           eb the event_base structure returned by event_init()

       Returns:
           0 if successful, or -1 if an error occurred

       See also:
           event_base_loopexit()


   EVENT2_EXPORT_SYMBOL int event_base_loopcontinue (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.

       Parameters:
           eb the event_base structure returned by event_init()

       Returns:
           0 if successful, or -1 if an error occurred

       See also:
           event_base_loopbreak()


   EVENT2_EXPORT_SYMBOL int event_base_loopexit (struct event_base *, const
       struct timeval *)
       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.

       Parameters:
           eb the event_base structure returned by event_init()
           tv the amount of time after which the loop should terminate, or
           NULL to exit after running all currently active events.

       Returns:
           0 if successful, or -1 if an error occurred

       See also:
           event_base_loopbreak()


   EVENT2_EXPORT_SYMBOL struct event_base* event_base_new (void)
       Create and return a new event_base to use with the rest of Libevent.

       Returns:
           a new event_base on success, or NULL on failure.

       See also:
           event_base_free(), event_base_new_with_config()


   EVENT2_EXPORT_SYMBOL struct event_base* event_base_new_with_config (const
       struct event_config *)
       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.

       Parameters:
           cfg the event configuration object

       Returns:
           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 also:
           event_base_new(), event_base_free(), event_init(), event_assign()


   EVENT2_EXPORT_SYMBOL int event_base_once (struct event_base *,
       evutil_socket_t, short, event_callback_fn, void *, const struct timeval
       *)
       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.

       Parameters:
           base an event_base
           fd a file descriptor to monitor, or -1 for no fd.
           events event(s) to monitor; can be any of EV_READ | EV_WRITE, or
           EV_TIMEOUT
           callback callback function to be invoked when the event occurs
           arg an argument to be passed to the callback function
           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 succees immediately.

       Returns:
           0 if successful, or -1 if an error occurred


   EVENT2_EXPORT_SYMBOL int event_base_priority_init (struct event_base *,
       int)
       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.

       Parameters:
           eb the event_base structure returned by event_base_new()
           npriorities the maximum number of priorities

       Returns:
           0 if successful, or -1 if an error occurred

       See also:
           event_priority_set()


   EVENT2_EXPORT_SYMBOL int event_base_set (struct event_base *, struct event
       *)
       Associate a different event base with an event. The event to be
       associated must not be currently active or pending.

       Parameters:
           eb the event base
           ev the event

       Returns:
           0 on success, -1 on failure.


   EVENT2_EXPORT_SYMBOL int event_base_update_cache_time (struct event_base *
       base)
       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.

       Returns:
           0 on success, -1 on failure


   EVENT2_EXPORT_SYMBOL int event_config_avoid_method (struct event_config *
       cfg, const char * method)
       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.

       Parameters:
           cfg the event configuration object
           method the name of the event method to avoid

       Returns:
           0 on success, -1 on failure.


   EVENT2_EXPORT_SYMBOL void event_config_free (struct event_config * cfg)
       Deallocates all memory associated with an event configuration object.

       Parameters:
           cfg the event configuration object to be freed.


   EVENT2_EXPORT_SYMBOL struct event_config* event_config_new (void)
       Allocates a new event configuration object. The event configuration
       object can be used to change the behavior of an event base.

       Returns:
           an event_config object that can be used to store configuration, or
           NULL if an error is encountered.

       See also:
           event_base_new_with_config(), event_config_free(), event_config


   EVENT2_EXPORT_SYMBOL int event_config_require_features (struct event_config
       * cfg, int feature)
       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:


         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);
         }

       Parameters:
           cfg the event configuration object
           feature a bitfield of one or more event_method_feature values.
           Replaces values from previous calls to this function.

       Returns:
           0 on success, -1 on failure.

       See also:
           event_method_feature, event_base_new_with_config()


   EVENT2_EXPORT_SYMBOL int event_config_set_flag (struct event_config * cfg,
       int flag)
       Sets one or more flags to configure what parts of the eventual
       event_base will be initialized, and how they'll work.

       See also:
           event_base_config_flags, event_base_new_with_config()


   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)
       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 higest 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!

       Parameters:
           cfg The event_base configuration object.
           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.
           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.
           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.

       Returns:
           0 on success, -1 on failure.


   EVENT2_EXPORT_SYMBOL int event_config_set_num_cpus_hint (struct
       event_config * cfg, int cpus)
       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.

       Parameters:
           cfg the event configuration object
           cpus the number of cpus

       Returns:
           0 on success, -1 on failure.


   EVENT2_EXPORT_SYMBOL void event_debug_unassign (struct event *)
       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 also:
           event_enable_debug_mode()


   EVENT2_EXPORT_SYMBOL int event_del (struct event *)
       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.

       Parameters:
           ev an event struct to be removed from the working set

       Returns:
           0 if successful, or -1 if an error occurred

       See also:
           event_add()


   EVENT2_EXPORT_SYMBOL int event_del_block (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. THIS IS AN EXPERIMENTAL API. IT MIGHT CHANGE BEFORE
       THE LIBEVENT 2.1 SERIES BECOMES STABLE.

   EVENT2_EXPORT_SYMBOL int event_del_noblock (struct event * ev)
       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. THIS IS AN EXPERIMENTAL API. IT MIGHT CHANGE BEFORE
       THE LIBEVENT 2.1 SERIES BECOMES STABLE.

   EVENT2_EXPORT_SYMBOL void event_enable_debug_logging (ev_uint32_t which)
       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.

       Parameters:
           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_mode (void)
       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 also:
           event_debug_unassign()


   EVENT2_EXPORT_SYMBOL void event_free (struct event *)
       Deallocate a struct event * returned by event_new(). If the event is
       pending or active, first make it non-pending and non-active.

   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)
       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 int event_get_priority (const struct event * ev)
       Return the priority of an event.

       See also:
           event_priority_init(), event_get_priority()


   EVENT2_EXPORT_SYMBOL size_t event_get_struct_event_size (void)
       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 const char** event_get_supported_methods (void)
       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.

       Returns:
           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_version (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.

       Returns:
           a string containing the version number of Libevent


   EVENT2_EXPORT_SYMBOL ev_uint32_t event_get_version_number (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 int event_initialized (const struct event * ev)
       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 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.

       Parameters:
           ev an event structure to be tested

       Returns:
           1 if the structure might be initialized, or 0 if it has not been
           initialized


   EVENT2_EXPORT_SYMBOL struct event* event_new (struct event_base *,
       evutil_socket_t, short, event_callback_fn, void *)
       Allocate and asssign 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 triggerd.

       When the event becomes active, the event loop will run the provided
       callbuck 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.

       Parameters:
           base the event base to which the event should be attached.
           fd the file descriptor or signal to be monitored, or -1.
           events desired events to monitor: bitfield of EV_READ, EV_WRITE,
           EV_SIGNAL, EV_PERSIST, EV_ET.
           callback callback function to be invoked when the event occurs
           callback_arg an argument to be passed to the callback function

       Returns:
           a newly allocated struct event that must later be freed with
           event_free().

       See also:
           event_free(), event_add(), event_del(), event_assign()


   EVENT2_EXPORT_SYMBOL int event_pending (const struct event * ev, short
       events, struct timeval * tv)
       Checks if a specific event is pending or scheduled.

       Parameters:
           ev an event struct previously passed to event_add()
           events the requested event type; any of EV_TIMEOUT|EV_READ|
           EV_WRITE|EV_SIGNAL
           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.

       Returns:
           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_priority_set (struct event *, int)
       Assign a priority to an event.

       Parameters:
           ev an event struct
           priority the new priority to be assigned

       Returns:
           0 if successful, or -1 if an error occurred

       See also:
           event_priority_init(), event_get_priority()


   EVENT2_EXPORT_SYMBOL int event_reinit (struct event_base * base)
       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.

       Parameters:
           base the event base that needs to be re-initialized

       Returns:
           0 if successful, or -1 if some events could not be re-added.

       See also:
           event_base_new()


   EVENT2_EXPORT_SYMBOL int event_remove_timer (struct event * ev)
       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.

       Parameters:
           ev an event struct initialized via event_assign() or event_new()

       Returns:
           0 on success, or -1 if an error occurrect.


   EVENT2_EXPORT_SYMBOL void* event_self_cbarg (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:


           struct event *ev = event_new(base, sock, events, callback, event_self_cbarg());

       For consistency with event_new(), it is possible to pass the return
       value of this function as the callback argument for event_assign() --
       this achieves the same result as passing the event in directly.

       Returns:
           a value to be passed as the callback argument to event_new() or
           event_assign().

       See also:
           event_new(), event_assign()


   EVENT2_EXPORT_SYMBOL void event_set_fatal_callback (event_fatal_cb cb)
       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_log_callback (event_log_cb cb)
       Redirect Libevent's log messages.

       Parameters:
           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_mem_functions (void *(*)(size_t sz)
       malloc_fn, void *(*)(void *ptr, size_t sz) realloc_fn, void(*)(void
       *ptr) free_fn)
       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 funtions will allocate their memory using malloc(),
       but then later free it using your provided free_fn.

       Parameters:
           malloc_fn A replacement for malloc.
           realloc_fn A replacement for realloc
           free_fn A replacement for free.


   EVENT2_EXPORT_SYMBOL void libevent_global_shutdown (void)
       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.

Author
       Generated automatically by Doxygen for libevent from the source code.



libevent                        Tue Jan 31 2017              event2/event.h(3)