Make eloop entirely independant from dhcpcd.

diff --git a/configure b/configure
index b13c23265653a48af65ed2cd5d9f61b7014ebe9b..b1fec5cc0ff86e7ac795513599299c3be2befed1 100755 (executable)
--- a/configure
+++ b/configure
@@ -227,6 +227,7 @@ fi
 echo "Configuring dhcpcd for ... $OS"
 rm -f $CONFIG_H $CONFIG_MK
 echo "# $OS" >$CONFIG_MK
+echo "CPPFLAGS+=       -DHAVE_CONFIG_H" >>$CONFIG_MK
 echo "/* $OS */" >$CONFIG_H
 
 for x in SYSCONFDIR SBINDIR LIBDIR LIBEXECDIR DBDIR RUNDIR; do
@@ -755,7 +756,7 @@ if [ "$TAILQ_FOREACH_SAFE" = no -o "$TAILQ_CONCAT" = no ]; then
        fi
        echo "#include          \"compat/queue.h\"">>$CONFIG_H
 else
-       echo "#include          <sys/queue.h>" >>$CONFIG_H
+       echo "#define HAVE_SYS_QUEUE_H" >>$CONFIG_H
 fi
 
 if [ -z "$POSIX_SPAWN" ]; then

diff --git a/dhcpcd.c b/dhcpcd.c
index 82c09806448039f5faa75b01157a9af9d5fbb5dc..cadc6ed49f7dd89563b44053c0a8879966b78f9b 100644 (file)
--- a/dhcpcd.c
+++ b/dhcpcd.c
@@ -1803,6 +1803,10 @@ main(int argc, char **argv)
        }
 
        i = eloop_start(ctx.eloop, &ctx.sigset);
+       if (i < 0) {
+               syslog(LOG_ERR, "eloop_start: %m");
+               goto exit_failure;
+       }
        goto exit1;
 
 exit_success:

diff --git a/eloop.c b/eloop.c
index f2efb8d6a0e8256b35771cd874384366a1813c7d..77be77e3d07c331e0b229aeb6e31824b80cf14f5 100644 (file)
--- a/eloop.c
+++ b/eloop.c
@@ -33,18 +33,22 @@
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
-#include <syslog.h>
 #include <unistd.h>
 
 /* config.h should define HAVE_KQUEUE, HAVE_EPOLL, etc */
 #include "config.h"
 #include "eloop.h"
 
-/* custom syslog wrapper for dhcpcd */
-#include "common.h"
-#include "dhcpcd.h"
-#define syslog(PRIO, FMT, ...) \
-       logger((struct dhcpcd_ctx *)eloop->signal_cb_ctx, PRIO, FMT, __VA_ARGS__)
+#ifndef UNUSED
+#define UNUSED(a) (void)((a))
+#endif
+
+#ifndef MSEC_PER_SEC
+#define MSEC_PER_SEC   1000L
+#endif
+#ifndef NSEC_PER_MSEC
+#define NSEC_PER_MSEC  1000000L
+#endif
 
 #if defined(HAVE_KQUEUE)
 #include <sys/event.h>
@@ -138,7 +142,7 @@ eloop_event_add(struct eloop *eloop, int fd,
                                e->write_cb = write_cb;
                                e->write_cb_arg = write_cb_arg;
                        }
-                       eloop_event_setup_fds(eloop)
+                       eloop_event_setup_fds(eloop);
                        return error;
                }
        }
