/*

 * ntp_intres.c - Implements a generic blocking worker child or thread,

 *      initially to provide a nonblocking solution for DNS

 *      name to address lookups available with getaddrinfo().

 *

 * This is a new implementation as of 2009 sharing the filename and

 * very little else with the prior implementation, which used a

 * temporary file to receive a single set of requests from the parent,

 * and a NTP mode 7 authenticated request to push back responses.

 *

 * A primary goal in rewriting this code was the need to support the

 * pool configuration directive's requirement to retrieve multiple

 * addresses resolving a single name, which has previously been

 * satisfied with blocking resolver calls from the ntpd mainline code.

 *

 * A secondary goal is to provide a generic mechanism for other

 * blocking operations to be delegated to a worker using a common

 * model for both Unix and Windows ntpd.  ntp_worker.c, work_fork.c,

 * and work_thread.c implement the generic mechanism.  This file

 * implements the two current consumers, getaddrinfo_sometime() and the

 * presently unused getnameinfo_sometime().

 *

 * Both routines deliver results to a callback and manage memory

 * allocation, meaning there is no freeaddrinfo_sometime().

 *

 * The initial implementation for Unix uses a pair of unidirectional

 * pipes, one each for requests and responses, connecting the forked

 * blocking child worker with the ntpd mainline.  The threaded code

 * uses arrays of pointers to queue requests and responses.

 *

 * The parent drives the process, including scheduling sleeps between

 * retries.

 *

 * Memory is managed differently for a child process, which mallocs

 * request buffers to read from the pipe into, whereas the threaded

 * code mallocs a copy of the request to hand off to the worker via

 * the queueing array.  The resulting request buffer is free()d by

 * platform-independent code.  A wrinkle is the request needs to be

 * available to the requestor during response processing.

 *

 * Response memory allocation is also platform-dependent.  With a

 * separate process and pipes, the response is free()d after being

 * written to the pipe.  With threads, the same memory is handed

 * over and the requestor frees it after processing is completed.

 *

 * The code should be generalized to support threads on Unix using

 * much of the same code used for Windows initially.

 *

 */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include "ntp_workimpl.h"

#ifdef WORKER

#include <stdio.h>

#include <ctype.h>

#include <signal.h>

/**/

#ifdef HAVE_SYS_TYPES_H

# include <sys/types.h>

#endif

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#include <arpa/inet.h>

/**/

#ifdef HAVE_SYS_PARAM_H

# include <sys/param.h>

#endif

#if !defined(HAVE_RES_INIT) && defined(HAVE___RES_INIT)

# define HAVE_RES_INIT

#endif

#if defined(HAVE_RESOLV_H) && defined(HAVE_RES_INIT)

# ifdef HAVE_ARPA_NAMESER_H

#  include <arpa/nameser.h> /* DNS HEADER struct */

# endif

# ifdef HAVE_NETDB_H

#  include <netdb.h>

# endif

# include <resolv.h>

# ifdef HAVE_INT32_ONLY_WITH_DNS

#  define HAVE_INT32

# endif

# ifdef HAVE_U_INT32_ONLY_WITH_DNS

#  define HAVE_U_INT32

# endif

#endif

#include "ntp.h"

#include "ntp_debug.h"

#include "ntp_malloc.h"

#include "ntp_syslog.h"

#include "ntp_unixtime.h"

#include "ntp_intres.h"

#include "intreswork.h"

/*

 * Following are implementations of getaddrinfo_sometime() and

 * getnameinfo_sometime().  Each is implemented in three routines:

 *

 * getaddrinfo_sometime()   getnameinfo_sometime()

 * blocking_getaddrinfo()   blocking_getnameinfo()

 * getaddrinfo_sometime_complete()  getnameinfo_sometime_complete()

 *

 * The first runs in the parent and marshalls (or serializes) request

 * parameters into a request blob which is processed in the child by

 * the second routine, blocking_*(), which serializes the results into

 * a response blob unpacked by the third routine, *_complete(), which

 * calls the callback routine provided with the request and frees

 * _request_ memory allocated by the first routine.  Response memory

 * is managed by the code which calls the *_complete routines.

 */

