/* dnsmasq is Copyright (c) 2000-2026 Simon Kelley

   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; version 2 dated June, 1991, or

   (at your option) version 3 dated 29 June, 2007.

   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, see <http://www.gnu.org/licenses/>.

*/

#include "dnsmasq.h"

#ifdef HAVE_DHCP

#define option_len(opt) ((int)(((unsigned char *)(opt))[1]))

#define option_ptr(opt, i) ((void *)&(((unsigned char *)(opt))[2u+(unsigned int)(i)]))

#ifdef HAVE_SCRIPT

static void add_extradata_opt(struct dhcp_lease *lease, unsigned char *opt);

#endif

static int sanitise(unsigned char *opt, char *buf);

static struct in_addr server_id(struct dhcp_context *context, struct in_addr override, struct in_addr fallback);

static unsigned int calc_time(struct dhcp_context *context, struct dhcp_config *config, unsigned char *opt);

static void option_put(struct dhcp_packet *mess, unsigned char *end, int opt, int len, unsigned int val);

static void option_put_string(struct dhcp_packet *mess, unsigned char *end, 

            int opt, const char *string, int null_term);

static struct in_addr option_addr(unsigned char *opt);

static unsigned int option_uint(unsigned char *opt, int offset, int size);

static void log_packet(char *type, void *addr, unsigned char *ext_mac, 

           int mac_len, char *interface, char *string, char *err, u32 xid);

static unsigned char *option_find(struct dhcp_packet *mess, size_t size, int opt_type, int minsize);

static unsigned char *option_find1(unsigned char *p, unsigned char *end, int opt, int minsize);

static size_t dhcp_packet_size(struct dhcp_packet *mess, unsigned char *agent_id, unsigned char *real_end);

static void clear_packet(struct dhcp_packet *mess, unsigned char *end);

static int in_list(unsigned char *list, int opt);

static unsigned char *free_space(struct dhcp_packet *mess, unsigned char *end, int opt, int len);

static void do_options(struct dhcp_context *context,

           struct dhcp_packet *mess,

           unsigned char *end,

           unsigned char *req_options,

           char *hostname, 

           char *domain,

           struct dhcp_netid *netid,

           struct in_addr subnet_addr, 

           unsigned char fqdn_flags,

           int null_term, int pxe_arch,

           unsigned char *uuid,

           int vendor_class_len,

           time_t now,

           unsigned int lease_time,

           unsigned short fuzz,

           const char *pxevendor,

           int leasequery);

static void match_vendor_opts(unsigned char *opt, struct dhcp_opt *dopt); 

static int do_encap_opts(struct dhcp_opt *opt, int encap, int flag, struct dhcp_packet *mess, unsigned char *end, int null_term);

static void pxe_misc(struct dhcp_packet *mess, unsigned char *end, unsigned char *uuid, const char *pxevendor);

static int prune_vendor_opts(struct dhcp_netid *netid);

static struct dhcp_opt *pxe_opts(int pxe_arch, struct dhcp_netid *netid, struct in_addr local, time_t now);

struct dhcp_boot *find_boot(struct dhcp_netid *netid);

static int pxe_uefi_workaround(int pxe_arch, struct dhcp_netid *netid, struct dhcp_packet *mess, struct in_addr local, time_t now, int pxe);

static void apply_delay(u32 xid, time_t recvtime, struct dhcp_netid *netid);

static int is_pxe_client(struct dhcp_packet *mess, size_t sz, const char **pxe_vendor);

static int do_opt(struct dhcp_opt *opt, unsigned char *p, struct dhcp_context *context, int null_term);

static void handle_encap(struct dhcp_packet *mess, unsigned char *end, unsigned char *req_options, int null_term, struct dhcp_netid *tagif, int pxemode);

size_t dhcp_reply(struct dhcp_context *context, char *iface_name, int int_index,

      size_t sz, time_t now, int unicast_dest, int loopback,

      int *is_inform, int pxe, struct in_addr fallback, time_t recvtime, struct in_addr leasequery_source)

