Changeset 3232 in MondoRescue for branches/3.2/mindi-busybox/networking/udhcp

Timestamp:

Jan 1, 2014, 12:47:38 AM (10 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.21.1

Location:

branches/3.2/mindi-busybox/networking/udhcp

Files:

• Config.src (modified) (5 diffs)
• arpping.c (modified) (1 diff)
• common.c (modified) (14 diffs)
• common.h (modified) (10 diffs)
• dhcpc.c (modified) (62 diffs)
• dhcpc.h (modified) (2 diffs)
• dhcpd.c (modified) (15 diffs)
• dhcprelay.c (modified) (2 diffs)
• dumpleases.c (modified) (2 diffs)
• files.c (modified) (1 diff)
• leases.c (modified) (3 diffs)
• packet.c (modified) (9 diffs)
• socket.c (modified) (5 diffs)

branches/3.2/mindi-busybox/networking/udhcp/Config.src

@@ -9 +9 @@
     bool "udhcp server (udhcpd)"
     default y
-    depends on PLATFORM_LINUX
+    select PLATFORM_LINUX
     help
       udhcpd is a DHCP server geared primarily toward embedded systems,
@@ -40 +40 @@
       time a new lease has been accepted, thus eliminating the need
       to send SIGUSR1 for the initial writing or updating. Any timed
-      rewriting remains undisturbed
+      rewriting remains undisturbed.
+
+config FEATURE_UDHCPD_BASE_IP_ON_MAC
+    bool "Select IP address based on client MAC"
+    default n
+    depends on UDHCPD
+    help
+      If selected, udhcpd will base its selection of IP address to offer
+      on the client's hardware address. Otherwise udhcpd uses the next
+      consecutive free address.
+
+      This reduces the frequency of IP address changes for clients
+      which let their lease expire, and makes consecutive DHCPOFFERS
+      for the same client to (almost always) contain the same
+      IP address.
 
 config DHCPD_LEASES_FILE
@@ -53 +67 @@
     bool "udhcp client (udhcpc)"
     default y
-    depends on PLATFORM_LINUX
+    select PLATFORM_LINUX
     help
       udhcpc is a DHCP client geared primarily toward embedded systems,
@@ -73 +87 @@
 config FEATURE_UDHCP_PORT
     bool "Enable '-P port' option for udhcpd and udhcpc"
-    default y
+    default n
     depends on UDHCPD || UDHCPC
     help
@@ -99 +113 @@
       search lists via option 119, specified in RFC 3397,
       and SIP servers option 120, specified in RFC 3361.
+
+config FEATURE_UDHCP_8021Q
+    bool "Support for 802.1Q VLAN parameters"
+    default y
+    depends on UDHCPD || UDHCPC
+    help
+      If selected, both client and server will support passing of VLAN
+      ID and priority via options 132 and 133 as per 802.1Q.
 
 config UDHCPC_DEFAULT_SCRIPT

branches/3.2/mindi-busybox/networking/udhcp/arpping.c

@@ -119 +119 @@
             }
         }
-        timeout_ms -= (unsigned)monotonic_ms() - prevTime;
-    } while (timeout_ms > 0);
+        timeout_ms -= (unsigned)monotonic_ms() - prevTime + 1;
+
+        /* We used to check "timeout_ms > 0", but
+         * this is more under/overflow-resistant
+         * (people did see overflows here when system time jumps):
+         */
+    } while ((unsigned)timeout_ms <= 2000);
 
  ret:

branches/3.2/mindi-busybox/networking/udhcp/common.c

@@ -30 +30 @@
 //  { OPTION_IP | OPTION_LIST                 , 0x08 }, /* DHCP_COOKIE_SERVER */
     { OPTION_IP | OPTION_LIST                 , 0x09 }, /* DHCP_LPR_SERVER    */
-    { OPTION_STRING               | OPTION_REQ, 0x0c }, /* DHCP_HOST_NAME     */
+    { OPTION_STRING_HOST          | OPTION_REQ, 0x0c }, /* DHCP_HOST_NAME     */
     { OPTION_U16                              , 0x0d }, /* DHCP_BOOT_SIZE     */
-    { OPTION_STRING               | OPTION_REQ, 0x0f }, /* DHCP_DOMAIN_NAME   */
+    { OPTION_STRING_HOST          | OPTION_REQ, 0x0f }, /* DHCP_DOMAIN_NAME   */
     { OPTION_IP                               , 0x10 }, /* DHCP_SWAP_SERVER   */
     { OPTION_STRING                           , 0x11 }, /* DHCP_ROOT_PATH     */
     { OPTION_U8                               , 0x17 }, /* DHCP_IP_TTL        */
     { OPTION_U16                              , 0x1a }, /* DHCP_MTU           */
+//TODO: why do we request DHCP_BROADCAST? Can't we assume that
+//in the unlikely case it is different from typical N.N.255.255,
+//server would let us know anyway?
     { OPTION_IP                   | OPTION_REQ, 0x1c }, /* DHCP_BROADCAST     */
     { OPTION_IP_PAIR | OPTION_LIST            , 0x21 }, /* DHCP_ROUTES        */
-    { OPTION_STRING                           , 0x28 }, /* DHCP_NIS_DOMAIN    */
+    { OPTION_STRING_HOST                      , 0x28 }, /* DHCP_NIS_DOMAIN    */
     { OPTION_IP | OPTION_LIST                 , 0x29 }, /* DHCP_NIS_SERVER    */
     { OPTION_IP | OPTION_LIST     | OPTION_REQ, 0x2a }, /* DHCP_NTP_SERVER    */
@@ -47 +50 @@
     { OPTION_STRING                           , 0x38 }, /* DHCP_ERR_MESSAGE   */
 //TODO: must be combined with 'sname' and 'file' handling:
-    { OPTION_STRING                           , 0x42 }, /* DHCP_TFTP_SERVER_NAME */
+    { OPTION_STRING_HOST                      , 0x42 }, /* DHCP_TFTP_SERVER_NAME */
     { OPTION_STRING                           , 0x43 }, /* DHCP_BOOT_FILE     */
 //TODO: not a string, but a set of LASCII strings:
@@ -55 +58 @@
     { OPTION_SIP_SERVERS                      , 0x78 }, /* DHCP_SIP_SERVERS   */
 #endif
-    { OPTION_STATIC_ROUTES                    , 0x79 }, /* DHCP_STATIC_ROUTES */
-    { OPTION_STATIC_ROUTES                    , 0xf9 }, /* DHCP_MS_STATIC_ROUTES */
+    { OPTION_STATIC_ROUTES | OPTION_LIST      , 0x79 }, /* DHCP_STATIC_ROUTES */
+#if ENABLE_FEATURE_UDHCP_8021Q
+    { OPTION_U16                              , 0x84 }, /* DHCP_VLAN_ID       */
+    { OPTION_U8                               , 0x85 }, /* DHCP_VLAN_PRIORITY */
+#endif
+    { OPTION_6RD                              , 0xd4 }, /* DHCP_6RD           */
+    { OPTION_STATIC_ROUTES | OPTION_LIST      , 0xf9 }, /* DHCP_MS_STATIC_ROUTES */
     { OPTION_STRING                           , 0xfc }, /* DHCP_WPAD          */
 
@@ -116 +124 @@
     "sipsrv" "\0"      /* DHCP_SIP_SERVERS    */
 #endif
-// doesn't work in udhcpd.conf since OPTION_STATIC_ROUTES
-// is not handled yet by "string->option" conversion code:
     "staticroutes" "\0"/* DHCP_STATIC_ROUTES  */
+#if ENABLE_FEATURE_UDHCP_8021Q
+    "vlanid" "\0"      /* DHCP_VLAN_ID        */
+    "vlanpriority" "\0"/* DHCP_VLAN_PRIORITY  */
+#endif
+    "ip6rd" "\0"       /* DHCP_6RD            */
     "msstaticroutes""\0"/* DHCP_MS_STATIC_ROUTES */
     "wpad" "\0"        /* DHCP_WPAD           */
@@ -136 +147 @@
 //  [OPTION_BOOLEAN] = 1,
     [OPTION_STRING] =  1,  /* ignored by udhcp_str2optset */
+    [OPTION_STRING_HOST] = 1,  /* ignored by udhcp_str2optset */
 #if ENABLE_FEATURE_UDHCP_RFC3397
     [OPTION_DNS_STRING] = 1,  /* ignored by both udhcp_str2optset and xmalloc_optname_optval */
@@ -147 +159 @@
     /* Just like OPTION_STRING, we use minimum length here */
     [OPTION_STATIC_ROUTES] = 5,
+    [OPTION_6RD] =    22,  /* ignored by udhcp_str2optset */
 };
 
@@ -324 +337 @@
     if (!lsa)
         return 0;
-    *(uint32_t*)arg = lsa->u.sin.sin_addr.s_addr;
+    /* arg maybe unaligned */
+    move_to_unaligned32((uint32_t*)arg, lsa->u.sin.sin_addr.s_addr);
     free(lsa);
     return 1;
@@ -404 +418 @@
 
             existing->data = xrealloc(existing->data, OPT_DATA + 1 + old_len + length);
