/* 
 * dhcpcd - DHCP client daemon
 * Copyright (c) 2006-2010 Roy Marples <roy@marples.name>
 * All rights reserved

 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "common.h"
#include "dhcp.h"

#define REQUEST (1 << 0)
#define UINT8   (1 << 1)
#define UINT16  (1 << 2)
#define SINT16  (1 << 3)
#define UINT32  (1 << 4)
#define SINT32  (1 << 5)
#define IPV4    (1 << 6)
#define STRING  (1 << 7)
#define PAIR    (1 << 8)
#define ARRAY   (1 << 9)
#define RFC3361 (1 << 10)
#define RFC3397 (1 << 11)
#define RFC3442 (1 << 12)

#define IPV4R   IPV4 | REQUEST

#define DAD     "Duplicate address detected"

/* Our aggregate option buffer.
 * We ONLY use this when options are split, which for most purposes is
 * practically never. See RFC3396 for details. */
static uint8_t *opt_buffer;

struct dhcp_opt {
        uint8_t option;
        int type;
        const char *var;
};

static const struct dhcp_opt dhcp_opts[] = {
        { 1,    IPV4 | REQUEST, "subnet_mask" },
                /* RFC 3442 states that the CSR has to come before all other
                 * routes. For completeness, we also specify static routes,
                 * then routers. */
        { 121,  RFC3442,        "classless_static_routes" },
        { 249,  RFC3442,        "ms_classless_static_routes" },
        { 33,   IPV4 | ARRAY | REQUEST, "static_routes" },
        { 3,    IPV4 | ARRAY | REQUEST, "routers" },
        { 2,    UINT32,         "time_offset" },
        { 4,    IPV4 | ARRAY,   "time_servers" },
        { 5,    IPV4 | ARRAY,   "ien116_name_servers" },
        { 6,    IPV4 | ARRAY,   "domain_name_servers" },
        { 7,    IPV4 | ARRAY,   "log_servers" },
        { 8,    IPV4 | ARRAY,   "cookie_servers" },
        { 9,    IPV4 | ARRAY,   "lpr_servers" },
        { 10,   IPV4 | ARRAY,   "impress_servers" },
        { 11,   IPV4 | ARRAY,   "resource_location_servers" },
        { 12,   STRING,         "host_name" },
        { 13,   UINT16,         "boot_size" },
        { 14,   STRING,         "merit_dump" },
        { 15,   STRING,         "domain_name" },
        { 16,   IPV4,           "swap_server" },
        { 17,   STRING,         "root_path" },
        { 18,   STRING,         "extensions_path" },
        { 19,   UINT8,          "ip_forwarding" },
        { 20,   UINT8,          "non_local_source_routing" },
        { 21,   IPV4 | ARRAY,   "policy_filter" },
        { 22,   SINT16,         "max_dgram_reassembly" },
        { 23,   UINT16,         "default_ip_ttl" },
        { 24,   UINT32,         "path_mtu_aging_timeout" },
        { 25,   UINT16 | ARRAY, "path_mtu_plateau_table" },
        { 26,   UINT16,         "interface_mtu" },
        { 27,   UINT8,          "all_subnets_local" },
        { 28,   IPV4 | REQUEST, "broadcast_address" },
        { 29,   UINT8,          "perform_mask_discovery" },
        { 30,   UINT8,          "mask_supplier" },
        { 31,   UINT8,          "router_discovery" },
        { 32,   IPV4,           "router_solicitation_address" },
        { 34,   UINT8,          "trailer_encapsulation" },
        { 35,   UINT32,         "arp_cache_timeout" },
        { 36,   UINT16,         "ieee802_3_encapsulation" },
        { 37,   UINT8,          "default_tcp_ttl" },
        { 38,   UINT32,         "tcp_keepalive_interval" },
        { 39,   UINT8,          "tcp_keepalive_garbage" },
        { 40,   STRING,         "nis_domain" },
        { 41,   IPV4 | ARRAY,   "nis_servers" },
        { 42,   IPV4 | ARRAY,   "ntp_servers" },
        { 43,   STRING,         "vendor_encapsulated_options" },
        { 44,   IPV4 | ARRAY,   "netbios_name_servers" },
        { 45,   IPV4,           "netbios_dd_server" },
        { 46,   UINT8,          "netbios_node_type" },
        { 47,   STRING,         "netbios_scope" },
        { 48,   IPV4 | ARRAY,   "font_servers" },
        { 49,   IPV4 | ARRAY,   "x_display_manager" },
        { 50,   IPV4,           "dhcp_requested_address" },
        { 51,   UINT32 | REQUEST,       "dhcp_lease_time" },
        { 52,   UINT8,          "dhcp_option_overload" },
        { 53,   UINT8,          "dhcp_message_type" },
        { 54,   IPV4,           "dhcp_server_identifier" },
        { 55,   UINT8 | ARRAY,  "dhcp_parameter_request_list" },
        { 56,   STRING,         "dhcp_message" },
        { 57,   UINT16,         "dhcp_max_message_size" },
        { 58,   UINT32 | REQUEST,       "dhcp_renewal_time" },
        { 59,   UINT32 | REQUEST,       "dhcp_rebinding_time" },
        { 64,   STRING,         "nisplus_domain" },
        { 65,   IPV4 | ARRAY,   "nisplus_servers" },
        { 66,   STRING,         "tftp_server_name" },
        { 67,   STRING,         "bootfile_name" },
        { 68,   IPV4 | ARRAY,   "mobile_ip_home_agent" },
        { 69,   IPV4 | ARRAY,   "smtp_server" },
        { 70,   IPV4 | ARRAY,   "pop_server" },
        { 71,   IPV4 | ARRAY,   "nntp_server" },
        { 72,   IPV4 | ARRAY,   "www_server" },
        { 73,   IPV4 | ARRAY,   "finger_server" },
        { 74,   IPV4 | ARRAY,   "irc_server" },
        { 75,   IPV4 | ARRAY,   "streettalk_server" },
        { 76,   IPV4 | ARRAY,   "streettalk_directory_assistance_server" },
        { 77,   STRING,         "user_class" },
        { 81,   STRING | RFC3397,       "fqdn_name" },
        { 85,   IPV4 | ARRAY,   "nds_servers" },
        { 86,   STRING,         "nds_tree_name" },
        { 87,   STRING,         "nds_context" },
        { 88,   STRING | RFC3397,       "bcms_controller_names" },
        { 89,   IPV4 | ARRAY,   "bcms_controller_address" },
        { 91,   UINT32,         "client_last_transaction_time" },
        { 92,   IPV4 | ARRAY,   "associated_ip" },
        { 98,   STRING,         "uap_servers" },
        { 112,  IPV4 | ARRAY,   "netinfo_server_address" },
        { 113,  STRING,         "netinfo_server_tag" },
        { 114,  STRING,         "default_url" },
        { 118,  IPV4,           "subnet_selection" },
        { 119,  STRING | RFC3397,       "domain_search" },
        { 0, 0, NULL }
};

