/****************************************************************************
 * apps/netutils/dhcp6c/dhcp6c.c
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>
#include <nuttx/compiler.h>

#include <time.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <limits.h>
#include <resolv.h>
#include <string.h>
#include <unistd.h>
#include <debug.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <malloc.h>
#include <pthread.h>
#include <sys/time.h>
#include <nuttx/clock.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/udp.h>
#include <net/if.h>
#include <net/ethernet.h>
#include <arpa/inet.h>

#include "netutils/netlib.h"
#include "netutils/dhcp6c.h"

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define DHCPV6_ALL_RELAYS {{{0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
                             0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02}}}
#define DHCPV6_CLIENT_PORT 546
#define DHCPV6_SERVER_PORT 547
#define DHCPV6_DUID_LLADDR 3
#define DHCPV6_REQ_DELAY 1

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

#define dhcpv6_for_each_option(_o, start, end, otype, olen, odata)\
    for ((_o) = (FAR uint8_t *)(start); (_o) + 4 <= (FAR uint8_t *)(end) &&\
        ((otype) = (_o)[0] << 8 | (_o)[1]) && ((odata) = (FAR void *)&(_o)[4]) &&\
        ((olen) = (_o)[2] << 8 | (_o)[3]) + (odata) <= (FAR uint8_t *)(end); \
        (_o) += 4 + ((_o)[2] << 8 | (_o)[3]))

/****************************************************************************
 * Private Types
 ****************************************************************************/

enum dhcpv6_opt_e
{
  DHCPV6_OPT_CLIENTID = 1,
  DHCPV6_OPT_SERVERID = 2,
  DHCPV6_OPT_IA_NA = 3,
  DHCPV6_OPT_IA_ADDR = 5,
  DHCPV6_OPT_ORO = 6,
  DHCPV6_OPT_PREF = 7,
  DHCPV6_OPT_ELAPSED = 8,
  DHCPV6_OPT_RELAY_MSG = 9,
  DHCPV6_OPT_AUTH = 11,
  DHCPV6_OPT_STATUS = 13,
  DHCPV6_OPT_RAPID_COMMIT = 14,
  DHCPV6_OPT_RECONF_MESSAGE = 19,
  DHCPV6_OPT_RECONF_ACCEPT = 20,
  DHCPV6_OPT_DNS_SERVERS = 23,
  DHCPV6_OPT_DNS_DOMAIN = 24,
  DHCPV6_OPT_IA_PD = 25,
  DHCPV6_OPT_IA_PREFIX = 26,
  DHCPV6_OPT_INFO_REFRESH = 32,
  DHCPV6_OPT_FQDN = 39,
  DHCPV6_OPT_NTP_SERVER = 56,
  DHCPV6_OPT_SIP_SERVER_D = 21,
  DHCPV6_OPT_SIP_SERVER_A = 22,
};

enum dhcpv6_opt_npt_e
{
  NTP_SRV_ADDR = 1,
  NTP_MC_ADDR = 2,
  NTP_SRV_FQDN = 3
};

enum dhcpv6_msg_e
{
  DHCPV6_MSG_UNKNOWN = 0,
  DHCPV6_MSG_SOLICIT = 1,
  DHCPV6_MSG_ADVERT = 2,
  DHCPV6_MSG_REQUEST = 3,
  DHCPV6_MSG_RENEW = 5,
  DHCPV6_MSG_REBIND = 6,
  DHCPV6_MSG_REPLY = 7,
  DHCPV6_MSG_RELEASE = 8,
  DHCPV6_MSG_DECLINE = 9,
  DHCPV6_MSG_RECONF = 10,
  DHCPV6_MSG_INFO_REQ = 11,
  DHCPV6_MSG_MAX
};

enum dhcpv6_status_e
{
  DHCPV6_NOADDRSAVAIL = 2,
  DHCPV6_NOPREFIXAVAIL = 6
};

enum dhcpv6_mode_e
{
  DHCPV6_UNKNOWN,
  DHCPV6_STATELESS,
  DHCPV6_STATEFUL
};

enum dhcpv6_state_e
{
  STATE_CLIENT_ID,
  STATE_SERVER_ID,
  STATE_SERVER_CAND,
  STATE_ORO,
  STATE_DNS,
  STATE_SEARCH,
  STATE_IA_NA,
  STATE_IA_PD,
  STATE_CUSTOM_OPTS,
  STATE_SNTP_IP,
  STATE_SNTP_FQDN,
  STATE_SIP_IP,
  STATE_SIP_FQDN,
  STATE_MAX
};

enum dhcp6c_ia_mode_e
{
  IA_MODE_NONE,
  IA_MODE_TRY,
  IA_MODE_FORCE,
};

/* DHCPV6 Protocol Headers */

begin_packed_struct struct dhcpv6_header_s
{
  uint8_t msg_type;
  uint8_t tr_id[3];
} end_packed_struct;

begin_packed_struct struct dhcpv6_ia_hdr_s
{
  uint16_t type;
  uint16_t len;
  uint32_t iaid;
  uint32_t t1;
  uint32_t t2;
} end_packed_struct;

begin_packed_struct struct dhcpv6_ia_addr_s
{
  uint16_t type;
  uint16_t len;
  struct in6_addr addr;
  uint32_t preferred;
  uint32_t valid;
} end_packed_struct;

begin_packed_struct struct dhcpv6_ia_prefix_s
{
  uint16_t type;
  uint16_t len;
  uint32_t preferred;
  uint32_t valid;
  uint8_t prefix;
  struct in6_addr addr;
} end_packed_struct;

struct dhcpv6_server_cand_s
{
  bool has_noaddravail;
  bool wants_reconfigure;
  int16_t preference;
  uint8_t duid_len;
  uint8_t duid[130];
};

struct dhcp6c_retx_s
{
  bool delay;
  uint8_t init_timeo;
  uint16_t max_timeo;
  char name[8];
  int(*handler_reply)(FAR void *handle, enum dhcpv6_msg_e orig,
                      FAR const void *opt, FAR const void *end,
                      uint32_t elapsed);
  int(*handler_finish)(FAR void *handle, uint32_t elapsed);
};

struct dhcp6c_state_s
{
  pthread_t thread;
  bool cancel;
  dhcp6c_callback_t callback;
  int sockfd;
  int urandom_fd;
  int ifindex;
  time_t t1;
  time_t t2;
  time_t t3;
  bool request_prefix;
  enum dhcp6c_ia_mode_e ia_mode;
  bool accept_reconfig;
  FAR uint8_t *state_data[STATE_MAX];
  size_t state_len[STATE_MAX];
};

/****************************************************************************
 * Private Function Prototypes
 ****************************************************************************/

static int dhcp6c_handle_reconfigure(FAR void *handle,
                                     enum dhcpv6_msg_e orig,
                                     FAR const void *opt,
                                     FAR const void *end,
                                     uint32_t elapsed);
static int dhcp6c_handle_advert(FAR void *handle, enum dhcpv6_msg_e orig,
                                FAR const void *opt, FAR const void *end,
                                uint32_t elapsed);
static int dhcp6c_commit_advert(FAR void *handle, uint32_t elapsed);
static int dhcp6c_handle_reply(FAR void *handle, enum dhcpv6_msg_e orig,
                               FAR const void *opt, FAR const void *end,
                               uint32_t elapsed);
static int dhcp6c_handle_rebind_reply(FAR void *handle,
                                      enum dhcpv6_msg_e orig,
                                      FAR const void *opt,
                                      FAR const void *end,
                                      uint32_t elapsed);

/****************************************************************************
 * Private Data
 ****************************************************************************/

/* RFC 3315 - 5.5 Timeout and Delay values */

