summaryrefslogtreecommitdiff
path: root/event.c
diff options
context:
space:
mode:
Diffstat (limited to 'event.c')
-rw-r--r--event.c347
1 files changed, 347 insertions, 0 deletions
diff --git a/event.c b/event.c
new file mode 100644
index 0000000..0cd278d
--- /dev/null
+++ b/event.c
@@ -0,0 +1,347 @@
+/*
+ * libevent compatibility layer
+ *
+ * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * 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
+ * OWNER 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.
+ */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+#include "event.h"
+
+struct event_base
+{
+ int dummy;
+};
+
+static int x_actives;
+
+static struct event_base x_base, *x_cur;
+
+static void
+tv_set (struct timeval *tv, ev_tstamp at)
+{
+ tv->tv_sec = (long)at;
+ tv->tv_usec = (long)((at - (ev_tstamp)tv->tv_sec) * 1e6);
+}
+
+static ev_tstamp
+tv_get (struct timeval *tv)
+{
+ if (tv)
+ return tv->tv_sec + tv->tv_usec * 1e-6;
+ else
+ return -1.;
+}
+
+#define EVENT_VERSION(a,b) # a "." # b
+
+const char *event_get_version (void)
+{
+ return EVENT_VERSION (EV_VERSION_MAJOR, EV_VERSION_MINOR);
+}
+
+const char *event_get_method (void)
+{
+ return "libev";
+}
+
+void *event_init (void)
+{
+ if (ev_init (0))
+ return x_cur = &x_base;
+
+ return 0;
+}
+
+void event_base_free (struct event_base *base)
+{
+ /* nop */
+}
+
+int event_dispatch (void)
+{
+ return event_base_dispatch (x_cur);
+}
+
+void event_set_log_callback (event_log_cb cb)
+{
+ /* nop */
+}
+
+int event_loop (int flags)
+{
+ return event_base_loop (x_cur, flags);
+}
+
+int event_loopexit (struct timeval *tv)
+{
+ event_base_loopexit (x_cur, tv);
+}
+
+static void
+x_cb (struct event *ev, int revents)
+{
+ if (ev_is_active (&ev->sig))
+ {
+ ev_signal_stop (&ev->sig);
+ --x_actives;
+ }
+
+ if (!(ev->ev_events & EV_PERSIST) && ev_is_active (&ev->io))
+ {
+ ev_io_stop (&ev->io);
+ --x_actives;
+ }
+
+ revents &= EV_READ | EV_WRITE | EV_TIMEOUT | EV_SIGNAL;
+
+ if (revents & EV_TIMEOUT)
+ --x_actives;
+
+ ev->ev_res = revents;
+ ev->ev_callback (ev->ev_fd, revents, ev->ev_arg);
+}
+
+static void
+x_cb_io (struct ev_io *w, int revents)
+{
+ x_cb ((struct event *)(((char *)w) - offsetof (struct event, io)), revents);
+}
+
+static void
+x_cb_to (struct ev_timer *w, int revents)
+{
+ x_cb ((struct event *)(((char *)w) - offsetof (struct event, to)), revents);
+}
+
+static void
+x_cb_sig (struct ev_signal *w, int revents)
+{
+ x_cb ((struct event *)(((char *)w) - offsetof (struct event, sig)), revents);
+}
+
+void event_set (struct event *ev, int fd, short events, void (*cb)(int, short, void *), void *arg)
+{
+ ev_watcher_init (&ev->io, x_cb_io);
+ ev_watcher_init (&ev->to, x_cb_to);
+ ev_watcher_init (&ev->sig, x_cb_sig);
+
+ ev->ev_base = x_cur;
+ ev->ev_fd = fd;
+ ev->ev_events = events;
+ ev->ev_pri = 0;
+ ev->ev_callback = cb;
+ ev->ev_arg = arg;
+ ev->ev_res = 0;
+}
+
+int event_once (int fd, short events, void (*cb)(int, short, void *), void *arg, struct timeval *tv)
+{
+ event_base_once (x_cur, fd, events, cb, arg, tv);
+}
+
+int event_add (struct event *ev, struct timeval *tv)
+{
+ if (tv)
+ {
+ if (ev_is_active (&ev->to))
+ {
+ ev_timer_stop (&ev->to);
+ --x_actives;
+ }
+
+ ev_timer_set (&ev->to, tv_get (tv), 0.);
+ ev_timer_start (&ev->to);
+ ++x_actives;
+ }
+
+ if (ev->ev_events & (EV_READ|EV_WRITE))
+ {
+ if (ev_is_active (&ev->io))
+ {
+ ev_io_stop (&ev->io);
+ --x_actives;
+ }
+
+ ev_io_set (&ev->io, ev->ev_fd, ev->ev_events);
+ ev_io_start (&ev->io);
+ ++x_actives;
+ }
+
+ if (ev->ev_events & EV_SIGNAL)
+ {
+ if (ev_is_active (&ev->sig))
+ {
+ ev_signal_stop (&ev->sig);
+ --x_actives;
+ }
+
+ ev_signal_set (&ev->sig, ev->ev_fd);
+ ev_signal_start (&ev->sig);
+ ++x_actives;
+ }
+
+ return 0;
+}
+
+int event_del (struct event *ev)
+{
+ if (ev_is_active (&ev->io))
+ {
+ ev_io_stop (&ev->io);
+ --x_actives;
+ }
+
+ if (ev_is_active (&ev->to))
+ {
+ ev_timer_stop (&ev->to);
+ --x_actives;
+ }
+
+ if (ev_is_active (&ev->sig))
+ {
+ ev_signal_stop (&ev->sig);
+ --x_actives;
+ }
+
+ return 0;
+}
+
+void event_active (struct event *ev, int fd, short events)
+{
+ /* unclear what this does, likely internal-use */
+}
+
+int event_pending (struct event *ev, short events, struct timeval *tv)
+{
+ short revents;
+
+ if (ev->io.pending)
+ revents |= ev->ev_events & (EV_READ | EV_WRITE);
+
+ if (ev->to.pending)
+ {
+ revents |= EV_TIMEOUT;
+
+ if (tv)
+ tv_set (tv, ev_now); /* not sure if this is right :) */
+ }
+
+ if (ev->sig.pending)
+ revents |= EV_SIGNAL;
+
+ return events & revents;
+}
+
+int event_priority_init (int npri)
+{
+ return event_base_priority_init (x_cur, npri);
+}
+
+int event_priority_set (struct event *ev, int pri)
+{
+ ev->ev_pri = pri;
+
+ return 0;
+}
+
+int event_base_set (struct event_base *base, struct event *ev)
+{
+ ev->ev_base = base;
+
+ return 0;
+}
+
+int event_base_loop (struct event_base *base, int flags)
+{
+ do
+ {
+ ev_loop (flags | EVLOOP_ONESHOT);
+ }
+ while (!(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)) && x_actives && !ev_loop_done);
+
+ return 0;
+}
+
+int event_base_dispatch (struct event_base *base)
+{
+ return event_base_loop (base, 0);
+}
+
+static void
+x_loopexit_cb (int revents, void *arg)
+{
+ ev_loop_done = 2;
+}
+
+int event_base_loopexit (struct event_base *base, struct timeval *tv)
+{
+ ev_tstamp after = tv_get (tv);
+
+ ev_once (-1, 0, after >= 0. ? after : 0., x_loopexit_cb, (void *)base);
+}
+
+struct x_once
+{
+ int fd;
+ void (*cb)(int, short, void *);
+ void *arg;
+};
+
+static void
+x_once_cb (int revents, void *arg)
+{
+ struct x_once *once = arg;
+
+ once->cb (once->fd, revents, once->arg);
+ free (once);
+}
+
+int event_base_once (struct event_base *base, int fd, short events, void (*cb)(int, short, void *), void *arg, struct timeval *tv)
+{
+ struct x_once *once = malloc (sizeof (struct x_once));
+
+ if (!once)
+ return -1;
+
+ once->fd = fd;
+ once->cb = cb;
+ once->arg = arg;
+
+ ev_once (fd, events & (EV_READ|EV_WRITE), tv_get (tv), x_once_cb, (void *)once);
+
+ return 0;
+}
+
+int event_base_priority_init (struct event_base *base, int npri)
+{
+ return 0;
+}
+