Improve eloop api so we don't force a delete write parameter when

deleting events.

diff --git a/arp.c b/arp.c
index 01a8ba44011ee25a0533d9c102d523e39f4aa958..d49ee1af68bf31dacd39bfe72c19a9d983ad8177 100644 (file)
--- a/arp.c
+++ b/arp.c
@@ -377,7 +377,7 @@ arp_close(struct interface *ifp)
                return;
 
        if (state->arp_fd != -1) {
-               eloop_event_delete(ifp->ctx->eloop, state->arp_fd, 0);
+               eloop_event_delete(ifp->ctx->eloop, state->arp_fd);
                close(state->arp_fd);
                state->arp_fd = -1;
        }

diff --git a/control.c b/control.c
index 1e53d0e9876fd82441f409c5f1356963c196f7f4..364883476e3e47fdac7f3f0b499326e12c8c268c 100644 (file)
--- a/control.c
+++ b/control.c
@@ -92,7 +92,7 @@ control_delete(struct fd_list *fd)
 {
 
        TAILQ_REMOVE(&fd->ctx->control_fds, fd, next);
-       eloop_event_delete(fd->ctx->eloop, fd->fd, 0);
+       eloop_event_delete(fd->ctx->eloop, fd->fd);
        close(fd->fd);
        control_queue_free(fd);
        free(fd);
@@ -303,14 +303,14 @@ control_stop(struct dhcpcd_ctx *ctx)
 
        if (ctx->control_fd == -1)
                return 0;
-       eloop_event_delete(ctx->eloop, ctx->control_fd, 0);
+       eloop_event_delete(ctx->eloop, ctx->control_fd);
        close(ctx->control_fd);
        ctx->control_fd = -1;
        if (unlink(ctx->control_sock) == -1)
                retval = -1;
 
        if (ctx->control_unpriv_fd != -1) {
-               eloop_event_delete(ctx->eloop, ctx->control_unpriv_fd, 0);
+               eloop_event_delete(ctx->eloop, ctx->control_unpriv_fd);
                close(ctx->control_unpriv_fd);
                ctx->control_unpriv_fd = -1;
                if (unlink(UNPRIVSOCKET) == -1)
@@ -320,7 +320,7 @@ control_stop(struct dhcpcd_ctx *ctx)
 freeit:
        while ((l = TAILQ_FIRST(&ctx->control_fds))) {
                TAILQ_REMOVE(&ctx->control_fds, l, next);
-               eloop_event_delete(ctx->eloop, l->fd, 0);
+               eloop_event_delete(ctx->eloop, l->fd);
                close(l->fd);
                control_queue_free(l);
                free(l);
@@ -399,7 +399,7 @@ control_writeone(void *arg)
        TAILQ_INSERT_TAIL(&fd->free_queue, data, next);
 
        if (TAILQ_FIRST(&fd->queue) == NULL)
-               eloop_event_delete(fd->ctx->eloop, fd->fd, 1);
+               eloop_event_remove_writecb(fd->ctx->eloop, fd->fd);
 }
 
 int

diff --git a/dhcp.c b/dhcp.c
index abdfc7874b50939ef94447a268ec00b54d68ee0c..4588d090af5c507c1739bef8a12da145c69d99b6 100644 (file)
--- a/dhcp.c
+++ b/dhcp.c
@@ -1437,7 +1437,7 @@ dhcp_close(struct interface *ifp)
                return;
 
        if (state->raw_fd != -1) {
-               eloop_event_delete(ifp->ctx->eloop, state->raw_fd, 0);
+               eloop_event_delete(ifp->ctx->eloop, state->raw_fd);
                close(state->raw_fd);
                state->raw_fd = -1;
        }
@@ -2951,7 +2951,7 @@ dhcp_handleudp(void *arg)
         * from the raw fd */
        if (read(ctx->udp_fd, buffer, sizeof(buffer)) == -1) {
                logger(ctx, LOG_ERR, "%s: %m", __func__);
-               eloop_event_delete(ctx->eloop, ctx->udp_fd, 0);
+               eloop_event_delete(ctx->eloop, ctx->udp_fd);
                close(ctx->udp_fd);
                ctx->udp_fd = -1;
        }
@@ -3046,7 +3046,7 @@ dhcp_free(struct interface *ifp)
        }
        if (ifp == NULL) {
                if (ctx->udp_fd != -1) {
-                       eloop_event_delete(ctx->eloop, ctx->udp_fd, 0);
+                       eloop_event_delete(ctx->eloop, ctx->udp_fd);
                        close(ctx->udp_fd);
                        ctx->udp_fd = -1;
                }

diff --git a/dhcp6.c b/dhcp6.c
index e59b2c731100303c839bd3efb117dd313bd5bc11..b35b02b7cbeec7994634f57fb34ea990a262d228 100644 (file)
--- a/dhcp6.c
+++ b/dhcp6.c
@@ -2615,7 +2615,7 @@ dhcp6_handledata(void *arg)
        if (bytes == -1) {
                logger(dctx, LOG_ERR, "%s: recvmsg: %m", __func__);
                close(ctx->dhcp_fd);
-               eloop_event_delete(dctx->eloop, ctx->dhcp_fd, 0);
+               eloop_event_delete(dctx->eloop, ctx->dhcp_fd);
                ctx->dhcp_fd = -1;
                return;
        }
@@ -3391,7 +3391,7 @@ dhcp6_freedrop(struct interface *ifp, int drop, const char *reason)
        }
        if (ifp == NULL && ctx->ipv6) {
                if (ctx->ipv6->dhcp_fd != -1) {
-                       eloop_event_delete(ctx->eloop, ctx->ipv6->dhcp_fd, 0);
+                       eloop_event_delete(ctx->eloop, ctx->ipv6->dhcp_fd);
                        close(ctx->ipv6->dhcp_fd);
                        ctx->ipv6->dhcp_fd = -1;
                }

diff --git a/dhcpcd.c b/dhcpcd.c
index 7bc9113d787a0d1bc5eaaec0a4b9c6688fa47f3a..019b78f2faafcfc16d0b63646127e91fe78d5b98 100644 (file)
--- a/dhcpcd.c
+++ b/dhcpcd.c
@@ -871,7 +871,7 @@ handle_link(void *arg)
        ctx = arg;
        if (if_managelink(ctx) == -1) {
                logger(ctx, LOG_ERR, "if_managelink: %m");
-               eloop_event_delete(ctx->eloop, ctx->link_fd, 0);
+               eloop_event_delete(ctx->eloop, ctx->link_fd);
                close(ctx->link_fd);
                ctx->link_fd = -1;
        }
@@ -1191,7 +1191,7 @@ dhcpcd_getinterfaces(void *arg)
        }
        if (write(fd->fd, &len, sizeof(len)) != sizeof(len))
                return;
-       eloop_event_delete(fd->ctx->eloop, fd->fd, 1);
+       eloop_event_remove_writecb(fd->ctx->eloop, fd->fd);
        TAILQ_FOREACH(ifp, fd->ctx->ifaces, next) {
                if (send_interface(fd, ifp) == -1)
                        logger(ifp->ctx, LOG_ERR,
@@ -1821,7 +1821,7 @@ exit1:
        }
        free(ctx.duid);
        if (ctx.link_fd != -1) {
-               eloop_event_delete(ctx.eloop, ctx.link_fd, 0);
+               eloop_event_delete(ctx.eloop, ctx.link_fd);
                close(ctx.link_fd);
        }
 

diff --git a/eloop.c b/eloop.c
index 458dd29e4a9ad2f5e179b21020ca2fadd52745bd..bac2e7df1c0833fcbaffd39ae8a0d63a3e215f1a 100644 (file)
--- a/eloop.c
+++ b/eloop.c
@@ -221,8 +221,10 @@ eloop_event_add(struct eloop *eloop, int fd,
        e->write_cb_arg = write_cb_arg;
 
 #if defined(HAVE_KQUEUE)
-       EV_SET(&ke[0], (uintptr_t)fd, EVFILT_READ, EV_ADD, 0, 0, UPTR(e));
-       if (write_cb)
+       if (read_cb != NULL)
+               EV_SET(&ke[0], (uintptr_t)fd, EVFILT_READ,
+                   EV_ADD, 0, 0, UPTR(e));
+       if (write_cb != NULL)
                EV_SET(&ke[1], (uintptr_t)fd, EVFILT_WRITE,
                    EV_ADD, 0, 0, UPTR(e));
        if (kevent(eloop->poll_fd, ke, write_cb ? 2 : 1, NULL, 0, NULL) == -1)
@@ -252,7 +254,7 @@ err:
 }
 
 void
-eloop_event_delete(struct eloop *eloop, int fd, int write_only)
+eloop_event_delete_write(struct eloop *eloop, int fd, int write_only)
 {
        struct eloop_event *e;
 #if defined(HAVE_KQUEUE)
@@ -265,8 +267,8 @@ eloop_event_delete(struct eloop *eloop, int fd, int write_only)
 
        TAILQ_FOREACH(e, &eloop->events, next) {
                if (e->fd == fd) {
-                       if (write_only) {
-                               if (e->write_cb) {
+                       if (write_only && e->read_cb != NULL) {
+                               if (e->write_cb != NULL) {
                                        e->write_cb = NULL;
                                        e->write_cb_arg = NULL;
 #if defined(HAVE_KQUEUE)
@@ -284,7 +286,6 @@ eloop_event_delete(struct eloop *eloop, int fd, int write_only)
                                            EPOLL_CTL_MOD, fd, &epe);
 #endif
                                }
-
                        } else {
                                TAILQ_REMOVE(&eloop->events, e, next);
 #if defined(HAVE_KQUEUE)
@@ -762,12 +763,13 @@ eloop_start(struct eloop *eloop, sigset_t *signals)
 #elif defined(HAVE_EPOLL)
                if (n) {
                        e = (struct eloop_event *)epe.data.ptr;
-                       if (epe.events & EPOLLOUT && e->write_cb) {
+                       if (epe.events & EPOLLOUT && e->write_cb != NULL) {
                                e->write_cb(e->write_cb_arg);
                                continue;
                        }
                        if (epe.events &
-                           (EPOLLIN | EPOLLERR | EPOLLHUP))
+                           (EPOLLIN | EPOLLERR | EPOLLHUP) &&
+                           e->read_cb != NULL)
                        {
                                e->read_cb(e->read_cb_arg);
                                continue;
@@ -777,12 +779,12 @@ eloop_start(struct eloop *eloop, sigset_t *signals)
                if (n > 0) {
                        TAILQ_FOREACH(e, &eloop->events, next) {
                                if (e->pollfd->revents & POLLOUT &&
-                                   e->write_cb)
+                                   e->write_cb != NULL)
                                {
                                        e->write_cb(e->write_cb_arg);
                                        break;
                                }
-                               if (e->pollfd->revents) {
+                               if (e->pollfd->revents && e->read_cb != NULL) {
                                        e->read_cb(e->read_cb_arg);
                                        break;
                                }

diff --git a/eloop.h b/eloop.h
index 6746aaff14585affb522e8a48c652245daee7a39..c5211a7562beec223bc902f098e6fe43f348c673 100644 (file)
--- a/eloop.h
+++ b/eloop.h
@@ -152,7 +152,11 @@ struct eloop {
 int eloop_event_add(struct eloop *, int,
     void (*)(void *), void *,
     void (*)(void *), void *);
-void eloop_event_delete(struct eloop *, int, int);
+#define eloop_event_delete(eloop, fd) \
+    eloop_event_delete_write((eloop), (fd), 0)
+#define eloop_event_remove_writecb(eloop, fd) \
+    eloop_event_delete_write((eloop), (fd), 1)
+void eloop_event_delete_write(struct eloop *, int, int);
 
 #define eloop_timeout_add_tv(eloop, tv, cb, ctx) \
     eloop_q_timeout_add_tv((eloop), ELOOP_QUEUE, (tv), (cb), (ctx))
@@ -162,11 +166,11 @@ void eloop_event_delete(struct eloop *, int, int);
     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,
+int eloop_q_timeout_add_tv(struct eloop *, int,
     const struct timespec *, void (*)(void *), void *);
-int eloop_q_timeout_add_sec(struct eloop *, int queue,
+int eloop_q_timeout_add_sec(struct eloop *, int,
     time_t, void (*)(void *), void *);
-int eloop_q_timeout_add_msec(struct eloop *, int queue,
+int eloop_q_timeout_add_msec(struct eloop *, int,
     long, void (*)(void *), void *);
 void eloop_q_timeout_delete(struct eloop *, int, void (*)(void *), void *);
 

diff --git a/ipv6nd.c b/ipv6nd.c
index 270e858fbf2e32fdbaaeef4b88ecf9b6fa6eb05c..e6ebd7bd4597a8f0236c8cbcc61c1980dfa1f46f 100644 (file)
--- a/ipv6nd.c
+++ b/ipv6nd.c
@@ -217,7 +217,7 @@ ipv6nd_open(struct dhcpcd_ctx *dctx)
 
 eexit:
        if (ctx->nd_fd != -1) {
-               eloop_event_delete(dctx->eloop, ctx->nd_fd, 0);
+               eloop_event_delete(dctx->eloop, ctx->nd_fd);
                close(ctx->nd_fd);
                ctx->nd_fd = -1;
        }
@@ -480,7 +480,7 @@ ipv6nd_free(struct interface *ifp)
        }
        if (ifp == NULL) {
                if (ctx->ipv6->nd_fd != -1) {
-                       eloop_event_delete(ctx->eloop, ctx->ipv6->nd_fd, 0);
+                       eloop_event_delete(ctx->eloop, ctx->ipv6->nd_fd);
                        close(ctx->ipv6->nd_fd);
                        ctx->ipv6->nd_fd = -1;
                }
@@ -1646,7 +1646,7 @@ ipv6nd_handledata(void *arg)
        len = recvmsg(ctx->nd_fd, &ctx->rcvhdr, 0);
        if (len == -1) {
                logger(dctx, LOG_ERR, "recvmsg: %m");
-               eloop_event_delete(dctx->eloop, ctx->nd_fd, 0);
+               eloop_event_delete(dctx->eloop, ctx->nd_fd);
                close(ctx->nd_fd);
                ctx->nd_fd = -1;
                return;