Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/networking/udhcp/dhcpc.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/networking/udhcp/dhcpc.c (modified) (8 diffs)

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

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-/* dhcpc.c
- *
- * udhcp DHCP client
+/*
+ * udhcp client
  *
  * Russ Dill <Russ.Dill@asu.edu> July 2001
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
-
-#include <getopt.h>
 #include <syslog.h>
-
 /* Override ENABLE_FEATURE_PIDFILE - ifupdown needs our pidfile to always exist */
 #define WANT_PIDFILE 1
@@ -17 +25 @@
 #include "dhcpd.h"
 #include "dhcpc.h"
-#include "options.h"
-
-
-/* Something is definitely wrong here. IPv4 addresses
- * in variables of type long?? BTW, we use inet_ntoa()
- * in the code. Manpage says that struct in_addr has a member of type long (!)
- * which holds IPv4 address, and the struct is passed by value (!!)
+
+#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>
+#endif
+#include <linux/filter.h>
+
+/* struct client_config_t client_config is in bb_common_bufsiz1 */
+
+
+/*** Script execution code ***/
+
+/* get a rough idea of how long an option will be (rounding up...) */
+static const uint8_t len_of_option_as_string[] = {
+    [OPTION_IP              ] = sizeof("255.255.255.255 "),
+    [OPTION_IP_PAIR         ] = sizeof("255.255.255.255 ") * 2,
+    [OPTION_STATIC_ROUTES   ] = sizeof("255.255.255.255/32 255.255.255.255 "),
+    [OPTION_STRING          ] = 1,
+#if ENABLE_FEATURE_UDHCP_RFC3397
+    [OPTION_DNS_STRING      ] = 1, /* unused */
+    /* Hmmm, this severely overestimates size if SIP_SERVERS option
+     * is in domain name form: N-byte option in binary form
+     * mallocs ~16*N bytes. But it is freed almost at once.
+     */
+    [OPTION_SIP_SERVERS     ] = sizeof("255.255.255.255 "),
+#endif
+//  [OPTION_BOOLEAN         ] = sizeof("yes "),
+    [OPTION_U8              ] = sizeof("255 "),
+    [OPTION_U16             ] = sizeof("65535 "),
+//  [OPTION_S16             ] = sizeof("-32768 "),
+    [OPTION_U32             ] = sizeof("4294967295 "),
+    [OPTION_S32             ] = sizeof("-2147483684 "),
+};
+
+/* note: ip is a pointer to an IP in network order, possibly misaliged */
+static int sprint_nip(char *dest, const char *pre, const uint8_t *ip)
+{
+    return sprintf(dest, "%s%u.%u.%u.%u", pre, ip[0], ip[1], ip[2], ip[3]);
+}
+
+/* really simple implementation, just count the bits */
+static int mton(uint32_t mask)
+{
+    int i = 0;
+    mask = ntohl(mask); /* 111110000-like bit pattern */
+    while (mask) {
+        i++;
+        mask <<= 1;
+    }
+    return i;
+}
+
+/* Create "opt_name=opt_value" string */
+static NOINLINE char *xmalloc_optname_optval(uint8_t *option, const struct dhcp_optflag *optflag, const char *opt_name)
+{
+    unsigned upper_length;
+    int len, type, optlen;
+    char *dest, *ret;
+
+    /* option points to OPT_DATA, need to go back and get OPT_LEN */
+    len = option[OPT_LEN - OPT_DATA];
+
+    type = optflag->flags & OPTION_TYPE_MASK;
+    optlen = dhcp_option_lengths[type];
+    upper_length = len_of_option_as_string[type] * ((unsigned)len / (unsigned)optlen);
+
+    dest = ret = xmalloc(upper_length + strlen(opt_name) + 2);
+    dest += sprintf(ret, "%s=", opt_name);
+
+    while (len >= optlen) {
+        unsigned ip_ofs = 0;
+
+        switch (type) {
+        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);
+            break;
+//      case OPTION_BOOLEAN:
+//          dest += sprintf(dest, *option ? "yes" : "no");
+//          break;
+        case OPTION_U8:
+            dest += sprintf(dest, "%u", *option);
+            break;
+//      case OPTION_S16:
+        case OPTION_U16: {
+            uint16_t val_u16;
+            move_from_unaligned16(val_u16, option);
+            dest += sprintf(dest, "%u", ntohs(val_u16));
+            break;
+        }
+        case OPTION_S32:
+        case OPTION_U32: {
+            uint32_t val_u32;
+            move_from_unaligned32(val_u32, option);
+            dest += sprintf(dest, type == OPTION_U32 ? "%lu" : "%ld", (unsigned long) ntohl(val_u32));
+            break;
+        }
+        case OPTION_STRING:
+            memcpy(dest, option, len);
+            dest[len] = '\0';
+            return ret;  /* Short circuit this case */
+        case OPTION_STATIC_ROUTES: {
+            /* Option binary format:
+             * mask [one byte, 0..32]
+             * ip [big endian, 0..4 bytes depending on mask]
+             * router [big endian, 4 bytes]
+             * may be repeated
+             *
+             * We convert it to a string "IP/MASK ROUTER IP2/MASK2 ROUTER2"
+             */
+            const char *pfx = "";
+
+            while (len >= 1 + 4) { /* mask + 0-byte ip + router */
+                uint32_t nip;
+                uint8_t *p;
+                unsigned mask;
+                int bytes;
+
+                mask = *option++;
+                if (mask > 32)
+                    break;
+                len--;
+
+                nip = 0;
+                p = (void*) &nip;
+                bytes = (mask + 7) / 8; /* 0 -> 0, 1..8 -> 1, 9..16 -> 2 etc */
+                while (--bytes >= 0) {
+                    *p++ = *option++;
+                    len--;
+                }
+                if (len < 4)
+                    break;
+
+                /* print ip/mask */
+                dest += sprint_nip(dest, pfx, (void*) &nip);
+                pfx = " ";
+                dest += sprintf(dest, "/%u ", mask);
+                /* print router */
+                dest += sprint_nip(dest, "", option);
+                option += 4;
+                len -= 4;
+            }
+
+            return ret;
+        }
+#if ENABLE_FEATURE_UDHCP_RFC3397
+        case OPTION_DNS_STRING:
+            /* unpack option into dest; use ret for prefix (i.e., "optname=") */
+            dest = dname_dec(option, len, ret);
+            if (dest) {
+                free(ret);
+                return dest;
+            }
+            /* error. return "optname=" string */
+            return ret;
+        case OPTION_SIP_SERVERS:
+            /* Option binary format:
+             * type: byte
+             * type=0: domain names, dns-compressed
+             * type=1: IP addrs
+             */
+            option++;
+            len--;
+            if (option[-1] == 0) {
+                dest = dname_dec(option, len, ret);
+                if (dest) {
+                    free(ret);
+                    return dest;
+                }
+            } else
+            if (option[-1] == 1) {
+                const char *pfx = "";
+                while (1) {
+                    len -= 4;
+                    if (len < 0)
+                        break;
+                    dest += sprint_nip(dest, pfx, option);
+                    pfx = " ";
+                    option += 4;
+                }
+            }
+            return ret;
+#endif
+        } /* switch */
+        option += optlen;
+        len -= optlen;
+// TODO: it can be a list only if (optflag->flags & OPTION_LIST).
+// 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) */)
+            break;
+        *dest++ = ' ';
+        *dest = '\0';
+    }
+    return ret;
+}
+
+/* put all the parameters into the environment */
+static char **fill_envp(struct dhcp_packet *packet)
+{
+    int envc;
+    int i;
+    char **envp, **curr;
+    const char *opt_name;
+    uint8_t *temp;
+    uint8_t overload = 0;
+
+    /* We need 6 elements for:
+     * "interface=IFACE"
+     * "ip=N.N.N.N" from packet->yiaddr
+     * "siaddr=IP" from packet->siaddr_nip (unless 0)
+     * "boot_file=FILE" from packet->file (unless overloaded)
+     * "sname=SERVER_HOSTNAME" from packet->sname (unless overloaded)
+     * terminating NULL
+     */
+    envc = 6;
+    /* +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 */
+                envc++;
+            }
+        }
+        temp = udhcp_get_option(packet, DHCP_OPTION_OVERLOAD);
+        if (temp)
+            overload = *temp;
+    }
+    curr = envp = xzalloc(sizeof(char *) * envc);
+
+    *curr = xasprintf("interface=%s", client_config.interface);
+    putenv(*curr++);
+
+    if (!packet)
+        return envp;
+
+    *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) {
+        *curr = xmalloc(sizeof("siaddr=255.255.255.255"));
+        sprint_nip(*curr, "siaddr=", (uint8_t *) &packet->siaddr_nip);
+        putenv(*curr++);
+    }
+    if (!(overload & FILE_FIELD) && packet->file[0]) {
+        /* watch out for invalid packets */
+        *curr = xasprintf("boot_file=%."DHCP_PKT_FILE_LEN_STR"s", packet->file);
+        putenv(*curr++);
+    }
+    if (!(overload & SNAME_FIELD) && packet->sname[0]) {
+        /* watch out for invalid packets */
+        *curr = xasprintf("sname=%."DHCP_PKT_SNAME_LEN_STR"s", packet->sname);
+        putenv(*curr++);
+    }
+    return envp;
+}
+
+/* Call a script with a par file and env vars */
+static void udhcp_run_script(struct dhcp_packet *packet, const char *name)
+{
+    char **envp, **curr;
+    char *argv[3];
+
+    if (client_config.script == NULL)
+        return;
+
+    envp = fill_envp(packet);
+
+    /* call script */
+    log1("Executing %s %s", client_config.script, name);
+    argv[0] = (char*) client_config.script;
+    argv[1] = (char*) name;
+    argv[2] = NULL;
+    spawn_and_wait(argv);
+
+    for (curr = envp; *curr; curr++) {
+        log2(" %s", *curr);
+        bb_unsetenv_and_free(*curr);
+    }
+    free(envp);
+}
+
+
+/*** Sending/receiving packets ***/
+
+static ALWAYS_INLINE uint32_t random_xid(void)
+{
+    return rand();
+}
+
+/* Initialize the packet with the proper defaults */
+static void init_packet(struct dhcp_packet *packet, char type)
+{
+    /* Fill in: op, htype, hlen, cookie fields; message type option: */
+    udhcp_init_header(packet, type);
+
+    packet->xid = random_xid();
+
+    memcpy(packet->chaddr, client_config.client_mac, 6);
+    if (client_config.clientid)
+        udhcp_add_binary_option(packet, client_config.clientid);
+}
+
+static void add_client_options(struct dhcp_packet *packet)
+{
+    uint8_t c;
+    int i, end, len;
+
+    udhcp_add_simple_option(packet, DHCP_MAX_SIZE, htons(IP_UDP_DHCP_SIZE));
+
+    /* Add a "param req" option with the list of options we'd like to have
+     * from stubborn DHCP servers. Pull the data from the struct in common.c.
+     * No bounds checking because it goes towards the head of the packet. */
+    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;
+            len++;
+        }
+    }
+    if (len) {
+        packet->options[end + OPT_CODE] = DHCP_PARAM_REQ;
+        packet->options[end + OPT_LEN] = len;
+        packet->options[end + OPT_DATA + len] = DHCP_END;
+    }
+
+    if (client_config.vendorclass)
+        udhcp_add_binary_option(packet, client_config.vendorclass);
+    if (client_config.hostname)
+        udhcp_add_binary_option(packet, client_config.hostname);
+    if (client_config.fqdn)
+        udhcp_add_binary_option(packet, client_config.fqdn);
+
+    /* Add -x options if any */
+    {
+        struct option_set *curr = client_config.options;
+        while (curr) {
+            udhcp_add_binary_option(packet, curr->data);
+            curr = curr->next;
+        }
+//      if (client_config.sname)
+//          strncpy((char*)packet->sname, client_config.sname, sizeof(packet->sname) - 1);
+//      if (client_config.boot_file)
+//          strncpy((char*)packet->file, client_config.boot_file, sizeof(packet->file) - 1);
+    }
+}
+
+/* RFC 2131
+ * 4.4.4 Use of broadcast and unicast
+ *
+ * The DHCP client broadcasts DHCPDISCOVER, DHCPREQUEST and DHCPINFORM
+ * messages, unless the client knows the address of a DHCP server.
+ * The client unicasts DHCPRELEASE messages to the server. Because
+ * the client is declining the use of the IP address supplied by the server,
+ * the client broadcasts DHCPDECLINE messages.
+ *
+ * When the DHCP client knows the address of a DHCP server, in either
+ * INIT or REBOOTING state, the client may use that address
+ * in the DHCPDISCOVER or DHCPREQUEST rather than the IP broadcast address.
+ * The client may also use unicast to send DHCPINFORM messages
+ * to a known DHCP server. If the client receives no response to DHCP
+ * messages sent to the IP address of a known DHCP server, the DHCP
+ * client reverts to using the IP broadcast address.
  */