-            if ((optflag->flags & OPTION_TYPE_MASK) == OPTION_STRING) {
+            if ((optflag->flags & OPTION_TYPE_MASK) == OPTION_STRING
+             || (optflag->flags & OPTION_TYPE_MASK) == OPTION_STRING_HOST
+            ) {
                 /* add space separator between STRING options in a list */
                 existing->data[OPT_DATA + old_len] = ' ';
@@ -421 +437 @@
 {
     struct option_set **opt_list = arg;
-    char *opt, *val, *endptr;
+    char *opt, *val;
     char *str;
     const struct dhcp_optflag *optflag;
@@ -427 +443 @@
     unsigned optcode;
     int retval, length;
-    char buffer[8] ALIGNED(4);
+    /* IP_PAIR needs 8 bytes, STATIC_ROUTES needs 9 max */
+    char buffer[9] ALIGNED(4);
     uint16_t *result_u16 = (uint16_t *) buffer;
     uint32_t *result_u32 = (uint32_t *) buffer;
@@ -468 +485 @@
             break;
         case OPTION_STRING:
+        case OPTION_STRING_HOST:
 #if ENABLE_FEATURE_UDHCP_RFC3397
         case OPTION_DNS_STRING:
@@ -484 +502 @@
 //      }
         case OPTION_U8:
-            buffer[0] = strtoul(val, &endptr, 0);
-            retval = (endptr[0] == '\0');
+            buffer[0] = bb_strtou32(val, NULL, 0);
+            retval = (errno == 0);
             break;
         /* htonX are macros in older libc's, using temp var
@@ -491 +509 @@
         /* TODO: use bb_strtoX? */
         case OPTION_U16: {
-            unsigned long tmp = strtoul(val, &endptr, 0);
+            uint32_t tmp = bb_strtou32(val, NULL, 0);
             *result_u16 = htons(tmp);
-            retval = (endptr[0] == '\0' /*&& tmp < 0x10000*/);
+            retval = (errno == 0 /*&& tmp < 0x10000*/);
             break;
         }
 //      case OPTION_S16: {
-//          long tmp = strtol(val, &endptr, 0);
+//          long tmp = bb_strtoi32(val, NULL, 0);
 //          *result_u16 = htons(tmp);
-//          retval = (endptr[0] == '\0');
+//          retval = (errno == 0);
 //          break;
 //      }
         case OPTION_U32: {
-            unsigned long tmp = strtoul(val, &endptr, 0);
+            uint32_t tmp = bb_strtou32(val, NULL, 0);
             *result_u32 = htonl(tmp);
-            retval = (endptr[0] == '\0');
+            retval = (errno == 0);
             break;
         }
         case OPTION_S32: {
-            long tmp = strtol(val, &endptr, 0);
+            int32_t tmp = bb_strtoi32(val, NULL, 0);
             *result_u32 = htonl(tmp);
-            retval = (endptr[0] == '\0');
+            retval = (errno == 0);
+            break;
+        }
+        case OPTION_STATIC_ROUTES: {
+            /* Input: "a.b.c.d/m" */
+            /* Output: mask(1 byte),pfx(0-4 bytes),gw(4 bytes) */
+            unsigned mask;
+            char *slash = strchr(val, '/');
+            if (slash) {
+                *slash = '\0';
+                retval = udhcp_str2nip(val, buffer + 1);
+                buffer[0] = mask = bb_strtou(slash + 1, NULL, 10);
+                val = strtok(NULL, ", \t/-");
+                if (!val || mask > 32 || errno)
+                    retval = 0;
+                if (retval) {
+                    length = ((mask + 7) >> 3) + 5;
+                    retval = udhcp_str2nip(val, buffer + (length - 4));
+                }
+            }
             break;
         }
@@ -522 +559 @@
         if (retval)
             attach_option(opt_list, optflag, opt, length);
-    } while (retval && optflag->flags & OPTION_LIST);
+    } while (retval && (optflag->flags & OPTION_LIST));
 
     return retval;
 }
+
+/* note: ip is a pointer to an IPv6 in network order, possibly misaliged */
+int FAST_FUNC sprint_nip6(char *dest, /*const char *pre,*/ const uint8_t *ip)
+{
+    char hexstrbuf[16 * 2];
+    bin2hex(hexstrbuf, (void*)ip, 16);
+    return sprintf(dest, /* "%s" */
+        "%.4s:%.4s:%.4s:%.4s:%.4s:%.4s:%.4s:%.4s",
+        /* pre, */
+        hexstrbuf + 0 * 4,
+        hexstrbuf + 1 * 4,
+        hexstrbuf + 2 * 4,
+        hexstrbuf + 3 * 4,
+        hexstrbuf + 4 * 4,
+        hexstrbuf + 5 * 4,
+        hexstrbuf + 6 * 4,
+        hexstrbuf + 7 * 4
+    );
+}

branches/3.2/mindi-busybox/networking/udhcp/common.h

@@ -15 +15 @@
 PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN
 
-extern const uint8_t MAC_BCAST_ADDR[6]; /* six all-ones */
+extern const uint8_t MAC_BCAST_ADDR[6] ALIGN2; /* six all-ones */
 
 
@@ -81 +81 @@
     OPTION_IP_PAIR,
     OPTION_STRING,
+    /* Opts of STRING_HOST type will be sanitized before they are passed
+     * to udhcpc script's environment: */
+    OPTION_STRING_HOST,
 //  OPTION_BOOLEAN,
     OPTION_U8,
@@ -89 +92 @@
     OPTION_BIN,
     OPTION_STATIC_ROUTES,
+    OPTION_6RD,
 #if ENABLE_FEATURE_UDHCP_RFC3397
     OPTION_DNS_STRING,  /* RFC1035 compressed domain name list */
@@ -104 +108 @@
  * http://www.iana.org/assignments/bootp-dhcp-parameters/
  * Commented out options are handled by common option machinery,
- * uncommented ones have spacial cases (grep for them to see).
+ * uncommented ones have special cases (grep for them to see).
  */
 #define DHCP_PADDING            0x00
@@ -146 +150 @@
 //#define DHCP_SIP_SERVERS      0x78 /* RFC 3361. flag byte, then: 0: domain names, 1: IP addrs */
 //#define DHCP_STATIC_ROUTES    0x79 /* RFC 3442. (mask,ip,router) tuples */
+#define DHCP_VLAN_ID            0x84 /* 802.1P VLAN ID */
+#define DHCP_VLAN_PRIORITY      0x85 /* 802.1Q VLAN priority */
 //#define DHCP_MS_STATIC_ROUTES 0xf9 /* Microsoft's pre-RFC 3442 code for 0x79? */
 //#define DHCP_WPAD             0xfc /* MSIE's Web Proxy Autodiscovery Protocol */
@@ -182 +188 @@
 
 extern const struct dhcp_optflag dhcp_optflags[];
-extern const char dhcp_option_strings[];
-extern const uint8_t dhcp_option_lengths[];
+extern const char dhcp_option_strings[] ALIGN1;
+extern const uint8_t dhcp_option_lengths[] ALIGN1;
 
 unsigned FAST_FUNC udhcp_option_idx(const char *name);
@@ -247 +253 @@
 
 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
+# define IF_UDHCP_VERBOSE(...) __VA_ARGS__
 extern unsigned dhcp_verbose;
 # define log1(...) do { if (dhcp_verbose >= 1) bb_info_msg(__VA_ARGS__); } while (0)
@@ -262 +269 @@
 # endif
 #else
+# define IF_UDHCP_VERBOSE(...)
 # define udhcp_dump_packet(...) ((void)0)
 # define log1(...) ((void)0)
@@ -275 +283 @@
 /* 2nd param is "struct option_set**" */
 int FAST_FUNC udhcp_str2optset(const char *str, void *arg);
-
-uint16_t udhcp_checksum(void *addr, int count) FAST_FUNC;
 
 void udhcp_init_header(struct dhcp_packet *packet, char type) FAST_FUNC;
@@ -306 +312 @@
         const char *interface) FAST_FUNC;
 
+/* note: ip is a pointer to an IPv6 in network order, possibly misaliged */
+int sprint_nip6(char *dest, /*const char *pre,*/ const uint8_t *ip) FAST_FUNC;
+
 POP_SAVED_FUNCTION_VISIBILITY
 

branches/3.2/mindi-busybox/networking/udhcp/dhcpc.c

@@ -26 +26 @@
 #include "dhcpc.h"
 
-#include <asm/types.h>
-#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined(_NEWLIB_VERSION)
-# include <netpacket/packet.h>
-# include <net/ethernet.h>
-#else
-# include <linux/if_packet.h>
-# include <linux/if_ether.h>
+#include <netinet/if_ether.h>
+#include <linux/filter.h>
+#include <linux/if_packet.h>
+
+/* "struct client_config_t client_config" is in bb_common_bufsiz1 */
+
+
+#if ENABLE_LONG_OPTS
+static const char udhcpc_longopts[] ALIGN1 =
+    "clientid-none\0"  No_argument       "C"
+    "vendorclass\0"    Required_argument "V"
+    "hostname\0"       Required_argument "H"
+    "fqdn\0"           Required_argument "F"
+    "interface\0"      Required_argument "i"
+    "now\0"            No_argument       "n"
+    "pidfile\0"        Required_argument "p"
+    "quit\0"           No_argument       "q"
+    "release\0"        No_argument       "R"
+    "request\0"        Required_argument "r"
+    "script\0"         Required_argument "s"
+    "timeout\0"        Required_argument "T"
+    "retries\0"        Required_argument "t"
+    "tryagain\0"       Required_argument "A"
+    "syslog\0"         No_argument       "S"
+    "request-option\0" Required_argument "O"
+    "no-default-options\0" No_argument   "o"
+    "foreground\0"     No_argument       "f"
+    "background\0"     No_argument       "b"
+    "broadcast\0"      No_argument       "B"
+    IF_FEATURE_UDHCPC_ARPING("arping\0" No_argument       "a")
+    IF_FEATURE_UDHCP_PORT("client-port\0"   Required_argument "P")
+    ;
 #endif
-#include <linux/filter.h>
-
-/* struct client_config_t client_config is in bb_common_bufsiz1 */
+/* Must match getopt32 option string order */
+enum {
+    OPT_C = 1 << 0,
+    OPT_V = 1 << 1,
+    OPT_H = 1 << 2,
+    OPT_h = 1 << 3,
+    OPT_F = 1 << 4,
+    OPT_i = 1 << 5,
+    OPT_n = 1 << 6,
+    OPT_p = 1 << 7,
+    OPT_q = 1 << 8,
+    OPT_R = 1 << 9,
+    OPT_r = 1 << 10,
+    OPT_s = 1 << 11,
+    OPT_T = 1 << 12,
+    OPT_t = 1 << 13,
+    OPT_S = 1 << 14,
+    OPT_A = 1 << 15,
+    OPT_O = 1 << 16,
+    OPT_o = 1 << 17,
+    OPT_x = 1 << 18,
+    OPT_f = 1 << 19,
+    OPT_B = 1 << 20,
+/* The rest has variable bit positions, need to be clever */
+    OPTBIT_B = 20,
+    USE_FOR_MMU(             OPTBIT_b,)
+    IF_FEATURE_UDHCPC_ARPING(OPTBIT_a,)
+    IF_FEATURE_UDHCP_PORT(   OPTBIT_P,)
+    USE_FOR_MMU(             OPT_b = 1 << OPTBIT_b,)
+    IF_FEATURE_UDHCPC_ARPING(OPT_a = 1 << OPTBIT_a,)
+    IF_FEATURE_UDHCP_PORT(   OPT_P = 1 << OPTBIT_P,)
+};
 
 
@@ -46 +100 @@
     [OPTION_IP_PAIR         ] = sizeof("255.255.255.255 ") * 2,
     [OPTION_STATIC_ROUTES   ] = sizeof("255.255.255.255/32 255.255.255.255 "),