static int
valid_length(uint8_t option, int dl, int *type)
{
        const struct dhcp_opt *opt;
        ssize_t sz;

        if (dl == 0)
                return -1;

        for (opt = dhcp_opts; opt->option; opt++) {
                if (opt->option != option)
                        continue;

                if (type)
                        *type = opt->type;

                if (opt->type == 0 ||
                    opt->type & STRING ||
                    opt->type & RFC3442)
                        return 0;

                sz = 0;
                if (opt->type & UINT32 || opt->type & IPV4)
                        sz = sizeof(uint32_t);
                if (opt->type & UINT16)
                        sz = sizeof(uint16_t);
                if (opt->type & UINT8)
                        sz = sizeof(uint8_t);
                if (opt->type & IPV4 || opt->type & ARRAY)
                        return dl % sz;
                return (dl == sz ? 0 : -1);
        }

        /* unknown option, so let it pass */
        return 0;
}

#ifdef DEBUG_MEMORY
static void
free_option_buffer(void)
{
        free(opt_buffer);
}
#endif

#define get_option_raw(dhcp, opt) get_option(dhcp, opt, NULL, NULL)
static const uint8_t *
get_option(const struct dhcp_message *dhcp, uint8_t opt, int *len, int *type)
{
        const uint8_t *p = dhcp->options;
        const uint8_t *e = p + sizeof(dhcp->options);
        uint8_t l, ol = 0;
        uint8_t o = 0;
        uint8_t overl = 0;
        uint8_t *bp = NULL;
        const uint8_t *op = NULL;
        int bl = 0;

        while (p < e) {
                o = *p++;
                if (o == opt) {
                        if (op) {
                                if (!opt_buffer) {
                                        opt_buffer = xmalloc(sizeof(*dhcp));
#ifdef DEBUG_MEMORY
                                        atexit(free_option_buffer);
#endif
                                }
                                if (!bp) 
                                        bp = opt_buffer;
                                memcpy(bp, op, ol);
                                bp += ol;
                        }
                        ol = *p;
                        op = p + 1;
                        bl += ol;
                }
                switch (o) {
                case DHO_PAD:
                        continue;
                case DHO_END:
                        if (overl & 1) {
                                /* bit 1 set means parse boot file */
                                overl &= ~1;
                                p = dhcp->bootfile;
                                e = p + sizeof(dhcp->bootfile);
                        } else if (overl & 2) {
                                /* bit 2 set means parse server name */
                                overl &= ~2;
                                p = dhcp->servername;
                                e = p + sizeof(dhcp->servername);
                        } else
                                goto exit;
                        break;
                case DHO_OPTIONSOVERLOADED:
                        /* Ensure we only get this option once */
                        if (!overl)
                                overl = p[1];
                        break;
                }
                l = *p++;
                p += l;
        }

exit:
        if (valid_length(opt, bl, type) == -1) {
                errno = EINVAL;
                return NULL;
        }
        if (len)
                *len = bl;
        if (bp) {
                memcpy(bp, op, ol);
                return (const uint8_t *)opt_buffer;
        }
        if (op)
                return op;
        errno = ENOENT;
        return NULL;
}