-static unsigned timeout;
-static uint32_t requested_ip; /* = 0 */
-static uint32_t server_addr;
-static int packet_num; /* = 0 */
+
+static int raw_bcast_from_client_config_ifindex(struct dhcp_packet *packet)
+{
+    return udhcp_send_raw_packet(packet,
+        /*src*/ INADDR_ANY, CLIENT_PORT,
+        /*dst*/ INADDR_BROADCAST, SERVER_PORT, MAC_BCAST_ADDR,
+        client_config.ifindex);
+}
+
+/* Broadcast a DHCP discover packet to the network, with an optionally requested IP */
+/* NOINLINE: limit stack usage in caller */
+static NOINLINE int send_discover(uint32_t xid, uint32_t requested)
+{
+    struct dhcp_packet packet;
+
+    /* Fill in: op, htype, hlen, cookie, chaddr fields,
+     * random xid field (we override it below),
+     * client-id option (unless -C), message type option:
+     */
+    init_packet(&packet, DHCPDISCOVER);
+
+    packet.xid = xid;
+    if (requested)
+        udhcp_add_simple_option(&packet, DHCP_REQUESTED_IP, requested);
+
+    /* Add options: maxsize,
+     * optionally: hostname, fqdn, vendorclass,
+     * "param req" option according to -O, options specified with -x
+     */
+    add_client_options(&packet);
+
+    bb_info_msg("Sending discover...");
+    return raw_bcast_from_client_config_ifindex(&packet);
+}
+
+/* Broadcast a DHCP request message */
+/* RFC 2131 3.1 paragraph 3:
+ * "The client _broadcasts_ a DHCPREQUEST message..."
+ */
+/* NOINLINE: limit stack usage in caller */
+static NOINLINE int send_select(uint32_t xid, uint32_t server, uint32_t requested)
+{
+    struct dhcp_packet packet;
+    struct in_addr addr;
+
+/*
+ * RFC 2131 4.3.2 DHCPREQUEST message
+ * ...
+ * If the DHCPREQUEST message contains a 'server identifier'
+ * option, the message is in response to a DHCPOFFER message.
+ * Otherwise, the message is a request to verify or extend an
+ * existing lease. If the client uses a 'client identifier'
+ * in a DHCPREQUEST message, it MUST use that same 'client identifier'
+ * in all subsequent messages. If the client included a list
+ * of requested parameters in a DHCPDISCOVER message, it MUST
+ * include that list in all subsequent messages.
+ */
+    /* Fill in: op, htype, hlen, cookie, chaddr fields,
+     * random xid field (we override it below),
+     * client-id option (unless -C), message type option:
+     */
+    init_packet(&packet, DHCPREQUEST);
+
+    packet.xid = xid;
+    udhcp_add_simple_option(&packet, DHCP_REQUESTED_IP, requested);
+
+    udhcp_add_simple_option(&packet, DHCP_SERVER_ID, server);
+
+    /* Add options: maxsize,
+     * optionally: hostname, fqdn, vendorclass,
+     * "param req" option according to -O, and options specified with -x
+     */
+    add_client_options(&packet);
+
+    addr.s_addr = requested;
+    bb_info_msg("Sending select for %s...", inet_ntoa(addr));
+    return raw_bcast_from_client_config_ifindex(&packet);
+}
+
+/* Unicast or broadcast a DHCP renew message */
+/* NOINLINE: limit stack usage in caller */
+static NOINLINE int send_renew(uint32_t xid, uint32_t server, uint32_t ciaddr)
+{
+    struct dhcp_packet packet;
+
+/*
+ * RFC 2131 4.3.2 DHCPREQUEST message
+ * ...
+ * DHCPREQUEST generated during RENEWING state:
+ *
+ * 'server identifier' MUST NOT be filled in, 'requested IP address'
+ * option MUST NOT be filled in, 'ciaddr' MUST be filled in with
+ * client's IP address. In this situation, the client is completely
+ * configured, and is trying to extend its lease. This message will
+ * be unicast, so no relay agents will be involved in its
+ * transmission.  Because 'giaddr' is therefore not filled in, the
+ * DHCP server will trust the value in 'ciaddr', and use it when
+ * replying to the client.
+ */
+    /* Fill in: op, htype, hlen, cookie, chaddr fields,
+     * random xid field (we override it below),
+     * client-id option (unless -C), message type option:
+     */
+    init_packet(&packet, DHCPREQUEST);
+
+    packet.xid = xid;
+    packet.ciaddr = ciaddr;
+
+    /* Add options: maxsize,
+     * optionally: hostname, fqdn, vendorclass,
+     * "param req" option according to -O, and options specified with -x
+     */
+    add_client_options(&packet);
+
+    bb_info_msg("Sending renew...");
+    if (server)
+        return udhcp_send_kernel_packet(&packet,
+            ciaddr, CLIENT_PORT,
+            server, SERVER_PORT);
+    return raw_bcast_from_client_config_ifindex(&packet);
+}
+
+#if ENABLE_FEATURE_UDHCPC_ARPING
+/* 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)
+{
+    struct dhcp_packet packet;
+
+    /* Fill in: op, htype, hlen, cookie, chaddr, random xid fields,
+     * client-id option (unless -C), message type option:
+     */
+    init_packet(&packet, DHCPDECLINE);
+
+    /* RFC 2131 says DHCPDECLINE's xid is randomly selected by client,
+     * but in case the server is buggy and wants DHCPDECLINE's xid
+     * to match the xid which started entire handshake,
+     * we use the same xid we used in initial DHCPDISCOVER:
+     */
+    packet.xid = xid;
+    /* DHCPDECLINE uses "requested ip", not ciaddr, to store offered IP */
+    udhcp_add_simple_option(&packet, DHCP_REQUESTED_IP, requested);
+
+    udhcp_add_simple_option(&packet, DHCP_SERVER_ID, server);
+
+    bb_info_msg("Sending decline...");
+    return raw_bcast_from_client_config_ifindex(&packet);
+}
+#endif
+
+/* Unicast a DHCP release message */
+static int send_release(uint32_t server, uint32_t ciaddr)
+{
+    struct dhcp_packet packet;
+
+    /* Fill in: op, htype, hlen, cookie, chaddr, random xid fields,
+     * client-id option (unless -C), message type option:
+     */
+    init_packet(&packet, DHCPRELEASE);
+
+    /* DHCPRELEASE uses ciaddr, not "requested ip", to store IP being released */
+    packet.ciaddr = ciaddr;
+
+    udhcp_add_simple_option(&packet, DHCP_SERVER_ID, server);
+
+    bb_info_msg("Sending release...");
+    return udhcp_send_kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
+}
+
+/* Returns -1 on errors that are fatal for the socket, -2 for those that aren't */
+/* NOINLINE: limit stack usage in caller */
+static NOINLINE int udhcp_recv_raw_packet(struct dhcp_packet *dhcp_pkt, int fd)
+{
+    int bytes;
+    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 */
+    }
+
+    if (bytes < (int) (sizeof(packet.ip) + sizeof(packet.udp))) {
+        log1("Packet is too short, ignoring");
+        return -2;
+    }
+
+    if (bytes < ntohs(packet.ip.tot_len)) {
+        /* packet is bigger than sizeof(packet), we did partial read */
+        log1("Oversized packet, ignoring");
+        return -2;
+    }
+
+    /* ignore any extra garbage bytes */
+    bytes = ntohs(packet.ip.tot_len);
+
+    /* make sure its the right packet for us, and that it passes sanity checks */
+    if (packet.ip.protocol != IPPROTO_UDP || packet.ip.version != IPVERSION
+     || packet.ip.ihl != (sizeof(packet.ip) >> 2)
+     || packet.udp.dest != htons(CLIENT_PORT)
+    /* || bytes > (int) sizeof(packet) - can't happen */
+     || ntohs(packet.udp.len) != (uint16_t)(bytes - sizeof(packet.ip))
+    ) {
+        log1("Unrelated/bogus packet, ignoring");
+        return -2;
+    }
+
+    /* verify IP checksum */
+    check = packet.ip.check;
+    packet.ip.check = 0;
+    if (check != udhcp_checksum(&packet.ip, sizeof(packet.ip))) {
+        log1("Bad IP header checksum, ignoring");
+        return -2;
+    }
+
+    /* verify UDP checksum. IP header has to be modified for this */
+    memset(&packet.ip, 0, offsetof(struct iphdr, protocol));
+    /* ip.xx fields which are not memset: protocol, check, saddr, daddr */
+    packet.ip.tot_len = packet.udp.len; /* yes, this is needed */
+    check = packet.udp.check;
+    packet.udp.check = 0;
+    if (check && check != udhcp_checksum(&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)) {
+        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));
+}
+
+
+/*** Main ***/
+
 static int sockfd = -1;
 
