Fix prior patches by using correct bitmasks for flags.

Add BPF_READING and BPF_FREE so that arp can free the state
after finishing the read loop.

diff --git a/src/arp.c b/src/arp.c
index 77a1dc3d96a79699154c3806330c48cf7628ad89..61a8c771e79a6041835d133d008a1852b763f548 100644 (file)
--- a/src/arp.c
+++ b/src/arp.c
@@ -198,19 +198,27 @@ arp_read(void *arg)
         * so we have to process the entire buffer. */
        state = ARP_STATE(ifp);
        state->bpf_flags &= ~BPF_EOF;
+       state->bpf_flags |= BPF_READING;
        while (!(state->bpf_flags & BPF_EOF)) {
                bytes = bpf_read(ifp, state->bpf_fd, buf, sizeof(buf),
                                 &state->bpf_flags);
                if (bytes == -1) {
                        logerr("%s: %s", __func__, ifp->name);
                        arp_close(ifp);
-                       return;
+                       break;
                }
                arp_packet(ifp, buf, (size_t)bytes);
                /* Check we still have a state after processing. */
                if ((state = ARP_STATE(ifp)) == NULL)
                        break;
        }
+       if (state != NULL) {
+               state->bpf_flags &= ~BPF_READING;
+               if (state->bpf_flags & BPF_FREE) {
+                       free(state);
+                       ifp->if_data[IF_DATA_ARP] = NULL;
+               }
+       }
 }
 
 int
@@ -503,8 +511,12 @@ arp_free(struct arp_state *astate)
        /* If there are no more ARP states, close the socket. */
        if (TAILQ_FIRST(&state->arp_states) == NULL) {
                arp_close(ifp);
-               free(state);
-               ifp->if_data[IF_DATA_ARP] = NULL;
+               if (state->bpf_flags & BPF_READING)
+                       state->bpf_flags |= BPF_EOF | BPF_FREE;
+               else {
+                       free(state);
+                       ifp->if_data[IF_DATA_ARP] = NULL;
+               }
        } else
                if (bpf_arp(ifp, state->bpf_fd) == -1)
                        logerr(__func__);

diff --git a/src/bpf.h b/src/bpf.h
index 89e69bcab8ec507c40c0b58557850a89dc5dd293..d41efdce08c7ff07c246b18939d27051b422b0c2 100644 (file)
--- a/src/bpf.h
+++ b/src/bpf.h
@@ -28,8 +28,10 @@
 #ifndef BPF_HEADER
 #define BPF_HEADER
 
-#define BPF_EOF                        (1U << 0)
-#define BPF_PARTIALCSUM                (2U << 0)
+#define        BPF_EOF                 (1U << 0)
+#define        BPF_PARTIALCSUM         (1U << 1)
+#define        BPF_READING             (1U << 2)
+#define        BPF_FREE                (1U << 3)
 
 #include "dhcpcd.h"
 

diff --git a/src/dhcp.c b/src/dhcp.c
index 1e93078d47a171c6081f7adb26c12d898f68e6ac..55a6d69dbab4aa322415317aaff228b511415e31 100644 (file)
--- a/src/dhcp.c
+++ b/src/dhcp.c
@@ -3300,6 +3300,7 @@ dhcp_readpacket(void *arg)
         * This means we have no kernel call to just get one packet,
         * so we have to process the entire buffer. */
        state->bpf_flags &= ~BPF_EOF;
+       state->bpf_flags |= BPF_READING;
        while (!(state->bpf_flags & BPF_EOF)) {
                bytes = bpf_read(ifp, state->bpf_fd, buf, sizeof(buf),
                                 &state->bpf_flags);
@@ -3308,13 +3309,15 @@ dhcp_readpacket(void *arg)
                                logerr("%s: %s", __func__, ifp->name);
                                dhcp_close(ifp);
                        }
-                       return;
+                       break;
                }
                dhcp_handlepacket(ifp, buf, (size_t)bytes);
                /* Check we still have a state after processing. */
                if ((state = D_STATE(ifp)) == NULL)
                        break;
        }
+       if (state != NULL)
+               state->bpf_flags &= ~BPF_READING;
 }
 
 static void