{

  unsigned char *opt, *clid = NULL;

  struct dhcp_lease *ltmp, *lease = NULL;

  struct dhcp_vendor *vendor;

  struct dhcp_mac *mac;

  struct dhcp_netid_list *id_list;

  int clid_len = 0, ignore = 0, do_classes = 0, rapid_commit = 0, selecting = 0, pxearch = -1;

  const char *pxevendor = NULL;

  struct dhcp_packet *mess = (struct dhcp_packet *)daemon->dhcp_packet.iov_base;

  unsigned char *end = (unsigned char *)(mess + 1); 

  unsigned char *real_end = (unsigned char *)(mess + 1); 

  char *hostname = NULL, *offer_hostname = NULL, *client_hostname = NULL, *domain = NULL;

  int hostname_auth = 0, borken_opt = 0;

  unsigned char *req_options = NULL;

  char *message = NULL;

  unsigned int time;

  struct dhcp_config *config;

  struct dhcp_netid *netid, *tagif_netid;

  struct in_addr subnet_addr, override;

  unsigned short fuzz = 0;

  unsigned int mess_type = 0;

  unsigned char fqdn_flags = 0;

  unsigned char *agent_id = NULL, *uuid = NULL;

  unsigned char *emac = NULL;

  int vendor_class_len = 0, emac_len = 0;

  struct dhcp_netid known_id, iface_id, cpewan_id;

  struct dhcp_opt *o;

  unsigned char pxe_uuid[17];

  unsigned char *oui = NULL, *serial = NULL;

#ifdef HAVE_SCRIPT

  unsigned char *class = NULL;

#endif

  subnet_addr.s_addr = override.s_addr = 0;

  /* set tag with name == interface */

  iface_id.net = iface_name;

  iface_id.next = NULL;

  netid = &iface_id; 

  if (mess->op != BOOTREQUEST || mess->hlen > DHCP_CHADDR_MAX)

    return 0;

  if (mess->htype == 0 && mess->hlen != 0)

    return 0;

  /* check for DHCP rather than BOOTP */

  if ((opt = option_find(mess, sz, OPTION_MESSAGE_TYPE, 1)))

    {

      u32 cookie = htonl(DHCP_COOKIE);

      /* only insist on a cookie for DHCP. */

      if (memcmp(mess->options, &cookie, sizeof(u32)) != 0)

  return 0;

      mess_type = option_uint(opt, 0, 1);

      /* two things to note here: expand_buf may move the packet,

   so reassign mess from daemon->packet. Also, the size

   sent includes the IP and UDP headers, hence the magic "-28" */

      if ((opt = option_find(mess, sz, OPTION_MAXMESSAGE, 2)))

  {

    size_t size = (size_t)option_uint(opt, 0, 2) - 28;

    if (size > DHCP_PACKET_MAX)

      size = DHCP_PACKET_MAX;

    else if (size < sizeof(struct dhcp_packet))

      size = sizeof(struct dhcp_packet);

    if (expand_buf(&daemon->dhcp_packet, size))

      {

        mess = (struct dhcp_packet *)daemon->dhcp_packet.iov_base;

        real_end = end = ((unsigned char *)mess) + size;

      }

  }

      /* Some buggy clients set ciaddr when they shouldn't, so clear that here since

   it can affect the context-determination code. */

      if ((option_find(mess, sz, OPTION_REQUESTED_IP, INADDRSZ) || mess_type == DHCPDISCOVER))

  mess->ciaddr.s_addr = 0;

      /* search for device identity from CPEWAN devices, we pass this through to the script */

      if ((opt = option_find(mess, sz, OPTION_VENDOR_IDENT_OPT, 5)))

  {

    unsigned  int elen, offset, len = option_len(opt);

    for (offset = 0; offset < (len - 5); offset += elen + 5)

      {

        elen = option_uint(opt, offset + 4 , 1);

        if (option_uint(opt, offset, 4) == BRDBAND_FORUM_IANA && offset + elen + 5 <= len)

    {

      unsigned char *x = option_ptr(opt, offset + 5);

      unsigned char *y = option_ptr(opt, offset + elen + 5);

      oui = option_find1(x, y, 1, 1);

      serial = option_find1(x, y, 2, 1);

#ifdef HAVE_SCRIPT

      class = option_find1(x, y, 3, 1);     

#endif

      /* If TR069-id is present set the tag "cpewan-id" to facilitate echoing 

         the gateway id back. Note that the device class is optional */

      if (oui && serial)

        {

          cpewan_id.net = "cpewan-id";

          cpewan_id.next = netid;

          netid = &cpewan_id;

        }

      break;

    }

      }

  }

      if (mess_type != DHCPLEASEQUERY && (opt = option_find(mess, sz, OPTION_AGENT_ID, 1)))

  {

    /* Any agent-id needs to be copied back out, verbatim, as the last option

       in the packet. Here, we shift it to the very end of the buffer, if it doesn't

       get overwritten, then it will be shuffled back at the end of processing.

       Note that the incoming options must not be overwritten here, so there has to 

       be enough free space at the end of the packet to copy the option. */

    unsigned char *sopt;

    unsigned int total = option_len(opt) + 2;

    unsigned char *last_opt = option_find1(&mess->options[0] + sizeof(u32), ((unsigned char *)mess) + sz,

             OPTION_END, 0);

    if (last_opt && last_opt < end - total)

      {

        end -= total;

        agent_id = end;

        memcpy(agent_id, opt, total);

      }

    /* look for RFC5010 flags sub-option */

    if ((sopt = option_find1(option_ptr(opt, 0), option_ptr(opt, option_len(opt)), SUBOPT_FLAGS, INADDRSZ)))

      unicast_dest = !!(option_uint(opt, 0, 1) & 0x80);

    /* look for RFC3527 Link selection sub-option */

    if ((sopt = option_find1(option_ptr(opt, 0), option_ptr(opt, option_len(opt)), SUBOPT_SUBNET_SELECT, INADDRSZ)))

      subnet_addr = option_addr(sopt);

    /* look for RFC5107 server-identifier-override */

    if ((sopt = option_find1(option_ptr(opt, 0), option_ptr(opt, option_len(opt)), SUBOPT_SERVER_OR, INADDRSZ)))

      override = option_addr(sopt);

    /* if a circuit-id or remote-is option is provided, exact-match to options. */

    for (vendor = daemon->dhcp_vendors; vendor; vendor = vendor->next)

      {

        int search;

        if (vendor->match_type == MATCH_CIRCUIT)

    search = SUBOPT_CIRCUIT_ID;

        else if (vendor->match_type == MATCH_REMOTE)

    search = SUBOPT_REMOTE_ID;

        else if (vendor->match_type == MATCH_SUBSCRIBER)

    search = SUBOPT_SUBSCR_ID;

        else 

    continue;

        if ((sopt = option_find1(option_ptr(opt, 0), option_ptr(opt, option_len(opt)), search, 1)) &&

      vendor->len == option_len(sopt) &&

      memcmp(option_ptr(sopt, 0), vendor->data, vendor->len) == 0)

    {

      vendor->netid.next = netid;

      netid = &vendor->netid;

    } 

      }

  }

      /* Check for RFC3011 subnet selector - only if RFC3527 one not present */

      if (subnet_addr.s_addr == 0 && (opt = option_find(mess, sz, OPTION_SUBNET_SELECT, INADDRSZ)))

  subnet_addr = option_addr(opt);

      /* If there is no client identifier option, use the hardware address */

      if (!option_bool(OPT_IGNORE_CLID) && (opt = option_find(mess, sz, OPTION_CLIENT_ID, 1)))

  {

    clid_len = option_len(opt);

    clid = option_ptr(opt, 0);

  }

      /* do we have a lease in store? */

      lease = lease_find_by_client(mess->chaddr, mess->hlen, mess->htype, clid, clid_len);

      /* If this request is missing a clid, but we've seen one before, 

   use it again for option matching etc. */

      if (lease && !clid && lease->clid)

  {

    clid_len = lease->clid_len;

    clid = lease->clid;

  }

      /* find mac to use for logging and hashing */

      emac = extended_hwaddr(mess->htype, mess->hlen, mess->chaddr, clid_len, clid, &emac_len);

    }

  for (mac = daemon->dhcp_macs; mac; mac = mac->next)

    if (mac->hwaddr_len == mess->hlen &&

  (mac->hwaddr_type == mess->htype || mac->hwaddr_type == 0) &&

  memcmp_masked(mac->hwaddr, mess->chaddr, mess->hlen, mac->mask))

      {

  mac->netid.next = netid;

  netid = &mac->netid;

      }

  /* Determine network for this packet. Our caller will have already linked all the 

     contexts which match the addresses of the receiving interface but if the 

     machine has an address already, or came via a relay, or we have a subnet selector, 

     we search again. If we don't have have a giaddr or explicit subnet selector, 

     use the ciaddr. This is necessary because a  machine which got a lease via a 

     relay won't use the relay to renew. If matching a ciaddr fails but we have a context 

     from the physical network, continue using that to allow correct DHCPNAK generation later. */

  if (mess->giaddr.s_addr || subnet_addr.s_addr || mess->ciaddr.s_addr)

    {

      struct dhcp_context *context_tmp, *context_new = NULL;

      struct shared_network *share = NULL;

      struct in_addr addr;

      int force = 0, via_relay = 0;

      if (subnet_addr.s_addr)

  {

    addr = subnet_addr;

    force = 1;

    if (mess->giaddr.s_addr)

      via_relay = 1;

  }

      else if (mess->giaddr.s_addr)

  {

    addr = mess->giaddr;

    force = 1;

    via_relay = 1;

  }

      else

  {

    /* If ciaddr is in the hardware derived set of contexts, leave that unchanged */

    addr = mess->ciaddr;

    for (context_tmp = context; context_tmp; context_tmp = context_tmp->current)

      if (context_tmp->netmask.s_addr && 

    is_same_net(addr, context_tmp->start, context_tmp->netmask) &&

    is_same_net(addr, context_tmp->end, context_tmp->netmask))

        {

    context_new = context;

    break;

        }

  } 

      if (!context_new)

  {

    for (context_tmp = daemon->dhcp; context_tmp; context_tmp = context_tmp->next)

      {

        struct in_addr netmask = context_tmp->netmask;

        /* guess the netmask for relayed networks */

        if (!(context_tmp->flags & CONTEXT_NETMASK) && context_tmp->netmask.s_addr == 0)

    {

      if (IN_CLASSA(ntohl(context_tmp->start.s_addr)) && IN_CLASSA(ntohl(context_tmp->end.s_addr)))

        netmask.s_addr = htonl(0xff000000);

      else if (IN_CLASSB(ntohl(context_tmp->start.s_addr)) && IN_CLASSB(ntohl(context_tmp->end.s_addr)))

        netmask.s_addr = htonl(0xffff0000);

      else if (IN_CLASSC(ntohl(context_tmp->start.s_addr)) && IN_CLASSC(ntohl(context_tmp->end.s_addr)))

        netmask.s_addr = htonl(0xffffff00); 

    }

        /* check to see is a context is OK because of a shared address on

     the relayed subnet. */

        if (via_relay)

    for (share = daemon->shared_networks; share; share = share->next)

      {

#ifdef HAVE_DHCP6

        if (share->shared_addr.s_addr == 0)

          continue;

#endif

        if (share->if_index != 0 ||

      share->match_addr.s_addr != mess->giaddr.s_addr)

          continue;

        if (netmask.s_addr != 0  && 

      is_same_net(share->shared_addr, context_tmp->start, netmask) &&

      is_same_net(share->shared_addr, context_tmp->end, netmask))

          break;

      }

        /* This section fills in context mainly when a client which is on a remote (relayed)

     network renews a lease without using the relay, after dnsmasq has restarted. */

        if (share ||

      (netmask.s_addr != 0  && 

       is_same_net(addr, context_tmp->start, netmask) &&

       is_same_net(addr, context_tmp->end, netmask)))

    {

      context_tmp->netmask = netmask;

      if (context_tmp->local.s_addr == 0)

        context_tmp->local = fallback;

      if (context_tmp->router.s_addr == 0 && !share)

        {

          if (override.s_addr)

      context_tmp->router = override;

          else

      context_tmp->router = mess->giaddr;

        }

      /* fill in missing broadcast addresses for relayed ranges */

      if (!(context_tmp->flags & CONTEXT_BRDCAST) && context_tmp->broadcast.s_addr == 0 )

        context_tmp->broadcast.s_addr = context_tmp->start.s_addr | ~context_tmp->netmask.s_addr;

      context_tmp->current = context_new;

      context_new = context_tmp;

    }

      }

  }

      if (context_new || force)

  context = context_new; 

    }

  if (mess_type != DHCPLEASEQUERY)

    {

      if  (!context)

  {

    const char *via;

    if (subnet_addr.s_addr)

      {

        via = _("with subnet selector");

        inet_ntop(AF_INET, &subnet_addr, daemon->addrbuff, ADDRSTRLEN);

      }

    else

      {

        via = _("via");

        if (mess->giaddr.s_addr)

    inet_ntop(AF_INET, &mess->giaddr, daemon->addrbuff, ADDRSTRLEN);

        else

    safe_strncpy(daemon->addrbuff, iface_name, ADDRSTRLEN);

      }

    my_syslog(MS_DHCP | LOG_WARNING, _("no address range available for DHCP request %s %s"),

        via, daemon->addrbuff);

    return 0;

  }

      if (option_bool(OPT_LOG_OPTS))

  {

    struct dhcp_context *context_tmp;

    for (context_tmp = context; context_tmp; context_tmp = context_tmp->current)

      {

        inet_ntop(AF_INET, &context_tmp->start, daemon->namebuff, MAXDNAMESTR);

        if (context_tmp->flags & (CONTEXT_STATIC | CONTEXT_PROXY))

    {

      inet_ntop(AF_INET, &context_tmp->netmask, daemon->addrbuff, ADDRSTRLEN);

      my_syslog(MS_DHCP | LOG_INFO, _("%u available DHCP subnet: %s/%s"),

          ntohl(mess->xid), daemon->namebuff, daemon->addrbuff);

    }

        else

    {

      inet_ntop(AF_INET, &context_tmp->end, daemon->addrbuff, ADDRSTRLEN);

      my_syslog(MS_DHCP | LOG_INFO, _("%u available DHCP range: %s -- %s"),

          ntohl(mess->xid), daemon->namebuff, daemon->addrbuff);

    }

      }

  }

    }

  /* dhcp-match. If we have hex-and-wildcards, look for a left-anchored match.

     Otherwise assume the option is an array, and look for a matching element. 

     If no data given, existence of the option is enough. This code handles 

     rfc3925 V-I classes too. */

  for (o = daemon->dhcp_match; o; o = o->next)

    {

      unsigned int len, elen, match = 0;

      size_t offset, o2;

      if (o->flags & DHOPT_RFC3925)

  {

    if (!(opt = option_find(mess, sz, OPTION_VENDOR_IDENT, 5)))

      continue;

    for (offset = 0; offset < (option_len(opt) - 5u); offset += len + 5)

      {

        len = option_uint(opt, offset + 4 , 1);

        /* Need to take care that bad data can't run us off the end of the packet */

        if ((offset + len + 5 <= (unsigned)(option_len(opt))) &&

      (option_uint(opt, offset, 4) == (unsigned int)o->u.encap))

    for (o2 = offset + 5; o2 < offset + len + 5; o2 += elen + 1)

      { 

        elen = option_uint(opt, o2, 1);

        if ((o2 + elen + 1 <= (unsigned)option_len(opt)) &&

      (match = match_bytes(o, option_ptr(opt, o2 + 1), elen)))

          break;

      }

        if (match) 

    break;

      }   

  }

      else

  {

    if (!(opt = option_find(mess, sz, o->opt, 1)))

      continue;

    match = match_bytes(o, option_ptr(opt, 0), option_len(opt));

  } 

      if (match)

  {

    o->netid->next = netid;

    netid = o->netid;

  }

    }

  /* user-class options are, according to RFC3004, supposed to contain

     a set of counted strings. Here we check that this is so (by seeing

     if the counts are consistent with the overall option length) and if

     so zero the counts so that we don't get spurious matches between 

     the vendor string and the counts. If the lengths don't add up, we

     assume that the option is a single string and non RFC3004 compliant 

     and just do the substring match. dhclient provides these broken options.

     The code, later, which sends user-class data to the lease-change script

     relies on the transformation done here.

  */

  if ((opt = option_find(mess, sz, OPTION_USER_CLASS, 1)))

    {

      unsigned char *ucp = option_ptr(opt, 0);

      int tmp, j;

      for (j = 0; j < option_len(opt); j += ucp[j] + 1);

      if (j == option_len(opt))

  for (j = 0; j < option_len(opt); j = tmp)

    {

      tmp = j + ucp[j] + 1;

      ucp[j] = 0;

    }

    }

  for (vendor = daemon->dhcp_vendors; vendor; vendor = vendor->next)

    {

      int mopt;

      if (vendor->match_type == MATCH_VENDOR)

  mopt = OPTION_VENDOR_ID;

      else if (vendor->match_type == MATCH_USER)

  mopt = OPTION_USER_CLASS; 

      else

  continue;

      if ((opt = option_find(mess, sz, mopt, 1)))

  {

    int i;

    for (i = 0; i <= (option_len(opt) - vendor->len); i++)

      if (memcmp(vendor->data, option_ptr(opt, i), vendor->len) == 0)

        {

    vendor->netid.next = netid;

    netid = &vendor->netid;

    break;

        }

  }

    }

  /* mark vendor-encapsulated options which match the client-supplied vendor class,

     save client-supplied vendor class */

  if ((opt = option_find(mess, sz, OPTION_VENDOR_ID, 1)))

    {

      memcpy(daemon->dhcp_buff3, option_ptr(opt, 0), option_len(opt));

      vendor_class_len = option_len(opt);

    }

  match_vendor_opts(opt, daemon->dhcp_opts);

  if (option_bool(OPT_LOG_OPTS))

    {

      if (sanitise(opt, daemon->namebuff))

  my_syslog(MS_DHCP | LOG_INFO, _("%u vendor class: %s"), ntohl(mess->xid), daemon->namebuff);

      if (sanitise(option_find(mess, sz, OPTION_USER_CLASS, 1), daemon->namebuff))

  my_syslog(MS_DHCP | LOG_INFO, _("%u user class: %s"), ntohl(mess->xid), daemon->namebuff);

    }

  mess->op = BOOTREPLY;

  config = find_config(daemon->dhcp_conf, context, clid, clid_len, 

           mess->chaddr, mess->hlen, mess->htype, NULL, run_tag_if(netid));

  /* set "known" tag for known hosts */

  if (config)

    {

      known_id.net = "known";

      known_id.next = netid;

      netid = &known_id;

    }

  else if (find_config(daemon->dhcp_conf, NULL, clid, clid_len, 

           mess->chaddr, mess->hlen, mess->htype, NULL, run_tag_if(netid)))

    {

      known_id.net = "known-othernet";

      known_id.next = netid;

      netid = &known_id;

    }

  if (mess_type == 0 && !pxe)

    {

      /* BOOTP request */

      struct dhcp_netid id, bootp_id;

      struct in_addr *logaddr = NULL;

      /* must have a MAC addr for bootp */

      if (mess->htype == 0 || mess->hlen == 0 || (context->flags & CONTEXT_PROXY))

  return 0;

      if (have_config(config, CONFIG_DISABLE))

  message = _("disabled");

      end = mess->options + 64; /* BOOTP vend area is only 64 bytes */

      if (have_config(config, CONFIG_NAME))

  {

    hostname = config->hostname;

    domain = config->domain;

  }

      if (config)

  {

    struct dhcp_netid_list *list;

    for (list = config->netid; list; list = list->next)

      {

        list->list->next = netid;

        netid = list->list;

      }

  }

      /* Match incoming filename field as a netid. */

      if (mess->file[0])

  {

    memcpy(daemon->dhcp_buff2, mess->file, sizeof(mess->file));

    daemon->dhcp_buff2[sizeof(mess->file)] = 0; /* ensure zero term. */

    id.net = (char *)daemon->dhcp_buff2;

    id.next = netid;

    netid = &id;

  }

      /* Add "bootp" as a tag to allow different options, address ranges etc

   for BOOTP clients */

      bootp_id.net = "bootp";

      bootp_id.next = netid;

      netid = &bootp_id;

      tagif_netid = run_tag_if(netid);

      for (id_list = daemon->dhcp_ignore; id_list; id_list = id_list->next)

  if (match_netid(id_list->list, tagif_netid, 0))

    message = _("ignored");

      if (!message)

  {

    int nailed = 0;

    if (have_config(config, CONFIG_ADDR))

      {

        nailed = 1;

        logaddr = &config->addr;

        mess->yiaddr = config->addr;

        if ((lease = lease_find_by_addr(config->addr)) &&

      (lease->hwaddr_len != mess->hlen ||

       lease->hwaddr_type != mess->htype ||

       memcmp(lease->hwaddr, mess->chaddr, lease->hwaddr_len) != 0))

    message = _("address in use");

      }

    else

      {

        if (!(lease = lease_find_by_client(mess->chaddr, mess->hlen, mess->htype, NULL, 0)) ||

      !address_available(context, lease->addr, tagif_netid))

    {

       if (lease)

         {

           /* lease exists, wrong network. */

           lease_prune(lease, now);

           lease = NULL;

         }

       if (!address_allocate(context, &mess->yiaddr, mess->chaddr, mess->hlen, tagif_netid, now, loopback))

         message = _("no address available");

    }

        else

    mess->yiaddr = lease->addr;

      }

    if (!message && !(context = narrow_context(context, mess->yiaddr, netid)))

      message = _("wrong network");

    else if (context->netid.net)

      {

        context->netid.next = netid;

        tagif_netid = run_tag_if(&context->netid);

      }

    log_tags(tagif_netid, ntohl(mess->xid));

    if (!message && !nailed)

      {

        for (id_list = daemon->bootp_dynamic; id_list; id_list = id_list->next)

    if ((!id_list->list) || match_netid(id_list->list, tagif_netid, 0))

      break;

        if (!id_list)

    message = _("no address configured");

      }

    if (!message && 

        !lease && 

        (!(lease = lease4_allocate(mess->yiaddr))))

      message = _("no leases left");

    if (!message)

      {

        logaddr = &mess->yiaddr;

        lease_set_hwaddr(lease, mess->chaddr, NULL, mess->hlen, mess->htype, 0, now, 1);

        if (hostname)

    lease_set_hostname(lease, hostname, 1, get_domain(lease->addr), domain); 

        /* infinite lease unless nailed in dhcp-host line. */

        lease_set_expires(lease,  

        have_config(config, CONFIG_TIME) ? config->lease_time : 0xffffffff, 

        now); 

        lease_set_interface(lease, int_index, now);

        clear_packet(mess, end);

        do_options(context, mess, end, NULL, hostname, get_domain(mess->yiaddr), 

       netid, subnet_addr, 0, 0, -1, NULL, vendor_class_len, now, 0xffffffff, 0, NULL, 0);

      }

  }

      daemon->metrics[METRIC_BOOTP]++;

      log_packet("BOOTP", logaddr, mess->chaddr, mess->hlen, iface_name, NULL, message, mess->xid);

      return message ? 0 : dhcp_packet_size(mess, agent_id, real_end);

    }

  if ((opt = option_find(mess, sz, OPTION_CLIENT_FQDN, 3)))

    {

      /* http://tools.ietf.org/wg/dhc/draft-ietf-dhc-fqdn-option/draft-ietf-dhc-fqdn-option-10.txt */

      int len = option_len(opt);

      char *pq = daemon->dhcp_buff;

      unsigned char *pp, *op = option_ptr(opt, 0);

      fqdn_flags = *op;

      len -= 3;

      op += 3;

      pp = op;

      /* NB, the following always sets at least one bit */

      if (option_bool(OPT_FQDN_UPDATE))

  {

    if (fqdn_flags & 0x01)

      {

        fqdn_flags |= 0x02; /* set O */

        fqdn_flags &= ~0x01; /* clear S */

      }

    fqdn_flags |= 0x08; /* set N */

  }

      else 

  {

    if (!(fqdn_flags & 0x01))

      fqdn_flags |= 0x03; /* set S and O */

    fqdn_flags &= ~0x08; /* clear N */

  }

      if (fqdn_flags & 0x04)

  while (*op != 0 && ((op + (*op)) - pp) < len)

    {

      memcpy(pq, op+1, *op);

      pq += *op;

      op += (*op)+1;

      *(pq++) = '.';

    }

      else

  {

    memcpy(pq, op, len);

    if (len > 0 && op[len-1] == 0)

      borken_opt = 1;

    pq += len + 1;

  }

      if (pq != daemon->dhcp_buff)

  pq--;

      *pq = 0;

      if (legal_hostname(daemon->dhcp_buff))

  offer_hostname = client_hostname = daemon->dhcp_buff;

    }

  else if ((opt = option_find(mess, sz, OPTION_HOSTNAME, 1)))

    {

      int len = option_len(opt);

      memcpy(daemon->dhcp_buff, option_ptr(opt, 0), len);

      /* Microsoft clients are broken, and need zero-terminated strings

   in options. We detect this state here, and do the same in

   any options we send */

      if (len > 0 && daemon->dhcp_buff[len-1] == 0)

  borken_opt = 1;

      else

  daemon->dhcp_buff[len] = 0;

      if (legal_hostname(daemon->dhcp_buff))

  client_hostname = daemon->dhcp_buff;

    }

  if (client_hostname)

    {

      struct dhcp_match_name *m;

      size_t nl = strlen(client_hostname);

      if (option_bool(OPT_LOG_OPTS))

  my_syslog(MS_DHCP | LOG_INFO, _("%u client provides name: %s"), ntohl(mess->xid), client_hostname);

      for (m = daemon->dhcp_name_match; m; m = m->next)

  {

    size_t ml = strlen(m->name);

    char save = 0;

    if (nl < ml)

      continue;

    if (nl > ml)

      {

        save = client_hostname[ml];

        client_hostname[ml] = 0;

      }

    if (hostname_isequal(client_hostname, m->name) &&

        (save == 0 || m->wildcard))

      {

        m->netid->next = netid;

        netid = m->netid;

      }

    if (save != 0)

      client_hostname[ml] = save;

  }

    }

  if (have_config(config, CONFIG_NAME))

    {

      hostname = config->hostname;

      domain = config->domain;

      hostname_auth = 1;

      /* be careful not to send an OFFER with a hostname not matching the DISCOVER. */

      if (fqdn_flags != 0 || !client_hostname || hostname_isequal(hostname, client_hostname))

        offer_hostname = hostname;

    }

  else if (client_hostname)

    {

      domain = strip_hostname(client_hostname);

      if (strlen(client_hostname) != 0)

  {

    hostname = client_hostname;

    if (!config)

      {

        /* Search again now we have a hostname. 

     Only accept configs without CLID and HWADDR here, (they won't match)

     to avoid impersonation by name. */

        struct dhcp_config *new = find_config(daemon->dhcp_conf, context, NULL, 0,

                mess->chaddr, mess->hlen, 

                mess->htype, hostname, run_tag_if(netid));

        if (new && !have_config(new, CONFIG_CLID) && !new->hwaddr)

    {