-#define LISTEN_NONE 0
+#define LISTEN_NONE   0
 #define LISTEN_KERNEL 1
-#define LISTEN_RAW 2
+#define LISTEN_RAW    2
 static smallint listen_mode;
 
+/* initial state: (re)start DHCP negotiation */
+#define INIT_SELECTING  0
+/* discover was sent, DHCPOFFER reply received */
+#define REQUESTING      1
+/* select/renew was sent, DHCPACK reply received */
+#define BOUND           2
+/* half of lease passed, want to renew it by sending unicast renew requests */
+#define RENEWING        3
+/* renew requests were not answered, lease is almost over, send broadcast renew */
+#define REBINDING       4
+/* manually requested renew (SIGUSR1) */
+#define RENEW_REQUESTED 5
+/* release, possibly manually requested (SIGUSR2) */
+#define RELEASED        6
 static smallint state;
 
-struct client_config_t client_config;
-
-
-/* just a little helper */
-static void change_mode(int new_mode)
-{
-    DEBUG("entering %s listen mode",
-        new_mode ? (new_mode == 1 ? "kernel" : "raw") : "none");
+static int udhcp_raw_socket(int ifindex)
+{
+    int fd;
+    struct sockaddr_ll sock;
+
+    /*
+     * Comment:
+     *
+     *  I've selected not to see LL header, so BPF doesn't see it, too.
+     *  The filter may also pass non-IP and non-ARP packets, but we do
+     *  a more complete check when receiving the message in userspace.
+     *
+     * and filter shamelessly stolen from:
+     *
+     *  http://www.flamewarmaster.de/software/dhcpclient/
+     *
+     * There are a few other interesting ideas on that page (look under
+     * "Motivation").  Use of netlink events is most interesting.  Think
+     * of various network servers listening for events and reconfiguring.
+     * That would obsolete sending HUP signals and/or make use of restarts.
+     *
+     * Copyright: 2006, 2007 Stefan Rompf <sux@loplof.de>.
+     * License: GPL v2.
+     *
+     * TODO: make conditional?
+     */
+#define SERVER_AND_CLIENT_PORTS  ((67 << 16) + 68)
+    static const struct sock_filter filter_instr[] = {
+        /* check for udp */
+        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 */
+    };
+    static const struct sock_fprog filter_prog = {
+        .len = sizeof(filter_instr) / sizeof(filter_instr[0]),
+        /* casting const away: */
+        .filter = (struct sock_filter *) filter_instr,
+    };
+
+    log1("Opening raw socket on ifindex %d", ifindex); //log2?
+
+    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?
+    }
+
+    sock.sll_family = AF_PACKET;
+    sock.sll_protocol = htons(ETH_P_IP);
+    sock.sll_ifindex = ifindex;
+    xbind(fd, (struct sockaddr *) &sock, sizeof(sock));
+    log1("Created raw socket");
+
+    return fd;
+}
+
+static void change_listen_mode(int new_mode)
+{
+    log1("Entering listen mode: %s",
+        new_mode != LISTEN_NONE
+            ? (new_mode == LISTEN_KERNEL ? "kernel" : "raw")
+            : "none"
+    );
+
+    listen_mode = new_mode;
     if (sockfd >= 0) {
         close(sockfd);
         sockfd = -1;
     }
-    listen_mode = new_mode;
-}
-
-
-/* perform a renew */
+    if (new_mode == LISTEN_KERNEL)
+        sockfd = udhcp_listen_socket(/*INADDR_ANY,*/ CLIENT_PORT, client_config.interface);
+    else if (new_mode != LISTEN_NONE)
+        sockfd = udhcp_raw_socket(client_config.ifindex);
+    /* else LISTEN_NONE: sockfd stays closed */
+}
+
 static void perform_renew(void)
 {
@@ -60 +785 @@
     switch (state) {
     case BOUND:
-        change_mode(LISTEN_KERNEL);
+        change_listen_mode(LISTEN_KERNEL);
     case RENEWING:
     case REBINDING:
@@ -69 +794 @@
     case REQUESTING:
     case RELEASED:
-        change_mode(LISTEN_RAW);
+        change_listen_mode(LISTEN_RAW);
         state = INIT_SELECTING;
         break;
@@ -75 +800 @@
         break;
     }
-
-    /* start things over */
-    packet_num = 0;
-
-    /* Kill any timeouts because the user wants this to hurry along */
-    timeout = 0;
-}
-
-
-/* perform a release */
-static void perform_release(void)
+}
+
+static void perform_release(uint32_t requested_ip, uint32_t server_addr)
 {
     char buffer[sizeof("255.255.255.255")];
@@ -102 +819 @@
     bb_info_msg("Entering released state");
 
-    change_mode(LISTEN_NONE);
+    change_listen_mode(LISTEN_NONE);
     state = RELEASED;
-    timeout = INT_MAX;
-}
-
-
-static void client_background(void)
-{
-#if !BB_MMU
-    bb_error_msg("cannot background in uclinux (yet)");
-/* ... mainly because udhcpc calls client_background()
- * in _the _middle _of _udhcpc _run_, not at the start!
- * If that will be properly disabled for NOMMU, client_background()
- * will work on NOMMU too */
-#else
-    bb_daemonize(0);
-    logmode &= ~LOGMODE_STDIO;
-    /* rewrite pidfile, as our pid is different now */
-    write_pidfile(client_config.pidfile);
-#endif
-    /* Do not fork again. */
-    client_config.foreground = 1;
-    client_config.background_if_no_lease = 0;
-}
-
+}
 
 static uint8_t* alloc_dhcp_option(int code, const char *str, int extra)
 {
     uint8_t *storage;
-    int len = strlen(str);
-    if (len > 255) len = 255;
+    int len = strnlen(str, 255);
     storage = xzalloc(len + extra + OPT_DATA);
     storage[OPT_CODE] = code;
@@ -140 +834 @@
 }
 
