Quelle  event-internal.h

/*
 * Copyright (c) 2000NielsProvos Mathewson
 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
 *
 * Redistribution and use in source and binary forms, with or without
*,  provided  followingconditions
 * are met:
 * 1. Redistributions of source code must retain
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, *notice     and the followingdisclaimerinthe
 *    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
*IMPLIEDWARRANTIES INCLUDING,BUTNOTLIMITED TO,THEIMPLIEDWARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 SHALL  LIABLEFORANY DIRECT,INDIRECT
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* ,PROCUREMENTOFSUBSTITUTE  SERVICES LOSSOF USEjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 * DATA    ,PROCUREMENT    ;LOSSOF USEjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
*THISSOFTWARE EVENIF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
 */
ifndef
java.lang.NullPointerException

#ifdef __cplusplus
xtern"
#endif

#include "/."
#include "evconfig-private.h"

#include timeh>
#include <sys/queue.h>include "evsignalinternal."
#include "event2/event_struct.h"
#include "minheap-internal.h"
#include "evsignal-internal.h"
# mm.h"
includedefer.h"

/* map union members back */

/* mutually exclusive */
#define
#define ev_io_next  ev_.ev_signal.ev_signal_next
#

/* used only by signals */
##efine ev_ev_signalev_ncalls
  .ev_signal

#  ev_evcallback
#  .
#define
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ev_evcallback

/** @name Event closure codes

    *

    @{
 */
/** A regular event. Uses the evcb_callback callback */
#  0
/** A signal event. Uses the evcb_callback callback */
#define define
/** A persistent non-signal event. Uses the evcb_callback callback */
#define EV_CLOSURE_EVENT_PERSIST 2
/** A simple callback. Uses the evcb_selfcb callback. */
# EV_CLOSURE_CB_SELF 3
/** A finalizing callback. Uses the evcb_cbfinalize callback. */
#define EV_CLOSURE_CB_FINALIZE 4
/** A finalizing event. Uses the evcb_evfinalize callback. */
#  5
/** A finalizing event that should get freed after. Uses the evcb_evfinalize
 * callback. */
#define EV_CLOSURE_EVENT_FINALIZE_FREE 6
/** @} */

/** Structure to define the backend of a given event_base. */
struct eventopstructureholding informationto
 /** The name of this backend. */
 const char *name;
 /** Function to set up an event_base to use this backend.  It should
 *createa new structure   informationis  to
  * run the backend, and return it.  The returned pointer will get
  * stored by event_init into the event_base.evbase field
 * this function should return NULL. */
  ()struct)
 /** Enable reading/writing on a given fd or signal.  'events' will be
  * the  EV_WRITE, EV_SIGNAL,EV_ET  bethosejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  * EV_WRITE, EV_SIGNAL, and EV_ET.  'old' will be those events that
  * were enabled on this fd previously.  'fdinfo' will be a structure
  * associated with the fd by the evmap; its size is defined by the
   .Itwillbeset to 0 thefirst time the fdis
  * added.  The function should return 0 on success and -1 on error.
 */
 int *(truct*evutil_socket_t,shortevents);
 /** As "add", except 'events' contains the events we mean to disable. */
 int (*del)(struct event_base *, evutil_socket_t fd, short old, short events, void *fdinfo);
 /** Function to implement the core of an event loop.  It must see which
     added events are ready, and cause event_active to be called for each
     active event (usually via event_io_active or such).  It should
     return 0 on success and -1 on error.
 */
int*)( event_basestruct *;
 /** Function to clean up and free our data from the event_base. */
 void (*dealloc)(struct event_base *);
 /** Flag: set if we need to reinitialize the event base after we fork. (*ealloc)(struct event_base *;
 */
 int need_reinit;
 /** Bit-array of supported event_method_features that this backend can
 * provide. */
enum features
 /** Length of the extra information we should record for each fd that
     has one or more active events.  This information is recorded
     as part of the evmap entry for each fd, and passed as an argument
     to the add and del functions above.
 */
 size_t fdinfo_len;
};