static const struct dhcp6c_retx_s g_dhcp6c_retx[DHCPV6_MSG_MAX] =
{
  {false, 1, 120, "<POLL>", dhcp6c_handle_reconfigure, NULL},
  {true, 1, 120, "SOLICIT", dhcp6c_handle_advert, dhcp6c_commit_advert},
  {0},
  {true, 1, 30, "REQUEST", dhcp6c_handle_reply, NULL},
  {0},
  {false, 10, 600, "RENEW", dhcp6c_handle_reply, NULL},
  {false, 10, 600, "REBIND", dhcp6c_handle_rebind_reply, NULL},
  {0},
  {false, 1, 600, "RELEASE", NULL, NULL},
  {false, 1, 3, "DECLINE", NULL, NULL},
  {0},
  {true, 1, 120, "INFOREQ", dhcp6c_handle_reply, NULL},
};

/****************************************************************************
 * Private Functions
 ****************************************************************************/

static uint64_t dhcp6c_get_milli_time(void)
{
  struct timespec t;

  clock_gettime(CLOCK_MONOTONIC, &t);

  return t.tv_sec * MSEC_PER_SEC + t.tv_nsec / USEC_PER_SEC;
}

static FAR uint8_t *dhcp6c_resize_state(FAR void *handle,
                                        enum dhcpv6_state_e state,
                                        ssize_t len)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  FAR uint8_t *n;

  if (len == 0)
    {
      return pdhcp6c->state_data[state] + pdhcp6c->state_len[state];
    }

  n = realloc(pdhcp6c->state_data[state], pdhcp6c->state_len[state] + len);
  if (n != NULL || pdhcp6c->state_len[state] + len == 0)
    {
      pdhcp6c->state_data[state] = n;
      n += pdhcp6c->state_len[state];
      pdhcp6c->state_len[state] += len;
    }

  return n;
}

static void dhcp6c_clear_state(FAR void *handle, enum dhcpv6_state_e state)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;

  pdhcp6c->state_len[state] = 0;
}

static void dhcp6c_add_state(FAR void *handle, enum dhcpv6_state_e state,
                             FAR const void *data, size_t len)
{
  FAR uint8_t *n = dhcp6c_resize_state(handle, state, len);

  if (n != NULL)
    {
      memcpy(n, data, len);
    }
}

static size_t dhcp6c_remove_state(FAR void *handle,
                                  enum dhcpv6_state_e state,
                                  size_t offset, size_t len)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  FAR uint8_t *data = pdhcp6c->state_data[state];
  ssize_t len_after = pdhcp6c->state_len[state] - (offset + len);

  if (len_after < 0)
    {
      return pdhcp6c->state_len[state];
    }

  memmove(data + offset, data + offset + len, len_after);

  return pdhcp6c->state_len[state] -= len;
}

static bool dhcp6c_commit_state(FAR void *handle, enum dhcpv6_state_e state,
                                size_t old_len)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  size_t new_len = pdhcp6c->state_len[state] - old_len;
  FAR uint8_t *old_data = pdhcp6c->state_data[state];
  FAR uint8_t *new_data = old_data + old_len;
  bool upd = (new_len != old_len) ||
             (memcmp(old_data, new_data, new_len) != 0);

  memmove(old_data, new_data, new_len);
  dhcp6c_resize_state(handle, state, -old_len);

  return upd;
}

static FAR void *dhcp6c_get_state(FAR void *handle,
                                  enum dhcpv6_state_e state,
                                  FAR size_t *len)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;

  *len = pdhcp6c->state_len[state];
  return pdhcp6c->state_data[state];
}

static void dhcp6c_get_result(FAR void *handle,
                              FAR struct dhcp6c_state *presult)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  size_t s_len;
  FAR uint8_t *s_data;
  uint16_t olen;
  uint16_t otype;
  FAR uint8_t *ite;
  FAR uint8_t *odata;
  FAR struct dhcpv6_ia_addr_s *addr;
  FAR struct dhcpv6_ia_prefix_s *pd;
  FAR struct in6_addr *dns;
  char addr_str[INET6_ADDRSTRLEN];

  if (handle == NULL || presult == NULL)
    {
      return;
    }

  s_data = dhcp6c_get_state(handle, STATE_IA_NA, &s_len);
  dhcpv6_for_each_option(ite, s_data, s_data + s_len, otype, olen, odata)
    {
      addr = (FAR void *)(odata - 4);
      memcpy(&presult->addr, &addr->addr, sizeof(presult->addr));
      inet_ntop(AF_INET6, &presult->addr, addr_str, sizeof(addr_str));
      ninfo("IA_NA %s for iface %i\n", addr_str, pdhcp6c->ifindex);
    }

  s_data = dhcp6c_get_state(handle, STATE_IA_PD, &s_len);
  dhcpv6_for_each_option(ite, s_data, s_data + s_len, otype, olen, odata)
    {
      pd = (FAR void *)(odata - 4);
      memcpy(&presult->pd, &pd->addr, sizeof(presult->pd));
      presult->pl = pd->prefix;
      netlib_prefix2ipv6netmask(presult->pl, &presult->netmask);
      inet_ntop(AF_INET6, &presult->pd, addr_str, sizeof(addr_str));
      ninfo("IA_PD %s for iface %i\n", addr_str, pdhcp6c->ifindex);
      inet_ntop(AF_INET6, &presult->netmask, addr_str, sizeof(addr_str));
      ninfo("netmask %s for iface %i\n", addr_str, pdhcp6c->ifindex);
    }

  dns = dhcp6c_get_state(handle, STATE_DNS, &s_len);
  memcpy(&presult->dns, dns, sizeof(presult->dns));
  inet_ntop(AF_INET6, &presult->dns, addr_str, sizeof(addr_str));
  ninfo("DNS server %s for iface %i\n", addr_str, pdhcp6c->ifindex);

  presult->t1 = pdhcp6c->t1;
  presult->t2 = pdhcp6c->t2;
  ninfo("T1:%d T2:%d for iface %i\n", presult->t1, presult->t2,
        pdhcp6c->ifindex);
}

static void dhcp6c_switch_process(FAR void *handle, FAR const char *name)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  struct dhcp6c_state result;

  ninfo("Process switch to %s\n", name);

  /* Delete lost prefixes and user opts */

  dhcp6c_clear_state(handle, STATE_CUSTOM_OPTS);

  if (pdhcp6c->callback != NULL)
    {
      memset(&result, 0, sizeof(result));
      dhcp6c_get_result(pdhcp6c, &result);
      pdhcp6c->callback(&result);
    }
}

static void dhcp6c_remove_addrs(FAR void *handle)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  size_t ia_na_len;
  FAR uint8_t *ite;
  FAR uint8_t *odata;
  FAR uint8_t *ia_na = dhcp6c_get_state(handle, STATE_IA_NA, &ia_na_len);
  uint16_t otype;
  uint16_t olen;
  FAR struct dhcpv6_ia_addr_s *addr;
  char addr_str[INET6_ADDRSTRLEN];

  dhcpv6_for_each_option(ite, ia_na, ia_na + ia_na_len, otype, olen, odata)
    {
      addr = (FAR void *)(odata - 4);
      inet_ntop(AF_INET6, &addr->addr, addr_str, sizeof(addr_str));
      ninfo("removing address %s/128 for iface %i\n",
            addr_str, pdhcp6c->ifindex);
    }
}

static void dhcp6c_set_iov(FAR struct iovec *piov,
                           FAR void *base, size_t len)
{
  piov->iov_base = base;
  piov->iov_len = len;
}