-
-int udhcpc_main(int argc, char **argv);
-int udhcpc_main(int argc, char **argv)
+#if BB_MMU
+static void client_background(void)
+{
+    bb_daemonize(0);
+    logmode &= ~LOGMODE_STDIO;
+    /* rewrite pidfile, as our pid is different now */
+    write_pidfile(client_config.pidfile);
+}
+#endif
+
+//usage:#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
+//usage:# define IF_UDHCP_VERBOSE(...) __VA_ARGS__
+//usage:#else
+//usage:# define IF_UDHCP_VERBOSE(...)
+//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:#define udhcpc_full_usage "\n"
+//usage:    IF_LONG_OPTS(
+//usage:     "\n    -i,--interface IFACE    Interface to use (default eth0)"
+//usage:     "\n    -p,--pidfile FILE   Create pidfile"
+//usage:     "\n    -s,--script PROG    Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
+//usage:     "\n    -t,--retries N      Send up to N discover packets"
+//usage:     "\n    -T,--timeout N      Pause between packets (default 3 seconds)"
+//usage:     "\n    -A,--tryagain N     Wait N seconds after failure (default 20)"
+//usage:     "\n    -f,--foreground     Run in foreground"
+//usage:    USE_FOR_MMU(
+//usage:     "\n    -b,--background     Background if lease is not obtained"
+//usage:    )
+//usage:     "\n    -n,--now        Exit if lease is not obtained"
+//usage:     "\n    -q,--quit       Exit after obtaining lease"
+//usage:     "\n    -R,--release        Release IP on exit"
+//usage:     "\n    -S,--syslog     Log to syslog too"
+//usage:    IF_FEATURE_UDHCP_PORT(
+//usage:     "\n    -P,--client-port N  Use port N (default 68)"
+//usage:    )
+//usage:    IF_FEATURE_UDHCPC_ARPING(
+//usage:     "\n    -a,--arping     Use arping to validate offered address"
+//usage:    )
+//usage:     "\n    -O,--request-option OPT Request option OPT from server (cumulative)"
+//usage:     "\n    -o,--no-default-options Don't request any options (unless -O is given)"
+//usage:     "\n    -r,--request IP     Request this IP address"
+//usage:     "\n    -x OPT:VAL      Include option OPT in sent packets (cumulative)"
+//usage:     "\n                Examples of string, numeric, and hex byte opts:"
+//usage:     "\n                -x hostname:bbox - option 12"
+//usage:     "\n                -x lease:3600 - option 51 (lease time)"
+//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"
+//usage:    IF_UDHCP_VERBOSE(
+//usage:     "\n    -v          Verbose"
+//usage:    )
+//usage:    )
+//usage:    IF_NOT_LONG_OPTS(
+//usage:     "\n    -i IFACE    Interface to use (default eth0)"
+//usage:     "\n    -p FILE     Create pidfile"
+//usage:     "\n    -s PROG     Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
+//usage:     "\n    -t N        Send up to N discover packets"
+//usage:     "\n    -T N        Pause between packets (default 3 seconds)"
+//usage:     "\n    -A N        Wait N seconds (default 20) after failure"
+//usage:     "\n    -f      Run in foreground"
+//usage:    USE_FOR_MMU(
+//usage:     "\n    -b      Background if lease is not obtained"
+//usage:    )
+//usage:     "\n    -n      Exit if lease is not obtained"
+//usage:     "\n    -q      Exit after obtaining lease"
+//usage:     "\n    -R      Release IP on exit"
+//usage:     "\n    -S      Log to syslog too"
+//usage:    IF_FEATURE_UDHCP_PORT(
+//usage:     "\n    -P N        Use port N (default 68)"
+//usage:    )
+//usage:    IF_FEATURE_UDHCPC_ARPING(
+//usage:     "\n    -a      Use arping to validate offered address"
+//usage:    )
+//usage:     "\n    -O OPT      Request option OPT from server (cumulative)"
+//usage:     "\n    -o      Don't request any options (unless -O is given)"
+//usage:     "\n    -r IP       Request this IP address"
+//usage:     "\n    -x OPT:VAL  Include option OPT in sent packets (cumulative)"
+//usage:     "\n            Examples of string, numeric, and hex byte opts:"
+//usage:     "\n            -x hostname:bbox - option 12"
+//usage:     "\n            -x lease:3600 - option 51 (lease time)"
+//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"
+//usage:    IF_UDHCP_VERBOSE(
+//usage:     "\n    -v      Verbose"
+//usage:    )
+//usage:    )
+
+int udhcpc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int udhcpc_main(int argc UNUSED_PARAM, char **argv)
 {
     uint8_t *temp, *message;
-    char *str_c, *str_V, *str_h, *str_F, *str_r, *str_T, *str_t;
+    const char *str_V, *str_h, *str_F, *str_r;
+    IF_FEATURE_UDHCP_PORT(char *str_P;)
+    void *clientid_mac_ptr;
+    llist_t *list_O = NULL;
+    llist_t *list_x = NULL;
+    int tryagain_timeout = 20;
+    int discover_timeout = 3;
+    int discover_retries = 3;
+    uint32_t server_addr = server_addr; /* for compiler */
+    uint32_t requested_ip = 0;
     uint32_t xid = 0;
-    uint32_t lease = 0; /* can be given as 32-bit quantity */
-    unsigned t1 = 0, t2 = 0; /* what a wonderful names */
-    unsigned start = 0;
-    unsigned now;
+    uint32_t lease_seconds = 0; /* can be given as 32-bit quantity */
+    int packet_num;
+    int timeout; /* must be signed */
+    unsigned already_waited_sec;
     unsigned opt;
     int max_fd;
     int retval;
-    int len;
     struct timeval tv;
-    struct in_addr temp_addr;
-    struct dhcpMessage packet;
+    struct dhcp_packet packet;
     fd_set rfds;
 
-    enum {
-        OPT_c = 1 << 0,
-        OPT_C = 1 << 1,
-        OPT_V = 1 << 2,
-        OPT_f = 1 << 3,
-        OPT_b = 1 << 4,
-        OPT_H = 1 << 5,
-        OPT_h = 1 << 6,
-        OPT_F = 1 << 7,
-        OPT_i = 1 << 8,
-        OPT_n = 1 << 9,
-        OPT_p = 1 << 10,
-        OPT_q = 1 << 11,
-        OPT_R = 1 << 12,
-        OPT_r = 1 << 13,
-        OPT_s = 1 << 14,
-        OPT_T = 1 << 15,
-        OPT_t = 1 << 16,
-        OPT_v = 1 << 17,
-        OPT_S = 1 << 18,
-    };
-#if ENABLE_GETOPT_LONG
+#if ENABLE_LONG_OPTS
     static const char udhcpc_longopts[] ALIGN1 =
-        "clientid\0"      Required_argument "c"
-        "clientid-none\0" No_argument       "C"
-        "vendorclass\0"   Required_argument "V"
-        "foreground\0"    No_argument       "f"
-        "background\0"    No_argument       "b"
-        "hostname\0"      Required_argument "H"
-        "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"
-        "syslog\0"        No_argument       "S"
+        "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
-    /* Default options. */
+    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 */
+    IF_FEATURE_UDHCP_PORT(SERVER_PORT = 67;)
+    IF_FEATURE_UDHCP_PORT(CLIENT_PORT = 68;)
     client_config.interface = "eth0";
-    client_config.script = DEFAULT_SCRIPT;
-    client_config.retries = 3;
-    client_config.timeout = 3;
+    client_config.script = CONFIG_UDHCPC_DEFAULT_SCRIPT;
+    str_V = "udhcp "BB_VER;
 
     /* Parse command line */
-    opt_complementary = "c--C:C--c" // mutually exclusive
-                        ":hH:Hh"; // -h and -H are the same
-#if ENABLE_GETOPT_LONG
-    applet_long_options = udhcpc_longopts;
+    /* 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 = getopt32(argv, "c:CV:fbH:h:F:i:np:qRr:s:T:t:vS",
-        &str_c, &str_V, &str_h, &str_h, &str_F,
-        &client_config.interface, &client_config.pidfile, &str_r,
-        &client_config.script, &str_T, &str_t
+        ;
+    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"
+        USE_FOR_MMU("b")
+        IF_FEATURE_UDHCPC_ARPING("a")
+        IF_FEATURE_UDHCP_PORT("P:")
+        "v"
+        , &str_V, &str_h, &str_h, &str_F
+        , &client_config.interface, &client_config.pidfile, &str_r /* i,p */
+        , &client_config.script /* s */
+        , &discover_timeout, &discover_retries, &tryagain_timeout /* T,t,A */
+        , &list_O
+        , &list_x
+        IF_FEATURE_UDHCP_PORT(, &str_P)
+#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
+        , &dhcp_verbose
+#endif
         );