/* === typedefs === */

typedef struct blocking_gai_req_tag { /* marshalled args */

  size_t      octets;

  u_int     dns_idx;

  time_t      scheduled;

  time_t      earliest;

  int     retry;

  struct addrinfo   hints;

  u_int     qflags;

  gai_sometime_callback callback;

  void *      context;

  size_t      nodesize;

  size_t      servsize;

} blocking_gai_req;

typedef struct blocking_gai_resp_tag {

  size_t      octets;

  int     retcode;

  int     retry;

  int     gai_errno; /* for EAI_SYSTEM case */

  int     ai_count;

  /*

   * Followed by ai_count struct addrinfo and then ai_count

   * sockaddr_u and finally the canonical name strings.

   */

} blocking_gai_resp;

typedef struct blocking_gni_req_tag {

  size_t      octets;

  u_int     dns_idx;

  time_t      scheduled;

  time_t      earliest;

  int     retry;

  size_t      hostoctets;

  size_t      servoctets;

  int     flags;

  gni_sometime_callback callback;

  void *      context;

  sockaddr_u    socku;

} blocking_gni_req;

typedef struct blocking_gni_resp_tag {

  size_t      octets;

  int     retcode;

  int     gni_errno; /* for EAI_SYSTEM case */

  int     retry;

  size_t      hostoctets;

  size_t      servoctets;

  /*

   * Followed by hostoctets bytes of null-terminated host,

   * then servoctets bytes of null-terminated service.

   */

} blocking_gni_resp;

/* per-DNS-worker state in parent */

typedef struct dnschild_ctx_tag {

  u_int index;

  time_t  next_dns_timeslot;

} dnschild_ctx;

/* per-DNS-worker state in worker */

typedef struct dnsworker_ctx_tag {

  blocking_child *  c;

  time_t      ignore_scheduled_before;

#ifdef HAVE_RES_INIT

  time_t  next_res_init;

#endif

} dnsworker_ctx;

/* === variables === */

dnschild_ctx **   dnschild_contexts;    /* parent */

u_int     dnschild_contexts_alloc;

dnsworker_ctx **  dnsworker_contexts;   /* child */

u_int     dnsworker_contexts_alloc;

#ifdef HAVE_RES_INIT

static  time_t    next_res_init;

#endif

/* === forward declarations === */

static  u_int   reserve_dnschild_ctx(void);

static  u_int   get_dnschild_ctx(void);

static  dnsworker_ctx * get_worker_context(blocking_child *, u_int);

static  void    scheduled_sleep(time_t, time_t,

          dnsworker_ctx *);

static  void    manage_dns_retry_interval(time_t *, time_t *,

              int *, time_t *,

              int/*BOOL*/);

static  int   should_retry_dns(int, int);

#ifdef HAVE_RES_INIT

static  void    reload_resolv_conf(dnsworker_ctx *);

#else

# define    reload_resolv_conf(wc)    \

  do {            \

    (void)(wc);       \

  } while (FALSE)

#endif

static  void    getaddrinfo_sometime_complete(blocking_work_req,

                  void *, size_t,

                  void *);

static  void    getnameinfo_sometime_complete(blocking_work_req,

                  void *, size_t,

                  void *);

/* === functions === */

/*

 * getaddrinfo_sometime - uses blocking child to call getaddrinfo then

 *        invokes provided callback completion function.

 */

int

getaddrinfo_sometime_ex(

  const char *    node,

  const char *    service,

  const struct addrinfo * hints,

  int     retry,

  gai_sometime_callback callback,

  void *      context,

  u_int     qflags

  )