static void dhcp6c_send(FAR void *handle, enum dhcpv6_msg_e type,
                        uint8_t trid[3], uint32_t ecs)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  char fqdn_buf[256];
  struct
  {
    uint16_t type;
    uint16_t len;
    uint8_t flags;
    uint8_t data[256];
  } fqdn;

  size_t fqdn_len;
  size_t cl_id_len;
  FAR void *cl_id;
  size_t srv_id_len;
  FAR void *srv_id;
  size_t ia_pd_len;
  FAR void *ia_pd;
  struct dhcpv6_ia_hdr_s hdr_ia_pd;
  struct dhcpv6_ia_prefix_s pref;
  size_t ia_na_len;
  FAR void *ia_na;
  struct dhcpv6_ia_hdr_s hdr_ia_na;
  struct
  {
    uint16_t type;
    uint16_t length;
  } reconf_accept;

  uint16_t oro_refresh;
  size_t oro_len;
  FAR void *oro;
  struct
  {
    uint8_t type;
    uint8_t trid[3];
    uint16_t elapsed_type;
    uint16_t elapsed_len;
    uint16_t elapsed_value;
    uint16_t oro_type;
    uint16_t oro_len;
  } hdr;

  struct iovec iov[11];
  size_t cnt;
  struct sockaddr_in6 dest =
  {
    AF_INET6, htons(DHCPV6_SERVER_PORT),
    0, DHCPV6_ALL_RELAYS, pdhcp6c->ifindex
  };

  struct msghdr msg;

  /* Build FQDN */

  gethostname(fqdn_buf, sizeof(fqdn_buf));
  fqdn_len = 5 + dn_comp(fqdn_buf, fqdn.data, sizeof(fqdn.data), NULL, NULL);
  fqdn.type = htons(DHCPV6_OPT_FQDN);
  fqdn.len = htons(fqdn_len - 4);
  fqdn.flags = 0;

  /* Build Client ID */

  cl_id = dhcp6c_get_state(handle, STATE_CLIENT_ID, &cl_id_len);

  /* Build Server ID */

  srv_id = dhcp6c_get_state(handle, STATE_SERVER_ID, &srv_id_len);

  /* Build IA_PDs */

  ia_pd = dhcp6c_get_state(handle, STATE_IA_PD, &ia_pd_len);
  hdr_ia_pd.type = htons(DHCPV6_OPT_IA_PD);
  hdr_ia_pd.len = htons(sizeof(hdr_ia_pd) - 4 + ia_pd_len);
  hdr_ia_pd.iaid = 1;
  hdr_ia_pd.t1 = 0;
  hdr_ia_pd.t2 = 0;
  pref.type = htons(DHCPV6_OPT_IA_PREFIX);
  pref.len = htons(25);
  pref.prefix = pdhcp6c->request_prefix;

  if (ia_pd_len == 0 && pdhcp6c->request_prefix &&
      (type == DHCPV6_MSG_SOLICIT || type == DHCPV6_MSG_REQUEST))
    {
      ia_pd = &pref;
      ia_pd_len = sizeof(pref);
    }

  /* Build IA_NAs */

  ia_na = dhcp6c_get_state(handle, STATE_IA_NA, &ia_na_len);
  hdr_ia_na.type = htons(DHCPV6_OPT_IA_NA);
  hdr_ia_na.len = htons(sizeof(hdr_ia_na) - 4 + ia_na_len);
  hdr_ia_na.iaid = 1;
  hdr_ia_na.t1 = 0;
  hdr_ia_na.t2 = 0;

  /* Reconfigure Accept */

  reconf_accept.type = htons(DHCPV6_OPT_RECONF_ACCEPT);
  reconf_accept.length = 0;

  /* Request Information Refresh */

  oro_refresh = htons(DHCPV6_OPT_INFO_REFRESH);

  /* Prepare Header */

  oro = dhcp6c_get_state(handle, STATE_ORO, &oro_len);
  hdr.type = type;
  hdr.trid[0] = trid[0];
  hdr.trid[1] = trid[1];
  hdr.trid[2] = trid[2];
  hdr.elapsed_type = htons(DHCPV6_OPT_ELAPSED);
  hdr.elapsed_len =  htons(2);
  hdr.elapsed_value = htons((ecs > 0xffff) ? 0xffff : ecs);
  hdr.oro_type = htons(DHCPV6_OPT_ORO);
  hdr.oro_len = htons(oro_len);

  /* Prepare iov */

  dhcp6c_set_iov(&iov[0], &hdr, sizeof(hdr));
  dhcp6c_set_iov(&iov[1], oro, oro_len);
  dhcp6c_set_iov(&iov[2], &oro_refresh, 0);
  dhcp6c_set_iov(&iov[3], cl_id, cl_id_len);
  dhcp6c_set_iov(&iov[4], srv_id, srv_id_len);
  dhcp6c_set_iov(&iov[5], &reconf_accept, 0);
  dhcp6c_set_iov(&iov[6], &fqdn, fqdn_len);
  dhcp6c_set_iov(&iov[7], &hdr_ia_na, sizeof(hdr_ia_na));
  dhcp6c_set_iov(&iov[8], ia_na, ia_na_len);
  dhcp6c_set_iov(&iov[9], &hdr_ia_pd, sizeof(hdr_ia_pd));
  dhcp6c_set_iov(&iov[10], ia_pd, ia_pd_len);

  cnt = ARRAY_SIZE(iov);
  if (type == DHCPV6_MSG_INFO_REQ)
    {
      cnt = 5;
      iov[2].iov_len = sizeof(oro_refresh);
      hdr.oro_len = htons(oro_len + sizeof(oro_refresh));
    }
  else if (!pdhcp6c->request_prefix)
    {
      cnt = 9;
    }

  /* Disable IAs if not used */

  if (type == DHCPV6_MSG_SOLICIT)
    {
      iov[5].iov_len = sizeof(reconf_accept);
    }
  else if (type != DHCPV6_MSG_REQUEST)
    {
      if (ia_na_len == 0)
        {
          iov[7].iov_len = 0;
        }

      if (ia_pd_len == 0)
        {
          iov[9].iov_len = 0;
        }
    }

  if (pdhcp6c->ia_mode == IA_MODE_NONE)
    {
      iov[7].iov_len = 0;
    }

  msg.msg_name = &dest;
  msg.msg_namelen = sizeof(dest);
  msg.msg_iov = iov;
  msg.msg_iovlen = cnt;
  msg.msg_control = NULL;
  msg.msg_controllen = 0;
  msg.msg_flags = 0;

  sendmsg(pdhcp6c->sockfd, &msg, 0);
}

static int64_t dhcp6c_rand_delay(FAR void *handle, int64_t time)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  int random;

  read(pdhcp6c->urandom_fd, &random, sizeof(random));
  return (time * (random % 1000)) / 10000;
}

