Add a USE_SIGNALS define.

If we're not using signals then we also create a control socket in the
non MASTER case. We then use this to communicate instead of signals.

diff --git a/control.c b/control.c
index bba78c11314d7cd93ac899bcc7643e89b6f68d89..a39176f9f436c9fbce9563c4937093739a82307c 100644 (file)
--- a/control.c
+++ b/control.c
@@ -47,42 +47,32 @@
             (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
 #endif
 
-static void
-control_remove(void *arg)
-{
-       struct dhcpcd_ctx *ctx;
-       struct fd_list *l, *n, *last = NULL;
-
-       ctx = arg;
-       l = ctx->control_fds;
-       while (l) {
-               n = l->next;
-               if (l == arg) {
-                       eloop_event_delete(ctx->eloop, l->fd);
-                       close(l->fd);
-                       if (last == NULL)
-                               ctx->control_fds = l->next;
-                       else
-                               last->next = l->next;
-                       free(l);
-                       break;
-               }
-               last = l;
-               l = n;
-       }
-}
-
 static void
 control_handle_data(void *arg)
 {
-       struct fd_list *l = arg;
+       struct fd_list *l = arg, *lp, *last;
        char buffer[1024], *e, *p, *argvp[255], **ap;
        ssize_t bytes;
        int argc;
 
        bytes = read(l->fd, buffer, sizeof(buffer) - 1);
        if (bytes == -1 || bytes == 0) {
-               control_remove(l);
+               /* Control was closed or there was an error.
+                * Remove it from our list. */
+               last = NULL;
+               for (lp = l->ctx->control_fds; lp; lp = lp->next) {
+                       if (lp == l) {
+                               eloop_event_delete(lp->ctx->eloop, lp->fd);
+                               close(lp->fd);
+                               if (last == NULL)
+                                       lp->ctx->control_fds = lp->next;
+                               else
+                                       last->next = lp->next;
+                               free(lp);
+                               break;
+                       }
+                       last = lp;
+               }
                return;
        }
        buffer[bytes] = '\0';
@@ -130,7 +120,7 @@ control_handle(void *arg)
 }
 
 static int
-make_sock(struct dhcpcd_ctx *ctx, struct sockaddr_un *sun)
+make_sock(struct dhcpcd_ctx *ctx, struct sockaddr_un *sun, const char *ifname)
 {
 
 #ifdef SOCK_CLOEXEC
@@ -159,26 +149,29 @@ make_sock(struct dhcpcd_ctx *ctx, struct sockaddr_un *sun)
 #endif
        memset(sun, 0, sizeof(*sun));
        sun->sun_family = AF_UNIX;
-       strlcpy(sun->sun_path, CONTROLSOCKET, sizeof(sun->sun_path));
+       snprintf(sun->sun_path, sizeof(sun->sun_path), CONTROLSOCKET,
+           ifname ? "-" : "", ifname ? ifname : "");
+       strlcpy(ctx->control_sock, sun->sun_path, sizeof(ctx->control_sock));
        return SUN_LEN(sun);
 }
 
 int
-control_start(struct dhcpcd_ctx *ctx)
+control_start(struct dhcpcd_ctx *ctx, const char *ifname)
 {
        struct sockaddr_un sun;
        int len;
 
-       if ((len = make_sock(ctx, &sun)) == -1)
+       if ((len = make_sock(ctx, &sun, ifname)) == -1)
                return -1;
-       unlink(CONTROLSOCKET);
+       unlink(ctx->control_sock);
        if (bind(ctx->control_fd, (struct sockaddr *)&sun, len) == -1 ||
-           chmod(CONTROLSOCKET,
+           chmod(ctx->control_sock,
                S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) == -1 ||
            listen(ctx->control_fd, sizeof(ctx->control_fds)) == -1)
        {
                close(ctx->control_fd);
                ctx->control_fd = -1;
+               unlink(ctx->control_sock);
                return -1;
        }
        eloop_event_add(ctx->eloop, ctx->control_fd, control_handle, ctx);
@@ -191,11 +184,13 @@ control_stop(struct dhcpcd_ctx *ctx)
        int retval = 0;
        struct fd_list *l;
 
+       if (ctx->control_fd == -1)
+               return 0;
        eloop_event_delete(ctx->eloop, ctx->control_fd);
        if (shutdown(ctx->control_fd, SHUT_RDWR) == -1)
                retval = 1;
        ctx->control_fd = -1;
-       if (unlink(CONTROLSOCKET) == -1)
+       if (unlink(ctx->control_sock) == -1)
                retval = -1;
 
        l = ctx->control_fds;
@@ -211,12 +206,12 @@ control_stop(struct dhcpcd_ctx *ctx)
 }
 
 int
-control_open(struct dhcpcd_ctx *ctx)
+control_open(struct dhcpcd_ctx *ctx, const char *ifname)
 {
        struct sockaddr_un sun;
        int len;
 
-       if ((len = make_sock(ctx, &sun)) == -1)
+       if ((len = make_sock(ctx, &sun, ifname)) == -1)
                return -1;
        if (connect(ctx->control_fd, (struct sockaddr *)&sun, len) == -1) {
                close(ctx->control_fd);
@@ -249,3 +244,13 @@ control_send(struct dhcpcd_ctx *ctx, int argc, char * const *argv)
        }
        return write(ctx->control_fd, buffer, p - buffer);
 }
+
+void
+control_close(struct dhcpcd_ctx *ctx)
+{
+
+       if (ctx->control_fd != -1) {
+               close(ctx->control_fd);
+               ctx->control_fd = -1;
+       }
+}

diff --git a/control.h b/control.h
index 5ca647f7c9ad5f364decf50243fbdd00419efdbf..7a4bb255c73636fc0abb1a54567d08839ad0cc88 100644 (file)
--- a/control.h
+++ b/control.h
@@ -37,9 +37,10 @@ struct fd_list {
        int listener;
 };
 
-int control_start(struct dhcpcd_ctx *);
+int control_start(struct dhcpcd_ctx *, const char *);
 int control_stop(struct dhcpcd_ctx *);
-int control_open(struct dhcpcd_ctx *);
+int control_open(struct dhcpcd_ctx *, const char *);
 int control_send(struct dhcpcd_ctx *, int, char * const *);
+void control_close(struct dhcpcd_ctx *ctx);
 
 #endif

diff --git a/defs.h b/defs.h
index f477272e0883f4b9849bc72ba1ce29192ca9ebff..32c49cd8c2aa2f1b53ce2e1d97780108b09bc02f 100644 (file)
--- a/defs.h
+++ b/defs.h
@@ -52,10 +52,19 @@
 # define PIDFILE               RUNDIR "/" PACKAGE "%s%s.pid"
 #endif
 #ifndef CONTROLSOCKET
-# define CONTROLSOCKET         RUNDIR "/" PACKAGE ".sock"
+# define CONTROLSOCKET         RUNDIR "/" PACKAGE "%s%s.sock"
 #endif
 #ifndef RDM_MONOFILE
 # define RDM_MONOFILE          DBDIR "/" PACKAGE "-rdm.monotonic"
 #endif
 
+#ifndef NO_SIGNALS
+#  define USE_SIGNALS
+#endif
+#ifndef USE_SIGNALS
+#  ifndef THERE_IS_NO_FORK
+#    define THERE_IS_NO_FORK
+#  endif
+#endif
+
 #endif

diff --git a/dhcpcd.c b/dhcpcd.c
index 34251c5888b001dec7ab6b49f59d007a54e4585e..fb232164e51e22e0a40ec516a0cda8c2f949d94f 100644 (file)
--- a/dhcpcd.c
+++ b/dhcpcd.c
@@ -67,6 +67,7 @@ const char dhcpcd_copyright[] = "Copyright (c) 2006-2014 Roy Marples";
 #include "platform.h"
 #include "script.h"
 
+#ifdef USE_SIGNALS
 const int handle_sigs[] = {
        SIGALRM,
        SIGHUP,
@@ -79,7 +80,9 @@ const int handle_sigs[] = {
 
 /* Handling signals needs *some* context */
 static struct dhcpcd_ctx *dhcpcd_ctx;
+#endif
 
+#if defined(USE_SIGNALS) || !defined(THERE_IS_NO_FORK)
 static pid_t
 read_pid(const char *pidfile)
 {
@@ -96,6 +99,17 @@ read_pid(const char *pidfile)
        return pid;
 }
 
+static inline int
+write_pid(int fd, pid_t pid)
+{
+
+       if (ftruncate(fd, (off_t)0) == -1)
+               return -1;
+       lseek(fd, (off_t)0, SEEK_SET);
+       return dprintf(fd, "%d\n", (int)pid);
+}
+#endif
+
 static void
 usage(void)
 {
@@ -195,21 +209,12 @@ handle_exit_timeout(void *arg)
        eloop_timeout_add_sec(ctx->eloop, timeout, handle_exit_timeout, ctx);
 }
 
-static inline int
-write_pid(int fd, pid_t pid)
-{
-
-       if (ftruncate(fd, (off_t)0) == -1)
-               return -1;
-       lseek(fd, (off_t)0, SEEK_SET);
-       return dprintf(fd, "%d\n", (int)pid);
-}
-
 /* Returns the pid of the child, otherwise 0. */
 pid_t
 daemonise(struct dhcpcd_ctx *ctx)
 {
 #ifdef THERE_IS_NO_FORK
+       eloop_timeout_delete(ctx->eloop, handle_exit_timeout, ctx);
        errno = ENOSYS;
        return 0;
 #else
@@ -821,6 +826,27 @@ reconf_reboot(struct dhcpcd_ctx *ctx, int action, int argc, char **argv, int oi)
        sort_interfaces(ctx);
 }
 
+static void
+stop_all_interfaces(struct dhcpcd_ctx *ctx, int do_release)
+{
+       struct interface *ifp;
+
+       /* drop_dhcp could change the order, so we do it like this. */
+       for (;;) {
+               /* Be sane and drop the last config first */
+               ifp = TAILQ_LAST(ctx->ifaces, if_head);
+               if (ifp == NULL)
+                       break;
+               if (do_release) {
+                       ifp->options->options |= DHCPCD_RELEASE;
+                       ifp->options->options &= ~DHCPCD_PERSISTENT;
+               }
+               ifp->options->options |= DHCPCD_EXITING;
+               stop_interface(ifp);
+       }
+}
+
+#ifdef USE_SIGNALS
 struct dhcpcd_siginfo {
        int signo;
        pid_t pid;
@@ -886,21 +912,8 @@ handle_signal1(void *arg)
                return;
        }
 
-       if (!(ctx->options & DHCPCD_TEST)) {
-               /* drop_dhcp could change the order, so we do it like this. */
-               for (;;) {
-                       /* Be sane and drop the last config first */
-                       ifp = TAILQ_LAST(ctx->ifaces, if_head);
-                       if (ifp == NULL)
-                               break;
-                       if (do_release) {
-                               ifp->options->options |= DHCPCD_RELEASE;
-                               ifp->options->options &= ~DHCPCD_PERSISTENT;
-                       }
-                       ifp->options->options |= DHCPCD_EXITING;
-                       stop_interface(ifp);
-               }
-       }
+       if (!(ctx->options & DHCPCD_TEST))
+               stop_all_interfaces(ctx, do_release);
        eloop_exit(ctx->eloop, EXIT_FAILURE);
 }
 
@@ -917,6 +930,30 @@ handle_signal(__unused int sig, siginfo_t *siginfo, __unused void *context)
            handle_signal1, &dhcpcd_siginfo);
 }
 
+static int
+signal_init(void (*func)(int, siginfo_t *, void *), sigset_t *oldset)
+{
+       unsigned int i;
+       struct sigaction sa;
+       sigset_t newset;
+
+       sigfillset(&newset);
+       if (sigprocmask(SIG_SETMASK, &newset, oldset) == -1)
+               return -1;
+
+       memset(&sa, 0, sizeof(sa));
+       sa.sa_sigaction = func;
+       sa.sa_flags = SA_SIGINFO;
+       sigemptyset(&sa.sa_mask);
+
+       for (i = 0; handle_sigs[i]; i++) {
+               if (sigaction(handle_sigs[i], &sa, NULL) == -1)
+                       return -1;
+       }
+       return 0;
+}
+#endif
+
 int
 handle_args(struct dhcpcd_ctx *ctx, struct fd_list *fd, int argc, char **argv)
 {
@@ -1000,17 +1037,19 @@ handle_args(struct dhcpcd_ctx *ctx, struct fd_list *fd, int argc, char **argv)
        }
 
        /* Log the command */
-       len = 0;
+       len = 1;
        for (opt = 0; opt < argc; opt++)
                len += strlen(argv[opt]) + 1;
-       tmp = p = malloc(len + 1);
+       tmp = malloc(len);
        if (tmp == NULL) {
                syslog(LOG_ERR, "%s: %m", __func__);
                return -1;
        }
+       p = tmp;
        for (opt = 0; opt < argc; opt++) {
                l = strlen(argv[opt]);
-               strlcpy(p, argv[opt], l + 1);
+               strlcpy(p, argv[opt], len);
+               len -= l + 1;
                p += l;
                *p++ = ' ';
        }
@@ -1037,13 +1076,12 @@ handle_args(struct dhcpcd_ctx *ctx, struct fd_list *fd, int argc, char **argv)
                }
        }
 
