/*

 * util/ub_event.c - directly call libevent (compatibility) functions

 *

 * Copyright (c) 2007, NLnet Labs. All rights reserved.

 *

 * This software is open source.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 

 * Redistributions of source code must retain the above copyright notice,

 * this list of conditions and the following disclaimer.

 * 

 * Redistributions in binary form must reproduce the above copyright notice,

 * this list of conditions and the following disclaimer in the documentation

 * and/or other materials provided with the distribution.

 * 

 * Neither the name of the NLNET LABS nor the names of its contributors may

 * be used to endorse or promote products derived from this software without

 * specific prior written permission.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/**

 * \file

 *

 * This file contains and implementation for the indirection layer for pluggable

 * events that transparently passes it either directly to libevent, or calls

 * the libevent compatibility layer functions.

 */

#include "config.h"

#include <sys/time.h>

#include "util/ub_event.h"

#include "util/log.h"

#include "util/netevent.h"

#include "util/tube.h"

#include "daemon/remote.h"

#ifdef USE_DNSTAP

#include "dnstap/dtstream.h"

#endif

#ifdef UB_ON_WINDOWS

#include "winrc/win_svc.h"

#endif

/* We define libevent structures here to hide the libevent stuff. */

#ifdef USE_MINI_EVENT

#  ifdef USE_WINSOCK

#    include "util/winsock_event.h"

#  else

#    include "util/mini_event.h"

#  endif /* USE_WINSOCK */

#else /* USE_MINI_EVENT */

   /* we use libevent */

#  ifdef HAVE_EVENT_H

#    include <event.h>

#  else

#    include "event2/event.h"

#    include "event2/event_struct.h"

#    include "event2/event_compat.h"

#  endif

#endif /* USE_MINI_EVENT */

#if UB_EV_TIMEOUT != EV_TIMEOUT || UB_EV_READ != EV_READ || \

    UB_EV_WRITE != EV_WRITE || UB_EV_SIGNAL != EV_SIGNAL || \

    UB_EV_PERSIST != EV_PERSIST 

/* Only necessary for libev */ 

#  define NATIVE_BITS(b) ( \

    (((b) & UB_EV_TIMEOUT) ? EV_TIMEOUT : 0) \

  | (((b) & UB_EV_READ   ) ? EV_READ    : 0) \

  | (((b) & UB_EV_WRITE  ) ? EV_WRITE   : 0) \

  | (((b) & UB_EV_SIGNAL ) ? EV_SIGNAL  : 0) \

  | (((b) & UB_EV_PERSIST) ? EV_PERSIST : 0))

#  define UB_EV_BITS(b) ( \

    (((b) & EV_TIMEOUT) ? UB_EV_TIMEOUT : 0) \

  | (((b) & EV_READ   ) ? UB_EV_READ    : 0) \

  | (((b) & EV_WRITE  ) ? UB_EV_WRITE   : 0) \

  | (((b) & EV_SIGNAL ) ? UB_EV_SIGNAL  : 0) \

  | (((b) & EV_PERSIST) ? UB_EV_PERSIST : 0))

#  define UB_EV_BITS_CB(C) void my_ ## C (int fd, short bits, void *arg) \

  { (C)(fd, UB_EV_BITS(bits), arg); }

UB_EV_BITS_CB(comm_point_udp_callback);

UB_EV_BITS_CB(comm_point_udp_ancil_callback)

UB_EV_BITS_CB(comm_point_tcp_accept_callback)

UB_EV_BITS_CB(comm_point_tcp_handle_callback)

UB_EV_BITS_CB(comm_timer_callback)

UB_EV_BITS_CB(comm_signal_callback)

UB_EV_BITS_CB(comm_point_local_handle_callback)

UB_EV_BITS_CB(comm_point_raw_handle_callback)

UB_EV_BITS_CB(tube_handle_signal)

UB_EV_BITS_CB(comm_base_handle_slow_accept)

UB_EV_BITS_CB(comm_point_http_handle_callback)

#ifdef HAVE_NGTCP2

UB_EV_BITS_CB(comm_point_doq_callback)

#endif

UB_EV_BITS_CB(fast_reload_service_cb)

#ifdef USE_DNSTAP

UB_EV_BITS_CB(dtio_output_cb)

UB_EV_BITS_CB(dtio_cmd_cb)

