dhcp: merge leases.c and static_leases.c into dhcpd.c

function                                             old     new   delta
send_offer                                           292     461    +169
udhcpd_main                                         1531    1588     +57
read_leases                                          330     332      +2
add_lease                                            314     312      -2
find_lease_by_mac                                     68       -     -68
find_free_or_expired_nip                             174       -    -174
------------------------------------------------------------------------------
(add/remove: 0/4 grow/shrink: 3/1 up/down: 228/-244)          Total: -16 bytes

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 218 insertions, 4 deletions

diff --git a/networking/udhcp/dhcpd.c b/networking/udhcp/dhcpd.c
index b625756f9..56116d01f 100644
--- a/networking/udhcp/dhcpd.c
+++ b/networking/udhcp/dhcpd.c
@@ -39,6 +39,10 @@
 #include "dhcpc.h"
 #include "dhcpd.h"
 
+/* globals */
+struct dyn_lease *g_leases;
+/* struct server_config_t server_config is in bb_common_bufsiz1 */
+
 /* Takes the address of the pointer to the static_leases linked list,
  * address to a 6 byte mac address,
  * 4 byte IP address */
@@ -72,6 +76,17 @@ static uint32_t get_static_nip_by_mac(struct static_lease *st_lease, void *mac)
         return 0;
 }
 
+static int is_nip_reserved(struct static_lease *st_lease, uint32_t nip)
+{
+        while (st_lease) {
+                if (st_lease->nip == nip)
+                        return 1;
+                st_lease = st_lease->next;
+        }
+
+        return 0;
+}
+
 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 2
 /* Print out static leases just to check what's going on */
 /* Takes the address of the pointer to the static_leases linked list */
@@ -96,6 +111,209 @@ static void log_static_leases(struct static_lease **st_lease_pp)
 # define log_static_leases(st_lease_pp) ((void)0)
 #endif
 