+    [OPTION_6RD             ] = sizeof("32 128 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 255.255.255.255 "),
     [OPTION_STRING          ] = 1,
+    [OPTION_STRING_HOST     ] = 1,
 #if ENABLE_FEATURE_UDHCP_RFC3397
     [OPTION_DNS_STRING      ] = 1, /* unused */
@@ -81 +137 @@
 }
 
+/* Check if a given label represents a valid DNS label
+ * Return pointer to the first character after the label upon success,
+ * NULL otherwise.
+ * See RFC1035, 2.3.1
+ */
+/* We don't need to be particularly anal. For example, allowing _, hyphen
+ * at the end, or leading and trailing dots would be ok, since it
+ * can't be used for attacks. (Leading hyphen can be, if someone uses
+ * cmd "$hostname"
+ * in the script: then hostname may be treated as an option)
+ */
+static const char *valid_domain_label(const char *label)
+{
+    unsigned char ch;
+    unsigned pos = 0;
+
+    for (;;) {
+        ch = *label;
+        if ((ch|0x20) < 'a' || (ch|0x20) > 'z') {
+            if (pos == 0) {
+                /* label must begin with letter */
+                return NULL;
+            }
+            if (ch < '0' || ch > '9') {
+                if (ch == '\0' || ch == '.')
+                    return label;
+                /* DNS allows only '-', but we are more permissive */
+                if (ch != '-' && ch != '_')
+                    return NULL;
+            }
+        }
+        label++;
+        pos++;
+        //Do we want this?
+        //if (pos > 63) /* NS_MAXLABEL; labels must be 63 chars or less */
+        //  return NULL;
+    }
+}
+
+/* Check if a given name represents a valid DNS name */
+/* See RFC1035, 2.3.1 */
+static int good_hostname(const char *name)
+{
+    //const char *start = name;
+
+    for (;;) {
+        name = valid_domain_label(name);
+        if (!name)
+            return 0;
+        if (!name[0])
+            return 1;
+            //Do we want this?
+            //return ((name - start) < 1025); /* NS_MAXDNAME */
+        name++;
+    }
+}
+
 /* Create "opt_name=opt_value" string */
 static NOINLINE char *xmalloc_optname_optval(uint8_t *option, const struct dhcp_optflag *optflag, const char *opt_name)
@@ -88 +201 @@
     char *dest, *ret;
 
-    /* option points to OPT_DATA, need to go back and get OPT_LEN */
-    len = option[OPT_LEN - OPT_DATA];
+    /* option points to OPT_DATA, need to go back to get OPT_LEN */
+    len = option[-OPT_DATA + OPT_LEN];
 
     type = optflag->flags & OPTION_TYPE_MASK;
     optlen = dhcp_option_lengths[type];
-    upper_length = len_of_option_as_string[type] * ((unsigned)len / (unsigned)optlen);
+    upper_length = len_of_option_as_string[type]
+        * ((unsigned)(len + optlen - 1) / (unsigned)optlen);
 
     dest = ret = xmalloc(upper_length + strlen(opt_name) + 2);
@@ -99 +213 @@
 
     while (len >= optlen) {
-        unsigned ip_ofs = 0;
-
         switch (type) {
+        case OPTION_IP:
         case OPTION_IP_PAIR:
             dest += sprint_nip(dest, "", option);
-            *dest++ = '/';
-            ip_ofs = 4;
-            /* fall through */
-        case OPTION_IP:
-            dest += sprint_nip(dest, "", option + ip_ofs);
+            if (type == OPTION_IP)
+                break;
+            dest += sprint_nip(dest, "/", option + 4);
             break;
 //      case OPTION_BOOLEAN:
@@ -130 +241 @@
             break;
         }
+        /* Note: options which use 'return' instead of 'break'
+         * (for example, OPTION_STRING) skip the code which handles
+         * the case of list of options.
+         */
         case OPTION_STRING:
+        case OPTION_STRING_HOST:
             memcpy(dest, option, len);
             dest[len] = '\0';
-            return ret;  /* Short circuit this case */
+            if (type == OPTION_STRING_HOST && !good_hostname(dest))
+                safe_strncpy(dest, "bad", len);
+            return ret;
         case OPTION_STATIC_ROUTES: {
             /* Option binary format:
@@ -178 +296 @@
             return ret;
         }
+        case OPTION_6RD:
+            /* Option binary format (see RFC 5969):
+             *  0                   1                   2                   3
+             *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+             * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+             * |  OPTION_6RD   | option-length |  IPv4MaskLen  |  6rdPrefixLen |
+             * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+             * |                           6rdPrefix                           |
+             * ...                        (16 octets)                        ...
+             * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+             * ...                   6rdBRIPv4Address(es)                    ...
+             * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+             * We convert it to a string
+             * "IPv4MaskLen 6rdPrefixLen 6rdPrefix 6rdBRIPv4Address..."
+             *
+             * Sanity check: ensure that our length is at least 22 bytes, that
+             * IPv4MaskLen <= 32,
+             * 6rdPrefixLen <= 128,
+             * 6rdPrefixLen + (32 - IPv4MaskLen) <= 128
+             * (2nd condition need no check - it follows from 1st and 3rd).
+             * Else, return envvar with empty value ("optname=")
+             */
+            if (len >= (1 + 1 + 16 + 4)
+             && option[0] <= 32
+             && (option[1] + 32 - option[0]) <= 128
+            ) {
+                /* IPv4MaskLen */
+                dest += sprintf(dest, "%u ", *option++);
+                /* 6rdPrefixLen */
+                dest += sprintf(dest, "%u ", *option++);
+                /* 6rdPrefix */
+                dest += sprint_nip6(dest, /* "", */ option);
+                option += 16;
+                len -= 1 + 1 + 16 + 4;
+                /* "+ 4" above corresponds to the length of IPv4 addr
+                 * we consume in the loop below */
+                while (1) {
+                    /* 6rdBRIPv4Address(es) */
+                    dest += sprint_nip(dest, " ", option);
+                    option += 4;
+                    len -= 4; /* do we have yet another 4+ bytes? */
+                    if (len < 0)
+                        break; /* no */
+                }
+            }
+
+            return ret;
 #if ENABLE_FEATURE_UDHCP_RFC3397
         case OPTION_DNS_STRING:
@@ -217 +382 @@
 #endif
         } /* switch */
+
+        /* If we are here, try to format any remaining data
+         * in the option as another, similarly-formatted option
+         */
         option += optlen;
         len -= optlen;
@@ -222 +391 @@
 // Should we bail out/warn if we see multi-ip option which is
 // not allowed to be such (for example, DHCP_BROADCAST)? -
-        if (len <= 0 /* || !(optflag->flags & OPTION_LIST) */)
+        if (len < optlen /* || !(optflag->flags & OPTION_LIST) */)
             break;
         *dest++ = ' ';
         *dest = '\0';
-    }
+    } /* while */
+
     return ret;
 }
@@ -239 +409 @@
     uint8_t *temp;
     uint8_t overload = 0;
