int

 event_add(struct event *ev, const struct timeval *tv)

 {

     int res;

     if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {

         event_warnx("%s: event has no event_base set.", __func__);

         return -;

     }

     EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);

     res = event_add_nolock_(ev, tv, );

     EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);

     return (res);

 }

 /* Implementation function to add an event.  Works just like event_add,

  * except: 1) it requires that we have the lock.  2) if tv_is_absolute is set,

  * we treat tv as an absolute time, not as an interval to add to the current

  * time */

 int

 event_add_nolock_(struct event *ev, const struct timeval *tv,

     int tv_is_absolute)

 {

     struct event_base *base = ev->ev_base;

     int res = ;

     int notify = ;

     EVENT_BASE_ASSERT_LOCKED(base);

     event_debug_assert_is_setup_(ev);

     event_debug((

          "event_add: event: %p (fd "EV_SOCK_FMT"), %s%s%s%scall %p",

          ev,

          EV_SOCK_ARG(ev->ev_fd),

          ev->ev_events & EV_READ ? "EV_READ " : " ",

          ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",

          ev->ev_events & EV_CLOSED ? "EV_CLOSED " : " ",

          tv ? "EV_TIMEOUT " : " ",

          ev->ev_callback));

     EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));

     if (ev->ev_flags & EVLIST_FINALIZING) {

         /* XXXX debug */

         return (-);

     }

     /*

      * prepare for timeout insertion further below, if we get a

      * failure on any step, we should not change any state.

      */

     if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {

         if (min_heap_reserve_(&base->timeheap,

              + min_heap_size_(&base->timeheap)) == -)

             return (-);  /* ENOMEM == errno */

     }

     /* If the main thread is currently executing a signal event's

      * callback, and we are not the main thread, then we want to wait

      * until the callback is done before we mess with the event, or else

      * we can race on ev_ncalls and ev_pncalls below. */

 #ifndef EVENT__DISABLE_THREAD_SUPPORT

     if (base->current_event == event_to_event_callback(ev) &&

         (ev->ev_events & EV_SIGNAL)

         && !EVBASE_IN_THREAD(base)) {

         ++base->current_event_waiters;

         EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);

     }

 #endif

     if ((ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED|EV_SIGNAL)) &&

         !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) {

         if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED))

             res = evmap_io_add_(base, ev->ev_fd, ev);

         else if (ev->ev_events & EV_SIGNAL)

             res = evmap_signal_add_(base, (int)ev->ev_fd, ev);

         if (res != -)

             event_queue_insert_inserted(base, ev);

         if (res == ) {

             /* evmap says we need to notify the main thread. */

             notify = ;

             res = ;

         }

     }

     /*

      * we should change the timeout state only if the previous event

      * addition succeeded.

      */

     if (res != - && tv != NULL) {

         struct timeval now;

         int common_timeout;

 #ifdef USE_REINSERT_TIMEOUT

         int was_common;

         int old_timeout_idx;

 #endif

         /*

          * for persistent timeout events, we remember the

          * timeout value and re-add the event.

          *

          * If tv_is_absolute, this was already set.

          */

         if (ev->ev_closure == EV_CLOSURE_EVENT_PERSIST && !tv_is_absolute)

             ev->ev_io_timeout = *tv;

 #ifndef USE_REINSERT_TIMEOUT

         if (ev->ev_flags & EVLIST_TIMEOUT) {

             event_queue_remove_timeout(base, ev);

         }

 #endif

         /* Check if it is active due to a timeout.  Rescheduling

          * this timeout before the callback can be executed

          * removes it from the active list. */

         if ((ev->ev_flags & EVLIST_ACTIVE) &&

             (ev->ev_res & EV_TIMEOUT)) {

             if (ev->ev_events & EV_SIGNAL) {

                 /* See if we are just active executing

                  * this event in a loop

                  */

                 if (ev->ev_ncalls && ev->ev_pncalls) {

                     /* Abort loop */

                     *ev->ev_pncalls = ;

                 }

             }

             event_queue_remove_active(base, event_to_event_callback(ev));

         }

         gettime(base, &now);

         common_timeout = is_common_timeout(tv, base);

 #ifdef USE_REINSERT_TIMEOUT

         was_common = is_common_timeout(&ev->ev_timeout, base);

         old_timeout_idx = COMMON_TIMEOUT_IDX(&ev->ev_timeout);

 #endif

         if (tv_is_absolute) {

             ev->ev_timeout = *tv;

         } else if (common_timeout) {

             struct timeval tmp = *tv;

             tmp.tv_usec &= MICROSECONDS_MASK;

             evutil_timeradd(&now, &tmp, &ev->ev_timeout);

             ev->ev_timeout.tv_usec |=

                 (tv->tv_usec & ~MICROSECONDS_MASK);

         } else {

             evutil_timeradd(&now, tv, &ev->ev_timeout);

         }

         event_debug((

              "event_add: event %p, timeout in %d seconds %d useconds, call %p",

              ev, (int)tv->tv_sec, (int)tv->tv_usec, ev->ev_callback));

 #ifdef USE_REINSERT_TIMEOUT

         event_queue_reinsert_timeout(base, ev, was_common, common_timeout, old_timeout_idx);

 #else

         event_queue_insert_timeout(base, ev);

 #endif

         if (common_timeout) {

             struct common_timeout_list *ctl =

                 get_common_timeout_list(base, &ev->ev_timeout);

             if (ev == TAILQ_FIRST(&ctl->events)) {

                 common_timeout_schedule(ctl, &now, ev);

             }

         } else {

             struct event* top = NULL;

             /* See if the earliest timeout is now earlier than it

              * was before: if so, we will need to tell the main

              * thread to wake up earlier than it would otherwise.

              * We double check the timeout of the top element to

              * handle time distortions due to system suspension.

              */

             if (min_heap_elt_is_top_(ev))

                 notify = ;

             else if ((top = min_heap_top_(&base->timeheap)) != NULL &&

                      evutil_timercmp(&top->ev_timeout, &now, <))

                 notify = ;

         }

     }

     /* if we are not in the right thread, we need to wake up the loop */

     if (res != - && notify && EVBASE_NEED_NOTIFY(base))

         evthread_notify_base(base);

     event_debug_note_add_(ev);

     return (res);

 }

 int

 event_del(struct event *ev)

 {

     return event_del_(ev, EVENT_DEL_AUTOBLOCK);

 }

 static int

 event_del_(struct event *ev, int blocking)

 {

     int res;

     if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {

         event_warnx("%s: event has no event_base set.", __func__);

         return -;

     }

     EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);

     res = event_del_nolock_(ev, blocking);

     EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);

     return (res);

 }

 /** Helper for event_del: always called with th_base_lock held.

  *

  * "blocking" must be one of the EVENT_DEL_{BLOCK, NOBLOCK, AUTOBLOCK,

  * EVEN_IF_FINALIZING} values. See those for more information.

  */

 int

 event_del_nolock_(struct event *ev, int blocking)

 {

     struct event_base *base;

     int res = , notify = ;

     event_debug(("event_del: %p (fd "EV_SOCK_FMT"), callback %p",

         ev, EV_SOCK_ARG(ev->ev_fd), ev->ev_callback));

     /* An event without a base has not been added */

     if (ev->ev_base == NULL)

         return (-);

     EVENT_BASE_ASSERT_LOCKED(ev->ev_base);

     if (blocking != EVENT_DEL_EVEN_IF_FINALIZING) {

         if (ev->ev_flags & EVLIST_FINALIZING) {

             /* XXXX Debug */

             return ;

         }

     }

     /* If the main thread is currently executing this event's callback,

      * and we are not the main thread, then we want to wait until the

      * callback is done before we start removing the event.  That way,

      * when this function returns, it will be safe to free the

      * user-supplied argument. */

     base = ev->ev_base;

 #ifndef EVENT__DISABLE_THREAD_SUPPORT

     if (blocking != EVENT_DEL_NOBLOCK &&

         base->current_event == event_to_event_callback(ev) &&

         !EVBASE_IN_THREAD(base) &&

         (blocking == EVENT_DEL_BLOCK || !(ev->ev_events & EV_FINALIZE))) {

         ++base->current_event_waiters;

         EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);

     }

 #endif

     EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));

     /* See if we are just active executing this event in a loop */

     if (ev->ev_events & EV_SIGNAL) {

         if (ev->ev_ncalls && ev->ev_pncalls) {

             /* Abort loop */

             *ev->ev_pncalls = ;

         }

     }

     if (ev->ev_flags & EVLIST_TIMEOUT) {

         /* NOTE: We never need to notify the main thread because of a

          * deleted timeout event: all that could happen if we don't is

          * that the dispatch loop might wake up too early.  But the

          * point of notifying the main thread _is_ to wake up the

          * dispatch loop early anyway, so we wouldn't gain anything by

          * doing it.

          */

         event_queue_remove_timeout(base, ev);

     }

     if (ev->ev_flags & EVLIST_ACTIVE)

         event_queue_remove_active(base, event_to_event_callback(ev));

     else if (ev->ev_flags & EVLIST_ACTIVE_LATER)

         event_queue_remove_active_later(base, event_to_event_callback(ev));

     if (ev->ev_flags & EVLIST_INSERTED) {

         event_queue_remove_inserted(base, ev);

         if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED))

             res = evmap_io_del_(base, ev->ev_fd, ev);

         else

             res = evmap_signal_del_(base, (int)ev->ev_fd, ev);

         if (res == ) {

             /* evmap says we need to notify the main thread. */

             notify = ;

             res = ;

         }

     }

     /* if we are not in the right thread, we need to wake up the loop */

     if (res != - && notify && EVBASE_NEED_NOTIFY(base))

         evthread_notify_base(base);

     event_debug_note_del_(ev);

     return (res);

 }