#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include "lookup.h"
#include "stdio_impl.h"
#include "syscall.h"

static int is_valid_hostname(const char* host) {
  const unsigned char* s;
  if (strnlen(host, 255) - 1 >= 254 || mbstowcs(0, host, 0) == -1)
    return 0;
  for (s = (void*)host; *s >= 0x80 || *s == '.' || *s == '-' || isalnum(*s);
       s++)
    ;
  return !*s;
}

static int name_from_null(struct address buf[static 2],
                          const char* name,
                          int family,
                          int flags) {
  int cnt = 0;
  if (name)
    return 0;
  if (flags & AI_PASSIVE) {
    if (family != AF_INET6)
      buf[cnt++] = (struct address){.family = AF_INET};
    if (family != AF_INET)
      buf[cnt++] = (struct address){.family = AF_INET6};
  } else {
    if (family != AF_INET6)
      buf[cnt++] = (struct address){.family = AF_INET, .addr = {127, 0, 0, 1}};
    if (family != AF_INET)
      buf[cnt++] = (struct address){.family = AF_INET6, .addr = {[15] = 1}};
  }
  return cnt;
}

static int name_from_numeric(struct address buf[static 1],
                             const char* name,
                             int family) {
  return __lookup_ipliteral(buf, name, family);
}

static int name_from_hosts(struct address buf[static MAXADDRS],
                           char canon[static 256],
                           const char* name,
                           int family) {
  char line[512];
  size_t l = strlen(name);
  int cnt = 0;
  unsigned char _buf[1032];
  FILE _f, *f = __fopen_rb_ca("/etc/hosts", &_f, _buf, sizeof _buf);
  if (!f)
    switch (errno) {
      case ENOENT:
      case ENOTDIR:
      case EACCES:
        return 0;
      default:
        return EAI_SYSTEM;
    }
  while (fgets(line, sizeof line, f) && cnt < MAXADDRS) {
    char *p, *z;

    if ((p = strchr(line, '#')))
      *p++ = '\n', *p = 0;
    for (p = line + 1;
         (p = strstr(p, name)) && (!isspace(p[-1]) || !isspace(p[l])); p++)
      ;
    if (!p)
      continue;

    /* Isolate IP address to parse */
    for (p = line; *p && !isspace(*p); p++)
      ;
    *p++ = 0;
    if (name_from_numeric(buf + cnt, line, family))
      cnt++;

    /* Extract first name as canonical name */
    for (; *p && isspace(*p); p++)
      ;
    for (z = p; *z && !isspace(*z); z++)
      ;
    *z = 0;
    if (is_valid_hostname(p))
      memcpy(canon, p, z - p + 1);
  }
  __fclose_ca(f);
  return cnt;
}

struct dpc_ctx {
  struct address* addrs;
  char* canon;
  int cnt;
};

int __dns_parse(const unsigned char*,
                int,
                int (*)(void*, int, const void*, int, const void*),
                void*);
int __dn_expand(const unsigned char*,
                const unsigned char*,
                const unsigned char*,
                char*,
                int);
int __res_mkquery(int,
                  const char*,
                  int,
                  int,
                  const unsigned char*,
                  int,
                  const unsigned char*,
                  unsigned char*,
                  int);
int __res_msend_rc(int,
                   const unsigned char* const*,
                   const int*,
                   unsigned char* const*,
                   int*,
                   int,
                   const struct resolvconf*);

#define RR_A 1
#define RR_CNAME 5
#define RR_AAAA 28

static int dns_parse_callback(void* c,
                              int rr,
                              const void* data,
                              int len,
                              const void* packet) {
  char tmp[256];
  struct dpc_ctx* ctx = c;
  switch (rr) {
    case RR_A:
      if (len != 4)
        return -1;
      ctx->addrs[ctx->cnt].family = AF_INET;
      ctx->addrs[ctx->cnt].scopeid = 0;
      memcpy(ctx->addrs[ctx->cnt++].addr, data, 4);
      break;
    case RR_AAAA:
      if (len != 16)
        return -1;
      ctx->addrs[ctx->cnt].family = AF_INET6;
      ctx->addrs[ctx->cnt].scopeid = 0;
      memcpy(ctx->addrs[ctx->cnt++].addr, data, 16);
      break;
    case RR_CNAME:
      if (__dn_expand(packet, (const unsigned char*)packet + 512, data, tmp,
                      sizeof tmp) > 0 &&
          is_valid_hostname(tmp))
        strcpy(ctx->canon, tmp);
      break;
  }
  return 0;
}

