contrib/ntp/libntp/ntp_intres.c

   1 /*
   2  * ntp_intres.c - Implements a generic blocking worker child or thread,
   3  *                initially to provide a nonblocking solution for DNS
   4  *                name to address lookups available with getaddrinfo().
   5  *
   6  * This is a new implementation as of 2009 sharing the filename and
   7  * very little else with the prior implementation, which used a
   8  * temporary file to receive a single set of requests from the parent,
   9  * and a NTP mode 7 authenticated request to push back responses.
  10  *
  11  * A primary goal in rewriting this code was the need to support the
  12  * pool configuration directive's requirement to retrieve multiple
  13  * addresses resolving a single name, which has previously been
  14  * satisfied with blocking resolver calls from the ntpd mainline code.
  15  *
  16  * A secondary goal is to provide a generic mechanism for other
  17  * blocking operations to be delegated to a worker using a common
  18  * model for both Unix and Windows ntpd.  ntp_worker.c, work_fork.c,
  19  * and work_thread.c implement the generic mechanism.  This file
  20  * implements the two current consumers, getaddrinfo_sometime() and the
  21  * presently unused getnameinfo_sometime().
  22  *
  23  * Both routines deliver results to a callback and manage memory
  24  * allocation, meaning there is no freeaddrinfo_sometime().
  25  *
  26  * The initial implementation for Unix uses a pair of unidirectional
  27  * pipes, one each for requests and responses, connecting the forked
  28  * blocking child worker with the ntpd mainline.  The threaded code
  29  * uses arrays of pointers to queue requests and responses.
  30  *
  31  * The parent drives the process, including scheduling sleeps between
  32  * retries.
  33  *
  34  * Memory is managed differently for a child process, which mallocs
  35  * request buffers to read from the pipe into, whereas the threaded
  36  * code mallocs a copy of the request to hand off to the worker via
  37  * the queueing array.  The resulting request buffer is free()d by
  38  * platform-independent code.  A wrinkle is the request needs to be
  39  * available to the requestor during response processing.
  40  *
  41  * Response memory allocation is also platform-dependent.  With a
  42  * separate process and pipes, the response is free()d after being
  43  * written to the pipe.  With threads, the same memory is handed
  44  * over and the requestor frees it after processing is completed.
  45  *
  46  * The code should be generalized to support threads on Unix using
  47  * much of the same code used for Windows initially.
  48  *
  49  */
  50 #ifdef HAVE_CONFIG_H
  51 # include <config.h>
  52 #endif
  53
  54 #include "ntp_workimpl.h"
  55
  56 #ifdef WORKER
  57
  58 #include <stdio.h>
  59 #include <ctype.h>
  60 #include <signal.h>
  61
  62 /**/
  63 #ifdef HAVE_SYS_TYPES_H
  64 # include <sys/types.h>
  65 #endif
  66 #ifdef HAVE_NETINET_IN_H
  67 #include <netinet/in.h>
  68 #endif
  69 #include <arpa/inet.h>
  70 /**/
  71 #ifdef HAVE_SYS_PARAM_H
  72 # include <sys/param.h>
  73 #endif
  74
  75 #if !defined(HAVE_RES_INIT) && defined(HAVE___RES_INIT)
  76 # define HAVE_RES_INIT
  77 #endif
  78
  79 #if defined(HAVE_RESOLV_H) && defined(HAVE_RES_INIT)
  80 # ifdef HAVE_ARPA_NAMESER_H
  81 #  include <arpa/nameser.h> /* DNS HEADER struct */
  82 # endif
  83 # ifdef HAVE_NETDB_H
  84 #  include <netdb.h>
  85 # endif
  86 # include <resolv.h>
  87 # ifdef HAVE_INT32_ONLY_WITH_DNS
  88 #  define HAVE_INT32
  89 # endif
  90 # ifdef HAVE_U_INT32_ONLY_WITH_DNS
  91 #  define HAVE_U_INT32
  92 # endif
  93 #endif
  94
  95 #include "ntp.h"
  96 #include "ntp_debug.h"
  97 #include "ntp_malloc.h"
  98 #include "ntp_syslog.h"
  99 #include "ntp_unixtime.h"
 100 #include "ntp_intres.h"
 101 #include "intreswork.h"
 102
 103
 104 /*
 105  * Following are implementations of getaddrinfo_sometime() and
 106  * getnameinfo_sometime().  Each is implemented in three routines:
 107  *
 108  * getaddrinfo_sometime()               getnameinfo_sometime()
 109  * blocking_getaddrinfo()               blocking_getnameinfo()
 110  * getaddrinfo_sometime_complete()      getnameinfo_sometime_complete()
 111  *
 112  * The first runs in the parent and marshalls (or serializes) request
 113  * parameters into a request blob which is processed in the child by
 114  * the second routine, blocking_*(), which serializes the results into
 115  * a response blob unpacked by the third routine, *_complete(), which
 116  * calls the callback routine provided with the request and frees
 117  * _request_ memory allocated by the first routine.  Response memory
 118  * is managed by the code which calls the *_complete routines.
 119  */
 120
 121
 122 /* === typedefs === */
 123 typedef struct blocking_gai_req_tag {   /* marshalled args */
 124         size_t                  octets;
 125         u_int                   dns_idx;
 126         time_t                  scheduled;
 127         time_t                  earliest;
 128         int                     retry;
 129         struct addrinfo         hints;
 130         u_int                   qflags;
 131         gai_sometime_callback   callback;
 132         void *                  context;
 133         size_t                  nodesize;
 134         size_t                  servsize;
 135 } blocking_gai_req;
 136
 137 typedef struct blocking_gai_resp_tag {
 138         size_t                  octets;
 139         int                     retcode;
 140         int                     retry;
 141         int                     gai_errno; /* for EAI_SYSTEM case */
 142         int                     ai_count;
 143         /*
 144          * Followed by ai_count struct addrinfo and then ai_count
 145          * sockaddr_u and finally the canonical name strings.
 146          */
 147 } blocking_gai_resp;
 148
 149 typedef struct blocking_gni_req_tag {
 150         size_t                  octets;
 151         u_int                   dns_idx;
 152         time_t                  scheduled;
 153         time_t                  earliest;
 154         int                     retry;
 155         size_t                  hostoctets;
 156         size_t                  servoctets;
 157         int                     flags;
 158         gni_sometime_callback   callback;
 159         void *                  context;
 160         sockaddr_u              socku;
 161 } blocking_gni_req;
 162
 163 typedef struct blocking_gni_resp_tag {
 164         size_t                  octets;
 165         int                     retcode;
 166         int                     gni_errno; /* for EAI_SYSTEM case */
 167         int                     retry;
 168         size_t                  hostoctets;
 169         size_t                  servoctets;
 170         /*
 171          * Followed by hostoctets bytes of null-terminated host,
 172          * then servoctets bytes of null-terminated service.
 173          */
 174 } blocking_gni_resp;
 175
 176 /* per-DNS-worker state in parent */
 177 typedef struct dnschild_ctx_tag {
 178         u_int   index;
 179         time_t  next_dns_timeslot;
 180 } dnschild_ctx;
 181
 182 /* per-DNS-worker state in worker */
 183 typedef struct dnsworker_ctx_tag {
 184         blocking_child *        c;
 185         time_t                  ignore_scheduled_before;
 186 #ifdef HAVE_RES_INIT
 187         time_t  next_res_init;
 188 #endif
 189 } dnsworker_ctx;
 190
 191
 192 /* === variables === */
 193 dnschild_ctx **         dnschild_contexts;              /* parent */
 194 u_int                   dnschild_contexts_alloc;
 195 dnsworker_ctx **        dnsworker_contexts;             /* child */
 196 u_int                   dnsworker_contexts_alloc;
 197
 198 #ifdef HAVE_RES_INIT
 199 static  time_t          next_res_init;
 200 #endif
 201
 202
 203 /* === forward declarations === */
 204 static  u_int           reserve_dnschild_ctx(void);
 205 static  u_int           get_dnschild_ctx(void);
 206 static  dnsworker_ctx * get_worker_context(blocking_child *, u_int);
 207 static  void            scheduled_sleep(time_t, time_t,
 208                                         dnsworker_ctx *);
 209 static  void            manage_dns_retry_interval(time_t *, time_t *,
 210                                                   int *, time_t *,
 211                                                   int/*BOOL*/);
 212 static  int             should_retry_dns(int, int);
 213 #ifdef HAVE_RES_INIT
 214 static  void            reload_resolv_conf(dnsworker_ctx *);
 215 #else
 216 # define                reload_resolv_conf(wc)          \
 217         do {                                            \
 218                 (void)(wc);                             \
 219         } while (FALSE)
 220 #endif
 221 static  void            getaddrinfo_sometime_complete(blocking_work_req,
 222                                                       void *, size_t,
 223                                                       void *);
 224 static  void            getnameinfo_sometime_complete(blocking_work_req,
 225                                                       void *, size_t,
 226                                                       void *);
 227
 228
 229 /* === functions === */
 230 /*
 231  * getaddrinfo_sometime - uses blocking child to call getaddrinfo then
 232  *                        invokes provided callback completion function.
 233  */
 234 int
 235 getaddrinfo_sometime_ex(
 236         const char *            node,
 237         const char *            service,
 238         const struct addrinfo * hints,
 239         int                     retry,
 240         gai_sometime_callback   callback,
 241         void *                  context,
 242         u_int                   qflags
 243         )
 244 {
 245         blocking_gai_req *      gai_req;
 246         u_int                   idx;
 247         dnschild_ctx *          child_ctx;
 248         size_t                  req_size;
 249         size_t                  nodesize;
 250         size_t                  servsize;
 251         time_t                  now;
 252
 253         REQUIRE(NULL != node);
 254         if (NULL != hints) {
 255                 REQUIRE(0 == hints->ai_addrlen);
 256                 REQUIRE(NULL == hints->ai_addr);
 257                 REQUIRE(NULL == hints->ai_canonname);
 258                 REQUIRE(NULL == hints->ai_next);
 259         }
 260
 261         idx = get_dnschild_ctx();
 262         child_ctx = dnschild_contexts[idx];
 263
 264         nodesize = strlen(node) + 1;
 265         servsize = strlen(service) + 1;
 266         req_size = sizeof(*gai_req) + nodesize + servsize;
 267
 268         gai_req = emalloc_zero(req_size);
 269
 270         gai_req->octets = req_size;
 271         gai_req->dns_idx = idx;
 272         now = time(NULL);
 273         gai_req->scheduled = now;
 274         gai_req->earliest = max(now, child_ctx->next_dns_timeslot);
 275         child_ctx->next_dns_timeslot = gai_req->earliest;
 276         if (hints != NULL)
 277                 gai_req->hints = *hints;
 278         gai_req->retry = retry;
 279         gai_req->callback = callback;
 280         gai_req->context = context;
 281         gai_req->nodesize = nodesize;
 282         gai_req->servsize = servsize;
 283         gai_req->qflags = qflags;
 284
 285         memcpy((char *)gai_req + sizeof(*gai_req), node, nodesize);
 286         memcpy((char *)gai_req + sizeof(*gai_req) + nodesize, service,
 287                servsize);
 288
 289         if (queue_blocking_request(
 290                 BLOCKING_GETADDRINFO,
 291                 gai_req,
 292                 req_size,
 293                 &getaddrinfo_sometime_complete,
 294                 gai_req)) {
 295
 296                 msyslog(LOG_ERR, "unable to queue getaddrinfo request");
 297                 errno = EFAULT;
 298                 return -1;
 299         }
 300
 301         return 0;
 302 }
 303
 304 int
 305 blocking_getaddrinfo(
 306         blocking_child *        c,
 307         blocking_pipe_header *  req
 308         )
 309 {
 310         blocking_gai_req *      gai_req;
 311         dnsworker_ctx *         worker_ctx;
 312         blocking_pipe_header *  resp;
 313         blocking_gai_resp *     gai_resp;
 314         char *                  node;
 315         char *                  service;
 316         struct addrinfo *       ai_res;
 317         struct addrinfo *       ai;
 318         struct addrinfo *       serialized_ai;
 319         size_t                  canons_octets;
 320         size_t                  this_octets;
 321         size_t                  resp_octets;
 322         char *                  cp;
 323         time_t                  time_now;
 324
 325         gai_req = (void *)((char *)req + sizeof(*req));
 326         node = (char *)gai_req + sizeof(*gai_req);
 327         service = node + gai_req->nodesize;
 328
 329         worker_ctx = get_worker_context(c, gai_req->dns_idx);
 330         scheduled_sleep(gai_req->scheduled, gai_req->earliest,
 331                         worker_ctx);
 332         reload_resolv_conf(worker_ctx);
 333
 334         /*
 335          * Take a shot at the final size, better to overestimate
 336          * at first and then realloc to a smaller size.
 337          */
 338
 339         resp_octets = sizeof(*resp) + sizeof(*gai_resp) +
 340                       16 * (sizeof(struct addrinfo) +
 341                             sizeof(sockaddr_u)) +
 342                       256;
 343         resp = emalloc_zero(resp_octets);
 344         gai_resp = (void *)(resp + 1);
 345
 346         TRACE(2, ("blocking_getaddrinfo given node %s serv %s fam %d flags %x\n",
 347                   node, service, gai_req->hints.ai_family,
 348                   gai_req->hints.ai_flags));
 349 #ifdef DEBUG
 350         if (debug >= 2)
 351                 fflush(stdout);
 352 #endif
 353         ai_res = NULL;
 354         gai_resp->retcode = getaddrinfo(node, service, &gai_req->hints,
 355                                         &ai_res);
 356         gai_resp->retry = gai_req->retry;
 357 #ifdef EAI_SYSTEM
 358         if (EAI_SYSTEM == gai_resp->retcode)
 359                 gai_resp->gai_errno = errno;
 360 #endif
 361         canons_octets = 0;
 362
 363         if (0 == gai_resp->retcode) {
 364                 ai = ai_res;
 365                 while (NULL != ai) {
 366                         gai_resp->ai_count++;
 367                         if (ai->ai_canonname)
 368                                 canons_octets += strlen(ai->ai_canonname) + 1;
 369                         ai = ai->ai_next;
 370                 }
 371                 /*
 372                  * If this query succeeded only after retrying, DNS may have
 373                  * just become responsive.  Ignore previously-scheduled
 374                  * retry sleeps once for each pending request, similar to
 375                  * the way scheduled_sleep() does when its worker_sleep()
 376                  * is interrupted.
 377                  */
 378                 if (gai_resp->retry > INITIAL_DNS_RETRY) {
 379                         time_now = time(NULL);
 380                         worker_ctx->ignore_scheduled_before = time_now;
 381                         TRACE(1, ("DNS success after retry, ignoring sleeps scheduled before now (%s)\n",
 382                                   humantime(time_now)));
 383                 }
 384         }
 385
 386         /*
 387          * Our response consists of a header, followed by ai_count
 388          * addrinfo structs followed by ai_count sockaddr_storage
 389          * structs followed by the canonical names.
 390          */
 391         gai_resp->octets = sizeof(*gai_resp)
 392                             + gai_resp->ai_count
 393                                 * (sizeof(gai_req->hints)
 394                                    + sizeof(sockaddr_u))
 395                             + canons_octets;
 396
 397         resp_octets = sizeof(*resp) + gai_resp->octets;
 398         resp = erealloc(resp, resp_octets);
 399         gai_resp = (void *)(resp + 1);
 400
 401         /* cp serves as our current pointer while serializing */
 402         cp = (void *)(gai_resp + 1);
 403         canons_octets = 0;
 404
 405         if (0 == gai_resp->retcode) {
 406                 ai = ai_res;
 407                 while (NULL != ai) {
 408                         memcpy(cp, ai, sizeof(*ai));
 409                         serialized_ai = (void *)cp;
 410                         cp += sizeof(*ai);
 411
 412                         /* transform ai_canonname into offset */
 413                         if (NULL != serialized_ai->ai_canonname) {
 414                                 serialized_ai->ai_canonname = (char *)canons_octets;
 415                                 canons_octets += strlen(ai->ai_canonname) + 1;
 416                         }
 417
 418                         /* leave fixup of ai_addr pointer for receiver */
 419
 420                         ai = ai->ai_next;
 421                 }
 422
 423                 ai = ai_res;
 424                 while (NULL != ai) {
 425                         INSIST(ai->ai_addrlen <= sizeof(sockaddr_u));
 426                         memcpy(cp, ai->ai_addr, ai->ai_addrlen);
 427                         cp += sizeof(sockaddr_u);
 428
 429                         ai = ai->ai_next;
 430                 }
 431
 432                 ai = ai_res;
 433                 while (NULL != ai) {
 434                         if (NULL != ai->ai_canonname) {
 435                                 this_octets = strlen(ai->ai_canonname) + 1;
 436                                 memcpy(cp, ai->ai_canonname, this_octets);
 437                                 cp += this_octets;
 438                         }
 439
 440                         ai = ai->ai_next;
 441                 }
 442                 freeaddrinfo(ai_res);
 443         }
 444
 445         /*
 446          * make sure our walk and earlier calc match
 447          */
 448         DEBUG_INSIST((size_t)(cp - (char *)resp) == resp_octets);
 449
 450         if (queue_blocking_response(c, resp, resp_octets, req)) {
 451                 msyslog(LOG_ERR, "blocking_getaddrinfo can not queue response");
 452                 return -1;
 453         }
 454
 455         return 0;
 456 }
 457
 458 int
 459 getaddrinfo_sometime(
 460         const char *            node,
 461         const char *            service,
 462         const struct addrinfo * hints,
 463         int                     retry,
 464         gai_sometime_callback   callback,
 465         void *                  context
 466         )
 467 {
 468         return getaddrinfo_sometime_ex(node, service, hints, retry,
 469                                        callback, context, 0);
 470 }
 471
 472
 473 static void
 474 getaddrinfo_sometime_complete(
 475         blocking_work_req       rtype,
 476         void *                  context,
 477         size_t                  respsize,
 478         void *                  resp
 479         )
 480 {
 481         blocking_gai_req *      gai_req;
 482         blocking_gai_resp *     gai_resp;
 483         dnschild_ctx *          child_ctx;
 484         struct addrinfo *       ai;
 485         struct addrinfo *       next_ai;
 486         sockaddr_u *            psau;
 487         char *                  node;
 488         char *                  service;
 489         char *                  canon_start;
 490         time_t                  time_now;
 491         int                     again, noerr;
 492         int                     af;
 493         const char *            fam_spec;
 494         int                     i;
 495
 496         gai_req = context;
 497         gai_resp = resp;
 498
 499         DEBUG_REQUIRE(BLOCKING_GETADDRINFO == rtype);
 500         DEBUG_REQUIRE(respsize == gai_resp->octets);
 501
 502         node = (char *)gai_req + sizeof(*gai_req);
 503         service = node + gai_req->nodesize;
 504
 505         child_ctx = dnschild_contexts[gai_req->dns_idx];
 506
 507         if (0 == gai_resp->retcode) {
 508                 /*
 509                  * If this query succeeded only after retrying, DNS may have
 510                  * just become responsive.
 511                  */
 512                 if (gai_resp->retry > INITIAL_DNS_RETRY) {
 513                         time_now = time(NULL);
 514                         child_ctx->next_dns_timeslot = time_now;
 515                         TRACE(1, ("DNS success after retry, %u next_dns_timeslot reset (%s)\n",
 516                                   gai_req->dns_idx, humantime(time_now)));
 517                 }
 518         } else {
 519                 noerr = !!(gai_req->qflags & GAIR_F_IGNDNSERR);
 520                 again = noerr || should_retry_dns(
 521                                         gai_resp->retcode, gai_resp->gai_errno);
 522                 /*
 523                  * exponential backoff of DNS retries to 64s
 524                  */
 525                 if (gai_req->retry > 0 && again) {
 526                         /* log the first retry only */
 527                         if (INITIAL_DNS_RETRY == gai_req->retry)
 528                                 NLOG(NLOG_SYSINFO) {
 529                                         af = gai_req->hints.ai_family;
 530                                         fam_spec = (AF_INET6 == af)
 531                                                        ? " (AAAA)"
 532                                                        : (AF_INET == af)
 533                                                              ? " (A)"
 534                                                              : "";
 535 #ifdef EAI_SYSTEM
 536                                         if (EAI_SYSTEM == gai_resp->retcode) {
 537                                                 errno = gai_resp->gai_errno;
 538                                                 msyslog(LOG_INFO,
 539                                                         "retrying DNS %s%s: EAI_SYSTEM %d: %m",
 540                                                         node, fam_spec,
 541                                                         gai_resp->gai_errno);
 542                                         } else
 543 #endif
 544                                                 msyslog(LOG_INFO,
 545                                                         "retrying DNS %s%s: %s (%d)",
 546                                                         node, fam_spec,
 547                                                         gai_strerror(gai_resp->retcode),
 548                                                         gai_resp->retcode);
 549                                 }
 550                         manage_dns_retry_interval(
 551                                 &gai_req->scheduled, &gai_req->earliest,
 552                                 &gai_req->retry, &child_ctx->next_dns_timeslot,
 553                                 noerr);
 554                         if (!queue_blocking_request(
 555                                         BLOCKING_GETADDRINFO,
 556                                         gai_req,
 557                                         gai_req->octets,
 558                                         &getaddrinfo_sometime_complete,
 559                                         gai_req))
 560                                 return;
 561                         else
 562                                 msyslog(LOG_ERR,
 563                                         "unable to retry hostname %s",
 564                                         node);
 565                 }
 566         }
 567
 568         /*
 569          * fixup pointers in returned addrinfo array
 570          */
 571         ai = (void *)((char *)gai_resp + sizeof(*gai_resp));
 572         next_ai = NULL;
 573         for (i = gai_resp->ai_count - 1; i >= 0; i--) {
 574                 ai[i].ai_next = next_ai;
 575                 next_ai = &ai[i];
 576         }
 577
 578         psau = (void *)((char *)ai + gai_resp->ai_count * sizeof(*ai));
 579         canon_start = (char *)psau + gai_resp->ai_count * sizeof(*psau);
 580
 581         for (i = 0; i < gai_resp->ai_count; i++) {
 582                 if (NULL != ai[i].ai_addr)
 583                         ai[i].ai_addr = &psau->sa;
 584                 psau++;
 585                 if (NULL != ai[i].ai_canonname)
 586                         ai[i].ai_canonname += (size_t)canon_start;
 587         }
 588
 589         ENSURE((char *)psau == canon_start);
 590
 591         if (!gai_resp->ai_count)
 592                 ai = NULL;
 593
 594         (*gai_req->callback)(gai_resp->retcode, gai_resp->gai_errno,
 595                              gai_req->context, node, service,
 596                              &gai_req->hints, ai);
 597
 598         free(gai_req);
 599         /* gai_resp is part of block freed by process_blocking_resp() */
 600 }
 601
 602
 603 #ifdef TEST_BLOCKING_WORKER
 604 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)
 605 {
 606         sockaddr_u addr;
 607
 608         if (rescode) {
 609                 TRACE(1, ("gai_test_callback context %p error rescode %d %s serv %s\n",
 610                           context, rescode, name, service));
 611                 return;
 612         }
 613         while (!rescode && NULL != ai_res) {
 614                 ZERO_SOCK(&addr);
 615                 memcpy(&addr, ai_res->ai_addr, ai_res->ai_addrlen);
 616                 TRACE(1, ("ctx %p fam %d addr %s canon '%s' type %s at %p ai_addr %p ai_next %p\n",
 617                           context,
 618                           AF(&addr),
 619                           stoa(&addr),
 620                           (ai_res->ai_canonname)
 621                               ? ai_res->ai_canonname
 622                               : "",
 623                           (SOCK_DGRAM == ai_res->ai_socktype)
 624                               ? "DGRAM"
 625                               : (SOCK_STREAM == ai_res->ai_socktype)
 626                                     ? "STREAM"
 627                                     : "(other)",
 628                           ai_res,
 629                           ai_res->ai_addr,
 630                           ai_res->ai_next));
 631
 632                 getnameinfo_sometime((sockaddr_u *)ai_res->ai_addr, 128, 32, 0, gni_test_callback, context);
 633
 634                 ai_res = ai_res->ai_next;
 635         }
 636 }
 637 #endif  /* TEST_BLOCKING_WORKER */
 638
 639
 640 int
 641 getnameinfo_sometime(
 642         sockaddr_u *            psau,
 643         size_t                  hostoctets,
 644         size_t                  servoctets,
 645         int                     flags,
 646         gni_sometime_callback   callback,
 647         void *                  context
 648         )
 649 {
 650         blocking_gni_req *      gni_req;
 651         u_int                   idx;
 652         dnschild_ctx *          child_ctx;
 653         time_t                  time_now;
 654
 655         REQUIRE(hostoctets);
 656         REQUIRE(hostoctets + servoctets < 1024);
 657
 658         idx = get_dnschild_ctx();
 659         child_ctx = dnschild_contexts[idx];
 660
 661         gni_req = emalloc_zero(sizeof(*gni_req));
 662
 663         gni_req->octets = sizeof(*gni_req);
 664         gni_req->dns_idx = idx;
 665         time_now = time(NULL);
 666         gni_req->scheduled = time_now;
 667         gni_req->earliest = max(time_now, child_ctx->next_dns_timeslot);
 668         child_ctx->next_dns_timeslot = gni_req->earliest;
 669         memcpy(&gni_req->socku, psau, SOCKLEN(psau));
 670         gni_req->hostoctets = hostoctets;
 671         gni_req->servoctets = servoctets;
 672         gni_req->flags = flags;
 673         gni_req->retry = INITIAL_DNS_RETRY;
 674         gni_req->callback = callback;
 675         gni_req->context = context;
 676
 677         if (queue_blocking_request(
 678                 BLOCKING_GETNAMEINFO,
 679                 gni_req,
 680                 sizeof(*gni_req),
 681                 &getnameinfo_sometime_complete,
 682                 gni_req)) {
 683
 684                 msyslog(LOG_ERR, "unable to queue getnameinfo request");
 685                 errno = EFAULT;
 686                 return -1;
 687         }
 688
 689         return 0;
 690 }
 691
 692
 693 int
 694 blocking_getnameinfo(
 695         blocking_child *        c,
 696         blocking_pipe_header *  req
 697         )
 698 {
 699         blocking_gni_req *      gni_req;
 700         dnsworker_ctx *         worker_ctx;
 701         blocking_pipe_header *  resp;
 702         blocking_gni_resp *     gni_resp;
 703         size_t                  octets;
 704         size_t                  resp_octets;
 705         char *                  service;
 706         char *                  cp;
 707         int                     rc;
 708         time_t                  time_now;
 709         char                    host[1024];
 710
 711         gni_req = (void *)((char *)req + sizeof(*req));
 712
 713         octets = gni_req->hostoctets + gni_req->servoctets;
 714
 715         /*
 716          * Some alloca() implementations are fragile regarding
 717          * large allocations.  We only need room for the host
 718          * and service names.
 719          */
 720         REQUIRE(octets < sizeof(host));
 721         service = host + gni_req->hostoctets;
 722
 723         worker_ctx = get_worker_context(c, gni_req->dns_idx);
 724         scheduled_sleep(gni_req->scheduled, gni_req->earliest,
 725                         worker_ctx);
 726         reload_resolv_conf(worker_ctx);
 727
 728         /*
 729          * Take a shot at the final size, better to overestimate
 730          * then realloc to a smaller size.
 731          */
 732
 733         resp_octets = sizeof(*resp) + sizeof(*gni_resp) + octets;
 734         resp = emalloc_zero(resp_octets);
 735         gni_resp = (void *)((char *)resp + sizeof(*resp));
 736
 737         TRACE(2, ("blocking_getnameinfo given addr %s flags 0x%x hostlen %lu servlen %lu\n",
 738                   stoa(&gni_req->socku), gni_req->flags,
 739                   (u_long)gni_req->hostoctets, (u_long)gni_req->servoctets));
 740
 741         gni_resp->retcode = getnameinfo(&gni_req->socku.sa,
 742                                         SOCKLEN(&gni_req->socku),
 743                                         host,
 744                                         gni_req->hostoctets,
 745                                         service,
 746                                         gni_req->servoctets,
 747                                         gni_req->flags);
 748         gni_resp->retry = gni_req->retry;
 749 #ifdef EAI_SYSTEM
 750         if (EAI_SYSTEM == gni_resp->retcode)
 751                 gni_resp->gni_errno = errno;
 752 #endif
 753
 754         if (0 != gni_resp->retcode) {
 755                 gni_resp->hostoctets = 0;
 756                 gni_resp->servoctets = 0;
 757         } else {
 758                 gni_resp->hostoctets = strlen(host) + 1;
 759                 gni_resp->servoctets = strlen(service) + 1;
 760                 /*
 761                  * If this query succeeded only after retrying, DNS may have
 762                  * just become responsive.  Ignore previously-scheduled
 763                  * retry sleeps once for each pending request, similar to
 764                  * the way scheduled_sleep() does when its worker_sleep()
 765                  * is interrupted.
 766                  */
 767                 if (gni_req->retry > INITIAL_DNS_RETRY) {
 768                         time_now = time(NULL);
 769                         worker_ctx->ignore_scheduled_before = time_now;
 770                         TRACE(1, ("DNS success after retrying, ignoring sleeps scheduled before now (%s)\n",
 771                                 humantime(time_now)));
 772                 }
 773         }
 774         octets = gni_resp->hostoctets + gni_resp->servoctets;
 775         /*
 776          * Our response consists of a header, followed by the host and
 777          * service strings, each null-terminated.
 778          */
 779         resp_octets = sizeof(*resp) + sizeof(*gni_resp) + octets;
 780
 781         resp = erealloc(resp, resp_octets);
 782         gni_resp = (void *)(resp + 1);
 783
 784         gni_resp->octets = sizeof(*gni_resp) + octets;
 785
 786         /* cp serves as our current pointer while serializing */
 787         cp = (void *)(gni_resp + 1);
 788
 789         if (0 == gni_resp->retcode) {
 790                 memcpy(cp, host, gni_resp->hostoctets);
 791                 cp += gni_resp->hostoctets;
 792                 memcpy(cp, service, gni_resp->servoctets);
 793                 cp += gni_resp->servoctets;
 794         }
 795
 796         INSIST((size_t)(cp - (char *)resp) == resp_octets);
 797         INSIST(resp_octets - sizeof(*resp) == gni_resp->octets);
 798
 799         rc = queue_blocking_response(c, resp, resp_octets, req);
 800         if (rc)
 801                 msyslog(LOG_ERR, "blocking_getnameinfo unable to queue response");
 802         return rc;
 803 }
 804
 805
 806 static void
 807 getnameinfo_sometime_complete(
 808         blocking_work_req       rtype,
 809         void *                  context,
 810         size_t                  respsize,
 811         void *                  resp
 812         )
 813 {
 814         blocking_gni_req *      gni_req;
 815         blocking_gni_resp *     gni_resp;
 816         dnschild_ctx *          child_ctx;
 817         char *                  host;
 818         char *                  service;
 819         time_t                  time_now;
 820         int                     again;
 821
 822         gni_req = context;
 823         gni_resp = resp;
 824
 825         DEBUG_REQUIRE(BLOCKING_GETNAMEINFO == rtype);
 826         DEBUG_REQUIRE(respsize == gni_resp->octets);
 827
 828         child_ctx = dnschild_contexts[gni_req->dns_idx];
 829
 830         if (0 == gni_resp->retcode) {
 831                 /*
 832                  * If this query succeeded only after retrying, DNS may have
 833                  * just become responsive.
 834                  */
 835                 if (gni_resp->retry > INITIAL_DNS_RETRY) {
 836                         time_now = time(NULL);
 837                         child_ctx->next_dns_timeslot = time_now;
 838                         TRACE(1, ("DNS success after retry, %u next_dns_timeslot reset (%s)\n",
 839                                   gni_req->dns_idx, humantime(time_now)));
 840                 }
 841         } else {
 842                 again = should_retry_dns(gni_resp->retcode, gni_resp->gni_errno);
 843                 /*
 844                  * exponential backoff of DNS retries to 64s
 845                  */
 846                 if (gni_req->retry > 0)
 847                         manage_dns_retry_interval(&gni_req->scheduled,
 848                             &gni_req->earliest, &gni_req->retry,
 849                                                   &child_ctx->next_dns_timeslot, FALSE);
 850
 851                 if (gni_req->retry > 0 && again) {
 852                         if (!queue_blocking_request(
 853                                 BLOCKING_GETNAMEINFO,
 854                                 gni_req,
 855                                 gni_req->octets,
 856                                 &getnameinfo_sometime_complete,
 857                                 gni_req))
 858                                 return;
 859
 860                         msyslog(LOG_ERR, "unable to retry reverse lookup of %s", stoa(&gni_req->socku));
 861                 }
 862         }
 863
 864         if (!gni_resp->hostoctets) {
 865                 host = NULL;
 866                 service = NULL;
 867         } else {
 868                 host = (char *)gni_resp + sizeof(*gni_resp);
 869                 service = (gni_resp->servoctets)
 870                               ? host + gni_resp->hostoctets
 871                               : NULL;
 872         }
 873
 874         (*gni_req->callback)(gni_resp->retcode, gni_resp->gni_errno,
 875                              &gni_req->socku, gni_req->flags, host,
 876                              service, gni_req->context);
 877
 878         free(gni_req);
 879         /* gni_resp is part of block freed by process_blocking_resp() */
 880 }
 881
 882
 883 #ifdef TEST_BLOCKING_WORKER
 884 void gni_test_callback(int rescode, int gni_errno, sockaddr_u *psau, int flags, const char *host, const char *service, void *context)
 885 {
 886         if (!rescode)
 887                 TRACE(1, ("gni_test_callback got host '%s' serv '%s' for addr %s context %p\n",
 888                           host, service, stoa(psau), context));
 889         else
 890                 TRACE(1, ("gni_test_callback context %p rescode %d gni_errno %d flags 0x%x addr %s\n",
 891                           context, rescode, gni_errno, flags, stoa(psau)));
 892 }
 893 #endif  /* TEST_BLOCKING_WORKER */
 894
 895
 896 #ifdef HAVE_RES_INIT
 897 static void
 898 reload_resolv_conf(
 899         dnsworker_ctx * worker_ctx
 900         )
 901 {
 902         time_t  time_now;
 903
 904         /*
 905          * This is ad-hoc.  Reload /etc/resolv.conf once per minute
 906          * to pick up on changes from the DHCP client.  [Bug 1226]
 907          * When using threads for the workers, this needs to happen
 908          * only once per minute process-wide.
 909          */
 910         time_now = time(NULL);
 911 # ifdef WORK_THREAD
 912         worker_ctx->next_res_init = next_res_init;
 913 # endif
 914         if (worker_ctx->next_res_init <= time_now) {
 915                 if (worker_ctx->next_res_init != 0)
 916                         res_init();
 917                 worker_ctx->next_res_init = time_now + 60;
 918 # ifdef WORK_THREAD
 919                 next_res_init = worker_ctx->next_res_init;
 920 # endif
 921         }
 922 }
 923 #endif  /* HAVE_RES_INIT */
 924
 925
 926 static u_int
 927 reserve_dnschild_ctx(void)
 928 {
 929         const size_t    ps = sizeof(dnschild_contexts[0]);
 930         const size_t    cs = sizeof(*dnschild_contexts[0]);
 931         u_int           c;
 932         u_int           new_alloc;
 933         size_t          octets;
 934         size_t          new_octets;
 935
 936         c = 0;
 937         while (TRUE) {
 938                 for ( ; c < dnschild_contexts_alloc; c++) {
 939                         if (NULL == dnschild_contexts[c]) {
 940                                 dnschild_contexts[c] = emalloc_zero(cs);
 941
 942                                 return c;
 943                         }
 944                 }
 945                 new_alloc = dnschild_contexts_alloc + 20;
 946                 new_octets = new_alloc * ps;
 947                 octets = dnschild_contexts_alloc * ps;
 948                 dnschild_contexts = erealloc_zero(dnschild_contexts,
 949                                                   new_octets, octets);
 950                 dnschild_contexts_alloc = new_alloc;
 951         }
 952 }
 953
 954
 955 static u_int
 956 get_dnschild_ctx(void)
 957 {
 958         static u_int    shared_ctx = UINT_MAX;
 959
 960         if (worker_per_query)
 961                 return reserve_dnschild_ctx();
 962
 963         if (UINT_MAX == shared_ctx)
 964                 shared_ctx = reserve_dnschild_ctx();
 965
 966         return shared_ctx;
 967 }
 968
 969
 970 static dnsworker_ctx *
 971 get_worker_context(
 972         blocking_child *        c,
 973         u_int                   idx
 974         )
 975 {
 976         u_int           min_new_alloc;
 977         u_int           new_alloc;
 978         size_t          octets;
 979         size_t          new_octets;
 980         dnsworker_ctx * retv;
 981
 982         worker_global_lock(TRUE);
 983
 984         if (dnsworker_contexts_alloc <= idx) {
 985                 min_new_alloc = 1 + idx;
 986                 /* round new_alloc up to nearest multiple of 4 */
 987                 new_alloc = (min_new_alloc + 4) & ~(4 - 1);
 988                 new_octets = new_alloc * sizeof(dnsworker_ctx*);
 989                 octets = dnsworker_contexts_alloc * sizeof(dnsworker_ctx*);
 990                 dnsworker_contexts = erealloc_zero(dnsworker_contexts,
 991                                                    new_octets, octets);
 992                 dnsworker_contexts_alloc = new_alloc;
 993                 retv = emalloc_zero(sizeof(dnsworker_ctx));
 994                 dnsworker_contexts[idx] = retv;
 995         } else if (NULL == (retv = dnsworker_contexts[idx])) {
 996                 retv = emalloc_zero(sizeof(dnsworker_ctx));
 997                 dnsworker_contexts[idx] = retv;
 998         }
 999
1000         worker_global_lock(FALSE);
1001
1002         ZERO(*retv);
1003         retv->c = c;
1004         return retv;
1005 }
1006
1007
1008 static void
1009 scheduled_sleep(
1010         time_t          scheduled,
1011         time_t          earliest,
1012         dnsworker_ctx * worker_ctx
1013         )
1014 {
1015         time_t now;
1016
1017         if (scheduled < worker_ctx->ignore_scheduled_before) {
1018                 TRACE(1, ("ignoring sleep until %s scheduled at %s (before %s)\n",
1019                           humantime(earliest), humantime(scheduled),
1020                           humantime(worker_ctx->ignore_scheduled_before)));
1021                 return;
1022         }
1023
1024         now = time(NULL);
1025
1026         if (now < earliest) {
1027                 TRACE(1, ("sleep until %s scheduled at %s (>= %s)\n",
1028                           humantime(earliest), humantime(scheduled),
1029                           humantime(worker_ctx->ignore_scheduled_before)));
1030                 if (-1 == worker_sleep(worker_ctx->c, earliest - now)) {
1031                         /* our sleep was interrupted */
1032                         now = time(NULL);
1033                         worker_ctx->ignore_scheduled_before = now;
1034 #ifdef HAVE_RES_INIT
1035                         worker_ctx->next_res_init = now + 60;
1036                         next_res_init = worker_ctx->next_res_init;
1037                         res_init();
1038 #endif
1039                         TRACE(1, ("sleep interrupted by daemon, ignoring sleeps scheduled before now (%s)\n",
1040                                   humantime(worker_ctx->ignore_scheduled_before)));
1041                 }
1042         }
1043 }
1044
1045
1046 /*
1047  * manage_dns_retry_interval is a helper used by
1048  * getaddrinfo_sometime_complete and getnameinfo_sometime_complete
1049  * to calculate the new retry interval and schedule the next query.
1050  */
1051 static void
1052 manage_dns_retry_interval(
1053         time_t *        pscheduled,
1054         time_t *        pwhen,
1055         int *           pretry,
1056         time_t *        pnext_timeslot,
1057         int             forever
1058         )
1059 {
1060         time_t  now;
1061         time_t  when;
1062         int     retry;
1063         int     retmax;
1064
1065         now = time(NULL);
1066         retry = *pretry;
1067         when = max(now + retry, *pnext_timeslot);
1068         *pnext_timeslot = when;
1069
1070         /* this exponential backoff is slower than doubling up: The
1071          * sequence goes 2-3-4-6-8-12-16-24-32... and the upper limit is
1072          * 64 seconds for things that should not repeat forever, and
1073          * 1024 when repeated forever.
1074          */
1075         retmax = forever ? 1024 : 64;
1076         retry <<= 1;
1077         if (retry & (retry - 1))
1078                 retry &= (retry - 1);
1079         else
1080                 retry -= (retry >> 2);
1081         retry = min(retmax, retry);
1082
1083         *pscheduled = now;
1084         *pwhen = when;
1085         *pretry = retry;
1086 }
1087
1088 /*
1089  * should_retry_dns is a helper used by getaddrinfo_sometime_complete
1090  * and getnameinfo_sometime_complete which implements ntpd's DNS retry
1091  * policy.
1092  */
1093 static int
1094 should_retry_dns(
1095         int     rescode,
1096         int     res_errno
1097         )
1098 {
1099         static int      eai_again_seen;
1100         int             again;
1101 #if defined (EAI_SYSTEM) && defined(DEBUG)
1102         char            msg[256];
1103 #endif
1104
1105         /*
1106          * If the resolver failed, see if the failure is
1107          * temporary. If so, return success.
1108          */
1109         again = 0;
1110
1111         switch (rescode) {
1112
1113         case EAI_FAIL:
1114                 again = 1;
1115                 break;
1116
1117         case EAI_AGAIN:
1118                 again = 1;
1119                 eai_again_seen = 1;             /* [Bug 1178] */
1120                 break;
1121
1122         case EAI_NONAME:
1123 #if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
1124         case EAI_NODATA:
1125 #endif
1126                 again = !eai_again_seen;        /* [Bug 1178] */
1127                 break;
1128
1129 #ifdef EAI_SYSTEM
1130         case EAI_SYSTEM:
1131                 /*
1132                  * EAI_SYSTEM means the real error is in errno.  We should be more
1133                  * discriminating about which errno values require retrying, but
1134                  * this matches existing behavior.
1135                  */
1136                 again = 1;
1137 # ifdef DEBUG
1138                 errno_to_str(res_errno, msg, sizeof(msg));
1139                 TRACE(1, ("intres: EAI_SYSTEM errno %d (%s) means try again, right?\n",
1140                           res_errno, msg));
1141 # endif
1142                 break;
1143 #endif
1144         }
1145
1146         TRACE(2, ("intres: resolver returned: %s (%d), %sretrying\n",
1147                   gai_strerror(rescode), rescode, again ? "" : "not "));
1148
1149         return again;
1150 }
1151
1152 #else   /* !WORKER follows */
1153 int ntp_intres_nonempty_compilation_unit;
1154 #endif