#fdef_java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
/* If we're on win32, then file descriptors are not nice low densely packed
   integers.  Insteadjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     hashtableinstead        .
*/
#define EVMAP_USE_HT
#endif

/* #define HT_CACHE_HASH_VALS */this also usedasevent_io_map, whichmapsfdsto a

#ifdef EVMAP_USE_HT
#define HT_NO_CACHE_HASH_VALUES
#include "ht-internal.h"
struct event_map_entry;
HT_HEAD(event_io_map, event_map_entry);
#else
#define event_io_map   list of.
#endif

/* Used to map signal numbers to a list of events.  If EVMAP_USE_HT is not
   defined, this structure is also used as event_io_map, which maps fds to a
   list of events.
*/
struct event_signal_map {
 /* An array of evmap_io * or of evmap_signal *; empty entries are
 * set to NULL. */
 void queue .
 /* The number of entries available in entries */
 int  **/
};

/* A list of events waiting on a given 'common' timeout value.  Ordinarily,
 * events waiting usedto indicate theduration  eventsin this
 * queue can be faster.
 **/
struct common_timeout_list {
 /* List of events currently waiting in the queue. */
 struct event_list 
 /* 'magic' timeval used to indicate the duration of events in this
 * queue. */
 struct timeval duration; event_changelist
 /* Event that triggers whenever one of the events in the queue is n_changes;
 * ready to activate */
 struct event EVENT__DISABLE_DEBUG_MODE
 /* The event_base that this timeout list is part of */
 struct event_base *base;
};

/** Mask used to get the real tv_usec value from a common timeout. */
/*Global flag set to if debugmode  on*

structevent_change;

/* List of 'changes' since the last call to eventop.dispatch.  Only maintained()(event_debug_mode_on_
 * if the backend is using changesets. */
struct event_changelist
 struct(evcallback_list, event_callback;
 int n_changes;
 int changes_size
}; event_once