{

  blocking_gai_req *  gai_req;

  u_int     idx;

  dnschild_ctx *    child_ctx;

  size_t      req_size;

  size_t      nodesize;

  size_t      servsize;

  time_t      now;

  REQUIRE(NULL != node);

  if (NULL != hints) {

    REQUIRE(0 == hints->ai_addrlen);

    REQUIRE(NULL == hints->ai_addr);

    REQUIRE(NULL == hints->ai_canonname);

    REQUIRE(NULL == hints->ai_next);

  }

  idx = get_dnschild_ctx();

  child_ctx = dnschild_contexts[idx];

  nodesize = strlen(node) + 1;

  servsize = strlen(service) + 1;

  req_size = sizeof(*gai_req) + nodesize + servsize;

  gai_req = emalloc_zero(req_size);

  gai_req->octets = req_size;

  gai_req->dns_idx = idx;

  now = time(NULL);

  gai_req->scheduled = now;

  gai_req->earliest = max(now, child_ctx->next_dns_timeslot);

  child_ctx->next_dns_timeslot = gai_req->earliest;

  if (hints != NULL)

    gai_req->hints = *hints;

  gai_req->retry = retry;

  gai_req->callback = callback;

  gai_req->context = context;

  gai_req->nodesize = nodesize;

  gai_req->servsize = servsize;

  gai_req->qflags = qflags;

  memcpy((char *)gai_req + sizeof(*gai_req), node, nodesize);

  memcpy((char *)gai_req + sizeof(*gai_req) + nodesize, service,

         servsize);

  if (queue_blocking_request(

    BLOCKING_GETADDRINFO,

    gai_req,

    req_size, 

    &getaddrinfo_sometime_complete, 

    gai_req)) {

    msyslog(LOG_ERR, "unable to queue getaddrinfo request");

    errno = EFAULT;

    return -1;

  }

  return 0;

}

int

blocking_getaddrinfo(

  blocking_child *  c,

  blocking_pipe_header *  req

  )

