udhcp: move options.c to common.c; disable unused bool and s16 option code

function                                             old     new   delta
udhcp_add_binary_option                                -      94     +94
udhcp_str2nip                                          -      42     +42
len_of_option_as_string                               12      10      -2
dhcp_option_lengths                                   12      10      -2
udhcpc_main                                         2859    2851      -8
read_nip                                              42       -     -42
xmalloc_optname_optval                               590     536     -54
udhcp_str2optset                                     443     366     -77
udhcp_add_option_string                               86       -     -86
------------------------------------------------------------------------------
(add/remove: 2/2 grow/shrink: 0/5 up/down: 136/-271)         Total: -135 bytes

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

1 files changed, 452 insertions, 2 deletions

diff --git a/networking/udhcp/common.c b/networking/udhcp/common.c
index 4de29f258..bc458ac7a 100644
--- a/networking/udhcp/common.c
+++ b/networking/udhcp/common.c
@@ -1,7 +1,8 @@
 /* vi: set sw=4 ts=4: */
-/* common.c
+/*
+ * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2, see file LICENSE in this tarball for details.
  */
 #include "common.h"
 
@@ -12,3 +13,452 @@ unsigned dhcp_verbose;
 const uint8_t MAC_BCAST_ADDR[6] ALIGN2 = {
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 };
+
+/* Supported options are easily added here.
+ * See RFC2132 for more options.
+ * OPTION_REQ: these options are requested by udhcpc (unless -o).
+ */
+const struct dhcp_option dhcp_options[] = {
+        /* flags                                    code */
+        { OPTION_IP                   | OPTION_REQ, 0x01 }, /* DHCP_SUBNET        */
+        { OPTION_S32                              , 0x02 }, /* DHCP_TIME_OFFSET   */
+        { OPTION_IP | OPTION_LIST     | OPTION_REQ, 0x03 }, /* DHCP_ROUTER        */
+//      { OPTION_IP | OPTION_LIST                 , 0x04 }, /* DHCP_TIME_SERVER   */
+//      { OPTION_IP | OPTION_LIST                 , 0x05 }, /* DHCP_NAME_SERVER   */
+        { OPTION_IP | OPTION_LIST     | OPTION_REQ, 0x06 }, /* DHCP_DNS_SERVER    */
+//      { OPTION_IP | OPTION_LIST                 , 0x07 }, /* DHCP_LOG_SERVER    */
+//      { 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_U16                              , 0x0d }, /* DHCP_BOOT_SIZE     */
+        { OPTION_STRING               | 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           */
+        { OPTION_IP                   | OPTION_REQ, 0x1c }, /* DHCP_BROADCAST     */
+        { OPTION_STRING                           , 0x28 }, /* DHCP_NIS_DOMAIN    */
+        { OPTION_IP | OPTION_LIST                 , 0x29 }, /* DHCP_NIS_SERVER    */
+        { OPTION_IP | OPTION_LIST     | OPTION_REQ, 0x2a }, /* DHCP_NTP_SERVER    */
+        { OPTION_IP | OPTION_LIST                 , 0x2c }, /* DHCP_WINS_SERVER   */
+        { OPTION_U32                              , 0x33 }, /* DHCP_LEASE_TIME    */
+        { OPTION_IP                               , 0x36 }, /* DHCP_SERVER_ID     */
+        { OPTION_STRING                           , 0x38 }, /* DHCP_ERR_MESSAGE   */
+//TODO: must be combined with 'sname' and 'file' handling:
+        { OPTION_STRING                           , 0x42 }, /* DHCP_TFTP_SERVER_NAME */
+        { OPTION_STRING                           , 0x43 }, /* DHCP_BOOT_FILE     */
+//TODO: not a string, but a set of LASCII strings:
+//      { OPTION_STRING                           , 0x4D }, /* DHCP_USER_CLASS    */
+#if ENABLE_FEATURE_UDHCP_RFC3397
+        { OPTION_STR1035 | OPTION_LIST            , 0x77 }, /* DHCP_DOMAIN_SEARCH */
+#endif
+        { OPTION_STATIC_ROUTES                    , 0x79 }, /* DHCP_STATIC_ROUTES */
+        { OPTION_STRING                           , 0xfc }, /* DHCP_WPAD          */
+
+        /* Options below have no match in dhcp_option_strings[],
+         * are not passed to dhcpc scripts, and cannot be specified
+         * with "option XXX YYY" syntax in dhcpd config file.
+         * These entries are only used internally by udhcp[cd]
+         * to correctly encode options into packets.
+         */
+
+        { OPTION_IP                               , 0x32 }, /* DHCP_REQUESTED_IP  */
+        { OPTION_U8                               , 0x35 }, /* DHCP_MESSAGE_TYPE  */
+        { OPTION_U16                              , 0x39 }, /* DHCP_MAX_SIZE      */
+        { OPTION_STRING                           , 0x3c }, /* DHCP_VENDOR        */
+//FIXME: handling of this option is not exactly correct:
+        { OPTION_STRING                           , 0x3d }, /* DHCP_CLIENT_ID     */
+        { 0, 0 } /* zeroed terminating entry */
+};
+
+/* Used for converting options from incoming packets to env variables
+ * for udhcpc stript, and for setting options for udhcpd via
+ * "opt OPTION_NAME OPTION_VALUE" directives in udhcpd.conf file.
+ */
+/* Must match dhcp_options[] order */
+const char dhcp_option_strings[] ALIGN1 =
+        "subnet" "\0"      /* DHCP_SUBNET         */
+        "timezone" "\0"    /* DHCP_TIME_OFFSET    */
+        "router" "\0"      /* DHCP_ROUTER         */
+//      "timesrv" "\0"     /* DHCP_TIME_SERVER    */
+//      "namesrv" "\0"     /* DHCP_NAME_SERVER    */
+        "dns" "\0"         /* DHCP_DNS_SERVER     */
+//      "logsrv" "\0"      /* DHCP_LOG_SERVER     */
+//      "cookiesrv" "\0"   /* DHCP_COOKIE_SERVER  */
+        "lprsrv" "\0"      /* DHCP_LPR_SERVER     */
+        "hostname" "\0"    /* DHCP_HOST_NAME      */
+        "bootsize" "\0"    /* DHCP_BOOT_SIZE      */
+        "domain" "\0"      /* DHCP_DOMAIN_NAME    */
+        "swapsrv" "\0"     /* DHCP_SWAP_SERVER    */
+        "rootpath" "\0"    /* DHCP_ROOT_PATH      */
+        "ipttl" "\0"       /* DHCP_IP_TTL         */
+        "mtu" "\0"         /* DHCP_MTU            */
+        "broadcast" "\0"   /* DHCP_BROADCAST      */
+        "nisdomain" "\0"   /* DHCP_NIS_DOMAIN     */
+        "nissrv" "\0"      /* DHCP_NIS_SERVER     */
+        "ntpsrv" "\0"      /* DHCP_NTP_SERVER     */
+        "wins" "\0"        /* DHCP_WINS_SERVER    */
+        "lease" "\0"       /* DHCP_LEASE_TIME     */
+        "serverid" "\0"    /* DHCP_SERVER_ID      */
+        "message" "\0"     /* DHCP_ERR_MESSAGE    */
+        "tftp" "\0"        /* DHCP_TFTP_SERVER_NAME */
+        "bootfile" "\0"    /* DHCP_BOOT_FILE      */
+//      "userclass" "\0"   /* DHCP_USER_CLASS     */
+#if ENABLE_FEATURE_UDHCP_RFC3397
+        "search" "\0"      /* DHCP_DOMAIN_SEARCH  */
+#endif
+// "staticroutes" is only used to set udhcpc environment, it doesn't work
+// in udhcpd.conf since OPTION_STATIC_ROUTES is not handled yet
+// by "string->option" conversion code:
+        "staticroutes" "\0"/* DHCP_STATIC_ROUTES */
+        "wpad" "\0"        /* DHCP_WPAD          */
+        ;
+
+/* Lengths of the different option types */
+const uint8_t dhcp_option_lengths[] ALIGN1 = {
+        [OPTION_IP] =      4,
+        [OPTION_IP_PAIR] = 8,
+//      [OPTION_BOOLEAN] = 1,
+        [OPTION_STRING] =  1,
+#if ENABLE_FEATURE_UDHCP_RFC3397
+        [OPTION_STR1035] = 1,
+#endif
+        [OPTION_U8] =      1,
+        [OPTION_U16] =     2,
+//      [OPTION_S16] =     2,
+        [OPTION_U32] =     4,
+        [OPTION_S32] =     4,
+        /* Just like OPTION_STRING, we use minimum length here */
+        [OPTION_STATIC_ROUTES] = 5,
+};
+
+
+#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 2
+static void log_option(const char *pfx, const uint8_t *opt)
+{
+        if (dhcp_verbose >= 2) {
+                char buf[256 * 2 + 2];
+                *bin2hex(buf, (void*) (opt + OPT_DATA), opt[OPT_LEN]) = '\0';
+                bb_info_msg("%s: 0x%02x %s", pfx, opt[OPT_CODE], buf);
+        }
+}
+#else
+# define log_option(pfx, opt) ((void)0)
+#endif
+
+/* get an option with bounds checking (warning, result is not aligned). */
+uint8_t* FAST_FUNC udhcp_get_option(struct dhcp_packet *packet, int code)
+{
+        uint8_t *optionptr;
+        int len;
+        int rem;
+        int overload = 0;
+        enum {
+                FILE_FIELD101  = FILE_FIELD  * 0x101,
+                SNAME_FIELD101 = SNAME_FIELD * 0x101,
+        };
+
+        /* option bytes: [code][len][data1][data2]..[dataLEN] */
+        optionptr = packet->options;
+        rem = sizeof(packet->options);
+        while (1) {
+                if (rem <= 0) {
+                        bb_error_msg("bad packet, malformed option field");
+                        return NULL;
+                }
+                if (optionptr[OPT_CODE] == DHCP_PADDING) {
+                        rem--;
+                        optionptr++;
+                        continue;
+                }
+                if (optionptr[OPT_CODE] == DHCP_END) {
+                        if ((overload & FILE_FIELD101) == FILE_FIELD) {
+                                /* can use packet->file, and didn't look at it yet */
+                                overload |= FILE_FIELD101; /* "we looked at it" */
+                                optionptr = packet->file;
+                                rem = sizeof(packet->file);
+                                continue;
+                        }
+                        if ((overload & SNAME_FIELD101) == SNAME_FIELD) {
+                                /* can use packet->sname, and didn't look at it yet */
+                                overload |= SNAME_FIELD101; /* "we looked at it" */
+                                optionptr = packet->sname;
+                                rem = sizeof(packet->sname);
+                                continue;
+                        }
+                        break;
+                }
+                len = 2 + optionptr[OPT_LEN];
+                rem -= len;
+                if (rem < 0)
+                        continue; /* complain and return NULL */
+
+                if (optionptr[OPT_CODE] == code) {
+                        log_option("Option found", optionptr);
+                        return optionptr + OPT_DATA;
+                }
+
+                if (optionptr[OPT_CODE] == DHCP_OPTION_OVERLOAD) {
+                        overload |= optionptr[OPT_DATA];
+                        /* fall through */
+                }
+                optionptr += len;
+        }
+
+        /* log3 because udhcpc uses it a lot - very noisy */
+        log3("Option 0x%02x not found", code);
+        return NULL;
+}
+
+/* return the position of the 'end' option (no bounds checking) */
+int FAST_FUNC udhcp_end_option(uint8_t *optionptr)
+{
+        int i = 0;
+
+        while (optionptr[i] != DHCP_END) {
+                if (optionptr[i] != DHCP_PADDING)
+                        i += optionptr[i + OPT_LEN] + OPT_DATA-1;
+                i++;
+        }
+        return i;
+}
+
+/* Add an option (supplied in binary form) to the options.
+ * Option format: [code][len][data1][data2]..[dataLEN]
+ */
+void FAST_FUNC udhcp_add_binary_option(uint8_t *optionptr, uint8_t *addopt)
+{
+        unsigned len;
+        unsigned end = udhcp_end_option(optionptr);
+
+        /* end position + option code/length + addopt length + end option */
+        len = OPT_DATA + addopt[OPT_LEN];
+        if (end + len + 1 >= DHCP_OPTIONS_BUFSIZE) {
+                bb_error_msg("option 0x%02x did not fit into the packet",
+                                addopt[OPT_CODE]);
+                return;
+        }
+        log_option("Adding option", addopt);
+        memcpy(optionptr + end, addopt, len);
+        optionptr[end + len] = DHCP_END;
+}
+
+/* Add a one to four byte option to a packet */
+void FAST_FUNC udhcp_add_simple_option(uint8_t *optionptr, uint8_t code, uint32_t data)
+{
+        const struct dhcp_option *dh;
+
+        for (dh = dhcp_options; dh->code; dh++) {
+                if (dh->code == code) {
+                        uint8_t option[6], len;
+
+                        option[OPT_CODE] = code;
+                        len = dhcp_option_lengths[dh->flags & OPTION_TYPE_MASK];
+                        option[OPT_LEN] = len;
+                        if (BB_BIG_ENDIAN)
+                                data <<= 8 * (4 - len);
+                        /* Assignment is unaligned! */
+                        move_to_unaligned32(&option[OPT_DATA], data);
+                        udhcp_add_binary_option(optionptr, option);
+                        return;
+                }
+        }
+
+        bb_error_msg("can't add option 0x%02x", code);
+}
+
+/* Find option 'code' in opt_list */
+struct option_set* FAST_FUNC find_option(struct option_set *opt_list, uint8_t code)
+{
+        while (opt_list && opt_list->data[OPT_CODE] < code)
+                opt_list = opt_list->next;
+
+        if (opt_list && opt_list->data[OPT_CODE] == code)
+                return opt_list;
+        return NULL;
+}
+
+/* Parse string to IP in network order */
+int FAST_FUNC udhcp_str2nip(const char *str, void *arg)
+{
+        len_and_sockaddr *lsa;
+
+        lsa = host_and_af2sockaddr(str, 0, AF_INET);
+        if (!lsa)
+                return 0;
+        *(uint32_t*)arg = lsa->u.sin.sin_addr.s_addr;
+        free(lsa);
+        return 1;
+}
+
+/* udhcp_str2optset:
+ * Parse string option representation to binary form
+ * and add it to opt_list
+ */
+/* helper: add an option to the opt_list */
+static NOINLINE void attach_option(
+                struct option_set **opt_list,
+                const struct dhcp_option *option,
+                char *buffer,
+                int length)
+{
+        struct option_set *existing, *new, **curr;
+#if ENABLE_FEATURE_UDHCP_RFC3397
+        char *allocated = NULL;
+#endif
+
+        existing = find_option(*opt_list, option->code);
+        if (!existing) {
+                log2("Attaching option %02x to list", option->code);
+#if ENABLE_FEATURE_UDHCP_RFC3397
+                if ((option->flags & OPTION_TYPE_MASK) == OPTION_STR1035) {
+                        /* reuse buffer and length for RFC1035-formatted string */
+                        allocated = buffer = (char *)dname_enc(NULL, 0, buffer, &length);
+                }
+#endif
+                /* make a new option */
+                new = xmalloc(sizeof(*new));
+                new->data = xmalloc(length + OPT_DATA);
+                new->data[OPT_CODE] = option->code;
+                new->data[OPT_LEN] = length;
+                memcpy(new->data + OPT_DATA, buffer, length);
+
+                curr = opt_list;
+                while (*curr && (*curr)->data[OPT_CODE] < option->code)
+                        curr = &(*curr)->next;
+
+                new->next = *curr;
+                *curr = new;
+                goto ret;
+        }
+
+        if (option->flags & OPTION_LIST) {
+                unsigned old_len;
+
+                /* add it to an existing option */
+                log1("Attaching option %02x to existing member of list", option->code);
+                old_len = existing->data[OPT_LEN];
+#if ENABLE_FEATURE_UDHCP_RFC3397
+                if ((option->flags & OPTION_TYPE_MASK) == OPTION_STR1035) {
+                        /* reuse buffer and length for RFC1035-formatted string */
+                        allocated = buffer = (char *)dname_enc(existing->data + OPT_DATA, old_len, buffer, &length);
+                }
+#endif
+                if (old_len + length < 255) {
+                        /* actually 255 is ok too, but adding a space can overlow it */
+
+                        existing->data = xrealloc(existing->data, OPT_DATA + 1 + old_len + length);
+                        if ((option->flags & OPTION_TYPE_MASK) == OPTION_STRING) {
+                                /* add space separator between STRING options in a list */
+                                existing->data[OPT_DATA + old_len] = ' ';
+                                old_len++;
+                        }
+                        memcpy(existing->data + OPT_DATA + old_len, buffer, length);
+                        existing->data[OPT_LEN] = old_len + length;
+                } /* else, ignore the data, we could put this in a second option in the future */
+        } /* else, ignore the new data */
+
+ ret: ;
+#if ENABLE_FEATURE_UDHCP_RFC3397
+        free(allocated);
+#endif
+}
+
+int FAST_FUNC udhcp_str2optset(const char *const_str, void *arg)
+{
+        struct option_set **opt_list = arg;
+        char *opt, *val, *endptr;
+        char *str;
+        const struct dhcp_option *option;
+        int retval, length, idx;
+        char buffer[8] ALIGNED(4);
+        uint16_t *result_u16 = (uint16_t *) buffer;
+        uint32_t *result_u32 = (uint32_t *) buffer;
+
+        /* Cheat, the only *const* str possible is "" */
+        str = (char *) const_str;
+        opt = strtok(str, " \t=");
+        if (!opt)
+                return 0;
+
+        idx = index_in_strings(dhcp_option_strings, opt); /* NB: was strcasecmp! */
+        if (idx < 0)
+                return 0;
+        option = &dhcp_options[idx];
+
+        retval = 0;
+        do {
+                val = strtok(NULL, ", \t");
+                if (!val)
+                        break;
+                length = dhcp_option_lengths[option->flags & OPTION_TYPE_MASK];
+                retval = 0;
+                opt = buffer; /* new meaning for variable opt */
+                switch (option->flags & OPTION_TYPE_MASK) {
+                case OPTION_IP:
+                        retval = udhcp_str2nip(val, buffer);
+                        break;
+                case OPTION_IP_PAIR:
+                        retval = udhcp_str2nip(val, buffer);
+                        val = strtok(NULL, ", \t/-");
+                        if (!val)
+                                retval = 0;
+                        if (retval)
+                                retval = udhcp_str2nip(val, buffer + 4);
+                        break;
+                case OPTION_STRING:
+#if ENABLE_FEATURE_UDHCP_RFC3397
+                case OPTION_STR1035:
+#endif
+                        length = strnlen(val, 254);
+                        if (length > 0) {
+                                opt = val;
+                                retval = 1;
+                        }
+                        break;
+//              case OPTION_BOOLEAN: {
+//                      static const char noyes[] ALIGN1 = "no\0yes\0";
+//                      buffer[0] = retval = index_in_strings(noyes, val);
+//                      retval++; /* 0 - bad; 1: "no" 2: "yes" */
+//                      break;
+//              }
+                case OPTION_U8:
+                        buffer[0] = strtoul(val, &endptr, 0);
+                        retval = (endptr[0] == '\0');
+                        break;
+                /* htonX are macros in older libc's, using temp var
+                 * in code below for safety */
+                /* TODO: use bb_strtoX? */
+                case OPTION_U16: {
+                        unsigned long tmp = strtoul(val, &endptr, 0);
+                        *result_u16 = htons(tmp);
+                        retval = (endptr[0] == '\0' /*&& tmp < 0x10000*/);
+                        break;
+                }
+//              case OPTION_S16: {
+//                      long tmp = strtol(val, &endptr, 0);
+//                      *result_u16 = htons(tmp);
+//                      retval = (endptr[0] == '\0');
+//                      break;
+//              }
+                case OPTION_U32: {
+                        unsigned long tmp = strtoul(val, &endptr, 0);
+                        *result_u32 = htonl(tmp);
+                        retval = (endptr[0] == '\0');
+                        break;
+                }
+                case OPTION_S32: {
+                        long tmp = strtol(val, &endptr, 0);
+                        *result_u32 = htonl(tmp);
+                        retval = (endptr[0] == '\0');
+                        break;
+                }
+                default:
+                        break;
+                }
+                if (retval)
+                        attach_option(opt_list, option, opt, length);
+        } while (retval && option->flags & OPTION_LIST);
+
+        return retval;
+}