int
get_option_addr(struct in_addr *a, const struct dhcp_message *dhcp,
    uint8_t option)
{
        const uint8_t *p = get_option_raw(dhcp, option);

        if (!p)
                return -1;
        memcpy(&a->s_addr, p, sizeof(a->s_addr));
        return 0;
}

int
get_option_uint32(uint32_t *i, const struct dhcp_message *dhcp, uint8_t option)
{
        const uint8_t *p = get_option_raw(dhcp, option);
        uint32_t d;

        if (!p)
                return -1;
        memcpy(&d, p, sizeof(d));
        *i = ntohl(d);
        return 0;
}

int
get_option_uint16(uint16_t *i, const struct dhcp_message *dhcp, uint8_t option)
{
        const uint8_t *p = get_option_raw(dhcp, option);
        uint16_t d;

        if (!p)
                return -1;
        memcpy(&d, p, sizeof(d));
        *i = ntohs(d);
        return 0;
}

int
get_option_uint8(uint8_t *i, const struct dhcp_message *dhcp, uint8_t option)
{
        const uint8_t *p = get_option_raw(dhcp, option);

        if (!p)
                return -1;
        if (i)
                *i = *(p);
        return 0;
}

static struct rt *
decode_rfc3442_rt(int dl, const uint8_t *data)
{
        const uint8_t *p = data;
        const uint8_t *e;
        uint8_t cidr;
        size_t ocets;
        struct rt *routes = NULL;
        struct rt *rt = NULL;

        /* Minimum is 5 -first is CIDR and a router length of 4 */
        if (dl < 5)
                return NULL;

        e = p + dl;
        while (p < e) {
                cidr = *p++;
                if (cidr > 32) {
                        free_routes(routes);
                        errno = EINVAL;
                        return NULL;
                }

                if (rt) {
                        rt->next = xzalloc(sizeof(*rt));
                        rt = rt->next;
                } else {
                        routes = rt = xzalloc(sizeof(*routes));
                }
                rt->next = NULL;

                ocets = (cidr + 7) / 8;
                /* If we have ocets then we have a destination and netmask */
                if (ocets > 0) {
                        memcpy(&rt->dest.s_addr, p, ocets);
                        p += ocets;
                        rt->net.s_addr = htonl(~0U << (32 - cidr));
                }

                /* Finally, snag the router */
                memcpy(&rt->gate.s_addr, p, 4);
                p += 4;
        }
        return routes;
}


/* This calculates the netmask that we should use for static routes.
 * This IS different from the calculation used to calculate the netmask
 * for an interface address. */