-
-    if (opt & OPT_c)
-        client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, str_c, 0);
-    //if (opt & OPT_C)
-    if (opt & OPT_V)
-        client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, str_V, 0);
-    if (opt & OPT_f)
-        client_config.foreground = 1;
-    if (opt & OPT_b)
-        client_config.background_if_no_lease = 1;
-    if (opt & OPT_h)
+    if (opt & (OPT_h|OPT_H))
         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> */
         client_config.fqdn = alloc_dhcp_option(DHCP_FQDN, str_F, 3);
-        /* Flags: 0000NEOS
-        S: 1 => Client requests Server to update A RR in DNS as well as PTR
-        O: 1 => Server indicates to client that DNS has been updated regardless
-        E: 1 => Name data is DNS format, i.e. <4>host<6>domain<4>com<0> not "host.domain.com"
-        N: 1 => Client requests Server to not update DNS
-        */
+        /* Flag bits: 0000NEOS
+         * S: 1 = Client requests server to update A RR in DNS as well as PTR
+         * O: 1 = Server indicates to client that DNS has been updated regardless
+         * E: 1 = Name is in DNS format, i.e. <4>host<6>domain<3>com<0>,
+         *    not "host.domain.com". Format 0 is obsolete.
+         * N: 1 = Client requests server to not update DNS (S must be 0 then)
+         * Two [0] bytes which follow are deprecated and must be 0.
+         */
         client_config.fqdn[OPT_DATA + 0] = 0x1;
-        /* client_config.fqdn[OPT_DATA + 1] = 0; - redundant */
-        /* client_config.fqdn[OPT_DATA + 2] = 0; - redundant */
-    }
-    // if (opt & OPT_i) client_config.interface = ...
-    if (opt & OPT_n)
-        client_config.abort_if_no_lease = 1;
-    // if (opt & OPT_p) client_config.pidfile = ...
-    if (opt & OPT_q)
-        client_config.quit_after_lease = 1;
-    if (opt & OPT_R)
-        client_config.release_on_quit = 1;
+        /*client_config.fqdn[OPT_DATA + 1] = 0; - xzalloc did it */
+        /*client_config.fqdn[OPT_DATA + 2] = 0; */
+    }
     if (opt & OPT_r)
         requested_ip = inet_addr(str_r);
