/*
 * dhcpcd - DHCP client daemon
 * Copyright 2006-2008 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 <sys/time.h>
#include <sys/types.h>
#include <arpa/inet.h>
#ifdef __linux__
# include <netinet/ether.h>
#endif
#include <ctype.h>
#include <errno.h>
#include <poll.h>
#include <signal.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include "config.h"
#include "common.h"
#ifdef ENABLE_ARP
# include "arp.h"
#endif
#include "client.h"
#include "configure.h"
#include "dhcp.h"
#include "dhcpcd.h"
#include "info.h"
#include "interface.h"
#ifdef ENABLE_IPV4LL
# include "ipv4ll.h"
#endif
#include "logger.h"
#include "signal.h"
#include "socket.h"

#include "logwriter.h"

#ifdef ENABLE_DUID
# include "duid.h"
#endif

#ifdef ENABLE_INFO
# include "info.h"
#endif

#ifdef THERE_IS_NO_FORK
# ifndef ENABLE_INFO
#  error "Non MMU requires ENABLE_INFO to work"
# endif
#endif

/* Some platforms don't define INFTIM */
#ifndef INFTIM
# define INFTIM                 -1
#endif

/* This is out mini timeout.
 * Basically we resend the last request every TIMEOUT_MINI seconds. */
#define TIMEOUT_MINI            3
/* Except for an infinite timeout. We keep adding TIMEOUT_MINI to
 * ourself until TIMEOUT_MINI_INF is reached. */
#define TIMEOUT_MINI_INF        60

#define STATE_INIT              0
#define STATE_REQUESTING        1
#define STATE_BOUND             2
#define STATE_RENEWING          3
#define STATE_REBINDING         4
#define STATE_REBOOT            5
#define STATE_RENEW_REQUESTED   6
#define STATE_RELEASED          7

/* We should define a maximum for the NAK exponential backoff */
#define NAKOFF_MAX              60

#define SOCKET_CLOSED           0
#define SOCKET_OPEN             1

/* Indexes for pollfds */
#define POLLFD_SIGNAL           0
#define POLLFD_IFACE            1

typedef struct _state
{
  int *pidfd;
  bool forked;
  int state;
  uint32_t xid;
  dhcp_t *dhcp;
  int socket;
  interface_t *interface;
  time_t start;
  time_t last_sent;
  time_t last_type;
  long timeout;
  time_t nakoff;
  bool daemonised;
  bool persistent;
  unsigned char *buffer;
  size_t buffer_len;
  size_t buffer_pos;
} state_t;

static pid_t daemonise (int *pidfd)
{
  pid_t pid;
  sigset_t full;
  sigset_t old;
#ifdef THERE_IS_NO_FORK
  char **argv;
  int i;
#endif

  sigfillset (&full);
  sigprocmask (SIG_SETMASK, &full, &old);

#ifndef THERE_IS_NO_FORK
  logger (LOG_DEBUG, "forking to background");
  switch (pid = fork())
    {
    case -1:
      logger (LOG_ERR, "fork: %s", strerror (errno));
      exit (EXIT_FAILURE);
      /* NOT REACHED */
    case 0:
      setsid ();
      close_fds ();
      break;
    default:
      /* Reset our signals as we're the parent about to exit. */
      signal_reset ();
      break;
    }
#else
  logger (LOG_INFO, "forking to background");

  /* We need to add --daemonise to our options */
  argv = xmalloc (sizeof (char *) * (dhcpcd_argc + 4));
  argv[0] = dhcpcd;
  for (i = 1; i < dhcpcd_argc; i++)
    argv[i] = dhcpcd_argv[i];
  argv[i] = (char *) "--daemonised";
  if (dhcpcd_skiproutes)
    {
      argv[++i] = (char *) "--skiproutes";
      argv[++i] = dhcpcd_skiproutes;
    }
  argv[i + 1] = NULL;

  switch (pid = vfork ())
    {
    case -1:
      logger (LOG_ERR, "vfork: %s", strerror (errno));
      _exit (EXIT_FAILURE);
    case 0:
      signal_reset ();
      sigprocmask (SIG_SETMASK, &old, NULL);
      execvp (dhcpcd, argv);
      logger (LOG_ERR, "execl `%s': %s", dhcpcd,
              strerror (errno));
      _exit (EXIT_FAILURE);
    }

  free (argv);
#endif

  /* Done with the fd now */
  if (pid != 0)
    {
      writepid (*pidfd, pid);
      close (*pidfd);
      *pidfd = -1;

    }

  sigprocmask (SIG_SETMASK, &old, NULL);
  return (pid);
}