static bool dhcp6c_response_is_valid(FAR void *handle, FAR const void *buf,
                                     ssize_t len,
                                     const uint8_t transaction[3],
                                     enum dhcpv6_msg_e type)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  FAR const struct dhcpv6_header_s *rep = buf;
  FAR uint8_t *ite;
  FAR uint8_t *end;
  FAR uint8_t *odata;
  uint16_t otype;
  uint16_t olen;
  bool clientid_ok = false;
  bool serverid_ok = false;
  size_t client_id_len;
  size_t server_id_len;
  FAR void *client_id;
  FAR void *server_id;

  if (len < sizeof(*rep) ||
      memcmp(rep->tr_id, transaction, sizeof(rep->tr_id)) != 0)
    {
      return false;
    }

  if (type == DHCPV6_MSG_SOLICIT)
    {
      if (rep->msg_type != DHCPV6_MSG_ADVERT &&
          rep->msg_type != DHCPV6_MSG_REPLY)
        {
          return false;
        }
    }
  else if (type == DHCPV6_MSG_UNKNOWN)
    {
      if (!pdhcp6c->accept_reconfig ||
          rep->msg_type != DHCPV6_MSG_RECONF)
        {
          return false;
        }
    }
  else if (rep->msg_type != DHCPV6_MSG_REPLY)
    {
      return false;
    }

  end = ((FAR uint8_t *)buf) + len;
  client_id = dhcp6c_get_state(handle, STATE_CLIENT_ID, &client_id_len);
  server_id = dhcp6c_get_state(handle, STATE_SERVER_ID, &server_id_len);

  dhcpv6_for_each_option(ite, &rep[1], end, otype, olen, odata)
    {
      if (otype == DHCPV6_OPT_CLIENTID)
        {
          clientid_ok = (olen + 4u == client_id_len) &&
                        (memcmp((odata - 4), client_id, client_id_len) == 0);
        }
      else if (otype == DHCPV6_OPT_SERVERID)
        {
          serverid_ok = (olen + 4u == server_id_len) &&
                        (memcmp((odata - 4), server_id, server_id_len) == 0);
        }
    }

  return clientid_ok && (serverid_ok || server_id_len == 0);
}

static int dhcp6c_command(FAR void *handle, enum dhcpv6_msg_e type)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  const int buf_length = 1536;
  FAR uint8_t *buf = (FAR uint8_t *)malloc(buf_length);
  uint32_t timeout = CONFIG_NETUTILS_DHCP6C_REQUEST_TIMEOUT < 3 ? 3 :
                     CONFIG_NETUTILS_DHCP6C_REQUEST_TIMEOUT;
  FAR const struct dhcp6c_retx_s *retx = &g_dhcp6c_retx[type];
  uint64_t start;
  uint64_t round_start;
  uint64_t round_end;
  uint64_t elapsed;
  uint8_t trid[3];
  ssize_t len = -1;
  int64_t rto = 0;

  if (buf == NULL)
    {
      return -1;
    }

  if (retx->delay)
    {
      struct timespec ts;
      ts.tv_sec = 0;
      ts.tv_nsec = dhcp6c_rand_delay(handle, 10 * DHCPV6_REQ_DELAY);
      nanosleep(&ts, NULL);
    }

  if (type == DHCPV6_MSG_RELEASE || type == DHCPV6_MSG_DECLINE)
    {
      timeout = 3;
    }
  else if (type == DHCPV6_MSG_UNKNOWN)
    {
      timeout = pdhcp6c->t1;
    }
  else if (type == DHCPV6_MSG_RENEW)
    {
      timeout = pdhcp6c->t2 - pdhcp6c->t1;
    }
  else if (type == DHCPV6_MSG_REBIND)
    {
      timeout = pdhcp6c->t3 - pdhcp6c->t2;
    }

  if (timeout == 0)
    {
      len = -1;
      goto end;
    }

  ninfo("Sending %s (timeout %u s)\n", retx->name, timeout);
  start = dhcp6c_get_milli_time();
  round_start = start;

  /* Generate transaction ID */

  read(pdhcp6c->urandom_fd, trid, sizeof(trid));

  do
    {
      rto = (rto == 0) ? (retx->init_timeo * MSEC_PER_SEC +
              dhcp6c_rand_delay(handle, retx->init_timeo * MSEC_PER_SEC)) :
              (2 * rto + dhcp6c_rand_delay(handle, rto));

      if (rto >= retx->max_timeo * MSEC_PER_SEC)
        {
          rto = retx->max_timeo * MSEC_PER_SEC +
                dhcp6c_rand_delay(handle, retx->max_timeo * MSEC_PER_SEC);
        }

      /* Calculate end for this round and elapsed time */

      round_end = round_start + rto;
      elapsed = round_start - start;

      /* Don't wait too long */

      if (round_end - start > timeout * MSEC_PER_SEC)
        {
          round_end = timeout * MSEC_PER_SEC + start;
        }

      /* Built and send package */

      if (type != DHCPV6_MSG_UNKNOWN)
        {
          dhcp6c_send(handle, type, trid, elapsed / 10);
        }

      /* Receive rounds */

      for (; len < 0 && round_start < round_end;
              round_start = dhcp6c_get_milli_time())
        {
          /* Set timeout for receiving */

          uint64_t t = round_end - round_start;
          struct timeval retime =
          {
            t / MSEC_PER_SEC, (t % MSEC_PER_SEC) * MSEC_PER_SEC
          };

          /* check for dhcp6c_close */

          if (pdhcp6c->cancel)
            {
              len = -1;
              goto end;
            }

          setsockopt(pdhcp6c->sockfd, SOL_SOCKET, SO_RCVTIMEO,
                     &retime, sizeof(retime));

          /* Receive cycle */

          len = recv(pdhcp6c->sockfd, buf, buf_length, 0);
          if (type != DHCPV6_MSG_UNKNOWN)
            {
              ninfo("%s[type:%d] recv len[%d]\n", __func__, type, len);
            }

          if (!dhcp6c_response_is_valid(handle, buf, len, trid, type))
            {
              len = -1;
            }

          if (len > 0)
            {
              FAR uint8_t *opt = &buf[4];
              FAR uint8_t *opt_end = opt + len - 4;

              round_start = dhcp6c_get_milli_time();
              elapsed = round_start - start;
              ninfo("Got a valid reply after %ums\n", (unsigned)elapsed);

              if (retx->handler_reply != NULL)
                {
                  len = retx->handler_reply(handle, type, opt,
                                            opt_end, elapsed / MSEC_PER_SEC);
                }
            }
        }

      if (retx->handler_finish != NULL)
        {
          len = retx->handler_finish(handle, elapsed / MSEC_PER_SEC);
        }
    }
  while (len < 0 && elapsed / MSEC_PER_SEC < timeout);

end:
  free(buf);
  return len;
}

static int dhcp6c_poll_reconfigure(FAR void *handle)
{
  int ret = dhcp6c_command(handle, DHCPV6_MSG_UNKNOWN);
  if (ret != -1)
    {
      ret = dhcp6c_command(handle, ret);
    }

  return ret;
}

/* Collect all advertised servers */

static int dhcp6c_handle_advert(FAR void *handle, enum dhcpv6_msg_e orig,
                                FAR const void *opt, FAR const void *end,
                                uint32_t elapsed)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  uint16_t olen;
  uint16_t otype;
  FAR uint8_t *ite0;
  FAR uint8_t *odata;
  struct dhcpv6_server_cand_s cand;

  memset(&cand, 0, sizeof(cand));
  dhcpv6_for_each_option(ite0, opt, end, otype, olen, odata)
    {
      if (otype == DHCPV6_OPT_SERVERID && olen <= 130)
        {
          memcpy(cand.duid, odata, olen);
          cand.duid_len = olen;
        }
      else if (otype == DHCPV6_OPT_STATUS && olen >= 2 && !odata[0]
               && odata[1] == DHCPV6_NOADDRSAVAIL)
        {
          if (pdhcp6c->ia_mode == IA_MODE_FORCE)
            {
              return -1;
            }
          else
            {
              cand.has_noaddravail = true;
              cand.preference -= 1000;
            }
        }
      else if (otype == DHCPV6_OPT_STATUS && olen >= 2 && !odata[0]
               && odata[1] == DHCPV6_NOPREFIXAVAIL)
        {
          cand.preference -= 2000;
        }
      else if (otype == DHCPV6_OPT_PREF && olen >= 1 &&
               cand.preference >= 0)
        {
          cand.preference = odata[1];
        }
      else if (otype == DHCPV6_OPT_RECONF_ACCEPT)
        {
          cand.wants_reconfigure = true;
        }
      else if (otype == DHCPV6_OPT_IA_PD && pdhcp6c->request_prefix)
        {
          FAR struct dhcpv6_ia_hdr_s *h = (FAR void *)odata;
          FAR uint8_t *oend = odata + olen;
          FAR uint8_t *ite1;
          FAR uint8_t *d;

          dhcpv6_for_each_option(ite1, &h[1], oend, otype, olen, d)
            {
              if (otype == DHCPV6_OPT_IA_PREFIX)
                {
                  cand.preference += 2000;
                }
              else if (otype == DHCPV6_OPT_STATUS &&
                       olen >= 2 && d[0] == 0 &&
                       d[1] == DHCPV6_NOPREFIXAVAIL)
                {
                  cand.preference -= 2000;
                }
            }
        }
    }

  if (cand.duid_len > 0)
    {
      dhcp6c_add_state(handle, STATE_SERVER_CAND, &cand, sizeof(cand));
    }

  return 0;
}