UB_EV_BITS_CB(dtio_reconnect_timeout_cb)

UB_EV_BITS_CB(dtio_stop_timer_cb)

UB_EV_BITS_CB(dtio_stop_ev_cb)

UB_EV_BITS_CB(dtio_tap_callback)

UB_EV_BITS_CB(dtio_mainfdcallback)

#endif

#ifdef HAVE_NGTCP2

UB_EV_BITS_CB(doq_client_event_cb)

UB_EV_BITS_CB(doq_client_timer_cb)

#endif

#ifdef UB_ON_WINDOWS

UB_EV_BITS_CB(worker_win_stop_cb)

#endif

static void (*NATIVE_BITS_CB(void (*cb)(int, short, void*)))(int, short, void*)

{

  if(cb == comm_point_udp_callback)

    return my_comm_point_udp_callback;

  else if(cb == comm_point_udp_ancil_callback)

    return my_comm_point_udp_ancil_callback;

  else if(cb == comm_point_tcp_accept_callback)

    return my_comm_point_tcp_accept_callback;

  else if(cb == comm_point_tcp_handle_callback)

    return my_comm_point_tcp_handle_callback;

  else if(cb == comm_timer_callback)

    return my_comm_timer_callback;

  else if(cb == comm_signal_callback)

    return my_comm_signal_callback;

  else if(cb == comm_point_local_handle_callback)

    return my_comm_point_local_handle_callback;

  else if(cb == comm_point_raw_handle_callback)

    return my_comm_point_raw_handle_callback;

  else if(cb == comm_point_http_handle_callback)

    return my_comm_point_http_handle_callback;

  else if(cb == tube_handle_signal)

    return my_tube_handle_signal;

  else if(cb == comm_base_handle_slow_accept)

    return my_comm_base_handle_slow_accept;

#ifdef HAVE_NGTCP2

  else if(cb == comm_point_doq_callback)

    return my_comm_point_doq_callback;

#endif

  else if(cb == fast_reload_service_cb)

    return my_fast_reload_service_cb;

#ifdef USE_DNSTAP

  else if(cb == dtio_output_cb)

    return my_dtio_output_cb;

  else if(cb == dtio_cmd_cb)

    return my_dtio_cmd_cb;

  else if(cb == dtio_reconnect_timeout_cb)

    return my_dtio_reconnect_timeout_cb;

  else if(cb == dtio_stop_timer_cb)

    return my_dtio_stop_timer_cb;

  else if(cb == dtio_stop_ev_cb)

    return my_dtio_stop_ev_cb;

  else if(cb == dtio_tap_callback)

    return my_dtio_tap_callback;

  else if(cb == dtio_mainfdcallback)

    return my_dtio_mainfdcallback;

#endif

#ifdef HAVE_NGTCP2

  else if(cb == doq_client_event_cb)

    return my_doq_client_event_cb;

  else if(cb == doq_client_timer_cb)

    return my_doq_client_timer_cb;

#endif

#ifdef UB_ON_WINDOWS

  else if(cb == worker_win_stop_cb)

    return my_worker_win_stop_cb;

#endif

  else {

    log_assert(0); /* this NULL callback pointer should not happen,

      we should have the necessary routine listed above */

    return NULL;

  }

}

#else 

#  define NATIVE_BITS(b) (b)

#  define NATIVE_BITS_CB(c) (c)

#endif

#ifndef EVFLAG_AUTO

#define EVFLAG_AUTO 0

#endif

#define AS_EVENT_BASE(x) ((struct event_base*)x)

#define AS_UB_EVENT_BASE(x) ((struct ub_event_base*)x)

#define AS_EVENT(x) ((struct event*)x)

#define AS_UB_EVENT(x) ((struct ub_event*)x)

const char* ub_event_get_version(void)

{

  return event_get_version();

}

#if (defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)) && defined(EV_FEATURE_BACKENDS)

static const char* ub_ev_backend2str(int b)

{

  switch(b) {

  case EVBACKEND_SELECT:  return "select";

  case EVBACKEND_POLL:  return "poll";

  case EVBACKEND_EPOLL: return "epoll";

  case EVBACKEND_KQUEUE:  return "kqueue";

  case EVBACKEND_DEVPOLL: return "devpoll";

  case EVBACKEND_PORT:  return "evport";

  }

  return "unknown";

}