static int name_from_dns(struct address buf[static MAXADDRS],
                         char canon[static 256],
                         const char* name,
                         int family,
                         const struct resolvconf* conf) {
  unsigned char qbuf[2][280], abuf[2][512];
  const unsigned char* qp[2] = {qbuf[0], qbuf[1]};
  unsigned char* ap[2] = {abuf[0], abuf[1]};
  int qlens[2], alens[2];
  int i, nq = 0;
  struct dpc_ctx ctx = {.addrs = buf, .canon = canon};

  if (family != AF_INET6) {
    qlens[nq] =
        __res_mkquery(0, name, 1, RR_A, 0, 0, 0, qbuf[nq], sizeof *qbuf);
    nq++;
  }
  if (family != AF_INET) {
    qlens[nq] =
        __res_mkquery(0, name, 1, RR_AAAA, 0, 0, 0, qbuf[nq], sizeof *qbuf);
    nq++;
  }

  if (__res_msend_rc(nq, qp, qlens, ap, alens, sizeof *abuf, conf) < 0)
    return EAI_SYSTEM;

  for (i = 0; i < nq; i++)
    __dns_parse(abuf[i], alens[i], dns_parse_callback, &ctx);

  if (ctx.cnt)
    return ctx.cnt;
  if (alens[0] < 4 || (abuf[0][3] & 15) == 2)
    return EAI_AGAIN;
  if ((abuf[0][3] & 15) == 0)
    return EAI_NONAME;
  if ((abuf[0][3] & 15) == 3)
    return 0;
  return EAI_FAIL;
}

static int name_from_dns_search(struct address buf[static MAXADDRS],
                                char canon[static 256],
                                const char* name,
                                int family) {
  char search[256];
  struct resolvconf conf;
  size_t l, dots;
  char *p, *z;

  if (__get_resolv_conf(&conf, search, sizeof search) < 0)
    return -1;

  /* Count dots, suppress search when >=ndots or name ends in
   * a dot, which is an explicit request for global scope. */
  for (dots = l = 0; name[l]; l++)
    if (name[l] == '.')
      dots++;
  if (dots >= conf.ndots || name[l - 1] == '.')
    *search = 0;

  /* This can never happen; the caller already checked length. */
  if (l >= 256)
    return EAI_NONAME;

  /* Name with search domain appended is setup in canon[]. This both
   * provides the desired default canonical name (if the requested
   * name is not a CNAME record) and serves as a buffer for passing
   * the full requested name to name_from_dns. */
  memcpy(canon, name, l);
  canon[l] = '.';

  for (p = search; *p; p = z) {
    for (; isspace(*p); p++)
      ;
    for (z = p; *z && !isspace(*z); z++)
      ;
    if (z == p)
      break;
    if (z - p < 256 - l - 1) {
      memcpy(canon + l + 1, p, z - p);
      canon[z - p + 1 + l] = 0;
      int cnt = name_from_dns(buf, canon, canon, family, &conf);
      if (cnt)
        return cnt;
    }
  }

  canon[l] = 0;
  return name_from_dns(buf, canon, name, family, &conf);
}

static const struct policy {
  unsigned char addr[16];
  unsigned char len, mask;
  unsigned char prec, label;
} defpolicy[] = {
    {"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1", 15, 0xff, 50, 0},
    {"\0\0\0\0\0\0\0\0\0\0\xff\xff", 11, 0xff, 35, 4},
    {"\x20\2", 1, 0xff, 30, 2},
    {"\x20\1", 3, 0xff, 5, 5},
    {"\xfc", 0, 0xfe, 3, 13},
    /* These are deprecated and/or returned to the address
     * pool, so despite the RFC, treating them as special
     * is probably wrong.
     * {"", 11, 0xff, 1, 3},
     * {"\xfe\xc0", 1, 0xc0, 1, 11},
     * {"\x3f\xfe", 1, 0xff, 1, 12},
     * Last rule must match all addresses to stop loop. */
    {"", 0, 0, 40, 1},
};

static const struct policy* policyof(const struct in6_addr* a) {
  int i;
  for (i = 0;; i++) {
    if (memcmp(a->s6_addr, defpolicy[i].addr, defpolicy[i].len))
      continue;
    if ((a->s6_addr[defpolicy[i].len] & defpolicy[i].mask) !=
        defpolicy[i].addr[defpolicy[i].len])
      continue;
    return defpolicy + i;
  }
}

static int labelof(const struct in6_addr* a) {
  return policyof(a)->label;
}

static int scopeof(const struct in6_addr* a) {
  if (IN6_IS_ADDR_MULTICAST(a))
    return a->s6_addr[1] & 15;
  if (IN6_IS_ADDR_LINKLOCAL(a))
    return 2;
  if (IN6_IS_ADDR_LOOPBACK(a))
    return 2;
  if (IN6_IS_ADDR_SITELOCAL(a))
    return 5;
  return 14;
}

static int prefixmatch(const struct in6_addr* s, const struct in6_addr* d) {
  /* FIXME: The common prefix length should be limited to no greater
   * than the nominal length of the prefix portion of the source
   * address. However the definition of the source prefix length is
   * not clear and thus this limiting is not yet implemented. */
  unsigned i;
  for (i = 0;
       i < 128 && !((s->s6_addr[i / 8] ^ d->s6_addr[i / 8]) & (128 >> (i % 8)));
       i++)
    ;
  return i;
}