static int dhcp6c_commit_advert(FAR void *handle, uint32_t elapsed)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  size_t cand_len;
  FAR struct dhcpv6_server_cand_s *c = NULL;
  FAR struct dhcpv6_server_cand_s *cand = dhcp6c_get_state(handle,
                                                           STATE_SERVER_CAND,
                                                           &cand_len);
  bool retry = false;

  for (size_t i = 0; i < cand_len / sizeof(*c); ++i)
    {
      if (cand[i].has_noaddravail)
        {
          retry = true;
        }

      if (c == NULL || c->preference < cand[i].preference)
        {
          c = &cand[i];
        }
    }

  if (retry && pdhcp6c->ia_mode == IA_MODE_TRY)
    {
      /* We give it a second try without the IA_NA */

      pdhcp6c->ia_mode = IA_MODE_NONE;
      return dhcp6c_command(handle, DHCPV6_MSG_SOLICIT);
    }

  if (c != NULL)
    {
      uint16_t hdr[2] =
      {
        htons(DHCPV6_OPT_SERVERID), htons(c->duid_len)
      };

      dhcp6c_add_state(handle, STATE_SERVER_ID, hdr, sizeof(hdr));
      dhcp6c_add_state(handle, STATE_SERVER_ID, c->duid, c->duid_len);
      pdhcp6c->accept_reconfig = c->wants_reconfigure;
    }

  dhcp6c_clear_state(handle, STATE_SERVER_CAND);

  if (c == NULL)
    {
      return -1;
    }
  else if (pdhcp6c->request_prefix || pdhcp6c->ia_mode != IA_MODE_NONE)
    {
      return DHCPV6_STATEFUL;
    }
  else
    {
      return DHCPV6_STATELESS;
    }
}

static time_t dhcp6c_parse_ia(FAR void *handle, FAR void *opt, FAR void *end)
{
  uint32_t timeout = UINT32_MAX;
  uint16_t otype;
  uint16_t olen;
  uint16_t stype;
  uint16_t slen;
  FAR uint8_t *ite0;
  FAR uint8_t *odata;
  FAR uint8_t *sdata;

  /* Update address IA */

  dhcpv6_for_each_option(ite0, opt, end, otype, olen, odata)
    {
      if (otype == DHCPV6_OPT_IA_PREFIX)
        {
          FAR struct dhcpv6_ia_prefix_s *prefix = (FAR void *)(odata - 4);
          FAR struct dhcpv6_ia_prefix_s *local = NULL;
          uint32_t valid;
          uint32_t pref;
          size_t pd_len;
          FAR uint8_t *pd;
          FAR uint8_t *ite1;

          if (olen + 4u < sizeof(*prefix))
            {
              continue;
            }

          olen = sizeof(*prefix);
          valid = ntohl(prefix->valid);
          pref = ntohl(prefix->preferred);

          if (pref > valid)
            {
              continue;
            }

          /* Search matching IA */

          pd = dhcp6c_get_state(handle, STATE_IA_PD, &pd_len);
          dhcpv6_for_each_option(ite1, pd, pd + pd_len,
                                 stype, slen, sdata)
            {
              if (memcmp(sdata + 8, odata + 8,
                         sizeof(local->addr) + 1) == 0)
                {
                  local = (FAR void *)(sdata - 4);
                }
            }

          if (local != NULL)
            {
              local->preferred = prefix->preferred;
              local->valid = prefix->valid;
            }
          else
            {
              dhcp6c_add_state(handle, STATE_IA_PD, prefix, olen);
            }

          if (timeout > valid)
            {
              timeout = valid;
            }
        }
      else if (otype == DHCPV6_OPT_IA_ADDR)
        {
          FAR struct dhcpv6_ia_addr_s *addr = (FAR void *)(odata - 4);
          FAR struct dhcpv6_ia_addr_s *local = NULL;
          uint32_t pref;
          uint32_t valid;
          size_t na_len;
          FAR uint8_t *na;
          FAR uint8_t *ite1;

          if (olen + 4u < sizeof(*addr))
            {
              continue;
            }

          olen = sizeof(*addr);
          pref = ntohl(addr->preferred);
          valid = ntohl(addr->valid);

          if (pref > valid)
            {
              continue;
            }

          /* Search matching IA */

          na = dhcp6c_get_state(handle, STATE_IA_NA, &na_len);
          dhcpv6_for_each_option(ite1, na, na + na_len,
                                 stype, slen, sdata)
            {
              if (memcmp(sdata, odata, sizeof(local->addr)) == 0)
                {
                  local = (FAR void *)(sdata - 4);
                }
            }

          if (local != NULL)
            {
              local->preferred = addr->preferred;
              local->valid = addr->valid;
            }
          else
            {
              dhcp6c_add_state(handle, STATE_IA_NA, addr, olen);
            }

          if (timeout > valid)
            {
              timeout = valid;
            }
        }
    }

  return timeout;
}