-    // if (opt & OPT_s) client_config.script = ...
-    if (opt & OPT_T)
-        client_config.timeout = xatoi_u(str_T);
-    if (opt & OPT_t)
-        client_config.retries = xatoi_u(str_t);
-    if (opt & OPT_v) {
-        printf("version %s\n", BB_VER);
-        return 0;
-    }
-
+#if ENABLE_FEATURE_UDHCP_PORT
+    if (opt & OPT_P) {
+        CLIENT_PORT = xatou16(str_P);
+        SERVER_PORT = CLIENT_PORT - 1;
+    }
+#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;
+        client_config.opt_mask[n >> 3] |= 1 << (n & 7);
+    }
+    while (list_x) {
+        char *optstr = llist_pop(&list_x);
+        char *colon = strchr(optstr, ':');
+        if (colon)
+            *colon = ' ';
+        /* now it looks similar to udhcpd's config file line:
+         * "optname optval", using the common routine: */
+        udhcp_str2optset(optstr, &client_config.options);
+    }
+
+    if (udhcp_read_interface(client_config.interface,
+            &client_config.ifindex,
+            NULL,
+            client_config.client_mac)
+    ) {
+        return 1;
+    }
+
+    clientid_mac_ptr = NULL;
+    if (!(opt & OPT_C) && !udhcp_find_option(client_config.options, DHCP_CLIENT_ID)) {
+        /* not suppressed and not set, set the default client ID */
+        client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, "", 7);
+        client_config.clientid[OPT_DATA] = 1; /* type: ethernet */
+        clientid_mac_ptr = client_config.clientid + OPT_DATA+1;
+        memcpy(clientid_mac_ptr, client_config.client_mac, 6);
+    }
+    if (str_V[0] != '\0')
+        client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, str_V, 0);
+#if !BB_MMU
+    /* on NOMMU reexec (i.e., background) early */
+    if (!(opt & OPT_f)) {
+        bb_daemonize_or_rexec(0 /* flags */, argv);
+        logmode = LOGMODE_NONE;
+    }
+#endif
     if (opt & OPT_S) {
-        openlog(applet_name, LOG_PID, LOG_LOCAL0);
+        openlog(applet_name, LOG_PID, LOG_DAEMON);
         logmode |= LOGMODE_SYSLOG;
     }
-
-    if (read_interface(client_config.interface, &client_config.ifindex,
-               NULL, client_config.arp))
-        return 1;
 
     /* Make sure fd 0,1,2 are open */
@@ -278 +1119 @@
     /* Equivalent of doing a fflush after every \n */
     setlinebuf(stdout);
-
     /* Create pidfile */
     write_pidfile(client_config.pidfile);
-    /* if (!..) bb_perror_msg("cannot create pidfile %s", pidfile); */
-
-    /* Goes to stdout and possibly syslog */
-    bb_info_msg("%s (v%s) started", applet_name, BB_VER);
-
-    /* if not set, and not suppressed, setup the default client ID */
-    if (!client_config.clientid && !(opt & OPT_C)) {
-        client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, "", 7);
-        client_config.clientid[OPT_DATA] = 1;
-        memcpy(client_config.clientid + OPT_DATA+1, client_config.arp, 6);
-    }
-
-    if (!client_config.vendorclass)
-        client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, "udhcp "BB_VER, 0);
-
-    /* setup the signal pipe */
+    /* Goes to stdout (unless NOMMU) and possibly syslog */
+    bb_info_msg("%s (v"BB_VER") started", applet_name);
+    /* Set up the signal pipe */
     udhcp_sp_setup();
+    /* We want random_xid to be random... */
+    srand(monotonic_us());
 
     state = INIT_SELECTING;
     udhcp_run_script(NULL, "deconfig");