{

  blocking_gai_req *  gai_req;

  dnsworker_ctx *   worker_ctx;

  blocking_pipe_header *  resp;

  blocking_gai_resp * gai_resp;

  char *      node;

  char *      service;

  struct addrinfo * ai_res;

  struct addrinfo * ai;

  struct addrinfo * serialized_ai;

  size_t      canons_octets;

  size_t      this_octets;

  size_t      resp_octets;

  char *      cp;

  time_t      time_now;

  gai_req = (void *)((char *)req + sizeof(*req));

  node = (char *)gai_req + sizeof(*gai_req);

  service = node + gai_req->nodesize;

  worker_ctx = get_worker_context(c, gai_req->dns_idx);

  scheduled_sleep(gai_req->scheduled, gai_req->earliest,

      worker_ctx);

  reload_resolv_conf(worker_ctx);

  /*

   * Take a shot at the final size, better to overestimate

   * at first and then realloc to a smaller size.

   */

  resp_octets = sizeof(*resp) + sizeof(*gai_resp) +

          16 * (sizeof(struct addrinfo) +

          sizeof(sockaddr_u)) +

          256;

  resp = emalloc_zero(resp_octets);

  gai_resp = (void *)(resp + 1);

  TRACE(2, ("blocking_getaddrinfo given node %s serv %s fam %d flags %x\n", 

      node, service, gai_req->hints.ai_family,

      gai_req->hints.ai_flags));

#ifdef DEBUG

  if (debug >= 2)

    fflush(stdout);

#endif  

  ai_res = NULL;

  gai_resp->retcode = getaddrinfo(node, service, &gai_req->hints,

          &ai_res);

  gai_resp->retry = gai_req->retry;

#ifdef EAI_SYSTEM

  if (EAI_SYSTEM == gai_resp->retcode)

    gai_resp->gai_errno = errno;

#endif

  canons_octets = 0;

  if (0 == gai_resp->retcode) {

    ai = ai_res;

    while (NULL != ai) {

      gai_resp->ai_count++;

      if (ai->ai_canonname)

        canons_octets += strlen(ai->ai_canonname) + 1;

      ai = ai->ai_next;

    }

    /*

     * If this query succeeded only after retrying, DNS may have

     * just become responsive.  Ignore previously-scheduled

     * retry sleeps once for each pending request, similar to

     * the way scheduled_sleep() does when its worker_sleep()

     * is interrupted.

     */

    if (gai_resp->retry > INITIAL_DNS_RETRY) {

      time_now = time(NULL);

      worker_ctx->ignore_scheduled_before = time_now;

      TRACE(1, ("DNS success after retry, ignoring sleeps scheduled before now (%s)\n",

          humantime(time_now)));

    }

  }

  /*

   * Our response consists of a header, followed by ai_count 

   * addrinfo structs followed by ai_count sockaddr_storage 

   * structs followed by the canonical names.

   */

  gai_resp->octets = sizeof(*gai_resp)

          + gai_resp->ai_count

        * (sizeof(gai_req->hints)

           + sizeof(sockaddr_u))

          + canons_octets;

  resp_octets = sizeof(*resp) + gai_resp->octets;

  resp = erealloc(resp, resp_octets);

  gai_resp = (void *)(resp + 1);

  /* cp serves as our current pointer while serializing */

  cp = (void *)(gai_resp + 1);

  canons_octets = 0;

  if (0 == gai_resp->retcode) {

    ai = ai_res;

    while (NULL != ai) {

      memcpy(cp, ai, sizeof(*ai));

      serialized_ai = (void *)cp;

      cp += sizeof(*ai);

      /* transform ai_canonname into offset */

      if (NULL != ai->ai_canonname) {

        serialized_ai->ai_canonname = (char *)canons_octets;

        canons_octets += strlen(ai->ai_canonname) + 1;

      }

      /* leave fixup of ai_addr pointer for receiver */

      ai = ai->ai_next;

    }

    ai = ai_res;

    while (NULL != ai) {

      INSIST(ai->ai_addrlen <= sizeof(sockaddr_u));

      memcpy(cp, ai->ai_addr, ai->ai_addrlen);

      cp += sizeof(sockaddr_u);

      ai = ai->ai_next;

    }

    ai = ai_res;

    while (NULL != ai) {

      if (NULL != ai->ai_canonname) {

        this_octets = strlen(ai->ai_canonname) + 1;

        memcpy(cp, ai->ai_canonname, this_octets);

        cp += this_octets;

      }

      ai = ai->ai_next;

    }

    freeaddrinfo(ai_res);

  }

  /*

   * make sure our walk and earlier calc match

   */

  DEBUG_INSIST((size_t)(cp - (char *)resp) == resp_octets);

  if (queue_blocking_response(c, resp, resp_octets, req)) {

    msyslog(LOG_ERR, "blocking_getaddrinfo can not queue response");

    return -1;

  }

  return 0;

}

int

getaddrinfo_sometime(

  const char *    node,

  const char *    service,

  const struct addrinfo * hints,

  int     retry,

  gai_sometime_callback callback,

  void *      context

  )

{

  return getaddrinfo_sometime_ex(node, service, hints, retry,

               callback, context, 0);

}

static void

getaddrinfo_sometime_complete(

  blocking_work_req rtype,

  void *      context,

  size_t      respsize,

  void *      resp

  )