static int dhcp6c_handle_reply(FAR void *handle, enum dhcpv6_msg_e orig,
                               FAR const void *opt, FAR const void *end,
                               uint32_t elapsed)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  uint16_t otype;
  uint16_t olen;
  FAR uint8_t *ite0;
  FAR uint8_t *odata;
  bool have_update = false;
  size_t ia_na_len;
  size_t ia_pd_len;
  size_t dns_len;
  size_t search_len;
  size_t sntp_ip_len;
  size_t sntp_dns_len;
  size_t sip_ip_len;
  size_t sip_fqdn_len;
  FAR uint8_t *ia_na = dhcp6c_get_state(handle, STATE_IA_NA, &ia_na_len);
  FAR uint8_t *ia_pd = dhcp6c_get_state(handle, STATE_IA_PD, &ia_pd_len);
  FAR uint8_t *ia_end;
  pdhcp6c->t1 = UINT32_MAX;
  pdhcp6c->t2 = UINT32_MAX;
  pdhcp6c->t3 = UINT32_MAX;

  dhcp6c_get_state(handle, STATE_DNS, &dns_len);
  dhcp6c_get_state(handle, STATE_SEARCH, &search_len);
  dhcp6c_get_state(handle, STATE_SNTP_IP, &sntp_ip_len);
  dhcp6c_get_state(handle, STATE_SNTP_FQDN, &sntp_dns_len);
  dhcp6c_get_state(handle, STATE_SIP_IP, &sip_ip_len);
  dhcp6c_get_state(handle, STATE_SIP_FQDN, &sip_fqdn_len);

  /* Decrease valid and preferred lifetime of prefixes */

  dhcpv6_for_each_option(ite0, ia_pd, ia_pd + ia_pd_len, otype, olen, odata)
    {
      FAR struct dhcpv6_ia_prefix_s *p = (FAR void *)(odata - 4);
      uint32_t valid = ntohl(p->valid);
      uint32_t pref = ntohl(p->preferred);

      if (valid != UINT32_MAX)
        {
          p->valid = (valid < elapsed) ? 0 : htonl(valid - elapsed);
        }

      if (pref != UINT32_MAX)
        {
          p->preferred = (pref < elapsed) ? 0 : htonl(pref - elapsed);
        }
    }

  /* Decrease valid and preferred lifetime of addresses */

  dhcpv6_for_each_option(ite0, ia_na, ia_na + ia_na_len, otype, olen, odata)
    {
      FAR struct dhcpv6_ia_addr_s *p = (FAR void *)(odata - 4);
      uint32_t valid = ntohl(p->valid);
      uint32_t pref = ntohl(p->preferred);

      if (valid != UINT32_MAX)
        {
          p->valid = (valid < elapsed) ? 0 : htonl(valid - elapsed);
        }

      if (pref != UINT32_MAX)
        {
          p->preferred = (pref < elapsed) ? 0 : htonl(pref - elapsed);
        }
    }

  /* Parse and find all matching IAs */

  dhcpv6_for_each_option(ite0, opt, end, otype, olen, odata)
    {
      if ((otype == DHCPV6_OPT_IA_PD || otype == DHCPV6_OPT_IA_NA)
           && olen > sizeof(struct dhcpv6_ia_hdr_s))
        {
          FAR struct dhcpv6_ia_hdr_s *ia_hdr = (FAR void *)(odata - 4);
          time_t l_t1 = ntohl(ia_hdr->t1);
          time_t l_t2 = ntohl(ia_hdr->t2);
          uint16_t stype;
          uint16_t slen;
          FAR uint8_t *ite1;
          FAR uint8_t *sdata;
          time_t n;

          /* Test ID and T1-T2 validity */

          if (ia_hdr->iaid != 1 || l_t2 < l_t1)
            {
              continue;
            }

          /* Test status and bail if error */

          dhcpv6_for_each_option(ite1, &ia_hdr[1], odata + olen,
                                 stype, slen, sdata)
            {
              if (stype == DHCPV6_OPT_STATUS && slen >= 2 &&
                  (sdata[0] || sdata[1]))
                {
                  continue;
                }
            }

          /* Update times */

          if (l_t1 > 0 && pdhcp6c->t1 > l_t1)
            {
              pdhcp6c->t1 = l_t1;
            }

          if (l_t2 > 0 && pdhcp6c->t2 > l_t2)
            {
              pdhcp6c->t2 = l_t2;
            }

          /* Always report update in case we have IA_PDs so that
           * the state-script is called with updated times
           */

          if (otype == DHCPV6_OPT_IA_PD && pdhcp6c->request_prefix)
            {
              have_update = true;
            }

          n = dhcp6c_parse_ia(handle, &ia_hdr[1], odata + olen);
          if (n < pdhcp6c->t1)
            {
              pdhcp6c->t1 = n;
            }

          if (n < pdhcp6c->t2)
            {
              pdhcp6c->t2 = n;
            }

          if (n < pdhcp6c->t3)
            {
              pdhcp6c->t3 = n;
            }
        }
      else if (otype == DHCPV6_OPT_DNS_SERVERS)
        {
          if (olen % 16 == 0)
            {
              dhcp6c_add_state(handle, STATE_DNS, odata, olen);
            }
        }
      else if (otype == DHCPV6_OPT_DNS_DOMAIN)
        {
          dhcp6c_add_state(handle, STATE_SEARCH, odata, olen);
        }
      else if (otype == DHCPV6_OPT_NTP_SERVER)
        {
          uint16_t stype;
          uint16_t slen;
          FAR uint8_t *sdata;
          FAR uint8_t *ite1;

          /* Test status and bail if error */

          dhcpv6_for_each_option(ite1, odata, odata + olen,
                                 stype, slen, sdata)
            {
              if (slen == 16 &&
                  (stype == NTP_MC_ADDR || stype == NTP_SRV_ADDR))
                {
                  dhcp6c_add_state(handle, STATE_SNTP_IP, sdata, slen);
                }
              else if (slen > 0 && stype == NTP_SRV_FQDN)
                {
                  dhcp6c_add_state(handle, STATE_SNTP_FQDN, sdata, slen);
                }
            }
        }
      else if (otype == DHCPV6_OPT_SIP_SERVER_A)
        {
          if (olen == 16)
            {
              dhcp6c_add_state(handle, STATE_SIP_IP, odata, olen);
            }
        }
      else if (otype == DHCPV6_OPT_SIP_SERVER_D)
        {
          dhcp6c_add_state(handle, STATE_SIP_FQDN, odata, olen);
        }
      else if (otype == DHCPV6_OPT_INFO_REFRESH && olen >= 4)
        {
          uint32_t refresh = ntohl(*((FAR uint32_t *)odata));
          if (refresh < (uint32_t)pdhcp6c->t1)
            {
              pdhcp6c->t1 = refresh;
            }
        }
      else if (otype != DHCPV6_OPT_CLIENTID && otype != DHCPV6_OPT_SERVERID)
        {
          dhcp6c_add_state(handle, STATE_CUSTOM_OPTS, (odata - 4), olen + 4);
        }
    }

  if (opt != NULL)
    {
      size_t new_ia_pd_len;
      size_t new_ia_na_len;
      have_update |= dhcp6c_commit_state(handle, STATE_DNS, dns_len);
      have_update |= dhcp6c_commit_state(handle, STATE_SEARCH, search_len);
      have_update |= dhcp6c_commit_state(handle, STATE_SNTP_IP,
                                         sntp_ip_len);
      have_update |= dhcp6c_commit_state(handle, STATE_SNTP_FQDN,
                                         sntp_dns_len);
      have_update |= dhcp6c_commit_state(handle, STATE_SIP_IP, sip_ip_len);
      have_update |= dhcp6c_commit_state(handle, STATE_SIP_FQDN,
                                         sip_fqdn_len);
      dhcp6c_get_state(handle, STATE_IA_PD, &new_ia_pd_len);
      dhcp6c_get_state(handle, STATE_IA_NA, &new_ia_na_len);
      have_update |= (new_ia_pd_len != ia_pd_len) ||
                     (new_ia_na_len != ia_na_len);
    }

  /* Delete prefixes with 0 valid-time */

  ia_pd = dhcp6c_get_state(handle, STATE_IA_PD, &ia_pd_len);
  ia_end = ia_pd + ia_pd_len;
  dhcpv6_for_each_option(ite0, ia_pd, ia_end, otype, olen, odata)
    {
      FAR struct dhcpv6_ia_prefix_s *p = (FAR void *)(odata - 4);
      while (!p->valid)
        {
          ia_end = ia_pd + dhcp6c_remove_state(handle, STATE_IA_PD,
                   (FAR uint8_t *)p - ia_pd, olen + 4);
          have_update = true;
        }
    }

  /* Delete addresses with 0 valid-time */

  ia_na = dhcp6c_get_state(handle, STATE_IA_NA, &ia_na_len);
  ia_end = ia_na + ia_na_len;
  dhcpv6_for_each_option(ite0, ia_na, ia_end, otype, olen, odata)
    {
      FAR struct dhcpv6_ia_addr_s *p = (FAR void *)(odata - 4);
      while (!p->valid)
        {
          ia_end = ia_na + dhcp6c_remove_state(handle, STATE_IA_NA,
                   (FAR uint8_t *)p - ia_na, olen + 4);
          have_update = true;
        }
    }

  return have_update;
}