@@ -196,7 +200,6 @@ eloop_event_add(struct eloop *eloop, int fd,
        return 0;
 
 err:
-       syslog(LOG_ERR, "%s: %m", __func__);
        if (e) {
                eloop->events_len--;
                TAILQ_INSERT_TAIL(&eloop->free_events, e, next);
@@ -291,11 +294,8 @@ eloop_q_timeout_add_tv(struct eloop *eloop, int queue,
                if ((t = TAILQ_FIRST(&eloop->free_timeouts))) {
                        TAILQ_REMOVE(&eloop->free_timeouts, t, next);
                } else {
-                       t = malloc(sizeof(*t));
-                       if (t == NULL) {
-                               syslog(LOG_ERR, "%s: %m", __func__);
+                       if ((t = malloc(sizeof(*t))) == NULL)
                                return -1;
-                       }
                }
        }
 
@@ -327,19 +327,26 @@ eloop_q_timeout_add_sec(struct eloop *eloop, int queue, time_t when,
        return eloop_q_timeout_add_tv(eloop, queue, &tv, callback, arg);
 }
 
+int
+eloop_q_timeout_add_msec(struct eloop *eloop, int queue, long when,
+    void (*callback)(void *), void *arg)
+{
+       struct timespec tv;
+
+       tv.tv_sec = when / MSEC_PER_SEC;
+       tv.tv_nsec = (when % MSEC_PER_SEC) * NSEC_PER_MSEC;
+       return eloop_q_timeout_add_tv(eloop, queue, &tv, callback, arg);
+}
+
 #if !defined(HAVE_KQUEUE)
 static int
 eloop_timeout_add_now(struct eloop *eloop,
     void (*callback)(void *), void *arg)
 {
 
-       if (ctx->timeout0 != NULL) {
-               syslog(LOG_WARNING, "%s: timeout0 already set", __func__);
-               return eloop_q_timeout_add_sec(eloop, 0, 0, callback, arg);
-       }
-
-       ctx->timeout0 = callback;
-       ctx->timeout0_arg = arg;
+       assert(eloop->timeout0 == NULL);
+       eloop->timeout0 = callback;
+       eloop->timeout0_arg = arg;
        return 0;
 }
 #endif
@@ -477,15 +484,15 @@ struct eloop_siginfo {
        int sig;
        struct eloop *eloop;
 };
-static struct eloop_siginfo eloop_siginfo;
-static struct eloop *eloop;
+static struct eloop_siginfo _eloop_siginfo;
+static struct eloop *_eloop;
 
 static void
 eloop_signal1(void *arg)
 {
        struct eloop_siginfo *si = arg;
 
-       si->eloop->signal_cb(si->sig, si->eloop->signal_cb_arg);
+       si->eloop->signal_cb(si->sig, si->eloop->signal_cb_ctx);
 }
 
 static void
@@ -495,9 +502,10 @@ eloop_signal3(int sig, __unused siginfo_t *siginfo, __unused void *arg)
        /* So that we can operate safely under a signal we instruct
         * eloop to pass a copy of the siginfo structure to handle_signal1
         * as the very first thing to do. */
-       eloop_siginfo.sig = sig;
-       eloop_siginfo.eloop = eloop;
-       eloop_timeout_add_now(eloop, eloop_signal1, &eloop_siginfo);
+       _eloop_siginfo.eloop = _eloop;
+       _eloop_siginfo.sig = sig;
+       eloop_timeout_add_now(_eloop_siginfo.eloop,
+           eloop_signal1, &_eloop_siginfo);
 }
 #endif
 
@@ -595,15 +603,17 @@ eloop_start(struct eloop *eloop, sigset_t *signals)
        struct eloop_timeout *t;
        struct timespec now, ts, *tsp;
        void (*t0)(void *);
-#if defined(HAVE_EPOLL) || !defined(USE_SIGNALS)
-       int timeout;
-#endif
 #if defined(HAVE_KQUEUE)
        struct kevent ke;
        UNUSED(signals);
 #elif defined(HAVE_EPOLL)
        struct epoll_event epe;
 #endif
+#ifndef HAVE_KQUEUE
+       int timeout;
+
+       _eloop = eloop;
+#endif
 
        for (;;) {
                if (eloop->exitnow)
@@ -630,12 +640,10 @@ eloop_start(struct eloop *eloop, sigset_t *signals)
                        /* No timeouts, so wait forever */
                        tsp = NULL;
 
-               if (tsp == NULL && eloop->events_len == 0) {
-                       syslog(LOG_WARNING, "%s: nothing to do", __func__);
+               if (tsp == NULL && eloop->events_len == 0)
                        break;
-               }
 
-#if defined(HAVE_EPOLL) || !defined(USE_SIGNALS)
+#ifndef HAVE_KQUEUE
                if (tsp == NULL)
                        timeout = -1;
                else if (tsp->tv_sec > INT_MAX / 1000 ||
@@ -650,23 +658,23 @@ eloop_start(struct eloop *eloop, sigset_t *signals)
 #if defined(HAVE_KQUEUE)
                n = kevent(eloop->poll_fd, NULL, 0, &ke, 1, tsp);
 #elif defined(HAVE_EPOLL)
-#ifdef USE_SIGNALS
-               n = epoll_pwait(eloop->poll_fd, &epe, 1, timeout, signals);
-#else
-               n = epoll_wait(eloop->poll_fd, &epe, 1, timeout);
-#endif
-#else
-#ifdef USE_SIGNALS
-               n = pollts(eloop->fds, (nfds_t)eloop->events_len, tsp, signals);
+               if (signals)
+                       n = epoll_pwait(eloop->poll_fd, &epe, 1,
+                           timeout, signals);
+               else
+                       n = epoll_wait(eloop->poll_fd, &epe, 1, timeout);
 #else
-               n = poll(eloop->fds, (nfds_t)eloop->events_len, timeout);
-#endif
+               if (signals)
+                       n = pollts(eloop->fds, (nfds_t)eloop->events_len,
+                           tsp, signals);
+               else
+                       n = poll(eloop->fds, (nfds_t)eloop->events_len,
+                           timeout);
 #endif
                if (n == -1) {
                        if (errno == EINTR)
                                continue;
-                       syslog(LOG_ERR, "%s: poll: %m", __func__);
-                       break;
+                       return -errno;
                }
 
                /* Process any triggered events.

diff --git a/eloop.h b/eloop.h
index 9c831630f3f254f394aa5dcb8e33aaaf5548d756..d3ba3349cdd575edb7dca7050ee423371e13d258 100644 (file)
--- a/eloop.h
+++ b/eloop.h
@@ -30,7 +30,28 @@
 
 #include <time.h>
 
+#ifdef HAVE_CONFIG_H
 #include "config.h"
+#else
+/* Attempt to autodetect kqueue or epoll */
+#if (defined(__unix__) || defined(unix)) && !defined(USG)
+#include <sys/param.h>
+#endif
+#if defined(BSD)
+/* Assume BSD has a working sys/queue.h and kqueue(2) interface */
+#define HAVE_SYS_QUEUE_H
+#define HAVE_KQUEUE
+#elif defined(__linux__)
+/* Assume Linux has a working epoll(3) interface */
+#define HAVE_EPOLL
+#endif
+#endif
+
+#ifdef HAVE_SYS_QUEUE_H
+#include <sys/queue.h>
+#else
+#include "queue.h"
+#endif
 
 #ifndef ELOOP_QUEUE
   #define ELOOP_QUEUE 1
@@ -90,16 +111,20 @@ int eloop_event_add(struct eloop *, int,
     void (*)(void *), void *);
 void eloop_event_delete(struct eloop *, int, int);
 
-#define eloop_timeout_add_tv(a, b, c, d) \
-    eloop_q_timeout_add_tv(a, ELOOP_QUEUE, b, c, d)
-#define eloop_timeout_add_sec(a, b, c, d) \
-    eloop_q_timeout_add_sec(a, ELOOP_QUEUE, b, c, d)
-#define eloop_timeout_delete(a, b, c) \
-    eloop_q_timeout_delete(a, ELOOP_QUEUE, b, c)
-int eloop_q_timeout_add_sec(struct eloop *, int queue,
-    time_t, void (*)(void *), void *);
+#define eloop_timeout_add_tv(eloop, tv, cb, ctx) \
+    eloop_q_timeout_add_tv((eloop), ELOOP_QUEUE, (tv), (cb), (ctx))
+#define eloop_timeout_add_sec(eloop, tv, cb, ctx) \
+    eloop_q_timeout_add_sec((eloop), ELOOP_QUEUE, (tv), (cb), (ctx))
+#define eloop_timeout_add_msec(eloop, ms, cb, ctx) \
+    eloop_q_timeout_add_msec((eloop), ELOOP_QUEUE, (ms), (cb), (ctx))
+#define eloop_timeout_delete(eloop, cb, ctx) \
+    eloop_q_timeout_delete((eloop), ELOOP_QUEUE, (cb), (ctx))
 int eloop_q_timeout_add_tv(struct eloop *, int queue,
     const struct timespec *, void (*)(void *), void *);
+int eloop_q_timeout_add_sec(struct eloop *, int queue,
+    time_t, void (*)(void *), void *);
+int eloop_q_timeout_add_msec(struct eloop *, int queue,
+    long, void (*)(void *), void *);
 void eloop_q_timeout_delete(struct eloop *, int, void (*)(void *), void *);
 
 int eloop_signal_set_cb(struct eloop *, const int *,
@@ -110,7 +135,7 @@ struct eloop * eloop_new(void);
 #if defined(HAVE_KQUEUE) || defined(HAVE_EPOLL)
 int eloop_requeue(struct eloop *);
 #else
-#define eloop_requeue(a, b) (0)
+#define eloop_requeue(eloop) (0)
 #endif
 void eloop_free(struct eloop *);
 void eloop_exit(struct eloop *, int);