{

  blocking_gai_req *  gai_req;

  blocking_gai_resp * gai_resp;

  dnschild_ctx *    child_ctx;

  struct addrinfo * ai;

  struct addrinfo * next_ai;

  sockaddr_u *    psau;

  char *      node;

  char *      service;

  char *      canon_start;

  time_t      time_now;

  int     again, noerr;

  int     af;

  const char *    fam_spec;

  int     i;

  gai_req = context;

  gai_resp = resp;

  DEBUG_REQUIRE(BLOCKING_GETADDRINFO == rtype);

  DEBUG_REQUIRE(respsize == gai_resp->octets);

  node = (char *)gai_req + sizeof(*gai_req);

  service = node + gai_req->nodesize;

  child_ctx = dnschild_contexts[gai_req->dns_idx];

  if (0 == gai_resp->retcode) {

    /*

     * If this query succeeded only after retrying, DNS may have

     * just become responsive.

     */

    if (gai_resp->retry > INITIAL_DNS_RETRY) {

      time_now = time(NULL);

      child_ctx->next_dns_timeslot = time_now;

      TRACE(1, ("DNS success after retry, %u next_dns_timeslot reset (%s)\n",

          gai_req->dns_idx, humantime(time_now)));

    }

  } else {

    noerr = !!(gai_req->qflags & GAIR_F_IGNDNSERR);

    again = noerr || should_retry_dns(

          gai_resp->retcode, gai_resp->gai_errno);

    /*

     * exponential backoff of DNS retries to 64s

     */

    if (gai_req->retry > 0 && again) {

      /* log the first retry only */

      if (INITIAL_DNS_RETRY == gai_req->retry)

        NLOG(NLOG_SYSINFO) {

          af = gai_req->hints.ai_family;

          fam_spec = (AF_INET6 == af)

                   ? " (AAAA)"

                   : (AF_INET == af)

                   ? " (A)"

                   : "";

#ifdef EAI_SYSTEM

          if (EAI_SYSTEM == gai_resp->retcode) {

            errno = gai_resp->gai_errno;

            msyslog(LOG_INFO,

              "retrying DNS %s%s: EAI_SYSTEM %d: %m",

              node, fam_spec,

              gai_resp->gai_errno);

          } else

#endif

            msyslog(LOG_INFO,

              "retrying DNS %s%s: %s (%d)",

              node, fam_spec,

              gai_strerror(gai_resp->retcode),

              gai_resp->retcode);

        }

      manage_dns_retry_interval(

        &gai_req->scheduled, &gai_req->earliest,

        &gai_req->retry, &child_ctx->next_dns_timeslot,

        noerr);

      if (!queue_blocking_request(

          BLOCKING_GETADDRINFO,

          gai_req,

          gai_req->octets,

          &getaddrinfo_sometime_complete,

          gai_req))

        return;

      else

        msyslog(LOG_ERR,

          "unable to retry hostname %s",

          node);

    }

  }

  /*

   * fixup pointers in returned addrinfo array

   */

  ai = (void *)((char *)gai_resp + sizeof(*gai_resp));

  next_ai = NULL;

  for (i = gai_resp->ai_count - 1; i >= 0; i--) {

    ai[i].ai_next = next_ai;

    next_ai = &ai[i];

  }

  psau = (void *)((char *)ai + gai_resp->ai_count * sizeof(*ai));

  canon_start = (char *)psau + gai_resp->ai_count * sizeof(*psau);

  for (i = 0; i < gai_resp->ai_count; i++) {

    if (NULL != ai[i].ai_addr)

      ai[i].ai_addr = &psau->sa;

    psau++;

    if (NULL != ai[i].ai_canonname)

      ai[i].ai_canonname += (size_t)canon_start;

  }

  ENSURE((char *)psau == canon_start);

  if (!gai_resp->ai_count)

    ai = NULL;

  (*gai_req->callback)(gai_resp->retcode, gai_resp->gai_errno,

           gai_req->context, node, service, 

           &gai_req->hints, ai);

  free(gai_req);

  /* gai_resp is part of block freed by process_blocking_resp() */

}

#ifdef TEST_BLOCKING_WORKER

void gai_test_callback(int rescode, int gai_errno, void *context, const char *name, const char *service, const struct addrinfo *hints, const struct addrinfo *ai_res)

