luna - curl/tests/server/dnsd.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.se/docs/copyright.html.
  13 *
  14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 * copies of the Software, and permit persons to whom the Software is
  16 * furnished to do so, under the terms of the COPYING file.
  17 *
  18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 * KIND, either express or implied.
  20 *
  21 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "first.h"
  25
  26static int dnsd_wrotepidfile = 0;
  27static int dnsd_wroteportfile = 0;
  28
  29#ifdef HAVE_SYS_SELECT_H
  30#include <sys/select.h>
  31#endif
  32
  33#ifdef __AMIGA__
  34#error building dnsd on AMIGA os is unsupported
  35#endif
  36
  37static uint16_t get16bit(const unsigned char **pkt, size_t *size)
  38{
  39  const unsigned char *p = *pkt;
  40  (*pkt) += 2;
  41  *size -= 2;
  42  return (uint16_t)((p[0] << 8) | p[1]);
  43}
  44
  45#define BLOB_MAX_LEN         4096
  46
  47struct blob {
  48  uint8_t data[BLOB_MAX_LEN];
  49  size_t dlen;
  50};
  51
  52static void blob_reset(struct blob *b)
  53{
  54  memset(b->data, 0, sizeof(b->data));
  55  b->dlen = 0;
  56}
  57
  58static int blob_add(struct blob *b, uint8_t n)
  59{
  60  if(b->dlen + 1 > BLOB_MAX_LEN)
  61    return 1;
  62  b->data[b->dlen] = n;
  63  b->dlen += 1;
  64  return 0;
  65}
  66
  67static int blob_addn(struct blob *b, const uint8_t *data, size_t n)
  68{
  69  if(b->dlen + n > BLOB_MAX_LEN)
  70    return 1;
  71  memcpy(&b->data[b->dlen], data, n);
  72  b->dlen += n;
  73  return 0;
  74}
  75
  76static int blob_add_uint16(struct blob *b, uint16_t n)
  77{
  78  if(b->dlen + 2 > BLOB_MAX_LEN)
  79    return 1;
  80  b->data[b->dlen] = (n >> 8) & 0xffU;
  81  b->data[b->dlen + 1] = n & 0xffU;
  82  b->dlen += 2;
  83  return 0;
  84}
  85
  86static int blob_addchars(struct blob *b, const char *data, size_t n)
  87{
  88  return blob_addn(b, (const uint8_t *)data, n);
  89}
  90
  91static int qname2str(const unsigned char **pkt, size_t *size,
  92                     char *name, size_t name_max)
  93{
  94  unsigned char length;
  95  size_t o = 0;
  96  const unsigned char *p = *pkt;
  97
  98  do {
  99    int i;
 100    length = *p++;
 101    if(*size < length)
 102      /* too long */
 103      return 1;
 104    if(length && o)
 105      name[o++] = '.';
 106    if(o + length >= name_max - 1)
 107      return 1;
 108    for(i = 0; i < length; i++) {
 109      name[o++] = *p++;
 110    }
 111  } while(length);
 112  *size -= (p - *pkt);
 113  *pkt = p;
 114  name[o] = '\0';
 115  return 0;
 116}
 117
 118static int blob_add_qname_part(struct blob *b, struct Curl_str *str)
 119{
 120  size_t dot, skip;
 121
 122  for(dot = 0; dot < str->len; ++dot) {
 123    if(str->str[dot] == '.')
 124      break;
 125  }
 126  if(!dot || (dot > 63)) /* RFC 1035, ch. 3.1 */
 127    return 1;
 128  if(blob_add(b, (uint8_t)dot) ||
 129     (dot && blob_addchars(b, str->str, dot)))
 130    return 1;
 131
 132  skip = dot;
 133  if(dot < str->len)
 134    skip += 1;
 135  str->str += skip;
 136  str->len -= skip;
 137  return 0;
 138}
 139
 140static int blob_add_qname(struct blob *b, const struct Curl_str *str)
 141{
 142  struct Curl_str s = *str;
 143
 144  while(s.len) {
 145    if(s.str[0] == '.') {
 146      if(s.len != 1)
 147        return 1;
 148      break;
 149    }
 150    else {
 151      if(blob_add_qname_part(b, &s))
 152        return 1;
 153    }
 154  }
 155  return blob_add(b, 0);
 156}
 157
 158#define QTYPE_A     1
 159#define QTYPE_AAAA  28
 160#define QTYPE_HTTPS 0x41
 161
 162#if 0
 163#define HTTPS_RR_CODE_MANDATORY       0x00
 164#endif
 165#define HTTPS_RR_CODE_ALPN            0x01
 166#define HTTPS_RR_CODE_NO_DEF_ALPN     0x02
 167#if 0
 168#define HTTPS_RR_CODE_PORT            0x03
 169#define HTTPS_RR_CODE_IPV4            0x04
 170#define HTTPS_RR_CODE_ECH             0x05
 171#define HTTPS_RR_CODE_IPV6            0x06
 172#endif
 173
 174static const char *type2string(uint16_t qtype)
 175{
 176  switch(qtype) {
 177  case QTYPE_A:
 178    return "A";
 179  case QTYPE_AAAA:
 180    return "AAAA";
 181  case QTYPE_HTTPS:
 182    return "HTTPS";
 183  }
 184  return "<unknown>";
 185}
 186
 187/*
 188 * Handle initial connection protocol.
 189 *
 190 * Return query (qname + type + class), type and id.
 191 */
 192static int store_incoming(int qid, const unsigned char *data, size_t size,
 193                          unsigned char *qbuf, size_t qbuflen, size_t *qlen,
 194                          uint16_t *qtype, uint16_t *idp)
 195{
 196  FILE *server;
 197  char dumpfile[256];
 198#if 0
 199  size_t i;
 200#endif
 201  uint16_t qd;
 202  const uint8_t *qptr;
 203  char name[256];
 204  size_t qsize;
 205
 206  *qlen = 0;
 207  *qtype = 0;
 208  *idp = 0;
 209
 210  snprintf(dumpfile, sizeof(dumpfile), "%s/dnsd.input", logdir);
 211
 212  /* Open request dump file. */
 213  server = curlx_fopen(dumpfile, "ab");
 214  if(!server) {
 215    char errbuf[STRERROR_LEN];
 216    int error = errno;
 217    logmsg("fopen() failed with error (%d) %s",
 218           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 219    logmsg("Error opening file '%s'", dumpfile);
 220    return -1;
 221  }
 222
 223  /*
 224                                    1  1  1  1  1  1
 225      0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
 226    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 227    |                      ID                       |
 228    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 229    |QR|   Opcode  |AA|TC|RD|RA|   Z    |   RCODE   |
 230    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 231    |                    QDCOUNT                    |
 232    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 233    |                    ANCOUNT                    |
 234    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 235    |                    NSCOUNT                    |
 236    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 237    |                    ARCOUNT                    |
 238    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 239   */
 240  *idp = get16bit(&data, &size);
 241  data += 2; /* skip the next 16 bits */
 242  size -= 2;
 243#if 0
 244  fprintf(server, "QR: %x\n", (*idp & 0x8000) > 15);
 245  fprintf(server, "OPCODE: %x\n", (*idp & 0x7800) >> 11);
 246  fprintf(server, "TC: %x\n", (*idp & 0x200) >> 9);
 247  fprintf(server, "RD: %x\n", (*idp & 0x100) >> 8);
 248  fprintf(server, "Z: %x\n", (*idp & 0x70) >> 4);
 249  fprintf(server, "RCODE: %x\n", (*idp & 0x0f));
 250#endif
 251  (void)get16bit(&data, &size);
 252
 253  data += 6; /* skip ANCOUNT, NSCOUNT and ARCOUNT */
 254  size -= 6;
 255
 256  /* store pointer and size at the QD point */
 257  qsize = size;
 258  qptr = data;
 259
 260  if(!qname2str(&data, &size, name, sizeof(name))) {
 261    qd = get16bit(&data, &size);
 262    fprintf(server, "QNAME %s QTYPE %s\n", name, type2string(qd));
 263    *qtype = qd;
 264    logmsg("[%d] Question for '%s' type %x / %s",
 265           qid, name, qd, type2string(qd));
 266
 267    (void)get16bit(&data, &size);
 268
 269    *qlen = qsize - size; /* total size of the query */
 270    if(*qlen > qbuflen) {
 271      logmsg("dnsd: query too large: %lu > %lu",
 272             (unsigned long)*qlen, (unsigned long)qbuflen);
 273      curlx_fclose(server);
 274      return -1;
 275    }
 276    memcpy(qbuf, qptr, *qlen);
 277  }
 278  else
 279    logmsg("Bad input qname");
 280#if 0
 281  for(i = 0; i < size; i++) {
 282    fprintf(server, "%02d", (unsigned int)data[i]);
 283  }
 284  fprintf(server, "\n");
 285#endif
 286
 287  curlx_fclose(server);
 288
 289  return 0;
 290}
 291
 292static int add_answer(struct blob *body,
 293                      const unsigned char *a, size_t alen,
 294                      uint16_t qtype)
 295{
 296  uint8_t prefix[10] = {
 297    0xc0, 0x0c, /* points to the query at this fixed packet index */
 298    0x00, 0x00,
 299    0x00, 0x01, /* QCLASS IN */
 300    0x00, 0x00,
 301    0x0a, 0x14, /* TTL, Time to live: 2580 (43 minutes) */
 302  };
 303
 304  /* QTYPE */
 305  prefix[2] = (unsigned char)(qtype >> 8);
 306  prefix[3] = (unsigned char)(qtype & 0xff);
 307
 308  if(blob_addn(body, prefix, sizeof(prefix)))
 309    return 1;
 310  if((alen > UINT16_MAX) || blob_add_uint16(body, (uint16_t)alen))
 311    return 1;
 312  return blob_addn(body, a, alen);
 313}
 314
 315#ifdef _WIN32
 316#define SENDTO3 int
 317#else
 318#define SENDTO3 size_t
 319#endif
 320
 321#define INSTRUCTIONS "dnsd.cmd"
 322
 323static curlx_struct_stat finfo_last;
 324static unsigned char ipv4_pref[4];
 325static unsigned char ipv6_pref[16];
 326static unsigned char ancount_a;
 327static unsigned char ancount_aaaa;
 328
 329static timediff_t a_delay_ms;
 330static timediff_t aaaa_delay_ms;
 331static timediff_t https_delay_ms;
 332
 333static int query_id = -1;
 334
 335static struct blob httpsrr;
 336
 337struct resp {
 338  struct resp *next;
 339  int qid;
 340  struct curltime send_ts;
 341  struct sockaddr addr;
 342  curl_socklen_t addrlen;
 343  struct blob body;
 344};
 345
 346static struct resp *resp_queue;
 347
 348static CURLcode send_resp(curl_socket_t sock, struct resp *resp)
 349{
 350  ssize_t rc;
 351
 352sending:
 353  rc = sendto(sock, (const void *)resp->body.data, (SENDTO3)resp->body.dlen, 0,
 354              &resp->addr, resp->addrlen);
 355  if((rc < 0) && (SOCKERRNO == SOCKEINTR))
 356    goto sending;
 357  if(rc != (ssize_t)resp->body.dlen) {
 358    logmsg("failed sending %d bytes, errno=%d\n",
 359           (int)resp->body.dlen, SOCKERRNO);
 360    return CURLE_SEND_ERROR;
 361  }
 362  logmsg("[%d] sent response", resp->qid);
 363  return CURLE_OK;
 364}
 365
 366static void queue_resp(struct resp *resp)
 367{
 368  struct resp **panchor = &resp_queue;
 369  while(*panchor) {
 370    timediff_t ms = curlx_ptimediff_ms(&(*panchor)->send_ts, &resp->send_ts);
 371    if(ms > 0) /* resp is to be sent before *panchor */
 372      break;
 373    panchor = &(*panchor)->next;
 374  }
 375  resp->next = *panchor;
 376  *panchor = resp;
 377}
 378
 379static timediff_t send_resp_queue(curl_socket_t sock)
 380{
 381  struct resp **panchor = &resp_queue;
 382  struct curltime now = curlx_now();
 383  timediff_t timeout_ms = 0;
 384
 385  while(*panchor) {
 386    struct resp *resp = *panchor;
 387    timediff_t ms = curlx_ptimediff_ms(&resp->send_ts, &now);
 388
 389    if(ms > 0) {
 390      timeout_ms = ms;
 391      break;
 392    }
 393    *panchor = resp->next;
 394    send_resp(sock, resp);
 395    curlx_free(resp);
 396  }
 397  return timeout_ms;
 398}
 399
 400static void clear_resp_queue(void)
 401{
 402  while(resp_queue) {
 403    struct resp *resp = resp_queue;
 404    resp_queue = resp->next;
 405    curlx_free(resp);
 406  }
 407}
 408
 409/* this is an answer to a question */
 410static struct resp *
 411create_resp(int qid, const struct sockaddr *addr, curl_socklen_t addrlen,
 412            const unsigned char *qbuf, size_t qlen,
 413            uint16_t qtype, uint16_t id)
 414{
 415  struct resp *resp;
 416  int a;
 417  timediff_t delay_ms = 0;
 418  char addrbuf[128]; /* IP address buffer */
 419  uint8_t header[12] = {
 420    0x80, 0xea, /* ID, overwrite */
 421    0x81, 0x80,
 422    /*
 423    Flags: 0x8180 Standard query response, No error
 424        1... .... .... .... = Response: Message is a response
 425        .000 0... .... .... = Opcode: Standard query (0)
 426        .... .0.. .... .... = Authoritative: Server is not an authority for
 427                              domain
 428        .... ..0. .... .... = Truncated: Message is not truncated
 429        .... ...1 .... .... = Recursion desired: Do query recursively
 430        .... .... 1... .... = Recursion available: Server can do recursive
 431                              queries
 432        .... .... .0.. .... = Z: reserved (0)
 433        .... .... ..0. .... = Answer authenticated: Answer/authority portion
 434                              was not authenticated by the server
 435        .... .... ...0 .... = Non-authenticated data: Unacceptable
 436        .... .... .... 0000 = Reply code: No error (0)
 437    */
 438    0x0, 0x1, /* QDCOUNT a single question */
 439    0x0, 0x0, /* ANCOUNT number of answers */
 440    0x0, 0x0, /* NSCOUNT */
 441    0x0, 0x0  /* ARCOUNT */
 442  };
 443  uint16_t ancount = 0;
 444
 445  switch(qtype) {
 446  case QTYPE_A:
 447    ancount = ancount_a;
 448    delay_ms = a_delay_ms;
 449    break;
 450  case QTYPE_AAAA:
 451    ancount = ancount_aaaa;
 452    delay_ms = aaaa_delay_ms;
 453    break;
 454  case QTYPE_HTTPS:
 455    if(httpsrr.dlen)
 456      ancount = 1;
 457    delay_ms = https_delay_ms;
 458    break;
 459  }
 460
 461  resp = curlx_calloc(1, sizeof(*resp));
 462  if(!resp)
 463    goto error;
 464
 465  resp->qid = qid;
 466  /* on some platforms `curl_socklen_t` is an `int`. Casting might
 467  * wrap this, but then it still has to fit our record size. */
 468  if((size_t)addrlen > sizeof(resp->addr)) {
 469    logmsg("unable to handle addrlen of %zu", (size_t)addrlen);
 470    goto error;
 471  }
 472  memcpy(&resp->addr, CURL_UNCONST(addr), addrlen);
 473  resp->addrlen = addrlen;
 474
 475  header[0] = (uint8_t)(id >> 8);
 476  header[1] = (uint8_t)(id & 0xff);
 477
 478  header[6] = (uint8_t)(ancount >> 8);
 479  header[7] = (uint8_t)(ancount & 0xff);
 480
 481  if(blob_addn(&resp->body, header, sizeof(header)))
 482    goto error;
 483
 484  if(blob_addn(&resp->body, qbuf, qlen)) {
 485    logmsg("unable to handle query of length %zu", qlen);
 486    goto error;
 487  }
 488
 489  switch(qtype) {
 490  case QTYPE_A:
 491    for(a = 0; a < ancount_a; a++) {
 492      const unsigned char *store = ipv4_pref;
 493      if(add_answer(&resp->body, store, sizeof(ipv4_pref), QTYPE_A))
 494        goto error;
 495      logmsg("[%d] response A (%x) '%s'", qid, QTYPE_A,
 496             curlx_inet_ntop(AF_INET, store, addrbuf, sizeof(addrbuf)));
 497    }
 498    if(!ancount_a)
 499      logmsg("[%d] response A empty", qid);
 500    break;
 501  case QTYPE_AAAA:
 502    for(a = 0; a < ancount_aaaa; a++) {
 503      const unsigned char *store = ipv6_pref;
 504      if(add_answer(&resp->body, store, sizeof(ipv6_pref), QTYPE_AAAA))
 505        goto error;
 506      logmsg("[%d] response AAAA (%x) '%s'", qid, QTYPE_AAAA,
 507             curlx_inet_ntop(AF_INET6, store, addrbuf, sizeof(addrbuf)));
 508    }
 509    if(!ancount_aaaa)
 510      logmsg("[%d] response AAAA empty", qid);
 511    break;
 512  case QTYPE_HTTPS:
 513    if(httpsrr.dlen) {
 514      if(add_answer(&resp->body, httpsrr.data, httpsrr.dlen, QTYPE_HTTPS)) {
 515        logmsg("[%d] error adding https %zu response bytes", qid,
 516               httpsrr.dlen);
 517        goto error;
 518      }
 519      logmsg("[%d] response HTTPS (%x), %zu bytes", qid, QTYPE_HTTPS,
 520             httpsrr.dlen);
 521    }
 522    else
 523      logmsg("[%d] response HTTPS, no record", qid);
 524    break;
 525  }
 526
 527  resp->send_ts = curlx_now();
 528  if(delay_ms > 0) {
 529    int usec = (int)((delay_ms % 1000) * 1000);
 530    resp->send_ts.tv_sec += (time_t)(delay_ms / 1000);
 531    resp->send_ts.tv_usec += usec;
 532    if(resp->send_ts.tv_usec >= 1000000) {
 533      resp->send_ts.tv_sec++;
 534      resp->send_ts.tv_usec -= 1000000;
 535    }
 536    logmsg("[%d] delay response by %" FMT_TIMEDIFF_T "ms", qid, delay_ms);
 537  }
 538  return resp;
 539
 540error:
 541  logmsg("[%d] failed to create response", qid);
 542  curlx_free(resp);
 543  return NULL;
 544}
 545
 546static int read_https_alpn_part(struct blob *b, struct Curl_str *str)
 547{
 548  size_t i, skip;
 549
 550  for(i = 0; i < str->len; ++i) {
 551    if(str->str[i] == ',')
 552      break;
 553  }
 554  if(i > 256)
 555    return 1;
 556  if(blob_add(b, (uint8_t)i) || blob_addchars(b, str->str, i))
 557    return 1;
 558  skip = i + ((i < str->len) ? 1 : 0);
 559  str->str += skip;
 560  str->len -= skip;
 561  return 0;
 562}
 563
 564static int read_https_alpn(struct blob *b, const char **ps)
 565{
 566  struct Curl_str word;
 567  struct blob tmp;
 568
 569  blob_reset(&tmp);
 570  if(curlx_str_word(ps, &word, UINT16_MAX))
 571    return 1;
 572  while(word.len) {
 573    if(read_https_alpn_part(&tmp, &word))
 574      return 1;
 575  }
 576
 577  if(tmp.dlen > UINT16_MAX)
 578    return 1;
 579
 580  if(blob_add_uint16(b, HTTPS_RR_CODE_ALPN) ||
 581     blob_add_uint16(b, (uint16_t)tmp.dlen) ||
 582     blob_addn(b, tmp.data, tmp.dlen))
 583    return 1;
 584  return 0;
 585}
 586
 587static int read_https(struct blob *b, const char *s)
 588{
 589  struct Curl_str word;
 590  curl_off_t n;
 591
 592  blob_reset(b);
 593  /* Parse a HTTPS textual representation inspired by RFC 9460 */
 594  curlx_str_passblanks(&s);
 595  if(curlx_str_number(&s, &n, UINT16_MAX))
 596    return 1;
 597  if(blob_add_uint16(b, (uint16_t)n))
 598    return 1;
 599
 600  curlx_str_passblanks(&s);
 601  if(curlx_str_word(&s, &word, UINT16_MAX)) {
 602    logmsg("https: unable to read target qname, input=%s", s);
 603    return 1;
 604  }
 605  if(blob_add_qname(b, &word))
 606    return 1;
 607
 608  while(*s) {
 609    curlx_str_passblanks(&s);
 610    if(!*s)
 611      break;
 612    if(!strncmp("alpn=", s, 5)) {
 613      s += 5;
 614      if(read_https_alpn(b, &s))
 615        return 1;
 616    }
 617    else if(!strncmp("no-default-alpn", s, 15)) {
 618      s += 15;
 619      if(blob_add_uint16(b, HTTPS_RR_CODE_NO_DEF_ALPN) ||
 620         blob_add_uint16(b, 0))
 621        return 1;
 622    }
 623    else
 624      return 1;
 625  }
 626  return 0;
 627}
 628
 629static void read_instructions(void)
 630{
 631  char file[256];
 632  FILE *f;
 633  curlx_struct_stat finfo;
 634
 635  snprintf(file, sizeof(file), "%s/" INSTRUCTIONS, logdir);
 636  if((curlx_stat(file, &finfo) == 0) &&
 637     (finfo.st_mtime == finfo_last.st_mtime) &&
 638     (finfo.st_size == finfo_last.st_size)
 639#ifndef _WIN32
 640     && (finfo.st_ino == finfo_last.st_ino)
 641#endif
 642#ifdef __APPLE__
 643     && (finfo.st_mtimespec.tv_nsec == finfo_last.st_mtimespec.tv_nsec)
 644#elif defined(_POSIX_C_SOURCE)
 645#if _POSIX_C_SOURCE >= 200809L
 646     && (finfo.st_mtim.tv_nsec == finfo_last.st_mtim.tv_nsec)
 647#endif
 648#endif
 649     ) {
 650    /* looks the same as before, skip reading it again */
 651    return;
 652  }
 653  /* reset defaults */
 654  a_delay_ms = aaaa_delay_ms = https_delay_ms = 0;
 655  blob_reset(&httpsrr);
 656  finfo_last = finfo;
 657
 658  logmsg("read instructions from %s", file);
 659  f = curlx_fopen(file, FOPEN_READTEXT);
 660  if(f) {
 661    char buf[256];
 662    ancount_aaaa = ancount_a = 0;
 663    while(fgets(buf, sizeof(buf), f)) {
 664      const char *rtype = NULL;
 665      char *p = strchr(buf, '\n');
 666      if(p) {
 667        int rc;
 668        *p = 0;
 669        if(!strncmp("A: ", buf, 3)) {
 670          rc = curlx_inet_pton(AF_INET, &buf[3], ipv4_pref);
 671          ancount_a = (rc == 1);
 672          rtype = "A";
 673        }
 674        else if(!strncmp("AAAA: ", buf, 6)) {
 675          char *p6 = &buf[6];
 676          if(*p6 == '[') {
 677            char *pt = strchr(p6, ']');
 678            if(pt)
 679              *pt = 0;
 680            p6++;
 681          }
 682          rc = curlx_inet_pton(AF_INET6, p6, ipv6_pref);
 683          ancount_aaaa = (rc == 1);
 684          rtype = "AAAA";
 685        }
 686        else if(!strncmp("HTTPS: ", buf, 7)) {
 687          rc = read_https(&httpsrr, &buf[7]) ? 0 : 1;
 688          rtype = "HTTPS";
 689        }
 690        else if(!strncmp("Delay-A: ", buf, 9)) {
 691          curl_off_t ms;
 692          const char *pms = &buf[9];
 693          rc = 0;
 694          if(!curlx_str_number(&pms, &ms, 100000)) {
 695            a_delay_ms = (timediff_t)ms;
 696            rc = 1;
 697          }
 698        }
 699        else if(!strncmp("Delay-AAAA: ", buf, 12)) {
 700          curl_off_t ms;
 701          const char *pms = &buf[12];
 702          rc = 0;
 703          if(!curlx_str_number(&pms, &ms, 100000)) {
 704            aaaa_delay_ms = (timediff_t)ms;
 705            rc = 1;
 706          }
 707        }
 708        else if(!strncmp("Delay-HTTPS: ", buf, 13)) {
 709          curl_off_t ms;
 710          const char *pms = &buf[13];
 711          rc = 0;
 712          if(!curlx_str_number(&pms, &ms, 100000)) {
 713            https_delay_ms = (timediff_t)ms;
 714            rc = 1;
 715          }
 716        }
 717        else {
 718          /* accept empty line */
 719          rc = buf[0] ? 0 : 1;
 720        }
 721        if(rc != 1) {
 722          logmsg("Bad line in %s: '%s'\n", file, buf);
 723        }
 724        else if(rtype) {
 725          logmsg("added %s record via '%s'", rtype, buf);
 726        }
 727      }
 728    }
 729    logmsg("set delays: A=%" FMT_TIMEDIFF_T "ms AAAA=%" FMT_TIMEDIFF_T
 730           "ms HTTPS=%" FMT_TIMEDIFF_T "ms",
 731           a_delay_ms, aaaa_delay_ms, https_delay_ms);
 732    curlx_fclose(f);
 733  }
 734  else
 735    logmsg("Error opening file '%s'", file);
 736}
 737
 738static int test_dnsd(int argc, const char **argv)
 739{
 740  srvr_sockaddr_union_t me;
 741  ssize_t n = 0;
 742  int arg = 1;
 743  uint16_t port = 9123; /* UDP */
 744  curl_socket_t sock = CURL_SOCKET_BAD;
 745  int flag;
 746  int rc;
 747  int error;
 748  char errbuf[STRERROR_LEN];
 749  int result = 0;
 750  struct resp *resp;
 751
 752  pidname = ".dnsd.pid";
 753  serverlogfile = "log/dnsd.log";
 754  serverlogslocked = 0;
 755
 756  while(argc > arg) {
 757    const char *opt;
 758    curl_off_t num;
 759    if(!strcmp("--verbose", argv[arg])) {
 760      arg++;
 761      /* nothing yet */
 762    }
 763    else if(!strcmp("--version", argv[arg])) {
 764      printf("dnsd IPv4%s\n",
 765#ifdef USE_IPV6
 766             "/IPv6"
 767#else
 768             ""
 769#endif
 770      );
 771      return 0;
 772    }
 773    else if(!strcmp("--pidfile", argv[arg])) {
 774      arg++;
 775      if(argc > arg)
 776        pidname = argv[arg++];
 777    }
 778    else if(!strcmp("--portfile", argv[arg])) {
 779      arg++;
 780      if(argc > arg)
 781        portname = argv[arg++];
 782    }
 783    else if(!strcmp("--logfile", argv[arg])) {
 784      arg++;
 785      if(argc > arg)
 786        serverlogfile = argv[arg++];
 787    }
 788    else if(!strcmp("--logdir", argv[arg])) {
 789      arg++;
 790      if(argc > arg)
 791        logdir = argv[arg++];
 792    }
 793    else if(!strcmp("--ipv4", argv[arg])) {
 794#ifdef USE_IPV6
 795      ipv_inuse = "IPv4";
 796      use_ipv6 = FALSE;
 797#endif
 798      arg++;
 799    }
 800    else if(!strcmp("--ipv6", argv[arg])) {
 801#ifdef USE_IPV6
 802      ipv_inuse = "IPv6";
 803      use_ipv6 = TRUE;
 804#endif
 805      arg++;
 806    }
 807    else if(!strcmp("--port", argv[arg])) {
 808      arg++;
 809      if(argc > arg) {
 810        opt = argv[arg];
 811        if(!curlx_str_number(&opt, &num, 0xffff))
 812          port = (uint16_t)num;
 813        arg++;
 814      }
 815    }
 816    else {
 817      if(argv[arg])
 818        fprintf(stderr, "unknown option: %s\n", argv[arg]);
 819      puts("Usage: dnsd [option]\n"
 820           " --version\n"
 821           " --logfile [file]\n"
 822           " --logdir [directory]\n"
 823           " --pidfile [file]\n"
 824           " --portfile [file]\n"
 825           " --ipv4\n"
 826           " --ipv6\n"
 827           " --port [port]\n");
 828      return 0;
 829    }
 830  }
 831
 832  snprintf(loglockfile, sizeof(loglockfile), "%s/%s/dnsd-%s.lock",
 833           logdir, SERVERLOGS_LOCKDIR, ipv_inuse);
 834
 835#ifdef USE_IPV6
 836  if(!use_ipv6)
 837#endif
 838    sock = socket(AF_INET, SOCK_DGRAM, 0);
 839#ifdef USE_IPV6
 840  else
 841    sock = socket(AF_INET6, SOCK_DGRAM, 0);
 842#endif
 843
 844  if(sock == CURL_SOCKET_BAD) {
 845    error = SOCKERRNO;
 846    logmsg("Error creating socket (%d) %s",
 847           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 848    result = 1;
 849    goto dnsd_cleanup;
 850  }
 851
 852  flag = 1;
 853  if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) {
 854    error = SOCKERRNO;
 855    logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
 856           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 857    result = 1;
 858    goto dnsd_cleanup;
 859  }
 860
 861#ifdef USE_IPV6
 862  if(!use_ipv6) {
 863#endif
 864    memset(&me.sa4, 0, sizeof(me.sa4));
 865    me.sa4.sin_family = AF_INET;
 866    me.sa4.sin_addr.s_addr = INADDR_ANY;
 867    me.sa4.sin_port = htons(port);
 868    rc = bind(sock, &me.sa, sizeof(me.sa4));
 869#ifdef USE_IPV6
 870  }
 871  else {
 872    memset(&me.sa6, 0, sizeof(me.sa6));
 873    me.sa6.sin6_family = AF_INET6;
 874    me.sa6.sin6_addr = in6addr_any;
 875    me.sa6.sin6_port = htons(port);
 876    rc = bind(sock, &me.sa, sizeof(me.sa6));
 877  }
 878#endif /* USE_IPV6 */
 879  if(rc) {
 880    error = SOCKERRNO;
 881    logmsg("Error binding socket on port %hu (%d) %s", port,
 882           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 883    result = 1;
 884    goto dnsd_cleanup;
 885  }
 886
 887  if(!port) {
 888    /* The system was supposed to choose a port number, figure out which
 889       port we actually got and update the listener port value with it. */
 890    curl_socklen_t la_size;
 891    srvr_sockaddr_union_t localaddr;
 892    memset(&localaddr, 0, sizeof(localaddr));
 893#ifdef USE_IPV6
 894    if(!use_ipv6)
 895#endif
 896      la_size = sizeof(localaddr.sa4);
 897#ifdef USE_IPV6
 898    else
 899      la_size = sizeof(localaddr.sa6);
 900#endif
 901    if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
 902      error = SOCKERRNO;
 903      logmsg("getsockname() failed with error (%d) %s",
 904             error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 905      sclose(sock);
 906      goto dnsd_cleanup;
 907    }
 908    switch(localaddr.sa.sa_family) {
 909    case AF_INET:
 910      port = ntohs(localaddr.sa4.sin_port);
 911      break;
 912#ifdef USE_IPV6
 913    case AF_INET6:
 914      port = ntohs(localaddr.sa6.sin6_port);
 915      break;
 916#endif
 917    default:
 918      break;
 919    }
 920    if(!port) {
 921      /* Real failure, listener port shall not be zero beyond this point. */
 922      logmsg("Apparently getsockname() succeeded, with listener port zero.");
 923      logmsg("A valid reason for this failure is a binary built without");
 924      logmsg("proper network library linkage. This might not be the only");
 925      logmsg("reason, but double check it before anything else.");
 926      result = 2;
 927      goto dnsd_cleanup;
 928    }
 929  }
 930
 931  dnsd_wrotepidfile = write_pidfile(pidname);
 932  if(!dnsd_wrotepidfile) {
 933    result = 1;
 934    goto dnsd_cleanup;
 935  }
 936
 937  if(portname) {
 938    dnsd_wroteportfile = write_portfile(portname, port);
 939    if(!dnsd_wroteportfile) {
 940      result = 1;
 941      goto dnsd_cleanup;
 942    }
 943  }
 944
 945  logmsg("Running %s version on port UDP/%d", ipv_inuse, (int)port);
 946  curlx_nonblock(sock, TRUE);
 947
 948  for(;;) {
 949    uint16_t id = 0;
 950    uint8_t inbuffer[1500];
 951    srvr_sockaddr_union_t from;
 952    curl_socklen_t fromlen;
 953    uint8_t qbuf[256]; /* query storage */
 954    size_t qlen = 0; /* query size */
 955    uint16_t qtype = 0;
 956    timediff_t timeout_ms = 0;
 957    fromlen = sizeof(from);
 958#ifdef USE_IPV6
 959    if(!use_ipv6)
 960#endif
 961      fromlen = sizeof(from.sa4);
 962#ifdef USE_IPV6
 963    else
 964      fromlen = sizeof(from.sa6);
 965#endif
 966
 967    timeout_ms = send_resp_queue(sock);
 968
 969    {
 970      fd_set readfds;
 971      struct timeval tv;
 972      int maxfd = (int)sock;
 973
 974      FD_ZERO(&readfds);
 975      FD_SET(sock, &readfds);
 976      if(!timeout_ms || (timeout_ms > 100))
 977        timeout_ms = 100;
 978
 979      rc = select(maxfd + 1, &readfds, NULL, NULL,
 980                  curlx_mstotv(&tv, timeout_ms));
 981
 982      if(rc == -1) {
 983        logmsg("error %d returned by select()", SOCKERRNO);
 984      }
 985      else if(!rc) { /* timeout */
 986        continue;
 987      }
 988    }
 989    n = (ssize_t)recvfrom(sock, (char *)inbuffer, sizeof(inbuffer), 0,
 990                          &from.sa, &fromlen);
 991    if(got_exit_signal)
 992      break;
 993    if(n < 0) {
 994      logmsg("recvfrom");
 995      result = 3;
 996      break;
 997    }
 998
 999    /* read once per incoming query, which is probably more than one
1000       per test case */
1001    read_instructions();
1002
1003    ++query_id;
1004    store_incoming(query_id, inbuffer, n,
1005                   qbuf, sizeof(qbuf), &qlen, &qtype, &id);
1006
1007    set_advisor_read_lock(loglockfile);
1008    serverlogslocked = 1;
1009
1010    resp = create_resp(query_id, &from.sa, fromlen, qbuf,
1011                       qlen, qtype, id);
1012    if(!resp)
1013      logmsg("error creating response");
1014    else
1015      queue_resp(resp);
1016
1017    if(got_exit_signal)
1018      break;
1019
1020    if(serverlogslocked) {
1021      serverlogslocked = 0;
1022      clear_advisor_read_lock(loglockfile);
1023    }
1024  }
1025
1026dnsd_cleanup:
1027
1028#if 0
1029  if((peer != sock) && (peer != CURL_SOCKET_BAD))
1030    sclose(peer);
1031#endif
1032
1033  if(sock != CURL_SOCKET_BAD)
1034    sclose(sock);
1035
1036  if(got_exit_signal)
1037    logmsg("signalled to die");
1038
1039  if(dnsd_wrotepidfile)
1040    unlink(pidname);
1041  if(dnsd_wroteportfile)
1042    unlink(portname);
1043
1044  if(serverlogslocked) {
1045    serverlogslocked = 0;
1046    clear_advisor_read_lock(loglockfile);
1047  }
1048
1049  clear_resp_queue();
1050  restore_signal_handlers(true);
1051
1052  if(got_exit_signal) {
1053    logmsg("========> %s dnsd (port: %d pid: %ld) exits with signal (%d)",
1054           ipv_inuse, (int)port, (long)our_getpid(), exit_signal);
1055    /*
1056     * To properly set the return status of the process we
1057     * must raise the same signal SIGINT or SIGTERM that we
1058     * caught and let the old handler take care of it.
1059     */
1060    raise(exit_signal);
1061  }
1062
1063  logmsg("========> dnsd quits");
1064  return result;
1065}