+
+#define BITMAP unsigned
+#define BBITS (sizeof(BITMAP) * 8)
+#define BMASK(i) (1 << (i & (sizeof(BITMAP) * 8 - 1)))
+#define FOUND_OPTS(i) (found_opts[(unsigned)i / BBITS])
+    BITMAP found_opts[256 / BBITS];
+
+    memset(found_opts, 0, sizeof(found_opts));
 
     /* We need 6 elements for:
@@ -251 +429 @@
     /* +1 element for each option, +2 for subnet option: */
     if (packet) {
-        for (i = 0; dhcp_optflags[i].code; i++) {
-            if (udhcp_get_option(packet, dhcp_optflags[i].code)) {
-                if (dhcp_optflags[i].code == DHCP_SUBNET)
-                    envc++; /* for mton */
+        /* note: do not search for "pad" (0) and "end" (255) options */
+//TODO: change logic to scan packet _once_
+        for (i = 1; i < 255; i++) {
+            temp = udhcp_get_option(packet, i);
+            if (temp) {
+                if (i == DHCP_OPTION_OVERLOAD)
+                    overload = *temp;
+                else if (i == DHCP_SUBNET)
+                    envc++; /* for $mask */
                 envc++;
+                /*if (i != DHCP_MESSAGE_TYPE)*/
+                FOUND_OPTS(i) |= BMASK(i);
             }
         }
-        temp = udhcp_get_option(packet, DHCP_OPTION_OVERLOAD);
-        if (temp)
-            overload = *temp;
-    }
-    curr = envp = xzalloc(sizeof(char *) * envc);
+    }
+    curr = envp = xzalloc(sizeof(envp[0]) * envc);
 
     *curr = xasprintf("interface=%s", client_config.interface);
@@ -270 +452 @@
         return envp;
 
+    /* Export BOOTP fields. Fields we don't (yet?) export:
+     * uint8_t op;      // always BOOTREPLY
+     * uint8_t htype;   // hardware address type. 1 = 10mb ethernet
+     * uint8_t hlen;    // hardware address length
+     * uint8_t hops;    // used by relay agents only
+     * uint32_t xid;
+     * uint16_t secs;   // elapsed since client began acquisition/renewal
+     * uint16_t flags;  // only one flag so far: bcast. Never set by server
+     * uint32_t ciaddr; // client IP (usually == yiaddr. can it be different
+     *                  // if during renew server wants to give us differn IP?)
+     * uint32_t gateway_nip; // relay agent IP address
+     * uint8_t chaddr[16]; // link-layer client hardware address (MAC)
+     * TODO: export gateway_nip as $giaddr?
+     */
+    /* Most important one: yiaddr as $ip */
     *curr = xmalloc(sizeof("ip=255.255.255.255"));
     sprint_nip(*curr, "ip=", (uint8_t *) &packet->yiaddr);
     putenv(*curr++);
-
-    opt_name = dhcp_option_strings;
-    i = 0;
-    while (*opt_name) {
-        temp = udhcp_get_option(packet, dhcp_optflags[i].code);
-        if (!temp)
-            goto next;
-        *curr = xmalloc_optname_optval(temp, &dhcp_optflags[i], opt_name);
-        putenv(*curr++);
-        if (dhcp_optflags[i].code == DHCP_SUBNET) {
-            /* Subnet option: make things like "$ip/$mask" possible */
-            uint32_t subnet;
-            move_from_unaligned32(subnet, temp);
-            *curr = xasprintf("mask=%d", mton(subnet));
-            putenv(*curr++);
-        }
- next:
-        opt_name += strlen(opt_name) + 1;
-        i++;
-    }
     if (packet->siaddr_nip) {
+        /* IP address of next server to use in bootstrap */
         *curr = xmalloc(sizeof("siaddr=255.255.255.255"));
         sprint_nip(*curr, "siaddr=", (uint8_t *) &packet->siaddr_nip);
@@ -308 +486 @@
         putenv(*curr++);
     }
+
+    /* Export known DHCP options */
+    opt_name = dhcp_option_strings;
+    i = 0;
+    while (*opt_name) {
+        uint8_t code = dhcp_optflags[i].code;
+        BITMAP *found_ptr = &FOUND_OPTS(code);
+        BITMAP found_mask = BMASK(code);
+        if (!(*found_ptr & found_mask))
+            goto next;
+        *found_ptr &= ~found_mask; /* leave only unknown options */
+        temp = udhcp_get_option(packet, code);
+        *curr = xmalloc_optname_optval(temp, &dhcp_optflags[i], opt_name);
+        putenv(*curr++);
+        if (code == DHCP_SUBNET) {
+            /* Subnet option: make things like "$ip/$mask" possible */
+            uint32_t subnet;
+            move_from_unaligned32(subnet, temp);
+            *curr = xasprintf("mask=%u", mton(subnet));
+            putenv(*curr++);
+        }
+ next:
+        opt_name += strlen(opt_name) + 1;
+        i++;
+    }
+    /* Export unknown options */
+    for (i = 0; i < 256;) {
+        BITMAP bitmap = FOUND_OPTS(i);
+        if (!bitmap) {
+            i += BBITS;
+            continue;
+        }
+        if (bitmap & BMASK(i)) {
+            unsigned len, ofs;
+
+            temp = udhcp_get_option(packet, i);
+            /* udhcp_get_option returns ptr to data portion,
+             * need to go back to get len
+             */
+            len = temp[-OPT_DATA + OPT_LEN];
+            *curr = xmalloc(sizeof("optNNN=") + 1 + len*2);
+            ofs = sprintf(*curr, "opt%u=", i);
+            *bin2hex(*curr + ofs, (void*) temp, len) = '\0';
+            putenv(*curr++);
+        }
+        i++;
+    }
+
     return envp;
 }
@@ -316 +542 @@
     char **envp, **curr;
     char *argv[3];
-
-    if (client_config.script == NULL)
-        return;
 
     envp = fill_envp(packet);
@@ -347 +570 @@
 static void init_packet(struct dhcp_packet *packet, char type)
 {
+    uint16_t secs;
+
     /* Fill in: op, htype, hlen, cookie fields; message type option: */
     udhcp_init_header(packet, type);
 
     packet->xid = random_xid();
+
+    client_config.last_secs = monotonic_sec();
+    if (client_config.first_secs == 0)
+        client_config.first_secs = client_config.last_secs;
+    secs = client_config.last_secs - client_config.first_secs;
+    packet->secs = htons(secs);
 
     memcpy(packet->chaddr, client_config.client_mac, 6);
@@ -359 +590 @@
 static void add_client_options(struct dhcp_packet *packet)
 {
-    uint8_t c;
     int i, end, len;
 
@@ -369 +599 @@
     end = udhcp_end_option(packet->options);
     len = 0;
-    for (i = 0; (c = dhcp_optflags[i].code) != 0; i++) {
-        if ((   (dhcp_optflags[i].flags & OPTION_REQ)
-             && !client_config.no_default_options
-            )
-         || (client_config.opt_mask[c >> 3] & (1 << (c & 7)))
-        ) {
-            packet->options[end + OPT_DATA + len] = c;
+    for (i = 1; i < DHCP_END; i++) {
+        if (client_config.opt_mask[i >> 3] & (1 << (i & 7))) {
+            packet->options[end + OPT_DATA + len] = i;
             len++;
         }
@@ -392 +618 @@
         udhcp_add_binary_option(packet, client_config.fqdn);
 
+    /* Request broadcast replies if we have no IP addr */
+    if ((option_mask32 & OPT_B) && packet->ciaddr == 0)
+        packet->flags |= htons(BROADCAST_FLAG);
+
     /* Add -x options if any */
     {
@@ -404 +634 @@
 //          strncpy((char*)packet->file, client_config.boot_file, sizeof(packet->file) - 1);
     }
+
+    // This will be needed if we remove -V VENDOR_STR in favor of
+    // -x vendor:VENDOR_STR
+    //if (!udhcp_find_option(packet.options, DHCP_VENDOR))
+    //  /* not set, set the default vendor ID */
+    //  ...add (DHCP_VENDOR, "udhcp "BB_VER) opt...
 }
 
@@ -548 +784 @@
 /* Broadcast a DHCP decline message */
 /* NOINLINE: limit stack usage in caller */
-static NOINLINE int send_decline(uint32_t xid, uint32_t server, uint32_t requested)
+static NOINLINE int send_decline(/*uint32_t xid,*/ uint32_t server, uint32_t requested)
 {
     struct dhcp_packet packet;
@@ -557 +793 @@
     init_packet(&packet, DHCPDECLINE);
 
+#if 0
     /* RFC 2131 says DHCPDECLINE's xid is randomly selected by client,
      * but in case the server is buggy and wants DHCPDECLINE's xid
@@ -563 +800 @@
      */
     packet.xid = xid;
+#endif
     /* DHCPDECLINE uses "requested ip", not ciaddr, to store offered IP */
     udhcp_add_simple_option(&packet, DHCP_REQUESTED_IP, requested);
@@ -599 +837 @@
     struct ip_udp_dhcp_packet packet;
     uint16_t check;
-
-    memset(&packet, 0, sizeof(packet));
-    bytes = safe_read(fd, &packet, sizeof(packet));
-    if (bytes < 0) {
-        log1("Packet read error, ignoring");
-        /* NB: possible down interface, etc. Caller should pause. */
-        return bytes; /* returns -1 */
+    unsigned char cmsgbuf[CMSG_LEN(sizeof(struct tpacket_auxdata))];
+    struct iovec iov;
+    struct msghdr msg;
+    struct cmsghdr *cmsg;
+
+    /* used to use just safe_read(fd, &packet, sizeof(packet))
+     * but we need to check for TP_STATUS_CSUMNOTREADY :(
+     */
+    iov.iov_base = &packet;
+    iov.iov_len = sizeof(packet);
+    memset(&msg, 0, sizeof(msg));
+    msg.msg_iov = &iov;
+    msg.msg_iovlen = 1;
+    msg.msg_control = cmsgbuf;
+    msg.msg_controllen = sizeof(cmsgbuf);
+    for (;;) {
+        bytes = recvmsg(fd, &msg, 0);
+        if (bytes < 0) {
+            if (errno == EINTR)
+                continue;
+            log1("Packet read error, ignoring");
+            /* NB: possible down interface, etc. Caller should pause. */
+            return bytes; /* returns -1 */
+        }
+        break;
     }
 
@@ -623 +879 @@
 
     /* make sure its the right packet for us, and that it passes sanity checks */
-    if (packet.ip.protocol != IPPROTO_UDP || packet.ip.version != IPVERSION
+    if (packet.ip.protocol != IPPROTO_UDP
+     || packet.ip.version != IPVERSION
      || packet.ip.ihl != (sizeof(packet.ip) >> 2)
      || packet.udp.dest != htons(CLIENT_PORT)
@@ -636 +893 @@
     check = packet.ip.check;
     packet.ip.check = 0;
-    if (check != udhcp_checksum(&packet.ip, sizeof(packet.ip))) {
+    if (check != inet_cksum((uint16_t *)&packet.ip, sizeof(packet.ip))) {
         log1("Bad IP header checksum, ignoring");
         return -2;
+    }
+
+    for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
+        if (cmsg->cmsg_level == SOL_PACKET
+         && cmsg->cmsg_type == PACKET_AUXDATA
+        ) {
+            /* some VMs don't checksum UDP and TCP data
+             * they send to the same physical machine,
+             * here we detect this case:
+             */
+            struct tpacket_auxdata *aux = (void *)CMSG_DATA(cmsg);
+            if (aux->tp_status & TP_STATUS_CSUMNOTREADY)
+                goto skip_udp_sum_check;
+        }
     }
 
@@ -647 +918 @@
     check = packet.udp.check;
     packet.udp.check = 0;
-    if (check && check != udhcp_checksum(&packet, bytes)) {
+    if (check && check != inet_cksum((uint16_t *)&packet, bytes)) {
         log1("Packet with bad UDP checksum received, ignoring");
         return -2;
     }
-
-    memcpy(dhcp_pkt, &packet.data, bytes - (sizeof(packet.ip) + sizeof(packet.udp)));
-
-    if (dhcp_pkt->cookie != htonl(DHCP_MAGIC)) {
+ skip_udp_sum_check:
+
+    if (packet.data.cookie != htonl(DHCP_MAGIC)) {
         bb_info_msg("Packet with bad magic, ignoring");
         return -2;
     }
-    log1("Got valid DHCP packet");
-    udhcp_dump_packet(dhcp_pkt);
-    return bytes - (sizeof(packet.ip) + sizeof(packet.udp));
+
+    log1("Received a packet");
+    udhcp_dump_packet(&packet.data);
+
+    bytes -= sizeof(packet.ip) + sizeof(packet.udp);
+    memcpy(dhcp_pkt, &packet.data, bytes);
+    return bytes;
 }
 
@@ -715 +989 @@
      * TODO: make conditional?
      */
-#define SERVER_AND_CLIENT_PORTS  ((67 << 16) + 68)
     static const struct sock_filter filter_instr[] = {
-        /* check for udp */
+        /* load 9th byte (protocol) */
         BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 9),
-        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, IPPROTO_UDP, 2, 0),     /* L5, L1, is UDP? */
-        /* ugly check for arp on ethernet-like and IPv4 */
-        BPF_STMT(BPF_LD|BPF_W|BPF_ABS, 2),                      /* L1: */
-        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 0x08000604, 3, 4),      /* L3, L4 */
-        /* skip IP header */
-        BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0),                     /* L5: */
-        /* check udp source and destination ports */
-        BPF_STMT(BPF_LD|BPF_W|BPF_IND, 0),
-        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, SERVER_AND_CLIENT_PORTS, 0, 1), /* L3, L4 */
-        /* returns */
-        BPF_STMT(BPF_RET|BPF_K, 0x0fffffff ),                   /* L3: pass */
-        BPF_STMT(BPF_RET|BPF_K, 0),                             /* L4: reject */
+        /* jump to L1 if it is IPPROTO_UDP, else to L4 */
+        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, IPPROTO_UDP, 0, 6),
+        /* L1: load halfword from offset 6 (flags and frag offset) */
+        BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 6),
+        /* jump to L4 if any bits in frag offset field are set, else to L2 */
+        BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x1fff, 4, 0),
+        /* L2: skip IP header (load index reg with header len) */
+        BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0),
+        /* load udp destination port from halfword[header_len + 2] */
+        BPF_STMT(BPF_LD|BPF_H|BPF_IND, 2),
+        /* jump to L3 if udp dport is CLIENT_PORT, else to L4 */
+        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 68, 0, 1),
+        /* L3: accept packet */
+        BPF_STMT(BPF_RET|BPF_K, 0xffffffff),
+        /* L4: discard packet */
+        BPF_STMT(BPF_RET|BPF_K, 0),
     };
     static const struct sock_fprog filter_prog = {
@@ -741 +1018 @@
 
     fd = xsocket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
-    log1("Got raw socket fd %d", fd); //log2?
-
-    if (SERVER_PORT == 67 && CLIENT_PORT == 68) {
-        /* Use only if standard ports are in use */
-        /* Ignoring error (kernel may lack support for this) */
-        if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog,
-                sizeof(filter_prog)) >= 0)
-            log1("Attached filter to raw socket fd %d", fd); // log?
-    }
+    log1("Got raw socket fd"); //log2?
 
     sock.sll_family = AF_PACKET;