{

  sockaddr_u addr;

  if (rescode) {

    TRACE(1, ("gai_test_callback context %p error rescode %d %s serv %s\n",

        context, rescode, name, service));

    return;

  }

  while (!rescode && NULL != ai_res) {

    ZERO_SOCK(&addr);

    memcpy(&addr, ai_res->ai_addr, ai_res->ai_addrlen);

    TRACE(1, ("ctx %p fam %d addr %s canon '%s' type %s at %p ai_addr %p ai_next %p\n", 

        context,

        AF(&addr),

        stoa(&addr), 

        (ai_res->ai_canonname)

            ? ai_res->ai_canonname

            : "",

        (SOCK_DGRAM == ai_res->ai_socktype) 

            ? "DGRAM" 

            : (SOCK_STREAM == ai_res->ai_socktype) 

            ? "STREAM" 

            : "(other)",

        ai_res,

        ai_res->ai_addr,

        ai_res->ai_next));

    getnameinfo_sometime((sockaddr_u *)ai_res->ai_addr, 128, 32, 0, gni_test_callback, context);

    ai_res = ai_res->ai_next;

  }

}

#endif  /* TEST_BLOCKING_WORKER */

int

getnameinfo_sometime(

  sockaddr_u *    psau,

  size_t      hostoctets,

  size_t      servoctets,

  int     flags,

  gni_sometime_callback callback,

  void *      context

  )

{

  blocking_gni_req *  gni_req;

  u_int     idx;

  dnschild_ctx *    child_ctx;

  time_t      time_now;

  REQUIRE(hostoctets);

  REQUIRE(hostoctets + servoctets < 1024);

  idx = get_dnschild_ctx();

  child_ctx = dnschild_contexts[idx];

  gni_req = emalloc_zero(sizeof(*gni_req));

  gni_req->octets = sizeof(*gni_req);

  gni_req->dns_idx = idx;

  time_now = time(NULL);

  gni_req->scheduled = time_now;

  gni_req->earliest = max(time_now, child_ctx->next_dns_timeslot);

  child_ctx->next_dns_timeslot = gni_req->earliest;

  memcpy(&gni_req->socku, psau, SOCKLEN(psau));

  gni_req->hostoctets = hostoctets;

  gni_req->servoctets = servoctets;

  gni_req->flags = flags;

  gni_req->retry = INITIAL_DNS_RETRY;

  gni_req->callback = callback;

  gni_req->context = context;

  if (queue_blocking_request(

    BLOCKING_GETNAMEINFO,

    gni_req,

    sizeof(*gni_req), 

    &getnameinfo_sometime_complete, 

    gni_req)) {

    msyslog(LOG_ERR, "unable to queue getnameinfo request");

    errno = EFAULT;

    return -1;

  }

  return 0;

}

int

blocking_getnameinfo(

  blocking_child *  c,

  blocking_pipe_header *  req

  )