-    change_mode(LISTEN_RAW);
-    tv.tv_sec = 0;
-    goto jump_in;
-
+    change_listen_mode(LISTEN_RAW);
+    packet_num = 0;
+    timeout = 0;
+    already_waited_sec = 0;
+
+    /* Main event loop. select() waits on signal pipe and possibly
+     * on sockfd.
+     * "continue" statements in code below jump to the top of the loop.
+     */
     for (;;) {
-        tv.tv_sec = timeout - monotonic_sec();
- jump_in:
+        /* silence "uninitialized!" warning */
+        unsigned timestamp_before_wait = timestamp_before_wait;
+
+        //bb_error_msg("sockfd:%d, listen_mode:%d", sockfd, listen_mode);
+
+        /* Was opening raw or udp socket here
+         * if (listen_mode != LISTEN_NONE && sockfd < 0),
+         * but on fast network renew responses return faster
+         * than we open sockets. Thus this code is moved
+         * to change_listen_mode(). Thus we open listen socket
+         * BEFORE we send renew request (see "case BOUND:"). */
+
+        max_fd = udhcp_sp_fd_set(&rfds, sockfd);
+
+        tv.tv_sec = timeout - already_waited_sec;
         tv.tv_usec = 0;
-
-        if (listen_mode != LISTEN_NONE && sockfd < 0) {
-            if (listen_mode == LISTEN_KERNEL)
-                sockfd = listen_socket(/*INADDR_ANY,*/ CLIENT_PORT, client_config.interface);
-            else
-                sockfd = raw_socket(client_config.ifindex);
-        }
-        max_fd = udhcp_sp_fd_set(&rfds, sockfd);
-
-        retval = 0; /* If we already timed out, fall through, else... */
-        if (tv.tv_sec > 0) {
-            DEBUG("Waiting on select...");
+        retval = 0;
+        /* If we already timed out, fall through with retval = 0, else... */
+        if ((int)tv.tv_sec > 0) {
+            timestamp_before_wait = (unsigned)monotonic_sec();
+            log1("Waiting on select...");
             retval = select(max_fd + 1, &rfds, NULL, NULL, &tv);
-        }
-
-        now = monotonic_sec();
-        if (retval < 0) {
-            /* EINTR? signal was caught, don't panic */
-            if (errno != EINTR) {
+            if (retval < 0) {
+                /* EINTR? A signal was caught, don't panic */
+                if (errno == EINTR) {
+                    already_waited_sec += (unsigned)monotonic_sec() - timestamp_before_wait;
+                    continue;
+                }
                 /* Else: an error occured, panic! */
                 bb_perror_msg_and_die("select");
             }
-        } else if (retval == 0) {
-            /* timeout dropped to zero */
+        }
+
+        /* If timeout dropped to zero, time to become active:
+         * resend discover/renew/whatever
+         */
+        if (retval == 0) {
+            /* When running on a bridge, the ifindex may have changed
+             * (e.g. if member interfaces were added/removed
+             * or if the status of the bridge changed).
+             * Refresh ifindex and client_mac:
+             */
+            if (udhcp_read_interface(client_config.interface,
+                    &client_config.ifindex,
+                    NULL,
+                    client_config.client_mac)
+            ) {
+                return 1; /* iface is gone? */
+            }
+            if (clientid_mac_ptr)
+                memcpy(clientid_mac_ptr, client_config.client_mac, 6);
+
+            /* We will restart the wait in any case */
+            already_waited_sec = 0;
+
             switch (state) {
             case INIT_SELECTING:
-                if (packet_num < client_config.retries) {
+                if (packet_num < discover_retries) {
                     if (packet_num == 0)
                         xid = random_xid();
-
-                    /* send discover packet */
-                    send_discover(xid, requested_ip); /* broadcast */
-
-                    timeout = now + client_config.timeout;
+                    /* broadcast */
+                    send_discover(xid, requested_ip);
+                    timeout = discover_timeout;
                     packet_num++;
+                    continue;
+                }
+ leasefail:
+                udhcp_run_script(NULL, "leasefail");
+#if BB_MMU /* -b is not supported on NOMMU */
+                if (opt & OPT_b) { /* background if no lease */
+                    bb_info_msg("No lease, forking to background");
+                    client_background();
+                    /* do not background again! */
+                    opt = ((opt & ~OPT_b) | OPT_f);
+                } else
+#endif
+                if (opt & OPT_n) { /* abort if no lease */
+                    bb_info_msg("No lease, failing");
+                    retval = 1;
+                    goto ret;
+                }
+                /* wait before trying again */
+                timeout = tryagain_timeout;
+                packet_num = 0;
+                continue;
+            case REQUESTING:
+                if (packet_num < discover_retries) {
+                    /* send broadcast select packet */
+                    send_select(xid, server_addr, requested_ip);
+                    timeout = discover_timeout;
+                    packet_num++;
+                    continue;
+                }
+                /* Timed out, go back to init state.
+                 * "discover...select...discover..." loops
+                 * were seen in the wild. Treat them similarly
+                 * to "no response to discover" case */
+                change_listen_mode(LISTEN_RAW);
+                state = INIT_SELECTING;
+                goto leasefail;
+            case BOUND:
+                /* 1/2 lease passed, enter renewing state */
+                state = RENEWING;
+                change_listen_mode(LISTEN_KERNEL);
+                log1("Entering renew state");
+                /* fall right through */
+            case RENEW_REQUESTED: /* manual (SIGUSR1) renew */
+            case_RENEW_REQUESTED:
+            case RENEWING:
+                if (timeout > 60) {
+                    /* send an unicast renew request */
+            /* Sometimes observed to fail (EADDRNOTAVAIL) to bind
+             * a new UDP socket for sending inside send_renew.
+             * I hazard to guess existing listening socket
+             * is somehow conflicting with it, but why is it
+             * not deterministic then?! Strange.
+             * Anyway, it does recover by eventually failing through
+             * into INIT_SELECTING state.
+             */
+                    send_renew(xid, server_addr, requested_ip);
+                    timeout >>= 1;
+                    continue;
+                }
+                /* Timed out, enter rebinding state */
+                log1("Entering rebinding state");
+                state = REBINDING;
+                /* fall right through */
+            case REBINDING:
+                /* Switch to bcast receive */
+                change_listen_mode(LISTEN_RAW);
+                /* Lease is *really* about to run out,
+                 * try to find DHCP server using broadcast */
+                if (timeout > 0) {
+                    /* send a broadcast renew request */
+                    send_renew(xid, 0 /*INADDR_ANY*/, requested_ip);
+                    timeout >>= 1;
+                    continue;
+                }
+                /* Timed out, enter init state */
+                bb_info_msg("Lease lost, entering init state");
+                udhcp_run_script(NULL, "deconfig");
+                state = INIT_SELECTING;
+                /*timeout = 0; - already is */
+                packet_num = 0;
+                continue;
+            /* case RELEASED: */
+            }
+            /* yah, I know, *you* say it would never happen */
+            timeout = INT_MAX;
+            continue; /* back to main loop */
+        } /* if select timed out */
+
+        /* select() didn't timeout, something happened */
+
+        /* Is it a signal? */
+        /* note: udhcp_sp_read checks FD_ISSET before reading */
+        switch (udhcp_sp_read(&rfds)) {
+        case SIGUSR1:
+            perform_renew();
+            if (state == RENEW_REQUESTED)
+                goto case_RENEW_REQUESTED;
+            /* Start things over */
+            packet_num = 0;
+            /* Kill any timeouts, user wants this to hurry along */
+            timeout = 0;
+            continue;
+        case SIGUSR2:
+            perform_release(requested_ip, server_addr);
+            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;
+        }
+
+        /* Is it a packet? */
+        if (listen_mode == LISTEN_NONE || !FD_ISSET(sockfd, &rfds))
+            continue; /* no */
+
+        {
+            int len;
+
+            /* A packet is ready, read it */
+            if (listen_mode == LISTEN_KERNEL)
+                len = udhcp_recv_kernel_packet(&packet, sockfd);
+            else
+                len = udhcp_recv_raw_packet(&packet, sockfd);
+            if (len == -1) {
+                /* Error is severe, reopen socket */
+                bb_info_msg("Read error: %s, reopening socket", strerror(errno));
+                sleep(discover_timeout); /* 3 seconds by default */
+                change_listen_mode(listen_mode); /* just close and reopen */
+            }
+            /* If this packet will turn out to be unrelated/bogus,
+             * we will go back and wait for next one.
+             * Be sure timeout is properly decreased. */
+            already_waited_sec += (unsigned)monotonic_sec() - timestamp_before_wait;
+            if (len < 0)
+                continue;
+        }
+
+        if (packet.xid != xid) {
+            log1("xid %x (our is %x), ignoring packet",
+                (unsigned)packet.xid, (unsigned)xid);
+            continue;
+        }
+
+        /* Ignore packets that aren't for us */
+        if (packet.hlen != 6
+         || memcmp(packet.chaddr, client_config.client_mac, 6) != 0
+        ) {
+//FIXME: need to also check that last 10 bytes are zero
+            log1("chaddr does not match, ignoring packet"); // log2?
+            continue;
+        }
+
+        message = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
+        if (message == NULL) {
+            bb_error_msg("no message type option, ignoring packet");
+            continue;
+        }
+
+        switch (state) {
+        case INIT_SELECTING:
+            /* Must be a DHCPOFFER to one of our xid's */
+            if (*message == DHCPOFFER) {
+        /* TODO: why we don't just fetch server's IP from IP header? */
+                temp = udhcp_get_option(&packet, DHCP_SERVER_ID);
+                if (!temp) {
+                    bb_error_msg("no server ID, ignoring packet");
+                    continue;
+                    /* still selecting - this server looks bad */
+                }
+                /* it IS unaligned sometimes, don't "optimize" */
+                move_from_unaligned32(server_addr, temp);
+                /*xid = packet.xid; - already is */
+                requested_ip = packet.yiaddr;
+
+                /* enter requesting state */
+                state = REQUESTING;
+                timeout = 0;
+                packet_num = 0;
+                already_waited_sec = 0;
+            }
+            continue;
+        case REQUESTING:
+        case RENEWING:
+        case RENEW_REQUESTED:
+        case REBINDING:
+            if (*message == DHCPACK) {
+                temp = udhcp_get_option(&packet, DHCP_LEASE_TIME);
+                if (!temp) {
+                    bb_error_msg("no lease time with ACK, using 1 hour lease");
+                    lease_seconds = 60 * 60;
                 } else {
-                    udhcp_run_script(NULL, "leasefail");
-                    if (client_config.background_if_no_lease) {
-                        bb_info_msg("No lease, forking to background");
-                        client_background();
-                    } else if (client_config.abort_if_no_lease) {
-                        bb_info_msg("No lease, failing");
-                        retval = 1;
-                        goto ret;
-                    }
-                    /* wait to try again */
-                    packet_num = 0;
-                    timeout = now + 60;
+                    /* it IS unaligned sometimes, don't "optimize" */
+                    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;
                 }
-                break;
-            case RENEW_REQUESTED:
-            case REQUESTING:
-                if (packet_num < client_config.retries) {
-                    /* send request packet */
-                    if (state == RENEW_REQUESTED)
-                        send_renew(xid, server_addr, requested_ip); /* unicast */
-                    else send_selecting(xid, server_addr, requested_ip); /* broadcast */
-
-                    timeout = now + ((packet_num == 2) ? 10 : 2);
-                    packet_num++;
-                } else {
-                    /* timed out, go back to init state */
-                    if (state == RENEW_REQUESTED)
-                        udhcp_run_script(NULL, "deconfig");
-                    state = INIT_SELECTING;
-                    timeout = now;
-                    packet_num = 0;
-                    change_mode(LISTEN_RAW);
-                }
-                break;
-            case BOUND:
-                /* Lease is starting to run out, time to enter renewing state */
-                state = RENEWING;
-                change_mode(LISTEN_KERNEL);
-                DEBUG("Entering renew state");
-                /* fall right through */
-            case RENEWING:
-                /* Either set a new T1, or enter REBINDING state */
-                if ((t2 - t1) <= (lease / 14400 + 1)) {
-                    /* timed out, enter rebinding state */
-                    state = REBINDING;
-                    timeout = now + (t2 - t1);
-                    DEBUG("Entering rebinding state");
-                } else {
-                    /* send a request packet */
-                    send_renew(xid, server_addr, requested_ip); /* unicast */
-                    t1 = (t2 - t1) / 2 + t1;
-                    timeout = start + t1;
-                }
-                break;
-            case REBINDING:
-                /* Either set a new T2, or enter INIT state */
-                if ((lease - t2) <= (lease / 14400 + 1)) {
-                    /* timed out, enter init state */
-                    state = INIT_SELECTING;
-                    bb_info_msg("Lease lost, entering init state");
-                    udhcp_run_script(NULL, "deconfig");
-                    timeout = now;
-                    packet_num = 0;
-                    change_mode(LISTEN_RAW);
-                } else {
-                    /* send a request packet */
-                    send_renew(xid, 0, requested_ip); /* broadcast */
-                    t2 = (lease - t2) / 2 + t2;
-                    timeout = start + t2;
-                }
-                break;
-            case RELEASED:
-                /* yah, I know, *you* say it would never happen */
-                timeout = INT_MAX;
-                break;
-            }
-        } else if (listen_mode != LISTEN_NONE && FD_ISSET(sockfd, &rfds)) {
-            /* a packet is ready, read it */
-
-            if (listen_mode == LISTEN_KERNEL)
-                len = udhcp_get_packet(&packet, sockfd);
-            else len = get_raw_packet(&packet, sockfd);
-
-            if (len == -1 && errno != EINTR) {
-                DEBUG("error on read, %s, reopening socket", strerror(errno));
-                change_mode(listen_mode); /* just close and reopen */
-            }
-            if (len < 0) continue;
-
-            if (packet.xid != xid) {
-                DEBUG("Ignoring XID %x (our xid is %x)",
-                    (unsigned)packet.xid, (unsigned)xid);
-                continue;
-            }
-
-            /* Ignore packets that aren't for us */
-            if (memcmp(packet.chaddr, client_config.arp, 6)) {
-                DEBUG("Packet does not have our chaddr - ignoring");
-                continue;
-            }
-
-            message = get_option(&packet, DHCP_MESSAGE_TYPE);
-            if (message == NULL) {
-                bb_error_msg("cannot get option from packet - ignoring");
-                continue;
-            }
-
-            switch (state) {
-            case INIT_SELECTING:
-                /* Must be a DHCPOFFER to one of our xid's */
-                if (*message == DHCPOFFER) {
-                    temp = get_option(&packet, DHCP_SERVER_ID);
-                    if (temp) {
-                        /* can be misaligned, thus memcpy */
-                        memcpy(&server_addr, temp, 4);
-                        xid = packet.xid;
-                        requested_ip = packet.yiaddr;
-
-                        /* enter requesting state */
-                        state = REQUESTING;
-                        timeout = now;
+#if ENABLE_FEATURE_UDHCPC_ARPING
+                if (opt & OPT_a) {
+/* RFC 2131 3.1 paragraph 5:
+ * "The client receives the DHCPACK message with configuration
+ * parameters. The client SHOULD perform a final check on the
+ * parameters (e.g., ARP for allocated network address), and notes
+ * the duration of the lease specified in the DHCPACK message. At this
+ * point, the client is configured. If the client detects that the
+ * address is already in use (e.g., through the use of ARP),
+ * the client MUST send a DHCPDECLINE message to the server and restarts
+ * the configuration process..." */
+                    if (!arpping(packet.yiaddr,
+                            NULL,
+                            (uint32_t) 0,
+                            client_config.client_mac,
+                            client_config.interface)
+                    ) {
+                        bb_info_msg("Offered address is in use "
+                            "(got ARP reply), declining");
+                        send_decline(xid, server_addr, packet.yiaddr);
+
+                        if (state != REQUESTING)
+                            udhcp_run_script(NULL, "deconfig");
+                        change_listen_mode(LISTEN_RAW);
+                        state = INIT_SELECTING;
+                        requested_ip = 0;
+                        timeout = tryagain_timeout;
                         packet_num = 0;
-                    } else {
-                        bb_error_msg("no server ID in message");
+                        already_waited_sec = 0;
+                        continue; /* back to main loop */
                     }
                 }
-                break;
-            case RENEW_REQUESTED:
-            case REQUESTING:
-            case RENEWING:
-            case REBINDING:
-                if (*message == DHCPACK) {
-                    temp = get_option(&packet, DHCP_LEASE_TIME);
-                    if (!temp) {
-                        bb_error_msg("no lease time with ACK, using 1 hour lease");
-                        lease = 60 * 60;
-                    } else {
-                        /* can be misaligned, thus memcpy */
-                        memcpy(&lease, temp, 4);
-                        lease = ntohl(lease);
-                    }
-
-                    /* enter bound state */
-                    t1 = lease / 2;
-
-                    /* little fixed point for n * .875 */
-                    t2 = (lease * 7) >> 3;
+#endif
+                /* 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);
-                    start = now;
-                    timeout = start + t1;
-                    requested_ip = packet.yiaddr;
-                    udhcp_run_script(&packet,
-                           ((state == RENEWING || state == REBINDING) ? "renew" : "bound"));
-
-                    state = BOUND;
-                    change_mode(LISTEN_NONE);
-                    if (client_config.quit_after_lease) {
-                        if (client_config.release_on_quit)
-                            perform_release();
-                        goto ret0;
-                    }
-                    if (!client_config.foreground)
-                        client_background();
-
-                } else if (*message == DHCPNAK) {
-                    /* return to init state */
-                    bb_info_msg("Received DHCP NAK");
-                    udhcp_run_script(&packet, "nak");
-                    if (state != REQUESTING)
-                        udhcp_run_script(NULL, "deconfig");
-                    state = INIT_SELECTING;
-                    timeout = now;
-                    requested_ip = 0;
-                    packet_num = 0;
-                    change_mode(LISTEN_RAW);
-                    sleep(3); /* avoid excessive network traffic */
+                        inet_ntoa(temp_addr), (unsigned)lease_seconds);
                 }
-                break;
-            /* case BOUND, RELEASED: - ignore all packets */
+                requested_ip = packet.yiaddr;
+                udhcp_run_script(&packet, state == REQUESTING ? "bound" : "renew");
+
+                state = BOUND;
+                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;
+                }
+                /* future renew failures should not exit (JM) */
+                opt &= ~OPT_n;
+#if BB_MMU /* NOMMU case backgrounded earlier */
+                if (!(opt & OPT_f)) {
+                    client_background();
+                    /* do not background again! */
+                    opt = ((opt & ~OPT_b) | OPT_f);
+                }
+#endif
+                already_waited_sec = 0;
+                continue; /* back to main loop */
             }
-        } else {
-            int signo = udhcp_sp_read(&rfds);
-            switch (signo) {
-            case SIGUSR1:
-                perform_renew();
-                break;
-            case SIGUSR2:
-                perform_release();
-                break;
-            case SIGTERM:
-                bb_info_msg("Received SIGTERM");
-                if (client_config.release_on_quit)
-                    perform_release();
-                goto ret0;
+            if (*message == DHCPNAK) {
+                /* return to init state */
+                bb_info_msg("Received DHCP NAK");
+                udhcp_run_script(&packet, "nak");
+                if (state != REQUESTING)
+                    udhcp_run_script(NULL, "deconfig");
+                change_listen_mode(LISTEN_RAW);
+                sleep(3); /* avoid excessive network traffic */
+                state = INIT_SELECTING;
+                requested_ip = 0;
+                timeout = 0;
+                packet_num = 0;
+                already_waited_sec = 0;
             }
+            continue;
+        /* case BOUND: - ignore all packets */
+        /* case RELEASED: - ignore all packets */
         }
-    } /* for (;;) */
+        /* back to main loop */
+    } /* for (;;) - main loop ends */
+
  ret0:
     retval = 0;
  ret:
-    /*if (client_config.pidfile) - remove_pidfile has it's own check */
+    /*if (client_config.pidfile) - remove_pidfile has its own check */
         remove_pidfile(client_config.pidfile);
     return retval;