@@ -755 +1024 @@
     sock.sll_ifindex = ifindex;
     xbind(fd, (struct sockaddr *) &sock, sizeof(sock));
+
+    if (CLIENT_PORT == 68) {
+        /* Use only if standard port is in use */
+        /* Ignoring error (kernel may lack support for this) */
+        if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog,
+                sizeof(filter_prog)) >= 0)
+            log1("Attached filter to raw socket fd"); // log?
+    }
+
+    if (setsockopt(fd, SOL_PACKET, PACKET_AUXDATA,
+            &const_int_1, sizeof(int)) < 0
+    ) {
+        if (errno != ENOPROTOOPT)
+            log1("Can't set PACKET_AUXDATA on raw socket");
+    }
+
     log1("Created raw socket");
 
@@ -780 +1065 @@
 }
 
+/* Called only on SIGUSR1 */
 static void perform_renew(void)
 {
@@ -802 +1088 @@
 }
 
-static void perform_release(uint32_t requested_ip, uint32_t server_addr)
+static void perform_release(uint32_t server_addr, uint32_t requested_ip)
 {
     char buffer[sizeof("255.255.255.255")];
@@ -850 +1136 @@
 //usage:#endif
 //usage:#define udhcpc_trivial_usage
-//usage:       "[-fbnq"IF_UDHCP_VERBOSE("v")"oCR] [-i IFACE] [-r IP] [-s PROG] [-p PIDFILE]\n"
-//usage:       "    [-H HOSTNAME] [-V VENDOR] [-x OPT:VAL]... [-O OPT]..." IF_FEATURE_UDHCP_PORT(" [-P N]")
+//usage:       "[-fbnq"IF_UDHCP_VERBOSE("v")"oCRB] [-i IFACE] [-r IP] [-s PROG] [-p PIDFILE]\n"
+//usage:       "    [-V VENDOR] [-x OPT:VAL]... [-O OPT]..." IF_FEATURE_UDHCP_PORT(" [-P N]")
 //usage:#define udhcpc_full_usage "\n"
 //usage:    IF_LONG_OPTS(
@@ -857 +1143 @@
 //usage:     "\n    -p,--pidfile FILE   Create pidfile"
 //usage:     "\n    -s,--script PROG    Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
+//usage:     "\n    -B,--broadcast      Request broadcast replies"
 //usage:     "\n    -t,--retries N      Send up to N discover packets"
 //usage:     "\n    -T,--timeout N      Pause between packets (default 3 seconds)"
@@ -883 +1170 @@
 //usage:     "\n                -x 0x3d:0100BEEFC0FFEE - option 61 (client id)"
 //usage:     "\n    -F,--fqdn NAME      Ask server to update DNS mapping for NAME"
-//usage:     "\n    -H,-h,--hostname NAME   Send NAME as client hostname (default none)"
 //usage:     "\n    -V,--vendorclass VENDOR Vendor identifier (default 'udhcp VERSION')"
 //usage:     "\n    -C,--clientid-none  Don't send MAC as client identifier"
@@ -894 +1180 @@
 //usage:     "\n    -p FILE     Create pidfile"
 //usage:     "\n    -s PROG     Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
+//usage:     "\n    -B      Request broadcast replies"
 //usage:     "\n    -t N        Send up to N discover packets"
 //usage:     "\n    -T N        Pause between packets (default 3 seconds)"
@@ -920 +1207 @@
 //usage:     "\n            -x 0x3d:0100BEEFC0FFEE - option 61 (client id)"
 //usage:     "\n    -F NAME     Ask server to update DNS mapping for NAME"
-//usage:     "\n    -H,-h NAME  Send NAME as client hostname (default none)"
 //usage:     "\n    -V VENDOR   Vendor identifier (default 'udhcp VERSION')"
 //usage:     "\n    -C      Don't send MAC as client identifier"
@@ -927 +1213 @@
 //usage:    )
 //usage:    )
+//usage:     "\nSignals:"
+//usage:     "\n    USR1    Renew lease"
+//usage:     "\n    USR2    Release lease"
+
 
 int udhcpc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
@@ -942 +1232 @@
     uint32_t server_addr = server_addr; /* for compiler */
     uint32_t requested_ip = 0;
-    uint32_t xid = 0;
-    uint32_t lease_seconds = 0; /* can be given as 32-bit quantity */
+    uint32_t xid = xid; /* for compiler */
     int packet_num;
     int timeout; /* must be signed */
@@ -950 +1239 @@
     int max_fd;
     int retval;
-    struct timeval tv;
-    struct dhcp_packet packet;
     fd_set rfds;
-
-#if ENABLE_LONG_OPTS
-    static const char udhcpc_longopts[] ALIGN1 =
-        "clientid-none\0"  No_argument       "C"
-        "vendorclass\0"    Required_argument "V"
-        "hostname\0"       Required_argument "H"
-        "fqdn\0"           Required_argument "F"
-        "interface\0"      Required_argument "i"
-        "now\0"            No_argument       "n"
-        "pidfile\0"        Required_argument "p"
-        "quit\0"           No_argument       "q"
-        "release\0"        No_argument       "R"
-        "request\0"        Required_argument "r"
-        "script\0"         Required_argument "s"
-        "timeout\0"        Required_argument "T"
-        "version\0"        No_argument       "v"
-        "retries\0"        Required_argument "t"
-        "tryagain\0"       Required_argument "A"
-        "syslog\0"         No_argument       "S"
-        "request-option\0" Required_argument "O"
-        "no-default-options\0" No_argument   "o"
-        "foreground\0"     No_argument       "f"
-        "background\0"     No_argument       "b"
-        IF_FEATURE_UDHCPC_ARPING("arping\0" No_argument       "a")
-        IF_FEATURE_UDHCP_PORT("client-port\0"   Required_argument "P")
-        ;
-#endif
-    enum {
-        OPT_C = 1 << 0,
-        OPT_V = 1 << 1,
-        OPT_H = 1 << 2,
-        OPT_h = 1 << 3,
-        OPT_F = 1 << 4,
-        OPT_i = 1 << 5,
-        OPT_n = 1 << 6,
-        OPT_p = 1 << 7,
-        OPT_q = 1 << 8,
-        OPT_R = 1 << 9,
-        OPT_r = 1 << 10,
-        OPT_s = 1 << 11,
-        OPT_T = 1 << 12,
-        OPT_t = 1 << 13,
-        OPT_S = 1 << 14,
-        OPT_A = 1 << 15,
-        OPT_O = 1 << 16,
-        OPT_o = 1 << 17,
-        OPT_x = 1 << 18,
-        OPT_f = 1 << 19,
-/* The rest has variable bit positions, need to be clever */
-        OPTBIT_f = 19,
-        USE_FOR_MMU(             OPTBIT_b,)
-        IF_FEATURE_UDHCPC_ARPING(OPTBIT_a,)
-        IF_FEATURE_UDHCP_PORT(   OPTBIT_P,)
-        USE_FOR_MMU(             OPT_b = 1 << OPTBIT_b,)
-        IF_FEATURE_UDHCPC_ARPING(OPT_a = 1 << OPTBIT_a,)
-        IF_FEATURE_UDHCP_PORT(   OPT_P = 1 << OPTBIT_P,)
-    };
 
     /* Default options */
@@ -1020 +1250 @@
     /* Parse command line */
     /* O,x: list; -T,-t,-A take numeric param */
-    opt_complementary = "O::x::T+:t+:A+"
-#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
-        ":vv"
-#endif
-        ;
+    opt_complementary = "O::x::T+:t+:A+" IF_UDHCP_VERBOSE(":vv") ;
     IF_LONG_OPTS(applet_long_options = udhcpc_longopts;)
-    opt = getopt32(argv, "CV:H:h:F:i:np:qRr:s:T:t:SA:O:ox:f"
+    opt = getopt32(argv, "CV:H:h:F:i:np:qRr:s:T:t:SA:O:ox:fB"
         USE_FOR_MMU("b")
         IF_FEATURE_UDHCPC_ARPING("a")
@@ -1038 +1264 @@
         , &list_x
         IF_FEATURE_UDHCP_PORT(, &str_P)
-#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
-        , &dhcp_verbose
-#endif
-        );
-    if (opt & (OPT_h|OPT_H))
+        IF_UDHCP_VERBOSE(, &dhcp_verbose)
+    );
+    if (opt & (OPT_h|OPT_H)) {
+        //msg added 2011-11
+        bb_error_msg("option -h NAME is deprecated, use -x hostname:NAME");
         client_config.hostname = alloc_dhcp_option(DHCP_HOST_NAME, str_h, 0);
+    }
     if (opt & OPT_F) {
         /* FQDN option format: [0x51][len][flags][0][0]<fqdn> */
@@ -1067 +1294 @@
     }
 #endif
-    if (opt & OPT_o)
-        client_config.no_default_options = 1;
     while (list_O) {
         char *optstr = llist_pop(&list_O);
-        unsigned n = udhcp_option_idx(optstr);
-        n = dhcp_optflags[n].code;
+        unsigned n = bb_strtou(optstr, NULL, 0);
+        if (errno || n > 254) {
+            n = udhcp_option_idx(optstr);
+            n = dhcp_optflags[n].code;
+        }
         client_config.opt_mask[n >> 3] |= 1 << (n & 7);
+    }
+    if (!(opt & OPT_o)) {
+        unsigned i, n;
+        for (i = 0; (n = dhcp_optflags[i].code) != 0; i++) {
+            if (dhcp_optflags[i].flags & OPTION_REQ) {
+                client_config.opt_mask[n >> 3] |= 1 << (n & 7);
+            }
+        }
     }
     while (list_x) {
@@ -1101 +1337 @@
         memcpy(clientid_mac_ptr, client_config.client_mac, 6);
     }
-    if (str_V[0] != '\0')
+    if (str_V[0] != '\0') {
+        // can drop -V, str_V, client_config.vendorclass,
+        // but need to add "vendor" to the list of recognized
+        // string opts for this to work;
+        // and need to tweak add_client_options() too...
+        // ...so the question is, should we?
+        //bb_error_msg("option -V VENDOR is deprecated, use -x vendor:VENDOR");
         client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, str_V, 0);
+    }
+
 #if !BB_MMU
     /* on NOMMU reexec (i.e., background) early */