#define DAS_USABLE 0x40000000
#define DAS_MATCHINGSCOPE 0x20000000
#define DAS_MATCHINGLABEL 0x10000000
#define DAS_PREC_SHIFT 20
#define DAS_SCOPE_SHIFT 16
#define DAS_PREFIX_SHIFT 8
#define DAS_ORDER_SHIFT 0

static int addrcmp(const void* _a, const void* _b) {
  const struct address *a = _a, *b = _b;
  return b->sortkey - a->sortkey;
}

int __lookup_name(struct address buf[static MAXADDRS],
                  char canon[static 256],
                  const char* name,
                  int family,
                  int flags) {
  int cnt = 0, i, j;

  *canon = 0;
  if (name) {
    /* reject empty name and check len so it fits into temp bufs */
    size_t l = strnlen(name, 255);
    if (l - 1 >= 254)
      return EAI_NONAME;
    memcpy(canon, name, l + 1);
  }

  /* Procedurally, a request for v6 addresses with the v4-mapped
   * flag set is like a request for unspecified family, followed
   * by filtering of the results. */
  if (flags & AI_V4MAPPED) {
    if (family == AF_INET6)
      family = AF_UNSPEC;
    else
      flags -= AI_V4MAPPED;
  }

  /* Try each backend until there's at least one result. */
  cnt = name_from_null(buf, name, family, flags);
  if (!cnt)
    cnt = name_from_numeric(buf, name, family);
  if (!cnt && !(flags & AI_NUMERICHOST)) {
    cnt = name_from_hosts(buf, canon, name, family);
    if (!cnt)
      cnt = name_from_dns_search(buf, canon, name, family);
  }
  if (cnt <= 0)
    return cnt ? cnt : EAI_NONAME;

  /* Filter/transform results for v4-mapped lookup, if requested. */
  if (flags & AI_V4MAPPED) {
    if (!(flags & AI_ALL)) {
      /* If any v6 results exist, remove v4 results. */
      for (i = 0; i < cnt && buf[i].family != AF_INET6; i++)
        ;
      if (i < cnt) {
        for (j = 0; i < cnt; i++) {
          if (buf[i].family == AF_INET6)
            buf[j++] = buf[i];
        }
        cnt = i = j;
      }
    }
    /* Translate any remaining v4 results to v6 */
    for (i = 0; i < cnt; i++) {
      if (buf[i].family != AF_INET)
        continue;
      memcpy(buf[i].addr + 12, buf[i].addr, 4);
      memcpy(buf[i].addr, "\0\0\0\0\0\0\0\0\0\0\xff\xff", 12);
      buf[i].family = AF_INET6;
    }
  }

  /* No further processing is needed if there are fewer than 2
   * results or if there are only IPv4 results. */
  if (cnt < 2 || family == AF_INET)
    return cnt;
  for (i = 0; buf[i].family == AF_INET; i++)
    if (i == cnt)
      return cnt;

  int cs;
  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);

  /* The following implements a subset of RFC 3484/6724 destination
   * address selection by generating a single 31-bit sort key for
   * each address. Rules 3, 4, and 7 are omitted for having
   * excessive runtime and code size cost and dubious benefit.
   * So far the label/precedence table cannot be customized. */
  for (i = 0; i < cnt; i++) {
    int key = 0;
    struct sockaddr_in6 sa, da = {.sin6_family = AF_INET6,
                                  .sin6_scope_id = buf[i].scopeid,
                                  .sin6_port = 65535};
    if (buf[i].family == AF_INET6) {
      memcpy(da.sin6_addr.s6_addr, buf[i].addr, 16);
    } else {
      memcpy(da.sin6_addr.s6_addr, "\0\0\0\0\0\0\0\0\0\0\xff\xff", 12);
      memcpy(da.sin6_addr.s6_addr + 12, buf[i].addr, 4);
    }
    const struct policy* dpolicy = policyof(&da.sin6_addr);
    int dscope = scopeof(&da.sin6_addr);
    int dlabel = dpolicy->label;
    int dprec = dpolicy->prec;
    int prefixlen = 0;
    int fd = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
    if (fd >= 0) {
      if (!connect(fd, (void*)&da, sizeof da)) {
        key |= DAS_USABLE;
        if (!getsockname(fd, (void*)&sa, &(socklen_t){sizeof sa})) {
          if (dscope == scopeof(&sa.sin6_addr))
            key |= DAS_MATCHINGSCOPE;
          if (dlabel == labelof(&sa.sin6_addr))
            key |= DAS_MATCHINGLABEL;
          prefixlen = prefixmatch(&sa.sin6_addr, &da.sin6_addr);
        }
      }
      close(fd);
    }
    key |= dprec << DAS_PREC_SHIFT;
    key |= (15 - dscope) << DAS_SCOPE_SHIFT;
    key |= prefixlen << DAS_PREFIX_SHIFT;
    key |= (MAXADDRS - i) << DAS_ORDER_SHIFT;
    buf[i].sortkey = key;
  }
  qsort(buf, cnt, sizeof *buf, addrcmp);

  pthread_setcancelstate(cs, 0);

  return cnt;
}