+/* Find the oldest expired lease, NULL if there are no expired leases */
+static struct dyn_lease *oldest_expired_lease(void)
+{
+        struct dyn_lease *oldest_lease = NULL;
+        leasetime_t oldest_time = time(NULL);
+        unsigned i;
+
+        /* Unexpired leases have g_leases[i].expires >= current time
+         * and therefore can't ever match */
+        for (i = 0; i < server_config.max_leases; i++) {
+                if (g_leases[i].expires == 0 /* empty entry */
+                 || g_leases[i].expires < oldest_time
+                ) {
+                        oldest_time = g_leases[i].expires;
+                        oldest_lease = &g_leases[i];
+                }
+        }
+        return oldest_lease;
+}
+
+/* Clear out all leases with matching nonzero chaddr OR yiaddr.
+ * If chaddr == NULL, this is a conflict lease.
+ */
+static void clear_leases(const uint8_t *chaddr, uint32_t yiaddr)
+{
+        unsigned i;
+
+        for (i = 0; i < server_config.max_leases; i++) {
+                if ((chaddr && memcmp(g_leases[i].lease_mac, chaddr, 6) == 0)
+                 || (yiaddr && g_leases[i].lease_nip == yiaddr)
+                ) {
+                        memset(&g_leases[i], 0, sizeof(g_leases[i]));
+                }
+        }
+}
+
+/* Add a lease into the table, clearing out any old ones.
+ * If chaddr == NULL, this is a conflict lease.
+ */
+static struct dyn_lease *add_lease(
+                const uint8_t *chaddr, uint32_t yiaddr,
+                leasetime_t leasetime,
+                const char *hostname, int hostname_len)
+{
+        struct dyn_lease *oldest;
+
+        /* clean out any old ones */
+        clear_leases(chaddr, yiaddr);
+
+        oldest = oldest_expired_lease();
+
+        if (oldest) {
+                memset(oldest, 0, sizeof(*oldest));
+                if (hostname) {
+                        char *p;
+
+                        hostname_len++; /* include NUL */
+                        if (hostname_len > sizeof(oldest->hostname))
+                                hostname_len = sizeof(oldest->hostname);
+                        p = safe_strncpy(oldest->hostname, hostname, hostname_len);
+                        /*
+                         * Sanitization (s/bad_char/./g).
+                         * The intent is not to allow only "DNS-valid" hostnames,
+                         * but merely make dumpleases output safe for shells to use.
+                         * We accept "0-9A-Za-z._-", all other chars turn to dots.
+                         */
+                        while (*p) {
+                                if (!isalnum(*p) && *p != '-' && *p != '_')
+                                        *p = '.';
+                                p++;
+                        }
+                }
+                if (chaddr)
+                        memcpy(oldest->lease_mac, chaddr, 6);
+                oldest->lease_nip = yiaddr;
+                oldest->expires = time(NULL) + leasetime;
+        }
+
+        return oldest;
+}
+
+/* True if a lease has expired */
+static int is_expired_lease(struct dyn_lease *lease)
+{
+        return (lease->expires < (leasetime_t) time(NULL));
+}
+
+/* Find the first lease that matches MAC, NULL if no match */
+static struct dyn_lease *find_lease_by_mac(const uint8_t *mac)
+{
+        unsigned i;
+
+        for (i = 0; i < server_config.max_leases; i++)
+                if (memcmp(g_leases[i].lease_mac, mac, 6) == 0)
+                        return &g_leases[i];
+
+        return NULL;
+}
+
+/* Find the first lease that matches IP, NULL is no match */
+static struct dyn_lease *find_lease_by_nip(uint32_t nip)
+{
+        unsigned i;
+
+        for (i = 0; i < server_config.max_leases; i++)
+                if (g_leases[i].lease_nip == nip)
+                        return &g_leases[i];
+
+        return NULL;
+}
+
+/* Check if the IP is taken; if it is, add it to the lease table */
+static int nobody_responds_to_arp(uint32_t nip, const uint8_t *safe_mac, unsigned arpping_ms)
+{
+        struct in_addr temp;
+        int r;
+
+        r = arpping(nip, safe_mac,
+                        server_config.server_nip,
+                        server_config.server_mac,
+                        server_config.interface,
+                        arpping_ms);
+        if (r)
+                return r;
+
+        temp.s_addr = nip;
+        bb_error_msg("%s belongs to someone, reserving it for %u seconds",
+                inet_ntoa(temp), (unsigned)server_config.conflict_time);
+        add_lease(NULL, nip, server_config.conflict_time, NULL, 0);
+        return 0;
+}
+
+/* Find a new usable (we think) address */
+static uint32_t find_free_or_expired_nip(const uint8_t *safe_mac, unsigned arpping_ms)
+{
+        uint32_t addr;
+        struct dyn_lease *oldest_lease = NULL;
+
+#if ENABLE_FEATURE_UDHCPD_BASE_IP_ON_MAC
+        uint32_t stop;
+        unsigned i, hash;
+
+        /* hash hwaddr: use the SDBM hashing algorithm.  Seems to give good
+         * dispersal even with similarly-valued "strings".
+         */
+        hash = 0;
+        for (i = 0; i < 6; i++)
+                hash += safe_mac[i] + (hash << 6) + (hash << 16) - hash;
+
+        /* pick a seed based on hwaddr then iterate until we find a free address. */
+        addr = server_config.start_ip
+                + (hash % (1 + server_config.end_ip - server_config.start_ip));
+        stop = addr;
+#else
+        addr = server_config.start_ip;
+#define stop (server_config.end_ip + 1)
+#endif
+        do {
+                uint32_t nip;
+                struct dyn_lease *lease;
+
+                /* ie, 192.168.55.0 */
+                if ((addr & 0xff) == 0)
+                        goto next_addr;
+                /* ie, 192.168.55.255 */
+                if ((addr & 0xff) == 0xff)
+                        goto next_addr;
+                nip = htonl(addr);
+                /* skip our own address */
+                if (nip == server_config.server_nip)
+                        goto next_addr;
+                /* is this a static lease addr? */
+                if (is_nip_reserved(server_config.static_leases, nip))
+                        goto next_addr;
+
+                lease = find_lease_by_nip(nip);
+                if (!lease) {
+//TODO: DHCP servers do not always sit on the same subnet as clients: should *ping*, not arp-ping!
+                        if (nobody_responds_to_arp(nip, safe_mac, arpping_ms))
+                                return nip;
+                } else {
+                        if (!oldest_lease || lease->expires < oldest_lease->expires)
+                                oldest_lease = lease;
+                }
+
+ next_addr:
+                addr++;
+#if ENABLE_FEATURE_UDHCPD_BASE_IP_ON_MAC
+                if (addr > server_config.end_ip)
+                        addr = server_config.start_ip;
+#endif
+        } while (addr != stop);
+
+        if (oldest_lease
+         && is_expired_lease(oldest_lease)
+         && nobody_responds_to_arp(oldest_lease->lease_nip, safe_mac, arpping_ms)
+        ) {
+                return oldest_lease->lease_nip;
+        }
+
+        return 0;
+}
+
 /* On these functions, make sure your datatype matches */
 static int FAST_FUNC read_str(const char *line, void *arg)
 {
@@ -568,10 +786,6 @@ static NOINLINE void send_inform(struct dhcp_packet *oldpacket)
         send_packet(&packet, /*force_bcast:*/ 0);
 }
 
-/* globals */
-struct dyn_lease *g_leases;
-/* struct server_config_t server_config is in bb_common_bufsiz1 */
-
 int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int udhcpd_main(int argc UNUSED_PARAM, char **argv)
 {