-       /* We need at least one interface */
-       if (optind == argc) {
-               syslog(LOG_ERR, "%s: no interface", __func__);
-               return -1;
-       }
-
        if (do_release || do_exit) {
+               if (optind == argc) {
+                       stop_all_interfaces(ctx, do_release);
+                       eloop_exit(ctx->eloop, EXIT_SUCCESS);
+                       return 0;
+               }
                for (oi = optind; oi < argc; oi++) {
                        if ((ifp = find_interface(ctx, argv[oi])) == NULL)
                                continue;
@@ -1061,29 +1099,6 @@ handle_args(struct dhcpcd_ctx *ctx, struct fd_list *fd, int argc, char **argv)
        return 0;
 }
 
-static int
-signal_init(void (*func)(int, siginfo_t *, void *), sigset_t *oldset)
-{
-       unsigned int i;
-       struct sigaction sa;
-       sigset_t newset;
-
-       sigfillset(&newset);
-       if (sigprocmask(SIG_SETMASK, &newset, oldset) == -1)
-               return -1;
-
-       memset(&sa, 0, sizeof(sa));
-       sa.sa_sigaction = func;
-       sa.sa_flags = SA_SIGINFO;
-       sigemptyset(&sa.sa_mask);
-
-       for (i = 0; handle_sigs[i]; i++) {
-               if (sigaction(handle_sigs[i], &sa, NULL) == -1)
-                       return -1;
-       }
-       return 0;
-}
-
 int
 main(int argc, char **argv)
 {
@@ -1092,13 +1107,21 @@ main(int argc, char **argv)
        struct if_options *ifo;
        struct interface *ifp;
        uint16_t family = 0;
-       int opt, oi = 0, sig = 0, i;
+       int opt, oi = 0, i;
        size_t len;
+#if defined(USE_SIGNALS) || !defined(THERE_IS_NO_FORK)
        pid_t pid;
+#endif
+#ifdef USE_SIGNALS
+       int sig;
+#endif
        struct timespec ts;
 
        memset(&ctx, 0, sizeof(ctx));
-       dhcpcd_ctx = &ctx; /* for our signal handler */
+#ifdef USE_SIGNALS
+       dhcpcd_ctx = &ctx;
+       sig = 0;
+#endif
        closefrom(3);
        openlog(PACKAGE, LOG_PERROR | LOG_PID, LOG_DAEMON);
        setlogmask(LOG_UPTO(LOG_INFO));
@@ -1136,6 +1159,7 @@ main(int argc, char **argv)
                case 'f':
                        ctx.cffile = optarg;
                        break;
+#ifdef USE_SIGNALS
                case 'g':
                        sig = SIGUSR1;
                        break;
@@ -1148,6 +1172,7 @@ main(int argc, char **argv)
                case 'x':
                        sig = SIGTERM;
                        break;
+#endif
                case 'T':
                        i = 1;
                        break;
@@ -1246,12 +1271,20 @@ main(int argc, char **argv)
                goto exit_success;
        }
 
+#ifdef USE_SIGNALS
        if (!(ctx.options & (DHCPCD_MASTER | DHCPCD_TEST))) {
-               if ((i = control_open(&ctx)) != -1) {
+#endif
+               if (ctx.options & DHCPCD_MASTER)
+                       i = -1;
+               else
+                       i = control_open(&ctx, argv[optind]);
+               if (i == -1)
+                       i = control_open(&ctx, NULL);
+               if (i != -1) {
                        syslog(LOG_INFO,
                            "sending commands to master dhcpcd process");
                        len = control_send(&ctx, argc, argv);
-                       close(i);
+                       control_close(&ctx);
                        if (len > 0) {
                                syslog(LOG_DEBUG, "send OK");
                                goto exit_success;
@@ -1263,12 +1296,21 @@ main(int argc, char **argv)
                        if (errno != ENOENT)
                                syslog(LOG_ERR, "control_open: %m");
                }
+#ifdef USE_SIGNALS
        }
+#endif
 
        if (geteuid())
                syslog(LOG_WARNING,
                    PACKAGE " will not work correctly unless run as root");
 
+       ctx.eloop = eloop_init();
+       if (ctx.eloop == NULL) {
+               syslog(LOG_ERR, "%s: %m", __func__);
+               goto exit_failure;
+       }
+
+#ifdef USE_SIGNALS
        if (sig != 0) {
                pid = read_pid(pidfile);
                if (pid != 0)
@@ -1335,30 +1377,28 @@ main(int argc, char **argv)
                }
        }
 
-       syslog(LOG_INFO, "version " VERSION " starting");
-       ctx.options |= DHCPCD_STARTED;
-       ctx.eloop = eloop_init();
-       if (ctx.eloop == NULL) {
-               syslog(LOG_ERR, "%s: %m", __func__);
+
+       if (ctx.options & DHCPCD_MASTER) {
+               if (control_start(&ctx, NULL) == -1)
+                       syslog(LOG_ERR, "control_start: %m");
+       }
+#else
+       if (control_start(&ctx,
+           ctx.options & DHCPCD_MASTER ? NULL : argv[optind]) == -1)
+       {
+               syslog(LOG_ERR, "control_start: %m");
                goto exit_failure;
        }
+#endif
 
+       syslog(LOG_INFO, "version " VERSION " starting");
+       ctx.options |= DHCPCD_STARTED;
+#ifdef USE_SIGNALS
        /* Save signal mask, block and redirect signals to our handler */
        if (signal_init(handle_signal, &ctx.sigset) == -1) {
                syslog(LOG_ERR, "signal_setup: %m");
                goto exit_failure;
        }
-
-       if (ctx.options & DHCPCD_MASTER) {
-               if (control_start(&ctx) == -1)
-                       syslog(LOG_ERR, "control_start: %m");
-       }
-
-#if 0
-       if (options & DHCPCD_IPV6RS && disable_rtadv() == -1) {
-               syslog(LOG_ERR, "disable_rtadvd: %m");
-               options &= ~DHCPCD_IPV6RS;
-       }
 #endif
 
        ctx.ifc = argc - optind;
@@ -1462,7 +1502,7 @@ main(int argc, char **argv)
                eloop_timeout_add_sec(ctx.eloop, 0, start_interface, ifp);
        }
 
-       i = eloop_start(ctx.eloop, &ctx.sigset);
+       i = eloop_start(&ctx);
        goto exit1;
 
 exit_success:
@@ -1493,11 +1533,9 @@ exit1:
        ipv4_ctxfree(&ctx);
        ipv6_ctxfree(&ctx);
        dev_stop(&ctx, !(ctx.options & DHCPCD_FORKED));
+       if (!(ctx.options & DHCPCD_FORKED) && control_stop(&ctx) == -1)
+               syslog(LOG_ERR, "control_stop: %m:");
        if (ctx.pid_fd != -1) {
-               if (ctx.options & DHCPCD_MASTER) {
-                       if (control_stop(&ctx) == -1)
-                               syslog(LOG_ERR, "control_stop: %m:");
-               }
                close(ctx.pid_fd);
                unlink(pidfile);
        }

diff --git a/dhcpcd.h b/dhcpcd.h
index 895c3e933b198a786aa4d9983de8df9628098dde..eee5ef8e60ae33d09809d402fe52f4bd6ee882d4 100644 (file)
--- a/dhcpcd.h
+++ b/dhcpcd.h
@@ -32,6 +32,7 @@
 #include <sys/socket.h>
 #include <net/if.h>
 
+#include "defs.h"
 #include "control.h"
 #include "if-options.h"
 
@@ -71,7 +72,9 @@ struct interface {
 TAILQ_HEAD(if_head, interface);
 
 struct dhcpcd_ctx {
+#ifdef USE_SIGNALS
        sigset_t sigset;
+#endif
        const char *cffile;
        unsigned long long options;
        int argc;
@@ -92,6 +95,7 @@ struct dhcpcd_ctx {
 
        int control_fd;
        struct fd_list *control_fds;
+       char control_sock[sizeof(CONTROLSOCKET) + IF_NAMESIZE];
 
        /* DHCP Enterprise options, RFC3925 */
        struct dhcp_opt *vivso;
@@ -131,9 +135,12 @@ struct dhcpcd_ctx {
 #endif
 };
 
+#ifdef USE_SIGNALS
 extern const int handle_sigs[];
+#endif
 
 pid_t daemonise(struct dhcpcd_ctx *);
+
 struct interface *find_interface(struct dhcpcd_ctx *, const char *);
 int handle_args(struct dhcpcd_ctx *, struct fd_list *, int, char **);
 void handle_carrier(struct dhcpcd_ctx *, int, int, const char *);

diff --git a/eloop.c b/eloop.c
index a653cb9c80e535a4000ce94c8f9d5fcd565aefce..3554b8c9e1be6c11c650af64fbf4de4f8ebd7ee7 100644 (file)
--- a/eloop.c
+++ b/eloop.c
@@ -324,8 +324,9 @@ void eloop_free(struct eloop_ctx *ctx)
 }
 
 int
-eloop_start(struct eloop_ctx *ctx, const sigset_t *sigmask)
+eloop_start(struct dhcpcd_ctx *dctx)
 {
+       struct eloop_ctx *ctx;
        struct timeval now;
        int n;
        struct eloop_event *e;
@@ -333,7 +334,11 @@ eloop_start(struct eloop_ctx *ctx, const sigset_t *sigmask)
        struct timeval tv;
        struct timespec ts, *tsp;
        void (*t0)(void *);
+#ifndef USE_SIGNALS
+       int timeout;
+#endif
 
+       ctx = dctx->eloop;
        for (;;) {
                if (ctx->exitnow)
                        break;
@@ -365,7 +370,20 @@ eloop_start(struct eloop_ctx *ctx, const sigset_t *sigmask)
                        break;
                }
 
-               n = pollts(ctx->fds, ctx->events_len, tsp, sigmask);
+#ifdef USE_SIGNALS
+               n = pollts(ctx->fds, ctx->events_len, tsp, &dctx->sigset);
+#else
+               if (tsp == NULL)
+                       timeout = -1;
+               else if (tsp->tv_sec > INT_MAX / 1000 ||
+                   (tsp->tv_sec == INT_MAX / 1000 &&
+                   (tsp->tv_nsec + 999999) / 1000000 > INT_MAX % 1000000))
+                       timeout = INT_MAX;
+               else
+                       timeout = tsp->tv_sec * 1000 +
+                           (tsp->tv_nsec + 999999) / 1000000;
+               n = poll(ctx->fds, ctx->events_len, timeout);
+#endif
                if (n == -1) {
                        if (errno == EAGAIN || errno == EINTR)
                                continue;

diff --git a/eloop.h b/eloop.h
index 45439cbb3c143eba94a0998ce9f300c568197211..f81eb933f559834de427b7a41e4fa5a19684f720 100644 (file)
--- a/eloop.h
+++ b/eloop.h
@@ -94,6 +94,6 @@ void eloop_q_timeouts_delete(struct eloop_ctx *, int, void *,
 struct eloop_ctx * eloop_init(void);
 void eloop_free(struct eloop_ctx *);
 void eloop_exit(struct eloop_ctx *, int);
-int eloop_start(struct eloop_ctx *, const sigset_t *);
+int eloop_start(struct dhcpcd_ctx *);
 
 #endif

diff --git a/script.c b/script.c
index 13e2a8d8cd26da3dd55874def2c7ce329df2c4e8..1fc5538f10dd108528a66b2a1adb53f4fcff86de 100644 (file)
--- a/script.c
+++ b/script.c
@@ -76,26 +76,36 @@ if_printoptions(void)
                printf(" -  %s\n", *p);
 }
 
+#ifdef USE_SIGNALS
+#define U
+#else
+#define U __unused
+#endif
 static int
-exec_script(const sigset_t *sigs, char *const *argv, char *const *env)
+exec_script(U const struct dhcpcd_ctx *ctx, char *const *argv, char *const *env)
+#undef U
 {
        pid_t pid;
        posix_spawnattr_t attr;
+       int i;
+#ifdef USE_SIGNALS
        short flags;
        sigset_t defsigs;
-       int i;
+#endif
 
        /* posix_spawn is a safe way of executing another image
         * and changing signals back to how they should be. */
        if (posix_spawnattr_init(&attr) == -1)
                return -1;
+#ifdef USE_SIGNALS
        flags = POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF;
        posix_spawnattr_setflags(&attr, flags);
        sigemptyset(&defsigs);
        for (i = 0; i < handle_sigs[i]; i++)
                sigaddset(&defsigs, handle_sigs[i]);
        posix_spawnattr_setsigdefault(&attr, &defsigs);
-       posix_spawnattr_setsigmask(&attr, sigs);
+       posix_spawnattr_setsigmask(&attr, &ctx->sigset);
+#endif
        errno = 0;
        i = posix_spawn(&pid, argv[0], NULL, &attr, argv, env);
        if (i) {
@@ -557,7 +567,7 @@ script_runreason(const struct interface *ifp, const char *reason)
        }
        env[++elen] = NULL;
 
-       pid = exec_script(&ifp->ctx->sigset, argv, env);
+       pid = exec_script(ifp->ctx, argv, env);
        if (pid == -1)
                syslog(LOG_ERR, "%s: %s: %m", __func__, argv[0]);
        else if (pid != 0) {