static uint32_t
route_netmask(uint32_t ip_in)
{
        /* used to be unsigned long - check if error */
        uint32_t p = ntohl(ip_in);
        uint32_t t;

        if (IN_CLASSA(p))
                t = ~IN_CLASSA_NET;
        else {
                if (IN_CLASSB(p))
                        t = ~IN_CLASSB_NET;
                else {
                        if (IN_CLASSC(p))
                                t = ~IN_CLASSC_NET;
                        else
                                t = 0;
                }
        }

        while (t & p)
                t >>= 1;

        return (htonl(~t));
}

/* We need to obey routing options.
 * If we have a CSR then we only use that.
 * Otherwise we add static routes and then routers. */
struct rt *
get_option_routes(const struct dhcp_message *dhcp,
    const char *ifname, int *opts)
{
        const uint8_t *p;
        const uint8_t *e;
        struct rt *routes = NULL;
        struct rt *route = NULL;
        int len;

        /* If we have CSR's then we MUST use these only */
        p = get_option(dhcp, DHO_CSR, &len, NULL);
        /* Check for crappy MS option */
        if (!p)
                p = get_option(dhcp, DHO_MSCSR, &len, NULL);
        if (p) {
                routes = decode_rfc3442_rt(len, p);
                if (routes && !(*opts & DHCPCD_CSR_WARNED)) {
                        *opts |= DHCPCD_CSR_WARNED;
                        return routes;
                }
        }

        /* OK, get our static routes first. */
        p = get_option(dhcp, DHO_STATICROUTE, &len, NULL);
        if (p) {
                e = p + len;
                while (p < e) {
                        if (route) {
                                route->next = xmalloc(sizeof(*route));
                                route = route->next;
                        } else
                                routes = route = xmalloc(sizeof(*routes));
                        route->next = NULL;
                        memcpy(&route->dest.s_addr, p, 4);
                        p += 4;
                        memcpy(&route->gate.s_addr, p, 4);
                        p += 4;
                        route->net.s_addr = route_netmask(route->dest.s_addr);
                }
        }

        /* Now grab our routers */
        p = get_option(dhcp, DHO_ROUTER, &len, NULL);
        if (p) {
                e = p + len;
                while (p < e) {
                        if (route) {
                                route->next = xzalloc(sizeof(*route));
                                route = route->next;
                        } else
                                routes = route = xzalloc(sizeof(*route));
                        memcpy(&route->gate.s_addr, p, 4);
                        p += 4;
                }
        }

        return routes;
}

static size_t
encode_rfc1035(const char *src, uint8_t *dst)
{
        uint8_t *p = dst;
        uint8_t *lp = p++;

        if (*src == '\0')
                return 0;
        for (; *src; src++) {
                if (*src == '\0')
                        break;
                if (*src == '.') {
                        /* Skip the trailing . */
                        if (src[1] == '\0')
                                break;
                        *lp = p - lp - 1;
                        if (*lp == '\0')
                                return p - dst;
                        lp = p++;
                } else
                        *p++ = (uint8_t)*src;
        }
        *lp = p - lp - 1;
        *p++ = '\0';
        return p - dst;
}

#define PUTADDR(_type, _val)                                                  \
        {                                                                     \
                *p++ = _type;                                                 \
                *p++ = 4;                                                     \
                memcpy(p, &_val.s_addr, 4);                                   \
                p += 4;                                                       \
        }

int
dhcp_message_add_addr(struct dhcp_message *dhcp,
    uint8_t type, struct in_addr addr)
{
        uint8_t *p;
        size_t len;

        p = dhcp->options;
        while (*p != DHO_END) {
                p++;
                p += *p + 1;
        }

        len = p - (uint8_t *)dhcp;
        if (len + 6 > sizeof(*dhcp)) {
                errno = ENOMEM;
                return -1;
        }

        PUTADDR(type, addr);
        *p = DHO_END;
        return 0;
}