#ifdef ENABLE_INFO
static bool get_old_lease (state_t *state, const options_t *options)
{
  interface_t *iface = state->interface;
  dhcp_t *dhcp = state->dhcp;
  struct timeval tv;
  unsigned int offset = 0;

  if (! IN_LINKLOCAL (ntohl (iface->previous_address.s_addr)))
    logger (LOG_INFO, "trying to use old lease in `%s'",
            iface->infofile);
  if (! read_info (iface, dhcp))
    return (false);

  /* Vitaly important we remove the server information here */
  memset (&dhcp->serveraddress, 0, sizeof (dhcp->serveraddress));
  memset (dhcp->servername, 0, sizeof (dhcp->servername));

#ifdef ENABLE_ARP
  /* Check that no-one is using the address */
  if ((options->dolastlease ||
       (IN_LINKLOCAL (ntohl (dhcp->address.s_addr)) &&
        (! options->doipv4ll ||
         arp_claim (iface, dhcp->address)))))
    {
      memset (&dhcp->address, 0, sizeof (dhcp->address));
      memset (&dhcp->netmask, 0, sizeof (dhcp->netmask));
      memset (&dhcp->broadcast, 0, sizeof (dhcp->broadcast));
      return (false);
    }

  /* Ok, lets use this */
  if (IN_LINKLOCAL (dhcp->address.s_addr))
    return (true);
#endif

  /* Ensure that we can still use the lease */
  if (gettimeofday (&tv, NULL) == -1)
    {
      logger (LOG_ERR, "gettimeofday: %s", strerror (errno));
      return (false);
    }

  offset = tv.tv_sec - dhcp->leasedfrom;
  if (dhcp->leasedfrom &&
      tv.tv_sec - dhcp->leasedfrom > dhcp->leasetime)
    {
      logger (LOG_ERR, "lease expired %u seconds ago",
              offset + dhcp->leasetime);
      return (false);
    }

  if (dhcp->leasedfrom == 0)
    offset = 0;
  state->timeout = dhcp->renewaltime - offset;
  iface->start_uptime = uptime ();
  return (true);
}
#endif

#ifdef THERE_IS_NO_FORK
static void remove_skiproutes (dhcp_t *dhcp, interface_t *iface)
{
  int i = -1;
  route_t *route;
  route_t *newroute;

  free_route (iface->previous_routes);
  iface->previous_routes = NULL;

  NSTAILQ_FOREACH (route, dhcp->routes, entries)
  {
    i++;

    /* Check that we did add this route or not */
    if (dhcpcd_skiproutes)
      {
        char *sk = xstrdup (dhcpcd_skiproutes);
        char *skp = sk;
        char *token;
        bool found = false;

        while ((token = strsep (&skp, ",")))
          {
            if (isdigit (*token) && atoi (token) == i)
              {
                found = true;
                break;
              }
          }
        free (sk);
        if (found)
          continue;
      }

    if (! iface->previous_routes)
      {
        iface->previous_routes = xmalloc (sizeof (*iface->previous_routes));
        STAILQ_INIT (iface->previous_routes);
      }

    newroute = xmalloc (sizeof (*newroute));
    memcpy (newroute, route, sizeof (*newroute));
    STAILQ_INSERT_TAIL (iface->previous_routes, newroute, entries);
  }

  /* We no longer need this argument */
  free (dhcpcd_skiproutes);
  dhcpcd_skiproutes = NULL;
}
#endif