#endif

void

ub_get_event_sys(struct ub_event_base* base, const char** n, const char** s,

  const char** m)

{

#ifdef USE_WINSOCK

  (void)base;

  *n = "event";

  *s = "winsock";

  *m = "WSAWaitForMultipleEvents";

#elif defined(USE_MINI_EVENT)

  (void)base;

  *n = "mini-event";

  *s = "internal";

  *m = "select";

#else

  struct event_base* b = AS_EVENT_BASE(base);

  *s = event_get_version();

#  if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)

  *n = "libev";

  if (!b)

    b = (struct event_base*)ev_default_loop(EVFLAG_AUTO);

#    ifdef EV_FEATURE_BACKENDS

  *m = ub_ev_backend2str(ev_backend((struct ev_loop*)b));

#    else

  *m = "not obtainable";

#    endif

#  elif defined(HAVE_EVENT_BASE_GET_METHOD)

  *n = "libevent";

  if (!b)

    b = event_base_new();

  *m = event_base_get_method(b);

#  else

  *n = "unknown";

  *m = "not obtainable";

  (void)b;

#  endif

#  ifdef HAVE_EVENT_BASE_FREE

  if (b && b != AS_EVENT_BASE(base))

    event_base_free(b);

#  endif

#endif

}

struct ub_event_base*

ub_default_event_base(int sigs, time_t* time_secs, struct timeval* time_tv)

{

  void* base;

  (void)base;

#ifdef USE_MINI_EVENT

  (void)sigs;

  /* use mini event time-sharing feature */

  base = event_init(time_secs, time_tv);

#else

  (void)time_secs;

  (void)time_tv;

#  if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)

  /* libev */

  if(sigs)

    base = ev_default_loop(EVFLAG_AUTO);

  else

    base = ev_loop_new(EVFLAG_AUTO);

#  else

  (void)sigs;

#    ifdef HAVE_EVENT_BASE_NEW

  base = event_base_new();

#    else

  base = event_init();

#    endif

#  endif

#endif

  return (struct ub_event_base*)base;

}

struct ub_event_base *

ub_libevent_event_base(struct event_base* libevent_base)

{

#ifdef USE_MINI_EVENT

  (void)libevent_base;

  return NULL;

#else

  return AS_UB_EVENT_BASE(libevent_base);

#endif

}

struct event_base *

ub_libevent_get_event_base(struct ub_event_base* base)

{

#ifdef USE_MINI_EVENT

  (void)base;

  return NULL;

#else

  return AS_EVENT_BASE(base);

#endif

}

void

ub_event_base_free(struct ub_event_base* base)

{

#ifdef USE_MINI_EVENT

  event_base_free(AS_EVENT_BASE(base));

#elif defined(HAVE_EVENT_BASE_FREE) && defined(HAVE_EVENT_BASE_ONCE)

  /* only libevent 1.2+ has it, but in 1.2 it is broken - 

     assertion fails on signal handling ev that is not deleted

     in libevent 1.3c (event_base_once appears) this is fixed. */

  event_base_free(AS_EVENT_BASE(base));

#else

  (void)base;

#endif /* HAVE_EVENT_BASE_FREE and HAVE_EVENT_BASE_ONCE */

}

int

ub_event_base_dispatch(struct ub_event_base* base)

{

  return event_base_dispatch(AS_EVENT_BASE(base));

}

int

ub_event_base_loopexit(struct ub_event_base* base)

{

  return event_base_loopexit(AS_EVENT_BASE(base), NULL);

}

struct ub_event*

ub_event_new(struct ub_event_base* base, int fd, short bits,

  void (*cb)(int, short, void*), void* arg)

{

  struct event *ev = (struct event*)calloc(1, sizeof(struct event));

  if (!ev)

    return NULL;

#ifndef HAVE_EVENT_ASSIGN

  event_set(ev, fd, NATIVE_BITS(bits), NATIVE_BITS_CB(cb), arg);

  if (event_base_set(AS_EVENT_BASE(base), ev) != 0) {

    free(ev);

    return NULL;

  }

#else

  if (event_assign(ev, AS_EVENT_BASE(base), fd, bits, cb, arg) != 0) {

    free(ev);

    return NULL;

  }

#endif

  return AS_UB_EVENT(ev);

}

struct ub_event*