static int dhcp6c_handle_reconfigure(FAR void *handle,
                                     enum dhcpv6_msg_e orig,
                                     FAR const void *opt,
                                     FAR const void *end,
                                     uint32_t elapsed)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  uint16_t otype;
  uint16_t olen;
  FAR uint8_t *odata;
  FAR uint8_t *ite;
  uint8_t msg = DHCPV6_MSG_RENEW;

  /* TODO: should verify the reconfigure message */

  dhcpv6_for_each_option(ite, opt, end, otype, olen, odata)
    {
      if (otype == DHCPV6_OPT_RECONF_MESSAGE && olen == 1 &&
          (odata[0] == DHCPV6_MSG_RENEW ||
           odata[0] == DHCPV6_MSG_INFO_REQ))
        {
          msg = odata[0];
        }
    }

  pdhcp6c->t1 -= elapsed;
  pdhcp6c->t2 -= elapsed;
  pdhcp6c->t3 -= elapsed;

  if (pdhcp6c->t1 < 0)
    {
      pdhcp6c->t1 = 0;
    }

  if (pdhcp6c->t2 < 0)
    {
      pdhcp6c->t2 = 0;
    }

  if (pdhcp6c->t3 < 0)
    {
      pdhcp6c->t3 = 0;
    }

  dhcp6c_handle_reply(handle, DHCPV6_MSG_UNKNOWN, NULL, NULL, elapsed);

  return msg;
}

static int dhcp6c_handle_rebind_reply(FAR void *handle,
                                      enum dhcpv6_msg_e orig,
                                      FAR const void *opt,
                                      FAR const void *end,
                                      uint32_t elapsed)
{
  dhcp6c_handle_advert(handle, orig, opt, end, elapsed);
  if (dhcp6c_commit_advert(handle, elapsed) < 0)
    {
      return -1;
    }

  return dhcp6c_handle_reply(handle, orig, opt, end, elapsed);
}

static int dhcp6c_single_request(FAR void *args)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)args;
  FAR const char *process = NULL;
  enum dhcpv6_mode_e mode;
  enum dhcpv6_msg_e type;
  int ret = -1;

  dhcp6c_clear_state(pdhcp6c, STATE_SERVER_ID);
  dhcp6c_clear_state(pdhcp6c, STATE_SERVER_CAND);
  dhcp6c_clear_state(pdhcp6c, STATE_IA_PD);
  dhcp6c_clear_state(pdhcp6c, STATE_SNTP_IP);
  dhcp6c_clear_state(pdhcp6c, STATE_SNTP_FQDN);
  dhcp6c_clear_state(pdhcp6c, STATE_SIP_IP);
  dhcp6c_clear_state(pdhcp6c, STATE_SIP_FQDN);
  dhcp6c_clear_state(pdhcp6c, STATE_CUSTOM_OPTS);
  ret = dhcp6c_command(pdhcp6c, DHCPV6_MSG_SOLICIT);
  if (ret < 0)
    {
      return -1;
    }
  else if (ret == DHCPV6_STATELESS)
    {
      mode = DHCPV6_STATELESS;
      type = DHCPV6_MSG_INFO_REQ;
      process = "informed";
    }
  else
    {
      mode = DHCPV6_STATEFUL;
      type = DHCPV6_MSG_REQUEST;
      process = "bound";
    }

  ret = dhcp6c_command(pdhcp6c, type);
  if (ret >= 0)
    {
      ret = mode;
      dhcp6c_switch_process(pdhcp6c, process);
    }

  return ret;
}

static int dhcp6c_lease(FAR void *args, uint8_t type)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)args;
  enum dhcpv6_mode_e mode = (enum dhcpv6_mode_e)type;
  size_t ia_pd_len;
  size_t ia_na_len;
  size_t ia_pd_new;
  size_t ia_na_new;
  size_t server_id_len;
  int ret = -1;

  if (mode == DHCPV6_STATELESS)
    {
      /* Stateless mode */

      while (!pdhcp6c->cancel)
        {
          /* Wait for T1 to expire or until we get a reconfigure */

          ret = dhcp6c_poll_reconfigure(pdhcp6c);
          if (ret >= 0)
            {
              dhcp6c_switch_process(pdhcp6c, "informed");
            }

          if (pdhcp6c->cancel)
            {
              break;
            }

          /* Information-Request */

          ret = dhcp6c_command(pdhcp6c, DHCPV6_MSG_INFO_REQ);
          if (ret < 0)
            {
              nerr("DHCPV6_MSG_INFO_REQ error\n");
              break;
            }
          else
            {
              dhcp6c_switch_process(pdhcp6c, "informed");
            }
        }
    }
  else
    {
      /* Stateful mode */

      while (!pdhcp6c->cancel)
        {
          /* Renew Cycle
           * Wait for T1 to expire or until we get a reconfigure
           */

          ret = dhcp6c_poll_reconfigure(pdhcp6c);
          if (ret >= 0)
            {
              dhcp6c_switch_process(pdhcp6c, "updated");
            }

          if (pdhcp6c->cancel)
            {
              break;
            }

          dhcp6c_get_state(pdhcp6c, STATE_IA_PD, &ia_pd_len);
          dhcp6c_get_state(pdhcp6c, STATE_IA_NA, &ia_na_len);

          /* If we have any IAs, send renew, otherwise request */

          if (ia_pd_len == 0 && ia_na_len == 0)
            ret = dhcp6c_command(pdhcp6c, DHCPV6_MSG_REQUEST);
          else
            ret = dhcp6c_command(pdhcp6c, DHCPV6_MSG_RENEW);

          if (pdhcp6c->cancel)
            {
              break;
            }

          if (ret >= 0)
            {
              /* Publish updates */

              dhcp6c_switch_process(pdhcp6c, "updated");
            }
          else
            {
              /* Remove binding */

              dhcp6c_clear_state(pdhcp6c, STATE_SERVER_ID);

              /* If we have IAs, try rebind otherwise restart */

              ret = dhcp6c_command(pdhcp6c, DHCPV6_MSG_REBIND);
              dhcp6c_get_state(pdhcp6c, STATE_IA_PD, &ia_pd_new);
              dhcp6c_get_state(pdhcp6c, STATE_IA_NA, &ia_na_new);

              /* We lost all our IAs, restart */

              if (ret < 0 || (ia_pd_new == 0 && ia_pd_len) ||
                  (ia_na_new == 0 && ia_na_len))
                {
                  break;
                }
              else if (ret >= 0)
                {
                  dhcp6c_switch_process(pdhcp6c, "rebound");
                }
            }
        }
    }

  dhcp6c_get_state(pdhcp6c, STATE_IA_PD, &ia_pd_len);
  dhcp6c_get_state(pdhcp6c, STATE_IA_NA, &ia_na_len);
  dhcp6c_get_state(pdhcp6c, STATE_SERVER_ID, &server_id_len);

  /* Add all prefixes to lost prefixes */

  dhcp6c_clear_state(pdhcp6c, STATE_IA_PD);
  dhcp6c_switch_process(pdhcp6c, "unbound");

  /* Remove assigned addresses */

  if (ia_na_len > 0)
    {
      dhcp6c_remove_addrs(pdhcp6c);
    }

  if (server_id_len > 0 && (ia_pd_len > 0 || ia_na_len > 0))
    {
      dhcp6c_command(pdhcp6c, DHCPV6_MSG_RELEASE);
    }

  return ret;
}

static FAR void *dhcp6c_run(FAR void *args)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)args;
  int ret;

  while (!pdhcp6c->cancel)
    {
      ret = dhcp6c_single_request(pdhcp6c);
      if (ret > 0)
        {
          dhcp6c_lease(pdhcp6c, ret);
        }
    }

  return 0;
}