ssize_t
make_message(struct dhcp_message **message,
    const struct interface *iface,
    uint8_t type)
{
        struct dhcp_message *dhcp;
        uint8_t *m, *lp, *p;
        uint8_t *n_params = NULL;
        time_t up = uptime() - iface->start_uptime;
        uint32_t ul;
        uint16_t sz;
        size_t len;
        const char *hp;
        const struct dhcp_opt *opt;
        const struct if_options *ifo = iface->state->options;
        const struct dhcp_lease *lease = &iface->state->lease;

        dhcp = xzalloc(sizeof (*dhcp));
        m = (uint8_t *)dhcp;
        p = dhcp->options;

        if ((type == DHCP_INFORM || type == DHCP_RELEASE ||
                (type == DHCP_REQUEST &&
                    iface->net.s_addr == lease->net.s_addr &&
                    (iface->state->new == NULL ||
                        iface->state->new->cookie == htonl(MAGIC_COOKIE)))))
        {
                dhcp->ciaddr = iface->addr.s_addr;
                /* In-case we haven't actually configured the address yet */
                if (type == DHCP_INFORM && iface->addr.s_addr == 0)
                        dhcp->ciaddr = lease->addr.s_addr;
        }

        dhcp->op = DHCP_BOOTREQUEST;
        dhcp->hwtype = iface->family;
        switch (iface->family) {
        case ARPHRD_ETHER:
        case ARPHRD_IEEE802:
                dhcp->hwlen = iface->hwlen;
                memcpy(&dhcp->chaddr, &iface->hwaddr, iface->hwlen);
                break;
        }

        if (ifo->options & DHCPCD_BROADCAST &&
            dhcp->ciaddr == 0 &&
            type != DHCP_DECLINE &&
            type != DHCP_RELEASE)
                dhcp->flags = htons(BROADCAST_FLAG);

        if (type != DHCP_DECLINE && type != DHCP_RELEASE) {
                if (up < 0 || up > (time_t)UINT16_MAX)
                        dhcp->secs = htons((uint16_t)UINT16_MAX);
                else
                        dhcp->secs = htons(up);
        }
        dhcp->xid = iface->state->xid;
        dhcp->cookie = htonl(MAGIC_COOKIE);

        *p++ = DHO_MESSAGETYPE; 
        *p++ = 1;
        *p++ = type;

        if (iface->clientid) {
                *p++ = DHO_CLIENTID;
                memcpy(p, iface->clientid, iface->clientid[0] + 1);
                p += iface->clientid[0] + 1;
        }

        if (lease->addr.s_addr && lease->cookie == htonl(MAGIC_COOKIE)) {
                if (type == DHCP_DECLINE ||
                    (type == DHCP_REQUEST &&
                        lease->addr.s_addr != iface->addr.s_addr))
                {
                        PUTADDR(DHO_IPADDRESS, lease->addr);
                        if (lease->server.s_addr)
                                PUTADDR(DHO_SERVERID, lease->server);
                }

                if (type == DHCP_RELEASE) {
                        if (lease->server.s_addr)
                                PUTADDR(DHO_SERVERID, lease->server);
                }
        }

        if (type == DHCP_DECLINE) {
                *p++ = DHO_MESSAGE;
                len = strlen(DAD);
                *p++ = len;
                memcpy(p, DAD, len);
                p += len;
        }

        if (type == DHCP_DISCOVER && ifo->options & DHCPCD_REQUEST)
                PUTADDR(DHO_IPADDRESS, ifo->req_addr);

        if (type == DHCP_DISCOVER ||
            type == DHCP_INFORM ||
            type == DHCP_REQUEST)
        {
                *p++ = DHO_MAXMESSAGESIZE;
                *p++ = 2;
                sz = get_mtu(iface->name);
                if (sz < MTU_MIN) {
                        if (set_mtu(iface->name, MTU_MIN) == 0)
                                sz = MTU_MIN;
                } else if (sz > MTU_MAX) {
                        /* Even though our MTU could be greater than
                         * MTU_MAX (1500) dhcpcd does not presently
                         * handle DHCP packets any bigger. */
                        sz = MTU_MAX;
                }
                sz = htons(sz);
                memcpy(p, &sz, 2);
                p += 2;

                if (ifo->userclass[0]) {
                        *p++ = DHO_USERCLASS;
                        memcpy(p, ifo->userclass, ifo->userclass[0] + 1);
                        p += ifo->userclass[0] + 1;
                }

                if (ifo->vendorclassid[0]) {
                        *p++ = DHO_VENDORCLASSID;
                        memcpy(p, ifo->vendorclassid,
                            ifo->vendorclassid[0] + 1);
                        p += ifo->vendorclassid[0] + 1;
                }


                if (type != DHCP_INFORM) {
                        if (ifo->leasetime != 0) {
                                *p++ = DHO_LEASETIME;
                                *p++ = 4;
                                ul = htonl(ifo->leasetime);
                                memcpy(p, &ul, 4);
                                p += 4;
                        }
                }

                /* Regardless of RFC2132, we should always send a hostname
                 * upto the first dot (the short hostname) as otherwise
                 * confuses some DHCP servers when updating DNS.
                 * The FQDN option should be used if a FQDN is required. */
                if (ifo->options & DHCPCD_HOSTNAME && ifo->hostname[0]) {
                        *p++ = DHO_HOSTNAME;
                        hp = strchr(ifo->hostname, '.');
                        if (hp)
                                len = hp - ifo->hostname;
                        else
                                len = strlen(ifo->hostname);
                        *p++ = len;
                        memcpy(p, ifo->hostname, len);
                        p += len;
                }
                if (ifo->fqdn != FQDN_DISABLE && ifo->hostname[0]) {
                        /* IETF DHC-FQDN option (81), RFC4702 */
                        *p++ = DHO_FQDN;
                        lp = p;
                        *p++ = 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
                         * E: 1 => Name data is DNS format
                         * N: 1 => Client requests Server to not
                         *         update DNS
                         */
                        *p++ = (ifo->fqdn & 0x09) | 0x04;
                        *p++ = 0; /* from server for PTR RR */
                        *p++ = 0; /* from server for A RR if S=1 */
                        ul = encode_rfc1035(ifo->hostname, p);
                        *lp += ul;
                        p += ul;
                }

                /* vendor is already encoded correctly, so just add it */
                if (ifo->vendor[0]) {
                        *p++ = DHO_VENDOR;
                        memcpy(p, ifo->vendor, ifo->vendor[0] + 1);
                        p += ifo->vendor[0] + 1;
                }

                *p++ = DHO_PARAMETERREQUESTLIST;
                n_params = p;
                *p++ = 0;
                for (opt = dhcp_opts; opt->option; opt++) {
                        if (!(opt->type & REQUEST || 
                                has_option_mask(ifo->requestmask, opt->option)))
                                continue;
                        if (type == DHCP_INFORM &&
                            (opt->option == DHO_RENEWALTIME ||
                                opt->option == DHO_REBINDTIME))
                                continue;
                        *p++ = opt->option;
                }
                *n_params = p - n_params - 1;
        }
        *p++ = DHO_END;

#ifdef BOOTP_MESSAGE_LENGTH_MIN
        /* Some crappy DHCP servers think they have to obey the BOOTP minimum
         * message length.
         * They are wrong, but we should still cater for them. */
        while (p - m < BOOTP_MESSAGE_LENGTH_MIN)
                *p++ = DHO_PAD;
#endif

        *message = dhcp;
        return p - m;
}