{

  blocking_gni_req *  gni_req;

  dnsworker_ctx *   worker_ctx;

  blocking_pipe_header *  resp;

  blocking_gni_resp * gni_resp;

  size_t      octets;

  size_t      resp_octets;

  char *      service;

  char *      cp;

  int     rc;

  time_t      time_now;

  char      host[1024];

  gni_req = (void *)((char *)req + sizeof(*req));

  octets = gni_req->hostoctets + gni_req->servoctets;

  /*

   * Some alloca() implementations are fragile regarding

   * large allocations.  We only need room for the host

   * and service names.

   */

  REQUIRE(octets < sizeof(host));

  service = host + gni_req->hostoctets;

  worker_ctx = get_worker_context(c, gni_req->dns_idx);

  scheduled_sleep(gni_req->scheduled, gni_req->earliest,

      worker_ctx);

  reload_resolv_conf(worker_ctx);

  /*

   * Take a shot at the final size, better to overestimate

   * then realloc to a smaller size.

   */

  resp_octets = sizeof(*resp) + sizeof(*gni_resp) + octets;

  resp = emalloc_zero(resp_octets);

  gni_resp = (void *)((char *)resp + sizeof(*resp));

  TRACE(2, ("blocking_getnameinfo given addr %s flags 0x%x hostlen %lu servlen %lu\n",

      stoa(&gni_req->socku), gni_req->flags,

      (u_long)gni_req->hostoctets, (u_long)gni_req->servoctets));

  gni_resp->retcode = getnameinfo(&gni_req->socku.sa,

          SOCKLEN(&gni_req->socku),

          host,

          gni_req->hostoctets,

          service,

          gni_req->servoctets,

          gni_req->flags);

  gni_resp->retry = gni_req->retry;

#ifdef EAI_SYSTEM

  if (EAI_SYSTEM == gni_resp->retcode)

    gni_resp->gni_errno = errno;

#endif

  if (0 != gni_resp->retcode) {

    gni_resp->hostoctets = 0;

    gni_resp->servoctets = 0;

  } else {

    gni_resp->hostoctets = strlen(host) + 1;

    gni_resp->servoctets = strlen(service) + 1;

    /*

     * If this query succeeded only after retrying, DNS may have

     * just become responsive.  Ignore previously-scheduled

     * retry sleeps once for each pending request, similar to

     * the way scheduled_sleep() does when its worker_sleep()

     * is interrupted.

     */

    if (gni_req->retry > INITIAL_DNS_RETRY) {

      time_now = time(NULL);

      worker_ctx->ignore_scheduled_before = time_now;

      TRACE(1, ("DNS success after retrying, ignoring sleeps scheduled before now (%s)\n",

        humantime(time_now)));

    }

  }

  octets = gni_resp->hostoctets + gni_resp->servoctets;

  /*

   * Our response consists of a header, followed by the host and

   * service strings, each null-terminated.

   */

  resp_octets = sizeof(*resp) + sizeof(*gni_resp) + octets;

  resp = erealloc(resp, resp_octets);

  gni_resp = (void *)(resp + 1);

  gni_resp->octets = sizeof(*gni_resp) + octets;

  /* cp serves as our current pointer while serializing */

  cp = (void *)(gni_resp + 1);

  if (0 == gni_resp->retcode) {

    memcpy(cp, host, gni_resp->hostoctets);

    cp += gni_resp->hostoctets;

    memcpy(cp, service, gni_resp->servoctets);

    cp += gni_resp->servoctets;

  }

  INSIST((size_t)(cp - (char *)resp) == resp_octets);

  INSIST(resp_octets - sizeof(*resp) == gni_resp->octets);

  rc = queue_blocking_response(c, resp, resp_octets, req);

  if (rc)

    msyslog(LOG_ERR, "blocking_getnameinfo unable to queue response");

  return rc;

}

static void

getnameinfo_sometime_complete(

  blocking_work_req rtype,

  void *      context,

  size_t      respsize,

  void *      resp

  )