@@ -1140 +1384 @@
      */
     for (;;) {
+        struct timeval tv;
+        struct dhcp_packet packet;
         /* silence "uninitialized!" warning */
         unsigned timestamp_before_wait = timestamp_before_wait;
@@ -1159 +1405 @@
         /* If we already timed out, fall through with retval = 0, else... */
         if ((int)tv.tv_sec > 0) {
+            log1("Waiting on select %u seconds", (int)tv.tv_sec);
             timestamp_before_wait = (unsigned)monotonic_sec();
-            log1("Waiting on select...");
             retval = select(max_fd + 1, &rfds, NULL, NULL, &tv);
             if (retval < 0) {
@@ -1187 +1433 @@
                     client_config.client_mac)
             ) {
-                return 1; /* iface is gone? */
+                goto ret0; /* iface is gone? */
             }
             if (clientid_mac_ptr)
@@ -1197 +1443 @@
             switch (state) {
             case INIT_SELECTING:
-                if (packet_num < discover_retries) {
+                if (!discover_retries || packet_num < discover_retries) {
                     if (packet_num == 0)
                         xid = random_xid();
@@ -1226 +1472 @@
                 continue;
             case REQUESTING:
-                if (packet_num < discover_retries) {
+                if (!discover_retries || packet_num < discover_retries) {
                     /* send broadcast select packet */
                     send_select(xid, server_addr, requested_ip);
@@ -1243 +1489 @@
                 /* 1/2 lease passed, enter renewing state */
                 state = RENEWING;
+                client_config.first_secs = 0; /* make secs field count from 0 */
                 change_listen_mode(LISTEN_KERNEL);
                 log1("Entering renew state");
@@ -1282 +1529 @@
                 udhcp_run_script(NULL, "deconfig");
                 state = INIT_SELECTING;
+                client_config.first_secs = 0; /* make secs field count from 0 */
                 /*timeout = 0; - already is */
                 packet_num = 0;
@@ -1298 +1546 @@
         switch (udhcp_sp_read(&rfds)) {
         case SIGUSR1:
+            client_config.first_secs = 0; /* make secs field count from 0 */
+            already_waited_sec = 0;
             perform_renew();
-            if (state == RENEW_REQUESTED)
+            if (state == RENEW_REQUESTED) {
+                /* We might be either on the same network
+                 * (in which case renew might work),
+                 * or we might be on a completely different one
+                 * (in which case renew won't ever succeed).
+                 * For the second case, must make sure timeout
+                 * is not too big, or else we can send
+                 * futile renew requests for hours.
+                 * (Ab)use -A TIMEOUT value (usually 20 sec)
+                 * as a cap on the timeout.
+                 */
+                if (timeout > tryagain_timeout)
+                    timeout = tryagain_timeout;
                 goto case_RENEW_REQUESTED;
+            }
             /* Start things over */
             packet_num = 0;
@@ -1307 +1570 @@
             continue;
         case SIGUSR2:
-            perform_release(requested_ip, server_addr);
+            perform_release(server_addr, requested_ip);
             timeout = INT_MAX;
             continue;
         case SIGTERM:
             bb_info_msg("Received SIGTERM");
-            if (opt & OPT_R) /* release on quit */
-                perform_release(requested_ip, server_addr);
             goto ret0;
         }
@@ -1366 +1627 @@
         switch (state) {
         case INIT_SELECTING:
-            /* Must be a DHCPOFFER to one of our xid's */
+            /* Must be a DHCPOFFER */
             if (*message == DHCPOFFER) {
-        /* TODO: why we don't just fetch server's IP from IP header? */
+/* What exactly is server's IP? There are several values.
+ * Example DHCP offer captured with tchdump:
+ *
+ * 10.34.25.254:67 > 10.34.25.202:68 // IP header's src
+ * BOOTP fields:
+ * Your-IP 10.34.25.202
+ * Server-IP 10.34.32.125   // "next server" IP
+ * Gateway-IP 10.34.25.254  // relay's address (if DHCP relays are in use)
+ * DHCP options:
+ * DHCP-Message Option 53, length 1: Offer
+ * Server-ID Option 54, length 4: 10.34.255.7       // "server ID"
+ * Default-Gateway Option 3, length 4: 10.34.25.254 // router
+ *
+ * We think that real server IP (one to use in renew/release)
+ * is one in Server-ID option. But I am not 100% sure.
+ * IP header's src and Gateway-IP (same in this example)
+ * might work too.
+ * "Next server" and router are definitely wrong ones to use, though...
+ */
                 temp = udhcp_get_option(&packet, DHCP_SERVER_ID);
                 if (!temp) {
@@ -1392 +1671 @@
         case REBINDING:
             if (*message == DHCPACK) {
+                uint32_t lease_seconds;
+                struct in_addr temp_addr;
+
                 temp = udhcp_get_option(&packet, DHCP_LEASE_TIME);
                 if (!temp) {
@@ -1400 +1682 @@
                     move_from_unaligned32(lease_seconds, temp);
                     lease_seconds = ntohl(lease_seconds);
-                    lease_seconds &= 0x0fffffff; /* paranoia: must not be prone to overflows */
-                    if (lease_seconds < 10) /* and not too small */
-                        lease_seconds = 10;
+                    /* paranoia: must not be too small and not prone to overflows */
+                    if (lease_seconds < 0x10)
+                        lease_seconds = 0x10;
+                    if (lease_seconds >= 0x10000000)
+                        lease_seconds = 0x0fffffff;
                 }
 #if ENABLE_FEATURE_UDHCPC_ARPING
@@ -1423 +1707 @@
                         bb_info_msg("Offered address is in use "
                             "(got ARP reply), declining");
-                        send_decline(xid, server_addr, packet.yiaddr);
+                        send_decline(/*xid,*/ server_addr, packet.yiaddr);
 
                         if (state != REQUESTING)
@@ -1429 +1713 @@
                         change_listen_mode(LISTEN_RAW);
                         state = INIT_SELECTING;
+                        client_config.first_secs = 0; /* make secs field count from 0 */
                         requested_ip = 0;
                         timeout = tryagain_timeout;
@@ -1439 +1724 @@
                 /* enter bound state */
                 timeout = lease_seconds / 2;
-                {
-                    struct in_addr temp_addr;
-                    temp_addr.s_addr = packet.yiaddr;
-                    bb_info_msg("Lease of %s obtained, lease time %u",
-                        inet_ntoa(temp_addr), (unsigned)lease_seconds);
-                }
+                temp_addr.s_addr = packet.yiaddr;
+                bb_info_msg("Lease of %s obtained, lease time %u",
+                    inet_ntoa(temp_addr), (unsigned)lease_seconds);
                 requested_ip = packet.yiaddr;
                 udhcp_run_script(&packet, state == REQUESTING ? "bound" : "renew");
@@ -1451 +1733 @@
                 change_listen_mode(LISTEN_NONE);
                 if (opt & OPT_q) { /* quit after lease */
-                    if (opt & OPT_R) /* release on quit */
-                        perform_release(requested_ip, server_addr);
                     goto ret0;
                 }
@@ -1464 +1744 @@
                 }
 #endif
+                /* make future renew packets use different xid */
+                /* xid = random_xid(); ...but why bother? */
                 already_waited_sec = 0;
                 continue; /* back to main loop */
@@ -1476 +1758 @@
                 sleep(3); /* avoid excessive network traffic */
                 state = INIT_SELECTING;
+                client_config.first_secs = 0; /* make secs field count from 0 */
                 requested_ip = 0;
                 timeout = 0;
@@ -1489 +1772 @@
 
  ret0:
+    if (opt & OPT_R) /* release on quit */
+        perform_release(server_addr, requested_ip);
     retval = 0;
  ret:

branches/3.2/mindi-busybox/networking/udhcp/dhcpc.h

@@ -10 +10 @@
 struct client_config_t {
     uint8_t client_mac[6];          /* Our mac address */
-    char no_default_options;        /* Do not include default options in request */
     IF_FEATURE_UDHCP_PORT(uint16_t port;)
     int ifindex;                    /* Index number of the interface to use */
@@ -22 +21 @@
     uint8_t *hostname;              /* Optional hostname to use */
     uint8_t *fqdn;                  /* Optional fully qualified domain name to use */
+
+    uint16_t first_secs;
+    uint16_t last_secs;
 } FIX_ALIASING;
 

branches/3.2/mindi-busybox/networking/udhcp/dhcpd.c

@@ -21 +21 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
+
+//usage:#define udhcpd_trivial_usage
+//usage:       "[-fS]" IF_FEATURE_UDHCP_PORT(" [-P N]") " [CONFFILE]"
+//usage:#define udhcpd_full_usage "\n\n"
+//usage:       "DHCP server\n"
+//usage:     "\n    -f  Run in foreground"
+//usage:     "\n    -S  Log to syslog too"
+//usage:    IF_FEATURE_UDHCP_PORT(
+//usage:     "\n    -P N    Use port N (default 67)"
+//usage:    )
+
 #include <syslog.h>
 #include "common.h"
@@ -134 +145 @@
 /* We got a DHCP DISCOVER. Send an OFFER. */
 /* NOINLINE: limit stack usage in caller */
-static NOINLINE void send_offer(struct dhcp_packet *oldpacket, uint32_t static_lease_nip, struct dyn_lease *lease)
+static NOINLINE void send_offer(struct dhcp_packet *oldpacket,
+        uint32_t static_lease_nip,
+        struct dyn_lease *lease,
+        uint8_t *requested_ip_opt)
 {
     struct dhcp_packet packet;
@@ -148 +162 @@
         /* We have no static lease for client's chaddr */
         uint32_t req_nip;
-        uint8_t *req_ip_opt;
         const char *p_host_name;
 
@@ -159 +172 @@
         }
         /* Or: if client has requested an IP */
-        else if ((req_ip_opt = udhcp_get_option(oldpacket, DHCP_REQUESTED_IP)) != NULL
+        else if (requested_ip_opt != NULL
          /* (read IP) */
-         && (move_from_unaligned32(req_nip, req_ip_opt), 1)
+         && (move_from_unaligned32(req_nip, requested_ip_opt), 1)
          /* and the IP is in the lease range */
          && ntohl(req_nip) >= server_config.start_ip
@@ -284 +297 @@
 int udhcpd_main(int argc UNUSED_PARAM, char **argv)
 {
-    fd_set rfds;
     int server_socket = -1, retval, max_sock;
-    struct dhcp_packet packet;
     uint8_t *state;
-    uint32_t static_lease_nip;
     unsigned timeout_end;
     unsigned num_ips;
     unsigned opt;
     struct option_set *option;
-    struct dyn_lease *lease, fake_lease;
     IF_FEATURE_UDHCP_PORT(char *str_P;)
 
@@ -306 +315 @@
     opt = getopt32(argv, "fSv"
         IF_FEATURE_UDHCP_PORT("P:", &str_P)
-#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
-        , &dhcp_verbose
-#endif
+        IF_UDHCP_VERBOSE(, &dhcp_verbose)
         );
     if (!(opt & 1)) { /* no -f */
@@ -371 +378 @@
     udhcp_sp_setup();
 
+ continue_with_autotime:
     timeout_end = monotonic_sec() + server_config.auto_time;
     while (1) { /* loop until universe collapses */
+        fd_set rfds;
+        struct dhcp_packet packet;
         int bytes;
         struct timeval tv;
         uint8_t *server_id_opt;
-        uint8_t *requested_opt;
+        uint8_t *requested_ip_opt;
         uint32_t requested_nip = requested_nip; /* for compiler */
+        uint32_t static_lease_nip;
+        struct dyn_lease *lease, fake_lease;
 
         if (server_socket < 0) {
@@ -396 +408 @@
         if (retval == 0) {
             write_leases();
-            timeout_end = monotonic_sec() + server_config.auto_time;
-            continue;
+            goto continue_with_autotime;
         }
         if (retval < 0 && errno != EINTR) {
@@ -409 +420 @@
             write_leases();
             /* why not just reset the timeout, eh */
-            timeout_end = monotonic_sec() + server_config.auto_time;
-            continue;
+            goto continue_with_autotime;
         case SIGTERM:
             bb_info_msg("Received SIGTERM");
+            write_leases();
             goto ret0;
         case 0: /* no signal: read a packet */
@@ -442 +453 @@
             bb_error_msg("no or bad message type option, ignoring packet");
             continue;
+        }
+
+        /* Get SERVER_ID if present */
+        server_id_opt = udhcp_get_option(&packet, DHCP_SERVER_ID);
+        if (server_id_opt) {
+            uint32_t server_id_network_order;
+            move_from_unaligned32(server_id_network_order, server_id_opt);
+            if (server_id_network_order != server_config.server_nip) {
+                /* client talks to somebody else */
+                log1("server ID doesn't match, ignoring");
+                continue;
+            }
         }
 
@@ -456 +479 @@
         }
 
-        /* Get REQUESTED_IP and SERVER_ID if present */
-        server_id_opt = udhcp_get_option(&packet, DHCP_SERVER_ID);
-        if (server_id_opt) {
-            uint32_t server_id_net;
-            move_from_unaligned32(server_id_net, server_id_opt);
-            if (server_id_net != server_config.server_nip) {
-                /* client talks to somebody else */
-                log1("server ID doesn't match, ignoring");
-                continue;
-            }
-        }
-        requested_opt = udhcp_get_option(&packet, DHCP_REQUESTED_IP);
-        if (requested_opt) {
-            move_from_unaligned32(requested_nip, requested_opt);
+        /* Get REQUESTED_IP if present */
+        requested_ip_opt = udhcp_get_option(&packet, DHCP_REQUESTED_IP);
+        if (requested_ip_opt) {
+            move_from_unaligned32(requested_nip, requested_ip_opt);
         }
 
@@ -477 +490 @@
             log1("Received DISCOVER");
 
-            send_offer(&packet, static_lease_nip, lease);
+            send_offer(&packet, static_lease_nip, lease, requested_ip_opt);
             break;
 
@@ -568 +581 @@
    administrative authority to do so.
 */
-            if (!requested_opt) {
+            if (!requested_ip_opt) {
                 requested_nip = packet.ciaddr;
                 if (requested_nip == 0) {
@@ -581 +594 @@
                 break;
             }
-            if (server_id_opt) {
-                /* client was talking specifically to us.
-                 * "No, we don't have this IP for you". */
+            /* No lease for this MAC, or lease IP != requested IP */
+
+            if (server_id_opt    /* client is in SELECTING state */
+             || requested_ip_opt /* client is in INIT-REBOOT state */
+            ) {
+                /* "No, we don't have this IP for you" */
                 send_NAK(&packet);
-            }
+            } /* else: client is in RENEWING or REBINDING, do not answer */
+
             break;
 
@@ -604 +621 @@
             log1("Received DECLINE");
             if (server_id_opt
-             && requested_opt
+             && requested_ip_opt
              && lease  /* chaddr matches this lease */
              && requested_nip == lease->lease_nip

branches/3.2/mindi-busybox/networking/udhcp/dhcprelay.c

@@ -10 +10 @@
  * Upstream has GPL v2 or later
  */
+
+//usage:#define dhcprelay_trivial_usage
+//usage:       "CLIENT_IFACE[,CLIENT_IFACE2]... SERVER_IFACE [SERVER_IP]"
+//usage:#define dhcprelay_full_usage "\n\n"
+//usage:       "Relay DHCP requests between clients and server"
+
 #include "common.h"
 
@@ -26 +32 @@
     struct sockaddr_in ip;
     struct xid_item *next;
-};
+} FIX_ALIASING;
 
 #define dhcprelay_xid_list (*(struct xid_item*)&bb_common_bufsiz1)

branches/3.2/mindi-busybox/networking/udhcp/dumpleases.c

@@ -3 +3 @@
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+
+//usage:#define dumpleases_trivial_usage
+//usage:       "[-r|-a] [-f LEASEFILE]"
+//usage:#define dumpleases_full_usage "\n\n"
+//usage:       "Display DHCP leases granted by udhcpd\n"
+//usage:    IF_LONG_OPTS(
+//usage:     "\n    -f,--file=FILE  Lease file"
+//usage:     "\n    -r,--remaining  Show remaining time"
+//usage:     "\n    -a,--absolute   Show expiration time"
+//usage:    )
+//usage:    IF_NOT_LONG_OPTS(
+//usage:     "\n    -f FILE Lease file"
+//usage:     "\n    -r  Show remaining time"
+//usage:     "\n    -a  Show expiration time"
+//usage:    )
+
 #include "common.h"
 #include "dhcpd.h"
@@ -58 +74 @@
 #if ENABLE_UNICODE_SUPPORT
         {
-            char *uni_name = unicode_conv_to_printable_fixedwidth(NULL, lease.hostname, 19);
+            char *uni_name = unicode_conv_to_printable_fixedwidth(/*NULL,*/ lease.hostname, 19);
             printf(" %-16s%s ", inet_ntoa(addr), uni_name);
             free(uni_name);

branches/3.2/mindi-busybox/networking/udhcp/files.c

@@ -81 +81 @@
     {"option"       , udhcp_str2optset, &server_config.options      , ""},
     {"opt"          , udhcp_str2optset, &server_config.options      , ""},
-    {"notify_file"  , read_str        , &server_config.notify_file  , ""},
-    {"sname"        , read_str        , &server_config.sname        , ""},
-    {"boot_file"    , read_str        , &server_config.boot_file    , ""},
+    {"notify_file"  , read_str        , &server_config.notify_file  , NULL},
+    {"sname"        , read_str        , &server_config.sname        , NULL},
+    {"boot_file"    , read_str        , &server_config.boot_file    , NULL},
     {"static_lease" , read_staticlease, &server_config.static_leases, ""},
 };

branches/3.2/mindi-busybox/networking/udhcp/leases.c

@@ -138 +138 @@
     struct dyn_lease *oldest_lease = NULL;
 
-    addr = server_config.start_ip; /* addr is in host order here */
-    for (; addr <= server_config.end_ip; addr++) {
+#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;
@@ -145 +163 @@
         /* ie, 192.168.55.0 */
         if ((addr & 0xff) == 0)
-            continue;
+            goto next_addr;
         /* ie, 192.168.55.255 */
         if ((addr & 0xff) == 0xff)
-            continue;
+            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))
-            continue;
+            goto next_addr;
 
         lease = find_lease_by_nip(nip);
@@ -163 +184 @@
                 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

branches/3.2/mindi-busybox/networking/udhcp/packet.c

@@ -7 +7 @@
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
-#include <netinet/in.h>
-#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
-# include <netpacket/packet.h>
-# include <net/ethernet.h>
-#else
-# include <asm/types.h>
-# include <linux/if_packet.h>
-# include <linux/if_ether.h>
-#endif
-
 #include "common.h"
 #include "dhcpd.h"
+#include <netinet/in.h>
+#include <netinet/if_ether.h>
+#include <netpacket/packet.h>
 
 void FAST_FUNC udhcp_init_header(struct dhcp_packet *packet, char type)
@@ -89 +82 @@
 {
     int bytes;
-    unsigned char *vendor;
 
     memset(packet, 0, sizeof(*packet));
@@ -98 +90 @@
     }
 
-    if (packet->cookie != htonl(DHCP_MAGIC)) {
+    if (bytes < offsetof(struct dhcp_packet, options)
+     || packet->cookie != htonl(DHCP_MAGIC)
+    ) {
         bb_info_msg("Packet with bad magic, ignoring");
         return -2;
@@ -105 +99 @@
     udhcp_dump_packet(packet);
 
-    if (packet->op == BOOTREQUEST) {
-        vendor = udhcp_get_option(packet, DHCP_VENDOR);
-        if (vendor) {
-#if 0
-            static const char broken_vendors[][8] = {
-                "MSFT 98",
-                ""
-            };
-            int i;
-            for (i = 0; broken_vendors[i][0]; i++) {
-                if (vendor[OPT_LEN - OPT_DATA] == (uint8_t)strlen(broken_vendors[i])
-                 && strncmp((char*)vendor, broken_vendors[i], vendor[OPT_LEN - OPT_DATA]) == 0
-                ) {
-                    log1("Broken client (%s), forcing broadcast replies",
-                        broken_vendors[i]);
-                    packet->flags |= htons(BROADCAST_FLAG);
-                }
-            }
-#else
-            if (vendor[OPT_LEN - OPT_DATA] == (uint8_t)(sizeof("MSFT 98")-1)
-             && memcmp(vendor, "MSFT 98", sizeof("MSFT 98")-1) == 0
-            ) {
-                log1("Broken client (%s), forcing broadcast replies", "MSFT 98");
-                packet->flags |= htons(BROADCAST_FLAG);
-            }
-#endif
-        }
-    }
-
     return bytes;
-}
-
-uint16_t FAST_FUNC udhcp_checksum(void *addr, int count)
-{
-    /* Compute Internet Checksum for "count" bytes
-     * beginning at location "addr".
-     */
-    int32_t sum = 0;
-    uint16_t *source = (uint16_t *) addr;
-
-    while (count > 1)  {
-        /*  This is the inner loop */
-        sum += *source++;
-        count -= 2;
-    }
-
-    /*  Add left-over byte, if any */
-    if (count > 0) {
-        /* Make sure that the left-over byte is added correctly both
-         * with little and big endian hosts */
-        uint16_t tmp = 0;
-        *(uint8_t*)&tmp = *(uint8_t*)source;
-        sum += tmp;
-    }
-    /*  Fold 32-bit sum to 16 bits */
-    while (sum >> 16)
-        sum = (sum & 0xffff) + (sum >> 16);
-
-    return ~sum;
 }
 
@@ -220 +156 @@
     /* for UDP checksumming, ip.len is set to UDP packet len */
     packet.ip.tot_len = packet.udp.len;
-    packet.udp.check = udhcp_checksum(&packet, IP_UDP_DHCP_SIZE - padding);
+    packet.udp.check = inet_cksum((uint16_t *)&packet,
+            IP_UDP_DHCP_SIZE - padding);
     /* but for sending, it is set to IP packet len */
     packet.ip.tot_len = htons(IP_UDP_DHCP_SIZE - padding);
@@ -226 +163 @@
     packet.ip.version = IPVERSION;
     packet.ip.ttl = IPDEFTTL;
-    packet.ip.check = udhcp_checksum(&packet.ip, sizeof(packet.ip));
+    packet.ip.check = inet_cksum((uint16_t *)&packet.ip, sizeof(packet.ip));
 
     udhcp_dump_packet(dhcp_pkt);
@@ -246 +183 @@
         uint32_t dest_nip, int dest_port)
 {
-    struct sockaddr_in client;
+    struct sockaddr_in sa;
     unsigned padding;
     int fd;
@@ -259 +196 @@
     setsockopt_reuseaddr(fd);
 
-    memset(&client, 0, sizeof(client));
-    client.sin_family = AF_INET;
-    client.sin_port = htons(source_port);
-    client.sin_addr.s_addr = source_nip;
-    if (bind(fd, (struct sockaddr *)&client, sizeof(client)) == -1) {
+    memset(&sa, 0, sizeof(sa));
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(source_port);
+    sa.sin_addr.s_addr = source_nip;
+    if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
         msg = "bind(%s)";
         goto ret_close;
     }
 
-    memset(&client, 0, sizeof(client));
-    client.sin_family = AF_INET;
-    client.sin_port = htons(dest_port);
-    client.sin_addr.s_addr = dest_nip;
-    if (connect(fd, (struct sockaddr *)&client, sizeof(client)) == -1) {
+    memset(&sa, 0, sizeof(sa));
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(dest_port);
+    sa.sin_addr.s_addr = dest_nip;
+    if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
         msg = "connect";
         goto ret_close;
@@ -278 +215 @@
 
     udhcp_dump_packet(dhcp_pkt);
-
     padding = DHCP_OPTIONS_BUFSIZE - 1 - udhcp_end_option(dhcp_pkt->options);
     result = safe_write(fd, dhcp_pkt, DHCP_SIZE - padding);

branches/3.2/mindi-busybox/networking/udhcp/socket.c

@@ -23 +23 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
+#include "common.h"
 #include <net/if.h>
-#if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined _NEWLIB_VERSION
-# include <netpacket/packet.h>
-# include <net/ethernet.h>
-#else
-# include <asm/types.h>
-# include <linux/if_packet.h>
-# include <linux/if_ether.h>
-#endif
-
-#include "common.h"
 
 int FAST_FUNC udhcp_read_interface(const char *interface, int *ifindex, uint32_t *nip, uint8_t *mac)
 {
+    /* char buffer instead of bona-fide struct avoids aliasing warning */
+    char ifr_buf[sizeof(struct ifreq)];
+    struct ifreq *const ifr = (void *)ifr_buf;
+
     int fd;
-    struct ifreq ifr;
     struct sockaddr_in *our_ip;
 
-    memset(&ifr, 0, sizeof(ifr));
+    memset(ifr, 0, sizeof(*ifr));
     fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
 
-    ifr.ifr_addr.sa_family = AF_INET;
-    strncpy_IFNAMSIZ(ifr.ifr_name, interface);
+    ifr->ifr_addr.sa_family = AF_INET;
+    strncpy_IFNAMSIZ(ifr->ifr_name, interface);
     if (nip) {
-        if (ioctl_or_perror(fd, SIOCGIFADDR, &ifr,
+        if (ioctl_or_perror(fd, SIOCGIFADDR, ifr,
             "is interface %s up and configured?", interface)
         ) {
@@ -53 +47 @@
             return -1;
         }
-        our_ip = (struct sockaddr_in *) &ifr.ifr_addr;
+        our_ip = (struct sockaddr_in *) &ifr->ifr_addr;
         *nip = our_ip->sin_addr.s_addr;
         log1("IP %s", inet_ntoa(our_ip->sin_addr));
@@ -59 +53 @@
 
     if (ifindex) {
-        if (ioctl_or_warn(fd, SIOCGIFINDEX, &ifr) != 0) {
+        if (ioctl_or_warn(fd, SIOCGIFINDEX, ifr) != 0) {
             close(fd);
             return -1;
         }
-        log1("Adapter index %d", ifr.ifr_ifindex);
-        *ifindex = ifr.ifr_ifindex;
+        log1("Adapter index %d", ifr->ifr_ifindex);
+        *ifindex = ifr->ifr_ifindex;
     }
 
     if (mac) {
-        if (ioctl_or_warn(fd, SIOCGIFHWADDR, &ifr) != 0) {
+        if (ioctl_or_warn(fd, SIOCGIFHWADDR, ifr) != 0) {
             close(fd);
             return -1;
         }
-        memcpy(mac, ifr.ifr_hwaddr.sa_data, 6);
+        memcpy(mac, ifr->ifr_hwaddr.sa_data, 6);
         log1("MAC %02x:%02x:%02x:%02x:%02x:%02x",
             mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
@@ -87 +81 @@
     int fd;
     struct sockaddr_in addr;
+    char *colon;
 
     log1("Opening listen socket on *:%d %s", port, inf);
@@ -95 +90 @@
         bb_perror_msg_and_die("SO_BROADCAST");
 
-    /* NB: bug 1032 says this doesn't work on ethernet aliases (ethN:M) */
+    /* SO_BINDTODEVICE doesn't work on ethernet aliases (ethN:M) */
+    colon = strrchr(inf, ':');
+    if (colon)
+        *colon = '\0';
+
     if (setsockopt_bindtodevice(fd, inf))
         xfunc_die(); /* warning is already printed */
+
+    if (colon)
+        *colon = ':';
 
     memset(&addr, 0, sizeof(addr));