ub_signal_new(struct ub_event_base* base, int fd,

  void (*cb)(int, short, void*), void* arg)

{

  struct event *ev = (struct event*)calloc(1, sizeof(struct event));

  if (!ev)

    return NULL;

#if !HAVE_DECL_EVSIGNAL_ASSIGN

  signal_set(ev, fd, NATIVE_BITS_CB(cb), arg);

  if (event_base_set(AS_EVENT_BASE(base), ev) != 0) {

    free(ev);

    return NULL;

  }

#else

  if (evsignal_assign(ev, AS_EVENT_BASE(base), fd, cb, arg) != 0) {

    free(ev);

    return NULL;

  }

#endif

  return AS_UB_EVENT(ev);

}

struct ub_event*

ub_winsock_register_wsaevent(struct ub_event_base* base, void* wsaevent,

  void (*cb)(int, short, void*), void* arg)

{

#if defined(USE_MINI_EVENT) && defined(USE_WINSOCK)

  struct event *ev = (struct event*)calloc(1, sizeof(struct event));

  if (!ev)

    return NULL;

  if (winsock_register_wsaevent(AS_EVENT_BASE(base), ev, wsaevent, cb,

        arg))

    return AS_UB_EVENT(ev);

  free(ev);

  return NULL;

#else

  (void)base;

  (void)wsaevent;

  (void)cb;

  (void)arg;

  return NULL;

#endif

}

void

ub_event_add_bits(struct ub_event* ev, short bits)

{

  AS_EVENT(ev)->ev_events |= NATIVE_BITS(bits);

}

void

ub_event_del_bits(struct ub_event* ev, short bits)

{

  AS_EVENT(ev)->ev_events &= ~NATIVE_BITS(bits);

}

void

ub_event_set_fd(struct ub_event* ev, int fd)

{

  AS_EVENT(ev)->ev_fd = fd;

}

void

ub_event_free(struct ub_event* ev)

{

  if (ev)

    free(AS_EVENT(ev));

}

int

ub_event_add(struct ub_event* ev, struct timeval* tv)

{

  return event_add(AS_EVENT(ev), tv);

}

int

ub_event_del(struct ub_event* ev)

{

  return event_del(AS_EVENT(ev));

}

int

ub_timer_add(struct ub_event* ev, struct ub_event_base* base,

  void (*cb)(int, short, void*), void* arg, struct timeval* tv)

{

  event_set(AS_EVENT(ev), -1, EV_TIMEOUT, NATIVE_BITS_CB(cb), arg);

  if (event_base_set(AS_EVENT_BASE(base), AS_EVENT(ev)) != 0)

    return -1;

  return evtimer_add(AS_EVENT(ev), tv);

}

int

ub_timer_del(struct ub_event* ev)

{

  return evtimer_del(AS_EVENT(ev));

}

int

ub_signal_add(struct ub_event* ev, struct timeval* tv)

{

  return signal_add(AS_EVENT(ev), tv);

}

int

ub_signal_del(struct ub_event* ev)

{

  return signal_del(AS_EVENT(ev));

}

void

ub_winsock_unregister_wsaevent(struct ub_event* ev)

{

#if defined(USE_MINI_EVENT) && defined(USE_WINSOCK)

  winsock_unregister_wsaevent(AS_EVENT(ev));

  free(AS_EVENT(ev));

#else

  (void)ev;

#endif

}

void

ub_winsock_tcp_wouldblock(struct ub_event* ev, int eventbits)

{

#if defined(USE_MINI_EVENT) && defined(USE_WINSOCK)

  winsock_tcp_wouldblock(AS_EVENT(ev), NATIVE_BITS(eventbits));

#else

  (void)ev;

  (void)eventbits;

#endif

}

void ub_comm_base_now(struct comm_base* cb)

{

#ifdef USE_MINI_EVENT

/** minievent updates the time when it blocks. */

  (void)cb; /* nothing to do */

#else /* !USE_MINI_EVENT */

/** fillup the time values in the event base */

  time_t *tt;

  struct timeval *tv;

  comm_base_timept(cb, &tt, &tv);

  if(gettimeofday(tv, NULL) < 0) {

    log_err("gettimeofday: %s", strerror(errno));

  }

#ifndef S_SPLINT_S

  *tt = tv->tv_sec;

#endif

#endif /* USE_MINI_EVENT */

}