void
get_lease(struct dhcp_lease *lease, const struct dhcp_message *dhcp)
{
        struct timeval now;

        lease->cookie = dhcp->cookie;
        /* BOOTP does not set yiaddr for replies when ciaddr is set. */
        if (dhcp->yiaddr)
                lease->addr.s_addr = dhcp->yiaddr;
        else
                lease->addr.s_addr = dhcp->ciaddr;
        if (get_option_addr(&lease->net, dhcp, DHO_SUBNETMASK) == -1)
                lease->net.s_addr = get_netmask(lease->addr.s_addr);
        if (get_option_addr(&lease->brd, dhcp, DHO_BROADCAST) == -1)
                lease->brd.s_addr = lease->addr.s_addr | ~lease->net.s_addr;
        if (get_option_uint32(&lease->leasetime, dhcp, DHO_LEASETIME) == 0) {
                /* Ensure that we can use the lease */
                get_monotonic(&now);
                if (now.tv_sec + (time_t)lease->leasetime < now.tv_sec)
                        lease->leasetime = ~0U; /* Infinite lease */
        } else
                lease->leasetime = ~0U; /* Default to infinite lease */
        if (get_option_uint32(&lease->renewaltime, dhcp, DHO_RENEWALTIME) != 0)
                lease->renewaltime = 0;
        if (get_option_uint32(&lease->rebindtime, dhcp, DHO_REBINDTIME) != 0)
                lease->rebindtime = 0;
        if (get_option_addr(&lease->server, dhcp, DHO_SERVERID) != 0)
                lease->server.s_addr = INADDR_ANY;
}