static bool client_setup (state_t *state, const options_t *options)
{
  dhcp_t *dhcp = state->dhcp;
  interface_t *iface = state->interface;

  state->state = STATE_INIT;
  state->last_type = DHCP_DISCOVER;
  state->nakoff = 1;
  state->daemonised = options->daemonised;
  state->persistent = options->persistent;

  if (options->request_address.s_addr == 0 &&
      (options->doinform || options->dorequest || options->daemonised))
    {
#ifdef ENABLE_INFO
      if (! get_old_lease (state, options))
#endif
        {
          free (dhcp);
          return (false);
        }
      state->timeout = 0;

      if (! options->daemonised &&
          IN_LINKLOCAL (ntohl (dhcp->address.s_addr)))
        {
          logger (LOG_ERR, "cannot request a link local address");
          return (false);
        }
#ifdef THERE_IS_NO_FORK
      if (options->daemonised)
        {
          state->state = STATE_BOUND;
          state->timeout = dhcp->renewaltime;
          iface->previous_address = dhcp->address;
          iface->previous_netmask = dhcp->netmask;
          remove_skiproutes (dhcp, iface);
        }
#endif

    }
  else
    {
      dhcp->address = options->request_address;
      dhcp->netmask = options->request_netmask;
      if (dhcp->netmask.s_addr == 0)
        dhcp->netmask.s_addr = get_netmask (dhcp->address.s_addr);
      dhcp->broadcast.s_addr = dhcp->address.s_addr |
                               ~dhcp->netmask.s_addr;
    }

  /* Remove all existing addresses.
   * After all, we ARE a DHCP client whose job it is to configure the
   * interface. We only do this on start, so persistent addresses
   * can be added afterwards by the user if needed. */
  if (! options->test && ! options->daemonised)
    {
      if (! options->doinform)
        {
          flush_addresses (iface->name);
        }
      else
        {
          /* The inform address HAS to be configured for it to
           * work with most DHCP servers */
          if (options->doinform &&
              has_address (iface->name, dhcp->address) < 1)
            {
              add_address (iface->name, dhcp->address,
                           dhcp->netmask, dhcp->broadcast);
              iface->previous_address = dhcp->address;
              iface->previous_netmask = dhcp->netmask;
            }
        }
    }

  if (*options->clientid)
    {
      /* Attempt to see if the ClientID is a hardware address */
      iface->clientid_len = hwaddr_aton (NULL, options->clientid);
      if (iface->clientid_len)
        {
          iface->clientid = xmalloc (iface->clientid_len);
          hwaddr_aton (iface->clientid, options->clientid);
        }
      else
        {
          /* Nope, so mark it as-is */
          iface->clientid_len = strlen (options->clientid) + 1;
          iface->clientid = xmalloc (iface->clientid_len);
          *iface->clientid = '\0';
          memcpy (iface->clientid + 1,
                  options->clientid, iface->clientid_len - 1);
        }
    }
  else
    {
#ifdef ENABLE_DUID
      unsigned char *duid = NULL;
      size_t duid_len = 0;

      if (options->doduid)
        {
          duid = xmalloc (DUID_LEN);
          duid_len = get_duid (duid, iface);
        }

      if (duid_len > 0)
        {
          logger (LOG_INFO, "DUID = %s", hwaddr_ntoa (duid, duid_len));

          iface->clientid_len = duid_len + 5;
          iface->clientid = xmalloc (iface->clientid_len);
          *iface->clientid = 255; /* RFC 4361 */

          /* IAID is 4 bytes, so if the iface name is 4 bytes use it */
          if (strlen (iface->name) == 4)
            {
              memcpy (iface->clientid + 1, iface->name, 4);
            }
          else
            {
              /* Name isn't 4 bytes, so use the index */
              uint32_t ul = htonl (if_nametoindex (iface->name));
              memcpy (iface->clientid + 1, &ul, 4);
            }

          memcpy (iface->clientid + 5, duid, duid_len);
          free (duid);
        }
      else
        {
#else
      {
#endif
          iface->clientid_len = iface->hwlen + 1;
          iface->clientid = xmalloc (iface->clientid_len);
          *iface->clientid = iface->family;
          memcpy (iface->clientid + 1, iface->hwaddr, iface->hwlen);
        }
    }

  return (true);
}

static bool do_socket (state_t *state, int mode)
{
  if (state->interface->fd >= 0)
    close (state->interface->fd);
#ifdef __linux
  if (mode == SOCKET_CLOSED && state->interface->listen_fd >= 0)
    {
      close (state->interface->listen_fd);
      state->interface->listen_fd = -1;
    }
#endif

  state->interface->fd = -1;
  if (mode == SOCKET_OPEN)
    if (open_socket (state->interface, ETHERTYPE_IP) == -1)
      return (false);
  state->socket = mode;
  return (true);
}

static bool _send_message (state_t *state, int type, const options_t *options)
{
  ssize_t retval;

  state->last_type = type;
  state->last_sent = uptime ();
  logSendToQt(type);
  retval = send_message (state->interface, state->dhcp, state->xid,
                         type, options);
  return (retval == -1 ? false : true);
}

static void drop_config (state_t *state, const options_t *options)
{
  if (! state->persistent)
    configure (options, state->interface, state->dhcp, false);

  free_dhcp (state->dhcp);
  memset (state->dhcp, 0, sizeof (*state->dhcp));
}

static int wait_for_packet (struct pollfd *fds, state_t *state,
                            const options_t *options)
{
  dhcp_t *dhcp = state->dhcp;
  interface_t *iface = state->interface;
  int timeout = 0;
  int retval = 0;

  if (! (state->timeout > 0 ||
         (options->timeout == 0 &&
          (state->state != STATE_INIT || state->xid))))
    {
      /* We need to zero our signal fd, otherwise we will block
       * trying to read a signal. */
      fds[POLLFD_SIGNAL].revents = 0;
      return (0);
    }

  fds[POLLFD_IFACE].fd = iface->fd;

  if ((options->timeout == 0 && state->xid) ||
      (dhcp->leasetime == (unsigned) - 1 &&
       state->state == STATE_BOUND))
    {
      logger (LOG_DEBUG, "waiting for infinity");
      while (retval == 0)
        {
          if (iface->fd == -1)
            retval = poll (fds, 1, INFTIM);
          else
            {
              /* Slow down our requests */
              if (timeout < TIMEOUT_MINI_INF)
                timeout += TIMEOUT_MINI;
              else if (timeout > TIMEOUT_MINI_INF)
                timeout = TIMEOUT_MINI_INF;

              retval = poll (fds, 2, timeout * 1000);
              if (retval == -1 && errno == EINTR)
                {
                  /* If interupted, continue as normal as
                   * the signal will be delivered down
                   * the pipe */
                  retval = 0;
                  continue;
                }
              if (retval == 0)
                _send_message (state, state->last_type,
                               options);
            }
        }

      return (retval);
    }

  /* Resend our message if we're getting loads of packets.
  * As we use BPF or LPF, we shouldn't hit this as much, but it's
  * still nice to have. */
  if (iface->fd > -1 && uptime () - state->last_sent >= TIMEOUT_MINI)
    _send_message (state, state->last_type, options);

  logger (LOG_DEBUG, "waiting for %ld seconds",
          (unsigned long) state->timeout);
  /* If we're waiting for a reply, then we re-send the last
   * DHCP request periodically in-case of a bad line */
  retval = 0;
  while (state->timeout > 0 && retval == 0)
    {
      if (iface->fd == -1)
        timeout = (int) state->timeout;
      else
        {
          timeout = TIMEOUT_MINI;
          if (state->timeout < timeout)
            timeout = (int) state->timeout;
        }
      timeout *= 1000;
      state->start = uptime ();
      retval = poll (fds, iface->fd == -1 ? 1 : 2, timeout);
      state->timeout -= uptime () - state->start;
      if (retval == -1 && errno == EINTR)
        {
          /* If interupted, continue as normal as the signal
           * will be delivered down the pipe */
          retval = 0;
          continue;
        }
      if (retval == 0 && iface->fd != -1 && state->timeout > 0)
        _send_message (state, state->last_type, options);
    }

  return (retval);
}

static bool handle_signal (int sig, state_t *state,  const options_t *options)
{
  switch (sig)
    {
    case SIGINT:
      logger (LOG_INFO, "received SIGINT, stopping");
      return (false);
    case SIGTERM:
      logger (LOG_INFO, "received SIGTERM, stopping");
      return (false);

    case SIGALRM:
      logger (LOG_INFO, "received SIGALRM, renewing lease");
      switch (state->state)
        {
        case STATE_BOUND:
        case STATE_RENEWING:
        case STATE_REBINDING:
          state->state = STATE_RENEW_REQUESTED;
          break;
        case STATE_RENEW_REQUESTED:
        case STATE_REQUESTING:
        case STATE_RELEASED:
          state->state = STATE_INIT;
          break;
        }
      state->timeout = 0;
      state->xid = 0;
      return (true);

    case SIGHUP:
      if (state->state != STATE_BOUND &&
          state->state != STATE_RENEWING &&
          state->state != STATE_REBINDING)
        {
          logger (LOG_ERR,
                  "received SIGHUP, but we no have lease to release");
          return (false);
        }

      logger (LOG_INFO, "received SIGHUP, releasing lease");
      if (! IN_LINKLOCAL (ntohl (state->dhcp->address.s_addr)))
        {
          do_socket (state, SOCKET_OPEN);
          state->xid = (uint32_t) random ();
          if ((open_socket (state->interface, false)) >= 0)
            {
              _send_message (state, DHCP_RELEASE, options);
            }
          do_socket (state, SOCKET_CLOSED);
        }
      unlink (state->interface->infofile);
      return (false);

    default:
      logger (LOG_ERR,
              "received signal %d, but don't know what to do with it",
              sig);
    }

  return (false);
}

static int handle_timeout (state_t *state, const options_t *options)
{
  dhcp_t *dhcp = state->dhcp;
  interface_t *iface = state->interface;

  /* No NAK, so reset the backoff */
  state->nakoff = 1;

  if (state->state == STATE_INIT && state->xid != 0)
    {
      if (iface->previous_address.s_addr != 0 &&
          ! IN_LINKLOCAL (ntohl (iface->previous_address.s_addr)) &&
          ! options->doinform)
        {
          logger (LOG_ERR, "lost lease");
          if (! options->persistent)
            drop_config (state, options);
        }
      else if (! IN_LINKLOCAL (ntohl (iface->previous_address.s_addr)))
        logger (LOG_ERR, "timed out");

      do_socket (state, SOCKET_CLOSED);
      free_dhcp (dhcp);
      memset (dhcp, 0, sizeof (*dhcp));

#ifdef ENABLE_INFO
      if (! options->test &&
          (options->doipv4ll || options->dolastlease))
        {
          errno = 0;
          if (! get_old_lease (state, options))
            {
              if (errno == EINTR)
                return (0);
              if (options->dolastlease)
                return (-1);
              free_dhcp (dhcp);
              memset (dhcp, 0, sizeof (*dhcp));
            }
          else if (errno == EINTR)
            return (0);
        }
#endif

#ifdef ENABLE_IPV4LL
      if (! options->test && options->doipv4ll &&
          (! dhcp->address.s_addr ||
           (! IN_LINKLOCAL (ntohl (dhcp->address.s_addr)) &&
            ! options->dolastlease)))
        {
          logger (LOG_INFO, "probing for an IPV4LL address");
          free_dhcp (dhcp);
          memset (dhcp, 0, sizeof (*dhcp));
          if (ipv4ll_get_address (iface, dhcp) == -1)
            {
              if (! state->daemonised)
                return (-1);

              /* start over */
              state->xid = 0;
              return (0);
            }
          state->timeout = dhcp->renewaltime;
        }
#endif

#if defined (ENABLE_INFO) || defined (ENABLE_IPV4LL)
      if (dhcp->address.s_addr)
        {
          if (! state->daemonised &&
              IN_LINKLOCAL (ntohl (dhcp->address.s_addr)))
            logger (LOG_WARNING, "using IPV4LL address %s",
                    inet_ntoa (dhcp->address));
          if (configure (options, iface, dhcp, true) == -1 &&
              ! state->daemonised)
            return (-1);

          state->state = STATE_BOUND;
          if (! state->daemonised && options->daemonise)
            {
              switch (daemonise (state->pidfd))
                {
                case -1:
                  return (-1);
                case 0:
                  state->daemonised = true;
                  return (0);
                default:
                  state->persistent = true;
                  state->forked = true;
                  return (-1);
                }
            }

          state->timeout = dhcp->renewaltime;
          state->xid = 0;
          return (0);
        }
#endif

      if (! state->daemonised)
        return (-1);
    }

  switch (state->state)
    {
    case STATE_INIT:
      state->xid = (uint32_t) random ();
      do_socket (state, SOCKET_OPEN);
      state->timeout = options->timeout;
      iface->start_uptime = uptime ();
      if (dhcp->address.s_addr == 0)
        {
          if (! IN_LINKLOCAL (ntohl (iface->previous_address.s_addr)))
            logger (LOG_INFO, "broadcasting for a lease");
          _send_message (state, DHCP_DISCOVER, options);
        }
      else if (options->doinform)
        {
          logger (LOG_INFO, "broadcasting inform for %s",
                  inet_ntoa (dhcp->address));
          _send_message (state, DHCP_INFORM, options);
          state->state = STATE_REQUESTING;
        }
      else
        {
          logger (LOG_INFO, "broadcasting for a lease of %s",
                  inet_ntoa (dhcp->address));
          _send_message (state, DHCP_REQUEST, options);
          state->state = STATE_REQUESTING;
        }

      break;
    case STATE_BOUND:
    case STATE_RENEW_REQUESTED:
      if (IN_LINKLOCAL (ntohl (dhcp->address.s_addr)))
        {
          memset (&dhcp->address, 0, sizeof (dhcp->address));
          state->state = STATE_INIT;
          state->xid = 0;
          break;
        }
      state->state = STATE_RENEWING;
      state->xid = (uint32_t) random ();
      /* FALLTHROUGH */
    case STATE_RENEWING:
      iface->start_uptime = uptime ();
      logger (LOG_INFO, "renewing lease of %s", inet_ntoa
              (dhcp->address));
      do_socket (state, SOCKET_OPEN);
      _send_message (state, DHCP_REQUEST, options);
      state->timeout = dhcp->rebindtime - dhcp->renewaltime;
      state->state = STATE_REBINDING;
      break;
    case STATE_REBINDING:
      logger (LOG_ERR, "lost lease, attemping to rebind");
      memset (&dhcp->address, 0, sizeof (dhcp->address));
      do_socket (state, SOCKET_OPEN);
      if (state->xid == 0)
        state->xid = (uint32_t) random ();
      dhcp->serveraddress.s_addr = 0;
      _send_message (state, DHCP_REQUEST, options);
      state->timeout = dhcp->leasetime - dhcp->rebindtime;
      state->state = STATE_REQUESTING;
      break;
    case STATE_REQUESTING:
      state->state = STATE_INIT;
      do_socket (state, SOCKET_CLOSED);
      state->timeout = 0;
      break;

    case STATE_RELEASED:
      dhcp->leasetime = 0;
      break;
    }

  return (0);
}


static int handle_dhcp (state_t *state, int type, const options_t *options)
{
  struct timespec ts;
  interface_t *iface = state->interface;
  dhcp_t *dhcp = state->dhcp;

  /* We should restart on a NAK */
  if (type == DHCP_NAK)
    {
      logger (LOG_INFO, "received NAK: %s", dhcp->message);
      logToQt(LOG_INFO, DHCP_NAK, "");
      state->state = STATE_INIT;
      state->timeout = 0;
      state->xid = 0;
      free_dhcp (dhcp);
      memset (dhcp, 0, sizeof (*dhcp));

      /* If we constantly get NAKS then we should slowly back off */
      if (state->nakoff > 0)
        {
          logger (LOG_DEBUG, "sleeping for %ld seconds",
                  (long) state->nakoff);
          ts.tv_sec = state->nakoff;
          ts.tv_nsec = 0;
          state->nakoff *= 2;
          if (state->nakoff > NAKOFF_MAX)
            state->nakoff = NAKOFF_MAX;
          nanosleep (&ts, NULL);
        }

      return (0);
    }

  /* No NAK, so reset the backoff */
  state->nakoff = 1;

  if (type == DHCP_OFFER && state->state == STATE_INIT)
    {
      char *addr = strdup (inet_ntoa (dhcp->address));
      if (dhcp->servername[0])
        logger (LOG_INFO, "offered %s from %s `%s'",
                addr, inet_ntoa (dhcp->serveraddress),
                dhcp->servername);
      else
        logger (LOG_INFO, "offered %s from %s",
                addr, inet_ntoa (dhcp->serveraddress));
      free (addr);

      logToQt(LOG_INFO, DHCP_OFFER, "");

#ifdef ENABLE_INFO
      if (options->test)
        {
          write_info (iface, dhcp, options, false);
          errno = 0;
          return (-1);
        }
#endif

      _send_message (state, DHCP_REQUEST, options);
      state->state = STATE_REQUESTING;

      return (0);
    }

  if (type == DHCP_OFFER)
    {
      logger (LOG_INFO, "got subsequent offer of %s, ignoring ",
              inet_ntoa (dhcp->address));
      return (0);
    }

  /* We should only be dealing with acks */
  if (type != DHCP_ACK)
    {
      logger (LOG_ERR, "%d not an ACK or OFFER", type);
      return (0);
    }

  /* if we are here, than we received an ACK and can go on with configuration */
  logToQt(LOG_INFO, DHCP_ACK, "");

  switch (state->state)
    {
    case STATE_RENEW_REQUESTED:
    case STATE_REQUESTING:
    case STATE_RENEWING:
    case STATE_REBINDING:
      break;
    default:
      logger (LOG_ERR, "wrong state %d", state->state);
    }

  do_socket (state, SOCKET_CLOSED);

#ifdef ENABLE_ARP
  if (options->doarp && iface->previous_address.s_addr !=
      dhcp->address.s_addr)
    {
      errno = 0;
      logToQt(LOG_INFO, DHCPCD_ARP_TEST, "");
      if (arp_claim (iface, dhcp->address))
        {
          do_socket (state, SOCKET_OPEN);
          _send_message (state, DHCP_DECLINE, options);
          do_socket (state, SOCKET_CLOSED);

          free_dhcp (dhcp);
          memset (dhcp, 0, sizeof (*dhcp));
          state->xid = 0;
          state->timeout = 0;
          state->state = STATE_INIT;

          /* RFC 2131 says that we should wait for 10 seconds
           * before doing anything else */
          logger (LOG_INFO, "sleeping for 10 seconds");
          ts.tv_sec = 10;
          ts.tv_nsec = 0;
          nanosleep (&ts, NULL);
          return (0);
        }
      else if (errno == EINTR)
        return (0);
    }
#endif

  if (options->doinform)
    {
      if (options->request_address.s_addr != 0)
        dhcp->address = options->request_address;
      else
        dhcp->address = iface->previous_address;

      logger (LOG_INFO, "received approval for %s",
              inet_ntoa (dhcp->address));
      if (iface->previous_netmask.s_addr != dhcp->netmask.s_addr)
        {
          add_address (iface->name, dhcp->address,
                       dhcp->netmask, dhcp->broadcast);
          iface->previous_netmask.s_addr = dhcp->netmask.s_addr;
        }
      state->timeout = options->leasetime;
      if (state->timeout == 0)
        state->timeout = DEFAULT_LEASETIME;
      state->state = STATE_INIT;
    }
  else if (dhcp->leasetime == (unsigned) - 1)
    {
      dhcp->renewaltime = dhcp->rebindtime = dhcp->leasetime;
      state->timeout = 1; /* So we wait for infinity */
      logger (LOG_INFO, "leased %s for infinity",
              inet_ntoa (dhcp->address));
      state->state = STATE_BOUND;
    }
  else
    {
      if (! dhcp->leasetime)
        {
          dhcp->leasetime = DEFAULT_LEASETIME;
          logger(LOG_INFO,
                 "no lease time supplied, assuming %d seconds",
                 dhcp->leasetime);
        }
      logger (LOG_INFO, "leased %s for %u seconds",
              inet_ntoa (dhcp->address), dhcp->leasetime);

      if (dhcp->rebindtime >= dhcp->leasetime)
        {
          dhcp->rebindtime = (dhcp->leasetime * 0.875);
          logger (LOG_ERR,
                  "rebind time greater than lease "
                  "time, forcing to %u seconds",
                  dhcp->rebindtime);
        }

      if (dhcp->renewaltime > dhcp->rebindtime)
        {
          dhcp->renewaltime = (dhcp->leasetime * 0.5);
          logger (LOG_ERR,
                  "renewal time greater than rebind time, "
                  "forcing to %u seconds",
                  dhcp->renewaltime);
        }

      if (! dhcp->renewaltime)
        {
          dhcp->renewaltime = (dhcp->leasetime * 0.5);
          logger (LOG_INFO,
                  "no renewal time supplied, assuming %d seconds",
                  dhcp->renewaltime);
        }
      else
        logger (LOG_DEBUG, "renew in %u seconds",
                dhcp->renewaltime);

      if (! dhcp->rebindtime)
        {
          dhcp->rebindtime = (dhcp->leasetime * 0.875);
          logger (LOG_INFO,
                  "no rebind time supplied, assuming %d seconds",
                  dhcp->rebindtime);
        }
      else
        logger (LOG_DEBUG, "rebind in %u seconds",
                dhcp->rebindtime);

      state->timeout = dhcp->renewaltime;
      state->state = STATE_BOUND;
    }

  state->xid = 0;

  logToQt(LOG_INFO, DHCPCD_CONFIGURE, "");
  if (configure (options, iface, dhcp, true) == -1 &&
      ! state->daemonised)
    return (-1);

  if (! state->daemonised && options->daemonise)
    {
      switch (daemonise (state->pidfd))
        {
        case 0:
          state->daemonised = true;
          return (0);
        case -1:
          return (-1);
        default:
          state->persistent = true;
          state->forked = true;
          return (-1);
        }
    }

  return (0);
}

static int handle_packet (state_t *state, const options_t *options)
{
  interface_t *iface = state->interface;
  bool valid = false;
  int type;
  struct dhcp_t *new_dhcp;
  dhcpmessage_t message;

  /* Allocate our buffer space for BPF.
   * We cannot do this until we have opened our socket as we don't
   * know how much of a buffer we need until then. */
  if (! state->buffer)
    state->buffer = xmalloc (iface->buffer_length);
  state->buffer_len = iface->buffer_length;
  state->buffer_pos = 0;

  /* We loop through until our buffer is empty.
   * The benefit is that if we get >1 DHCP packet in our buffer and
   * the first one fails for any reason, we can use the next. */

  memset (&message, 0, sizeof (message));
  new_dhcp = xmalloc (sizeof (*new_dhcp));

  do
    {
      if (get_packet (iface, (unsigned char *) &message,
                      state->buffer,
                      &state->buffer_len, &state->buffer_pos) == -1)
        break;

      if (state->xid != message.xid)
        {
          logger (LOG_DEBUG,
                  "ignoring packet with xid 0x%x as it's not ours (0x%x)",
                  message.xid, state->xid);
          continue;
        }

      logger (LOG_DEBUG, "got a packet with xid 0x%x", message.xid);
      memset (new_dhcp, 0, sizeof (*new_dhcp));
      type = parse_dhcpmessage (new_dhcp, &message);
      if (type == -1)
        {
          logger (LOG_ERR, "failed to parse packet");
          free_dhcp (new_dhcp);
          /* We don't abort on this, so return zero */
          return (0);
        }

      /* If we got here then the DHCP packet is valid and appears to
       * be for us, so let's clear the buffer as we don't care about
       * any more DHCP packets at this point. */
      valid = true;
      break;
    }
  while (state->buffer_pos != 0);

  /* No packets for us, so wait until we get one */
  if (! valid)
    {
      free (new_dhcp);
      return (0);
    }

  /* new_dhcp is now our master DHCP message */
  free_dhcp (state->dhcp);
  free (state->dhcp);
  state->dhcp = new_dhcp;
  new_dhcp = NULL;

  return (handle_dhcp (state, type, options));
}

int dhcp_run (const options_t *options, int *pidfd)
{
  interface_t *iface;
  state_t *state = NULL;
  struct pollfd fds[] =
  {
    { -1, POLLIN, 0 },
    { -1, POLLIN, 0 }
  };
  int retval = -1;
  int sig;

  if (! options)
    return (-1);

  /*read_interface : defined in interface.c*/
  iface = read_interface (options->interface, options->metric);
  if (! iface)
    goto eexit;

  state = xzalloc (sizeof (*state));
  state->dhcp = xzalloc (sizeof (*state->dhcp));
  state->pidfd = pidfd;
  state->interface = iface;

  if (! client_setup (state, options))
    goto eexit;

  if (signal_init () == -1)
    goto eexit;
  if (signal_setup () == -1)
    goto eexit;

  fds[POLLFD_SIGNAL].fd = signal_fd ();

  for (;;)
    {
      retval = wait_for_packet (fds, state, options);

      /* We should always handle our signals first */
      if ((sig = (signal_read (&fds[POLLFD_SIGNAL]))) != -1)
        {
          if (handle_signal (sig, state, options))
            retval = 0;
          else
            retval = -1;
        }
      else if (retval == 0)
        retval = handle_timeout (state, options);
      else if (retval > 0 &&
               state->socket != SOCKET_CLOSED &&
               fds[POLLFD_IFACE].revents & POLLIN)
        retval = handle_packet (state, options);
      else if (retval == -1 && errno == EINTR)
        {
          /* The interupt will be handled above */
          retval = 0;
        }
      else
        {
          logger (LOG_ERR, "poll: %s", strerror (errno));
          retval = -1;
        }

      if (retval != 0)
        break;
    }

eexit:
  if (iface)
    {
      do_socket (state, SOCKET_CLOSED);
      drop_config (state, options);
      free_route (iface->previous_routes);
      free (iface->clientid);
      free (iface);
    }

  if (state)
    {
      if (state->forked)
        retval = 0;

      if (state->daemonised)
        unlink (options->pidfile);

      free_dhcp (state->dhcp);
      free (state->dhcp);
      free (state->buffer);
      free (state);
    }

  return (retval);
}