static FAR void *dhcp6c_precise_open(FAR const char *ifname,
                                     enum dhcp6c_ia_mode_e ia_mode,
                                     bool request_pd,
                                     uint16_t opt[], int cnt)
{
  FAR struct dhcp6c_state_s *pdhcp6c;
  struct sockaddr_in6 client_addr;
  struct ifreq ifr;
  size_t client_id_len;
  int val = 1;
  uint16_t oro[] =
  {
    htons(DHCPV6_OPT_DNS_SERVERS),
    htons(DHCPV6_OPT_DNS_DOMAIN),
    htons(DHCPV6_OPT_NTP_SERVER),
    htons(DHCPV6_OPT_SIP_SERVER_A),
    htons(DHCPV6_OPT_SIP_SERVER_D)
  };

  pdhcp6c = malloc(sizeof(struct dhcp6c_state_s));
  if (pdhcp6c == NULL)
    {
      return NULL;
    }

  memset(pdhcp6c, 0, sizeof(*pdhcp6c));
  pdhcp6c->urandom_fd = open("/dev/urandom", O_CLOEXEC | O_RDONLY);
  if (pdhcp6c->urandom_fd < 0)
    {
      free(pdhcp6c);
      return NULL;
    }

  pdhcp6c->sockfd = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
  if (pdhcp6c->sockfd < 0)
    {
      close(pdhcp6c->urandom_fd);
      free(pdhcp6c);
      return NULL;
    }

  /* Detect interface */

  strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
  if (ioctl(pdhcp6c->sockfd, SIOCGIFINDEX, &ifr))
    {
      close(pdhcp6c->urandom_fd);
      close(pdhcp6c->sockfd);
      free(pdhcp6c);
      return NULL;
    }

  pdhcp6c->ifindex = ifr.ifr_ifindex;

  /* Create client DUID */

  dhcp6c_get_state(pdhcp6c, STATE_CLIENT_ID, &client_id_len);
  if (client_id_len == 0)
    {
      uint8_t duid[14] =
      {
        0, DHCPV6_OPT_CLIENTID, 0, 10, 0,
        DHCPV6_DUID_LLADDR, 0, 1
      };

      uint8_t zero[ETHER_ADDR_LEN];
      struct ifreq ifs[100];
      FAR struct ifreq *ifp;
      FAR struct ifreq *ifend;
      struct ifconf ifc;

      ioctl(pdhcp6c->sockfd, SIOCGIFHWADDR, &ifr);
      memcpy(&duid[8], ifr.ifr_hwaddr.sa_data, ETHER_ADDR_LEN);
      memset(zero, 0, sizeof(zero));
      ifc.ifc_req = ifs;
      ifc.ifc_len = sizeof(ifs);

      if (memcmp(&duid[8], zero, ETHER_ADDR_LEN) == 0 &&
          ioctl(pdhcp6c->sockfd, SIOCGIFCONF, &ifc) >= 0)
        {
          /* If our interface doesn't have an address... */

          ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
          for (ifp = ifc.ifc_req; ifp < ifend &&
               memcmp(&duid[8], zero, 6) == 0; ifp++)
            {
              memcpy(ifr.ifr_name, ifp->ifr_name,
                     sizeof(ifr.ifr_name));
              ioctl(pdhcp6c->sockfd, SIOCGIFHWADDR, &ifr);
              memcpy(&duid[8], ifr.ifr_hwaddr.sa_data,
                     ETHER_ADDR_LEN);
            }
        }

      dhcp6c_add_state(pdhcp6c, STATE_CLIENT_ID, duid, sizeof(duid));
    }

  /* Create ORO */

  dhcp6c_add_state(pdhcp6c, STATE_ORO, oro, sizeof(oro));

  /* Configure IPv6-options */

  setsockopt(pdhcp6c->sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val));
  setsockopt(pdhcp6c->sockfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
  setsockopt(pdhcp6c->sockfd, SOL_SOCKET, SO_BINDTODEVICE, ifname,
             strlen(ifname));

  memset(&client_addr, 0, sizeof(client_addr));
  client_addr.sin6_family = AF_INET6;
  client_addr.sin6_port = htons(DHCPV6_CLIENT_PORT);

  if (bind(pdhcp6c->sockfd, (struct sockaddr *)&client_addr,
           sizeof(client_addr)) != 0)
    {
      close(pdhcp6c->urandom_fd);
      close(pdhcp6c->sockfd);
      free(pdhcp6c);
      return NULL;
    }

  pdhcp6c->thread = 0;
  pdhcp6c->cancel = false;
  pdhcp6c->t1 = 0;
  pdhcp6c->t2 = 0;
  pdhcp6c->t3 = 0;
  pdhcp6c->request_prefix = request_pd;
  switch (ia_mode)
    {
      case IA_MODE_NONE:
      case IA_MODE_TRY:
      case IA_MODE_FORCE:
        break;
      default:
        ia_mode = IA_MODE_TRY;
        break;
    }

  pdhcp6c->ia_mode = ia_mode;
  pdhcp6c->accept_reconfig = false;
  if (opt != NULL && cnt > 0)
    {
      uint16_t opttype;
      for (int i = 0; i < cnt; i++)
        {
          opttype = htons(opt[i]);
          dhcp6c_add_state(pdhcp6c, STATE_ORO, &opttype, 2);
        }
    }

  return pdhcp6c;
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

FAR void *dhcp6c_open(FAR const char *interface)
{
  return dhcp6c_precise_open(interface, IA_MODE_TRY, true, NULL, 0);
}

int dhcp6c_request(FAR void *handle, FAR struct dhcp6c_state *presult)
{
  int ret;

  if (handle == NULL)
    {
      return ERROR;
    }

  ret = dhcp6c_single_request(handle);
  if (ret >= 0)
    {
      dhcp6c_get_result(handle, presult);
      return OK;
    }
  else
    {
      return ERROR;
    }
}

int dhcp6c_request_async(FAR void *handle, dhcp6c_callback_t callback)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  int ret;

  if (handle == NULL)
    {
      return ERROR;
    }

  if (pdhcp6c->thread)
    {
      nerr("DHCP6C thread already running\n");
      return ERROR;
    }

  pdhcp6c->callback = callback;
  ret = pthread_create(&pdhcp6c->thread, NULL, dhcp6c_run, pdhcp6c);
  if (ret != 0)
    {
      nerr("Failed to start the DHCP6C thread\n");
      return ERROR;
    }

  return OK;
}

void dhcp6c_cancel(FAR void *handle)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;
  sighandler_t old;
  int ret;

  if (pdhcp6c != NULL)
    {
      pdhcp6c->cancel = true;
      if (pdhcp6c->thread)
        {
          old = signal(SIGQUIT, SIG_IGN);

          /* Signal the dhcp6c_run */

          ret = pthread_kill(pdhcp6c->thread, SIGQUIT);
          if (ret != 0)
            {
              nerr("pthread_kill DHCP6C thread\n");
            }

          /* Wait for the end of dhcp6c_run */

          ret = pthread_join(pdhcp6c->thread, NULL);
          if (ret != 0)
            {
              nerr("pthread_join DHCP6C thread\n");
            }

          pdhcp6c->thread = 0;
          signal(SIGQUIT, old);
        }
    }
}

void dhcp6c_close(FAR void *handle)
{
  FAR struct dhcp6c_state_s *pdhcp6c = (FAR struct dhcp6c_state_s *)handle;

  if (pdhcp6c != NULL)
    {
      dhcp6c_cancel(pdhcp6c);
      if (pdhcp6c->urandom_fd > 0)
        {
          close(pdhcp6c->urandom_fd);
        }

      if (pdhcp6c->sockfd > 0)
        {
          close(pdhcp6c->sockfd);
        }

      for (int i = 0; i < STATE_MAX; i++)
        {
          if (pdhcp6c->state_data[i] != NULL)
            {
              free(pdhcp6c->state_data[i]);
            }
        }

      free(pdhcp6c);
    }
}