{

  blocking_gni_req *  gni_req;

  blocking_gni_resp * gni_resp;

  dnschild_ctx *    child_ctx;

  char *      host;

  char *      service;

  time_t      time_now;

  int     again;

  gni_req = context;

  gni_resp = resp;

  DEBUG_REQUIRE(BLOCKING_GETNAMEINFO == rtype);

  DEBUG_REQUIRE(respsize == gni_resp->octets);

  child_ctx = dnschild_contexts[gni_req->dns_idx];

  if (0 == gni_resp->retcode) {

    /*

     * If this query succeeded only after retrying, DNS may have

     * just become responsive.

     */

    if (gni_resp->retry > INITIAL_DNS_RETRY) {

      time_now = time(NULL);

      child_ctx->next_dns_timeslot = time_now;

      TRACE(1, ("DNS success after retry, %u next_dns_timeslot reset (%s)\n",

          gni_req->dns_idx, humantime(time_now)));

    }

  } else {

    again = should_retry_dns(gni_resp->retcode, gni_resp->gni_errno);

    /*

     * exponential backoff of DNS retries to 64s

     */

    if (gni_req->retry > 0)

      manage_dns_retry_interval(&gni_req->scheduled,

          &gni_req->earliest, &gni_req->retry,

              &child_ctx->next_dns_timeslot, FALSE);

    if (gni_req->retry > 0 && again) {

      if (!queue_blocking_request(

        BLOCKING_GETNAMEINFO,

        gni_req,

        gni_req->octets, 

        &getnameinfo_sometime_complete, 

        gni_req))

        return;

      msyslog(LOG_ERR, "unable to retry reverse lookup of %s", stoa(&gni_req->socku));

    }

  }

  if (!gni_resp->hostoctets) {

    host = NULL;

    service = NULL;

  } else {

    host = (char *)gni_resp + sizeof(*gni_resp);

    service = (gni_resp->servoctets) 

            ? host + gni_resp->hostoctets

            : NULL;

  }

  (*gni_req->callback)(gni_resp->retcode, gni_resp->gni_errno,

           &gni_req->socku, gni_req->flags, host,

           service, gni_req->context);

  free(gni_req);

  /* gni_resp is part of block freed by process_blocking_resp() */

}

#ifdef TEST_BLOCKING_WORKER

void gni_test_callback(int rescode, int gni_errno, sockaddr_u *psau, int flags, const char *host, const char *service, void *context)

{

  if (!rescode)

    TRACE(1, ("gni_test_callback got host '%s' serv '%s' for addr %s context %p\n", 

        host, service, stoa(psau), context));

  else

    TRACE(1, ("gni_test_callback context %p rescode %d gni_errno %d flags 0x%x addr %s\n",

        context, rescode, gni_errno, flags, stoa(psau)));

}

#endif  /* TEST_BLOCKING_WORKER */

#ifdef HAVE_RES_INIT

static void

reload_resolv_conf(

  dnsworker_ctx * worker_ctx

  )

{

  time_t  time_now;

  /*

   * This is ad-hoc.  Reload /etc/resolv.conf once per minute

   * to pick up on changes from the DHCP client.  [Bug 1226]

   * When using threads for the workers, this needs to happen

   * only once per minute process-wide.

   */

  time_now = time(NULL);

# ifdef WORK_THREAD

  worker_ctx->next_res_init = next_res_init;

# endif

  if (worker_ctx->next_res_init <= time_now) {

    if (worker_ctx->next_res_init != 0)

      res_init();

    worker_ctx->next_res_init = time_now + 60;

# ifdef WORK_THREAD

    next_res_init = worker_ctx->next_res_init;

# endif

  }

}

#endif  /* HAVE_RES_INIT */

static u_int

reserve_dnschild_ctx(void)

{

  const size_t  ps = sizeof(dnschild_contexts[0]);

  const size_t  cs = sizeof(*dnschild_contexts[0]);

  u_int   c;

  u_int   new_alloc;

  size_t    octets;

  size_t    new_octets;

  c = 0;

  while (TRUE) {

    for ( ; c < dnschild_contexts_alloc; c++) {

      if (NULL == dnschild_contexts[c]) {

        dnschild_contexts[c] = emalloc_zero(cs);

        return c;

      }

    }

    new_alloc = dnschild_contexts_alloc + 20;

    new_octets = new_alloc * ps;

    octets = dnschild_contexts_alloc * ps;

    dnschild_contexts = erealloc_zero(dnschild_contexts,

              new_octets, octets);

    dnschild_contexts_alloc = new_alloc;

  }

}

static u_int

get_dnschild_ctx(void)

{

  static u_int  shared_ctx = UINT_MAX;

  if (worker_per_query)

    return reserve_dnschild_ctx();