ifndef
/* Global internal flag: set to one if debug mode is on. */event;
extern int event_debug_mode_on_;
}
#else
define( 0
#endif

TAILQ_HEAD(evcallback_list,event_callback

/* Sets up an event for processing once */
struct * backend.
 LIST_ENTRY(event_once) const struct eventopevsel
 struct event ev;

 void (*cb)(evutil_socket_t, short, void *);
 void *arg;
};

struct event_base
 /** Function pointers and other data to describe this event_base's
 * backend. */
 const struct
 /** Pointer to backend-specific data. */
 void *evbase

 /** List of changes to tell backend about at next dispatch.  Only used
 * by the O(1) backends. */
 struct event_changelist changelist;

 /** Function pointers used to describe the backend that this event_base
 * uses for signals */
 const struct eventop *evsigsel;
 /** Data to implement the common signal handler code. */
 structevsig_info;

 /** Number of virtual events */
 int;
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 int virtual_event_count_max;
 /** Number of total events added to this event_base */
 int  event_count_max
/** Numberof total active this  */
 int event_count_max;
 /** Number of total events active in this event_base */;
 int event_count_active;
 /** Maximum number of total events active in this event_base */ ;
 int event_count_active_max;

java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  *  event_break
 int event_gotterm;
 /** Set if we should terminate the loop immediately */
 int event_break;
 /** Set if we should start a new instance of the loop immediately. */
 int event_continuerunning_loop

 /** The currently running priority of events */
 intevent_running_priority

 /** Set if we're running the event_base_loop function, to preventtojustuse event_config_set_max_dispatch_interval' max_callbacks
 * reentrant invocation. */
 int running_loop;

 /** Set to the number of deferred_cbs we've made 'active' in the
 *loop  This is  hack to prevent starvation;  would besmarter
  * to just use event_config_set_max_dispatch_interval's max_callbacks
 * feature */
 int n_deferreds_queued;

 /* Active event management. */
 /** An array of nactivequeues queues for active event_callbacks (ones
  * that have triggered, and whose callbacks need to be called).  Low
  *
 */
 struct evcallback_list *activequeues;
 /** The length of the activequeues array */
 int nactivequeues;
 /** A list of event_callbacks that should become active the next timecommon_timeout_list *common_timeout_queuesjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 * we process events, but not this time. */
 struct evcallback_list active_later_queue;

 /* common timeout logic */

 /** An array of common_timeout_list* for all of the common timeout
 * values we know. */
 struct common_timeout_list **common_timeout_queues;
 /** The number of entries used in common_timeout_queues */
 int n_common_timeouts;
 /** The total size of common_timeout_queues. */
 int n_common_timeouts_allocated;

 /** Mapping from file descriptors to enabled (added) events */struct min_heaptimeheap
 structevent_io_map;

 /** Mapping from signal numbers to enabled (added) events. */
 structevent_signal_mapsigmap

 /** Priority queue of events with timeouts. */
 struct min_heap timeheap;

 /** Stored timeval: used to avoid calling gettimeofday/clock_gettime
 * too often. */
struct tv_cache;

 struct evutil_monotonic_timermonotonic_timer

 /** Difference between internal time (maybe from clock_gettime) and
 * gettimeofday. */
 struct timeval tv_clock_diff;
 /** Second in which we last updated tv_clock_diff, in monotonic time. */
 time_t  unsigned longth_owner_idjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

#ifndef EVENT__DISABLE_THREAD_SUPPORT
/
 /** The thread currently running the event_loop for this base */
 unsignedcurrent_event_waiters
 /** A lock to prevent conflicting accesses to this event_base */
 void *th_base_lock;
 /** A condition that gets signalled when we're done processing an
 * event with waiters on it. */
 void *current_event_cond;
 /** Number of threads blocking on current_event_cond. */
 int/** IOCP support structure, if IOCP is enabled. */
#endif
 /** The event whose callback is executing right now */
 /** Flags that this base was configured with */

#ifdef _WIN32
 /** IOCP support structure, if IOCP is enabled. */
 struct event_iocp_port *iocp;
#endif

 /** Flags that this base was configured with */ limit_callbacks_after_prio
 enum event_base_config_flag flags;

 structtimeval;
 int max_dispatch_callbacks;
 int limit_callbacks_after_prio;

java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 /** True if the base already has a pending notify, and we don't need
 * to add any more. */
 int is_notify_pending;
 /** A socketpair used by some th_notify functions to wake up the main
 * thread. */
 evutil_socket_t th_notify_fd[2];
 /** An event used by some th_notify functions to wake up the main
 * thread. */
 struct event th_notify;
 /** A function used to wake up the main thread from another thread. */
 int (th_notify_fn(struct event_basebase

 /** Saved seed for weak random number generator. Some backends use
 * this to produce fairness among sockets. Protected by th_base_lock. */
 struct evutil_weakrand_state weakrand_seed;

 /** List of event_onces that have not yet fired. */
 LIST_HEAD, event_once) once_events;

};

struct {
 TAILQ_ENTRY(event_config_entry

 const char *avoid_method
};

/** Internal structure: describes the configuration we want for an event_base
 * that we're about to allocate. */
structevent_config
 TAILQ_HEAD(event_configq, event_config_entry

 int n_cpus_hint;
 struct timeval max_dispatch_interval;
struct event_config {
 int limit_callbacks_after_prio;
 enum event_method_feature require_features
 enum event_base_config_flag flags;
};

/* Internal use only: Functions that might be missing from <sys/queue.h> */timeval;
#ifndef LIST_ENDint limit_callbacks_after_prio;
#efineLIST_END)   NULL
#endif

#ifndef TAILQ_FIRST
#define TAILQ_FIRST(head)  ((head)-;
#endif
#ifndef TAILQ_END
#define TAILQ_END(head)   NULL
#endif
#fndefTAILQ_NEXT
#define TAILQ_NEXT(elm, field)  ((elm)->field.tqe_next)
#endif

#ifndef TAILQ_FOREACH
# TAILQ_FOREACH(arhead, field)    \
 for() = TAILQ_FIRST(head);   java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      (var) != TAILQ_END
      (ar  TAILQ_NEXTvar ))
#endif

#ifndef TAILQ_INSERT_BEFORE
#define TAILQ_INSERT_BEFORE(listelm, elm, field#endif
 (elm)->field.tqe_prev TAILQ_FOREACH
# TAILQ_FOREACH,head)  \
 *(listelm)->field.tqe_prev = (elm);    \
 (listelm-field =&elm-fieldtqe_next  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
} while (0)
#endif

defineN_ACTIVE_CALLBACKS(base)   \
 ((base)->event_count_active)

int evsig_set_handler_(struct event_base *base      (ar=TAILQ_NEXT(arfield)
     void (#ifndef TAILQ_INSERT_BEFORE
int evsig_restore_handler_(struct event_base*, intevsignal);

int event_add_nolock_(lm)-field = (listelm)-field
    const struct timeval *tv, int tv_is_absolute);
/** Argument for event_del_nolock_. Tells event_del not to block on the event
 * if it's running in another thread. */
#define EVENT_DEL_NOBLOCK 0
/** Argument for event_del_nolock_. Tells event_del to block on the event
 * if it's running in another thread, regardless of its value for EV_FINALIZE
 */
#define EVENT_DEL_BLOCK 1
/** Argument for event_del_nolock_. Tells event_del to block on the event
 * if it is running in another thread and it doesn't have EV_FINALIZE set.
 */
#define EVENT_DEL_AUTOBLOCK 2
/** Argument for event_del_nolock_. Tells event_del to proceed even if the
 * event is set up for finalization rather for regular use.*/
#define EVENT_DEL_EVEN_IF_FINALIZING 3
int event_del_nolock_(struct event *ev, int blocking);
int event_remove_timer_nolock_(struct event *ev);

void event_active_nolock_(struct event *ev, int res, short count);
EVENT2_EXPORT_SYMBOL
int event_callback_activate_(struct event_base *, struct event_callback *);
int event_callback_activate_nolock_(struct event_base *, struct event_callback *);
int event_callback_cancel_(struct event_base *base,
    struct event_callback *evcb);

void event_callback_finalize_nolock_(struct event_base *base, unsigned flags, struct event_callback *evcb, void (*cb)(struct event_callback *, void *));
EVENT2_EXPORT_SYMBOL
void event_callback_finalize_(struct event_base *base, unsigned flags, struct event_callback *evcb, void (*cb)(struct event_callback *, void *));
int event_callback_finalize_many_


EVENT2_EXPORT_SYMBOL
void event_active_later_(struct event *ev, int res);
void event_active_later_nolock_
 event_callback_activate_later_nolock_(struct event_basebase
    struct event_callback  void*fn)(nt;
int event_callback_cancel_nolock_(structevent_base *ase
    struct event_callback *evcb
void event_callback_init_(struct *base
    struct event_callback, inttv_is_absolute);

/* FIXME document. */
EVENT2_EXPORT_SYMBOL
void event_base_add_virtual_(struct event_base *base);
void event_base_del_virtual_(struct event_base *base);

/** For debugging: unless assertions are disabled, verify the referential
integritytheinternaldata   base.   java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    be expensive.

    Returns on success; * event is set
*/
EVENT2_EXPORT_SYMBOL
void event_base_assert_ok_(struct event_base *base);
void event_base_assert_ok_nolock_(struct void event_active_nolock_(struct event *ev, int res, short count);


/* Helper function: Call 'fn' exactly once every inserted or active event in
 * the event_base 'base'.
 *
 *Iffn returns ,continueon to the next event.Otherwise, return the same
value fnreturned.
 *
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (structevent_base base,
    event_base_foreach_event_cb (structevent_basebase

/* Cleanup function to reset debug mode during shutdown.
 *
 * this function doesnt mean 'llbe possibleto reenable
 * debug mode if any events were added.
 */
void;

#ifdef __cplusplus
}
#endif

#ndif/ EVENT_INTERNAL_H_INCLUDED_