src/rfc1035.c

   1 /* dnsmasq is Copyright (c) 2000-2022 Simon Kelley
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 dated June, 1991, or
   6    (at your option) version 3 dated 29 June, 2007.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15 */
  16
  17 #include "dnsmasq.h"
  18
  19 int extract_name(struct dns_header *header, size_t plen, unsigned char **pp,
  20                  char *name, int isExtract, int extrabytes)
  21 {
  22   unsigned char *cp = (unsigned char *)name, *p = *pp, *p1 = NULL;
  23   unsigned int j, l, namelen = 0, hops = 0;
  24   int retvalue = 1;
  25
  26   if (isExtract)
  27     *cp = 0;
  28
  29   while (1)
  30     {
  31       unsigned int label_type;
  32
  33       if (!CHECK_LEN(header, p, plen, 1))
  34         return 0;
  35
  36       if ((l = *p++) == 0)
  37         /* end marker */
  38         {
  39           /* check that there are the correct no. of bytes after the name */
  40           if (!CHECK_LEN(header, p1 ? p1 : p, plen, extrabytes))
  41             return 0;
  42
  43           if (isExtract)
  44             {
  45               if (cp != (unsigned char *)name)
  46                 cp--;
  47               *cp = 0; /* terminate: lose final period */
  48             }
  49           else if (*cp != 0)
  50             retvalue = 2;
  51
  52           if (p1) /* we jumped via compression */
  53             *pp = p1;
  54           else
  55             *pp = p;
  56
  57           return retvalue;
  58         }
  59
  60       label_type = l & 0xc0;
  61
  62       if (label_type == 0xc0) /* pointer */
  63         {
  64           if (!CHECK_LEN(header, p, plen, 1))
  65             return 0;
  66
  67           /* get offset */
  68           l = (l&0x3f) << 8;
  69           l |= *p++;
  70
  71           if (!p1) /* first jump, save location to go back to */
  72             p1 = p;
  73
  74           hops++; /* break malicious infinite loops */
  75           if (hops > 255)
  76             return 0;
  77
  78           p = l + (unsigned char *)header;
  79         }
  80       else if (label_type == 0x00)
  81         { /* label_type = 0 -> label. */
  82           namelen += l + 1; /* include period */
  83           if (namelen >= MAXDNAME)
  84             return 0;
  85           if (!CHECK_LEN(header, p, plen, l))
  86             return 0;
  87
  88           for(j=0; j<l; j++, p++)
  89             if (isExtract)
  90               {
  91                 unsigned char c = *p;
  92 #ifdef HAVE_DNSSEC
  93                 if (option_bool(OPT_DNSSEC_VALID))
  94                   {
  95                     if (c == 0 || c == '.' || c == NAME_ESCAPE)
  96                       {
  97                         *cp++ = NAME_ESCAPE;
  98                         *cp++ = c+1;
  99                       }
 100                     else
 101                       *cp++ = c;
 102                   }
 103                 else
 104 #endif
 105                 if (c != 0 && c != '.')
 106                   *cp++ = c;
 107                 else
 108                   return 0;
 109               }
 110             else
 111               {
 112                 unsigned char c1 = *cp, c2 = *p;
 113
 114                 if (c1 == 0)
 115                   retvalue = 2;
 116                 else
 117                   {
 118                     cp++;
 119                     if (c1 >= 'A' && c1 <= 'Z')
 120                       c1 += 'a' - 'A';
 121 #ifdef HAVE_DNSSEC
 122                     if (option_bool(OPT_DNSSEC_VALID) && c1 == NAME_ESCAPE)
 123                       c1 = (*cp++)-1;
 124 #endif
 125
 126                     if (c2 >= 'A' && c2 <= 'Z')
 127                       c2 += 'a' - 'A';
 128
 129                     if (c1 != c2)
 130                       retvalue =  2;
 131                   }
 132               }
 133
 134           if (isExtract)
 135             *cp++ = '.';
 136           else if (*cp != 0 && *cp++ != '.')
 137             retvalue = 2;
 138         }
 139       else
 140         return 0; /* label types 0x40 and 0x80 not supported */
 141     }
 142 }
 143
 144 /* Max size of input string (for IPv6) is 75 chars.) */
 145 #define MAXARPANAME 75
 146 int in_arpa_name_2_addr(char *namein, union all_addr *addrp)
 147 {
 148   int j;
 149   char name[MAXARPANAME+1], *cp1;
 150   unsigned char *addr = (unsigned char *)addrp;
 151   char *lastchunk = NULL, *penchunk = NULL;
 152
 153   if (strlen(namein) > MAXARPANAME)
 154     return 0;
 155
 156   memset(addrp, 0, sizeof(union all_addr));
 157
 158   /* turn name into a series of asciiz strings */
 159   /* j counts no. of labels */
 160   for(j = 1,cp1 = name; *namein; cp1++, namein++)
 161     if (*namein == '.')
 162       {
 163         penchunk = lastchunk;
 164         lastchunk = cp1 + 1;
 165         *cp1 = 0;
 166         j++;
 167       }
 168     else
 169       *cp1 = *namein;
 170
 171   *cp1 = 0;
 172
 173   if (j<3)
 174     return 0;
 175
 176   if (hostname_isequal(lastchunk, "arpa") && hostname_isequal(penchunk, "in-addr"))
 177     {
 178       /* IP v4 */
 179       /* address arrives as a name of the form
 180          www.xxx.yyy.zzz.in-addr.arpa
 181          some of the low order address octets might be missing
 182          and should be set to zero. */
 183       for (cp1 = name; cp1 != penchunk; cp1 += strlen(cp1)+1)
 184         {
 185           /* check for digits only (weeds out things like
 186              50.0/24.67.28.64.in-addr.arpa which are used
 187              as CNAME targets according to RFC 2317 */
 188           char *cp;
 189           for (cp = cp1; *cp; cp++)
 190             if (!isdigit((unsigned char)*cp))
 191               return 0;
 192
 193           addr[3] = addr[2];
 194           addr[2] = addr[1];
 195           addr[1] = addr[0];
 196           addr[0] = atoi(cp1);
 197         }
 198
 199       return F_IPV4;
 200     }
 201   else if (hostname_isequal(penchunk, "ip6") &&
 202            (hostname_isequal(lastchunk, "int") || hostname_isequal(lastchunk, "arpa")))
 203     {
 204       /* IP v6:
 205          Address arrives as 0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f.ip6.[int|arpa]
 206          or \[xfedcba9876543210fedcba9876543210/128].ip6.[int|arpa]
 207
 208          Note that most of these the various representations are obsolete and
 209          left-over from the many DNS-for-IPv6 wars. We support all the formats
 210          that we can since there is no reason not to.
 211       */
 212
 213       if (*name == '\\' && *(name+1) == '[' &&
 214           (*(name+2) == 'x' || *(name+2) == 'X'))
 215         {
 216           for (j = 0, cp1 = name+3; *cp1 && isxdigit((unsigned char) *cp1) && j < 32; cp1++, j++)
 217             {
 218               char xdig[2];
 219               xdig[0] = *cp1;
 220               xdig[1] = 0;
 221               if (j%2)
 222                 addr[j/2] |= strtol(xdig, NULL, 16);
 223               else
 224                 addr[j/2] = strtol(xdig, NULL, 16) << 4;
 225             }
 226
 227           if (*cp1 == '/' && j == 32)
 228             return F_IPV6;
 229         }
 230       else
 231         {
 232           for (cp1 = name; cp1 != penchunk; cp1 += strlen(cp1)+1)
 233             {
 234               if (*(cp1+1) || !isxdigit((unsigned char)*cp1))
 235                 return 0;
 236
 237               for (j = sizeof(struct in6_addr)-1; j>0; j--)
 238                 addr[j] = (addr[j] >> 4) | (addr[j-1] << 4);
 239               addr[0] = (addr[0] >> 4) | (strtol(cp1, NULL, 16) << 4);
 240             }
 241
 242           return F_IPV6;
 243         }
 244     }
 245
 246   return 0;
 247 }
 248
 249 unsigned char *skip_name(unsigned char *ansp, struct dns_header *header, size_t plen, int extrabytes)
 250 {
 251   while(1)
 252     {
 253       unsigned int label_type;
 254
 255       if (!CHECK_LEN(header, ansp, plen, 1))
 256         return NULL;
 257
 258       label_type = (*ansp) & 0xc0;
 259
 260       if (label_type == 0xc0)
 261         {
 262           /* pointer for compression. */
 263           ansp += 2;
 264           break;
 265         }
 266       else if (label_type == 0x80)
 267         return NULL; /* reserved */
 268       else if (label_type == 0x40)
 269         {
 270           /* Extended label type */
 271           unsigned int count;
 272
 273           if (!CHECK_LEN(header, ansp, plen, 2))
 274             return NULL;
 275
 276           if (((*ansp++) & 0x3f) != 1)
 277             return NULL; /* we only understand bitstrings */
 278
 279           count = *(ansp++); /* Bits in bitstring */
 280
 281           if (count == 0) /* count == 0 means 256 bits */
 282             ansp += 32;
 283           else
 284             ansp += ((count-1)>>3)+1;
 285         }
 286       else
 287         { /* label type == 0 Bottom six bits is length */
 288           unsigned int len = (*ansp++) & 0x3f;
 289
 290           if (!ADD_RDLEN(header, ansp, plen, len))
 291             return NULL;
 292
 293           if (len == 0)
 294             break; /* zero length label marks the end. */
 295         }
 296     }
 297
 298   if (!CHECK_LEN(header, ansp, plen, extrabytes))
 299     return NULL;
 300
 301   return ansp;
 302 }
 303
 304 unsigned char *skip_questions(struct dns_header *header, size_t plen)
 305 {
 306   int q;
 307   unsigned char *ansp = (unsigned char *)(header+1);
 308
 309   for (q = ntohs(header->qdcount); q != 0; q--)
 310     {
 311       if (!(ansp = skip_name(ansp, header, plen, 4)))
 312         return NULL;
 313       ansp += 4; /* class and type */
 314     }
 315
 316   return ansp;
 317 }
 318
 319 unsigned char *skip_section(unsigned char *ansp, int count, struct dns_header *header, size_t plen)
 320 {
 321   int i, rdlen;
 322
 323   for (i = 0; i < count; i++)
 324     {
 325       if (!(ansp = skip_name(ansp, header, plen, 10)))
 326         return NULL;
 327       ansp += 8; /* type, class, TTL */
 328       GETSHORT(rdlen, ansp);
 329       if (!ADD_RDLEN(header, ansp, plen, rdlen))
 330         return NULL;
 331     }
 332
 333   return ansp;
 334 }
 335
 336 size_t resize_packet(struct dns_header *header, size_t plen, unsigned char *pheader, size_t hlen)
 337 {
 338   unsigned char *ansp = skip_questions(header, plen);
 339
 340   /* if packet is malformed, just return as-is. */
 341   if (!ansp)
 342     return plen;
 343
 344   if (!(ansp = skip_section(ansp, ntohs(header->ancount) + ntohs(header->nscount) + ntohs(header->arcount),
 345                             header, plen)))
 346     return plen;
 347
 348   /* restore pseudoheader */
 349   if (pheader && ntohs(header->arcount) == 0)
 350     {
 351       /* must use memmove, may overlap */
 352       memmove(ansp, pheader, hlen);
 353       header->arcount = htons(1);
 354       ansp += hlen;
 355     }
 356
 357   return ansp - (unsigned char *)header;
 358 }
 359
 360 /* is addr in the non-globally-routed IP space? */
 361 int private_net(struct in_addr addr, int ban_localhost)
 362 {
 363   in_addr_t ip_addr = ntohl(addr.s_addr);
 364
 365   return
 366     (((ip_addr & 0xFF000000) == 0x7F000000) && ban_localhost)  /* 127.0.0.0/8    (loopback) */ ||
 367     (((ip_addr & 0xFF000000) == 0x00000000) && ban_localhost) /* RFC 5735 section 3. "here" network */ ||
 368     ((ip_addr & 0xFF000000) == 0x0A000000)  /* 10.0.0.0/8     (private)  */ ||
 369     ((ip_addr & 0xFFF00000) == 0xAC100000)  /* 172.16.0.0/12  (private)  */ ||
 370     ((ip_addr & 0xFFFF0000) == 0xC0A80000)  /* 192.168.0.0/16 (private)  */ ||
 371     ((ip_addr & 0xFFFF0000) == 0xA9FE0000)  /* 169.254.0.0/16 (zeroconf) */ ||
 372     ((ip_addr & 0xFFFFFF00) == 0xC0000200)  /* 192.0.2.0/24   (test-net) */ ||
 373     ((ip_addr & 0xFFFFFF00) == 0xC6336400)  /* 198.51.100.0/24(test-net) */ ||
 374     ((ip_addr & 0xFFFFFF00) == 0xCB007100)  /* 203.0.113.0/24 (test-net) */ ||
 375     ((ip_addr & 0xFFFFFFFF) == 0xFFFFFFFF)  /* 255.255.255.255/32 (broadcast)*/ ;
 376 }
 377
 378 static int private_net6(struct in6_addr *a, int ban_localhost)
 379 {
 380   /* Block IPv4-mapped IPv6 addresses in private IPv4 address space */
 381   if (IN6_IS_ADDR_V4MAPPED(a))
 382     {
 383       struct in_addr v4;
 384       v4.s_addr = ((const uint32_t *) (a))[3];
 385       return private_net(v4, ban_localhost);
 386     }
 387
 388   return
 389     (IN6_IS_ADDR_UNSPECIFIED(a) && ban_localhost) || /* RFC 6303 4.3 */
 390     (IN6_IS_ADDR_LOOPBACK(a) && ban_localhost) ||    /* RFC 6303 4.3 */
 391     IN6_IS_ADDR_LINKLOCAL(a) ||   /* RFC 6303 4.5 */
 392     IN6_IS_ADDR_SITELOCAL(a) ||
 393     ((unsigned char *)a)[0] == 0xfd ||   /* RFC 6303 4.4 */
 394     ((u32 *)a)[0] == htonl(0x20010db8); /* RFC 6303 4.6 */
 395 }
 396
 397 static unsigned char *do_doctor(unsigned char *p, int count, struct dns_header *header, size_t qlen, int *doctored)
 398 {
 399   int i, qtype, qclass, rdlen;
 400
 401   for (i = count; i != 0; i--)
 402     {
 403       if (!(p = skip_name(p, header, qlen, 10)))
 404         return 0; /* bad packet */
 405
 406       GETSHORT(qtype, p);
 407       GETSHORT(qclass, p);
 408       p += 4; /* ttl */
 409       GETSHORT(rdlen, p);
 410
 411       if (qclass == C_IN && qtype == T_A)
 412         {
 413           struct doctor *doctor;
 414           struct in_addr addr;
 415
 416           if (!CHECK_LEN(header, p, qlen, INADDRSZ))
 417             return 0;
 418
 419           /* alignment */
 420           memcpy(&addr, p, INADDRSZ);
 421
 422           for (doctor = daemon->doctors; doctor; doctor = doctor->next)
 423             {
 424               if (doctor->end.s_addr == 0)
 425                 {
 426                   if (!is_same_net(doctor->in, addr, doctor->mask))
 427                     continue;
 428                 }
 429               else if (ntohl(doctor->in.s_addr) > ntohl(addr.s_addr) ||
 430                        ntohl(doctor->end.s_addr) < ntohl(addr.s_addr))
 431                 continue;
 432
 433               addr.s_addr &= ~doctor->mask.s_addr;
 434               addr.s_addr |= (doctor->out.s_addr & doctor->mask.s_addr);
 435               /* Since we munged the data, the server it came from is no longer authoritative */
 436               header->hb3 &= ~HB3_AA;
 437               *doctored = 1;
 438               memcpy(p, &addr, INADDRSZ);
 439               break;
 440             }
 441         }
 442
 443       if (!ADD_RDLEN(header, p, qlen, rdlen))
 444          return 0; /* bad packet */
 445     }
 446
 447   return p;
 448 }
 449
 450 static int find_soa(struct dns_header *header, size_t qlen, int *doctored)
 451 {
 452   unsigned char *p;
 453   int qtype, qclass, rdlen;
 454   unsigned long ttl, minttl = ULONG_MAX;
 455   int i, found_soa = 0;
 456
 457   /* first move to NS section and find TTL from any SOA section */
 458   if (!(p = skip_questions(header, qlen)) ||
 459       !(p = do_doctor(p, ntohs(header->ancount), header, qlen, doctored)))
 460     return 0;  /* bad packet */
 461
 462   for (i = ntohs(header->nscount); i != 0; i--)
 463     {
 464       if (!(p = skip_name(p, header, qlen, 10)))
 465         return 0; /* bad packet */
 466
 467       GETSHORT(qtype, p);
 468       GETSHORT(qclass, p);
 469       GETLONG(ttl, p);
 470       GETSHORT(rdlen, p);
 471
 472       if ((qclass == C_IN) && (qtype == T_SOA))
 473         {
 474           found_soa = 1;
 475           if (ttl < minttl)
 476             minttl = ttl;
 477
 478           /* MNAME */
 479           if (!(p = skip_name(p, header, qlen, 0)))
 480             return 0;
 481           /* RNAME */
 482           if (!(p = skip_name(p, header, qlen, 20)))
 483             return 0;
 484           p += 16; /* SERIAL REFRESH RETRY EXPIRE */
 485
 486           GETLONG(ttl, p); /* minTTL */
 487           if (ttl < minttl)
 488             minttl = ttl;
 489         }
 490       else if (!ADD_RDLEN(header, p, qlen, rdlen))
 491         return 0; /* bad packet */
 492     }
 493
 494   /* rewrite addresses in additional section too */
 495   if (!do_doctor(p, ntohs(header->arcount), header, qlen, doctored))
 496     return 0;
 497
 498   if (!found_soa)
 499     minttl = daemon->neg_ttl;
 500
 501   return minttl;
 502 }
 503
 504 /* Print TXT reply to log */
 505 static int print_txt(struct dns_header *header, const size_t qlen, char *name,
 506                      unsigned char *p, const int ardlen, int secflag)
 507 {
 508   unsigned char *p1 = p;
 509   if (!CHECK_LEN(header, p1, qlen, ardlen))
 510     return 0;
 511   /* Loop over TXT payload */
 512   while ((p1 - p) < ardlen)
 513     {
 514       unsigned int i, len = *p1;
 515       unsigned char *p3 = p1;
 516       if ((p1 + len - p) >= ardlen)
 517         return 0; /* bad packet */
 518
 519       /* make counted string zero-term and sanitise */
 520       for (i = 0; i < len; i++)
 521         {
 522           if (!isprint((int)*(p3+1)))
 523             break;
 524           *p3 = *(p3+1);
 525           p3++;
 526         }
 527
 528       *p3 = 0;
 529       log_query(secflag | F_FORWARD | F_UPSTREAM, name, NULL, (char*)p1, 0);
 530       /* restore */
 531       memmove(p1 + 1, p1, i);
 532       *p1 = len;
 533       p1 += len+1;
 534     }
 535   return 1;
 536 }
 537
 538 /* Note that the following code can create CNAME chains that don't point to a real record,
 539    either because of lack of memory, or lack of SOA records.  These are treated by the cache code as
 540    expired and cleaned out that way.
 541    Return 1 if we reject an address because it look like part of dns-rebinding attack.
 542    Return 2 if the packet is malformed.
 543 */
 544 int extract_addresses(struct dns_header *header, size_t qlen, char *name, time_t now,
 545                       struct ipsets *ipsets, struct ipsets *nftsets, int is_sign, int check_rebind,
 546                       int no_cache_dnssec, int secure, int *doctored)
 547 {
 548   unsigned char *p, *p1, *endrr, *namep;
 549   int j, qtype, qclass, aqtype, aqclass, ardlen, res, searched_soa = 0;
 550   unsigned long ttl = 0;
 551   union all_addr addr;
 552 #ifdef HAVE_IPSET
 553   char **ipsets_cur;
 554 #else
 555   (void)ipsets; /* unused */
 556 #endif
 557 #ifdef HAVE_NFTSET
 558   char **nftsets_cur;
 559 #else
 560   (void)nftsets; /* unused */
 561 #endif
 562   int found = 0, cname_count = CNAME_CHAIN;
 563   struct crec *cpp = NULL;
 564   int flags = RCODE(header) == NXDOMAIN ? F_NXDOMAIN : 0;
 565 #ifdef HAVE_DNSSEC
 566   int cname_short = 0;
 567 #endif
 568   unsigned long cttl = ULONG_MAX, attl;
 569
 570   cache_start_insert();
 571
 572   /* find_soa is needed for dns_doctor side effects, so don't call it lazily if there are any. */
 573   if (daemon->doctors || option_bool(OPT_DNSSEC_VALID))
 574     {
 575       searched_soa = 1;
 576       ttl = find_soa(header, qlen, doctored);
 577
 578       if (*doctored)
 579         {
 580           if (secure)
 581             return 0;
 582 #ifdef HAVE_DNSSEC
 583           if (option_bool(OPT_DNSSEC_VALID))
 584             for (j = 0; j < ntohs(header->ancount); j++)
 585               if (daemon->rr_status[j] != 0)
 586                 return 0;
 587 #endif
 588         }
 589     }
 590
 591   namep = p = (unsigned char *)(header+1);
 592
 593   if (ntohs(header->qdcount) != 1 || !extract_name(header, qlen, &p, name, 1, 4))
 594     return 2; /* bad packet */
 595
 596   GETSHORT(qtype, p);
 597   GETSHORT(qclass, p);
 598
 599   if (qclass != C_IN)
 600     return 0;
 601
 602   /* PTRs: we chase CNAMEs here, since we have no way to
 603      represent them in the cache. */
 604   if (qtype == T_PTR)
 605     {
 606       int insert = 1, name_encoding = in_arpa_name_2_addr(name, &addr);
 607
 608       if (!(flags & F_NXDOMAIN))
 609         {
 610         cname_loop:
 611           if (!(p1 = skip_questions(header, qlen)))
 612             return 2;
 613
 614           for (j = 0; j < ntohs(header->ancount); j++)
 615             {
 616               int secflag = 0;
 617               if (!(res = extract_name(header, qlen, &p1, name, 0, 10)))
 618                 return 2; /* bad packet */
 619
 620               GETSHORT(aqtype, p1);
 621               GETSHORT(aqclass, p1);
 622               GETLONG(attl, p1);
 623
 624               if ((daemon->max_ttl != 0) && (attl > daemon->max_ttl) && !is_sign)
 625                 {
 626                   (p1) -= 4;
 627                   PUTLONG(daemon->max_ttl, p1);
 628                 }
 629               GETSHORT(ardlen, p1);
 630               endrr = p1+ardlen;
 631
 632               /* TTL of record is minimum of CNAMES and PTR */
 633               if (attl < cttl)
 634                 cttl = attl;
 635
 636               if (aqclass == C_IN && res != 2 && (aqtype == T_CNAME || aqtype == T_PTR))
 637                 {
 638 #ifdef HAVE_DNSSEC
 639                   if (option_bool(OPT_DNSSEC_VALID) && !no_cache_dnssec && daemon->rr_status[j] != 0)
 640                     {
 641                       /* validated RR anywhere in CNAME chain, don't cache. */
 642                       if (cname_short || aqtype == T_CNAME)
 643                         insert = 0;
 644
 645                       secflag = F_DNSSECOK;
 646                       /* limit TTL based on signature. */
 647                       if (daemon->rr_status[j] < cttl)
 648                         cttl = daemon->rr_status[j];
 649                     }
 650 #endif
 651
 652                   if (aqtype == T_CNAME)
 653                     log_query(secflag | F_CNAME | F_FORWARD | F_UPSTREAM, name, NULL, NULL, 0);
 654
 655                   if (!extract_name(header, qlen, &p1, name, 1, 0))
 656                     return 2;
 657
 658                   if (aqtype == T_CNAME)
 659                     {
 660                       if (!cname_count--)
 661                         return 0; /* looped CNAMES, we can't cache. */
 662 #ifdef HAVE_DNSSEC
 663                       cname_short = 1;
 664 #endif
 665                       goto cname_loop;
 666                     }
 667
 668                   found = 1;
 669
 670                   if (!name_encoding)
 671                     log_query(secflag | F_FORWARD | F_UPSTREAM, name, NULL, NULL, aqtype);
 672                   else
 673                     {
 674                       log_query(name_encoding | secflag | F_REVERSE | F_UPSTREAM, name, &addr, NULL, 0);
 675                       if (insert)
 676                         cache_insert(name, &addr, C_IN, now, cttl, name_encoding | secflag | F_REVERSE);
 677                     }
 678                 }
 679
 680               p1 = endrr;
 681               if (!CHECK_LEN(header, p1, qlen, 0))
 682                 return 2; /* bad packet */
 683             }
 684         }
 685
 686       if (!found && !option_bool(OPT_NO_NEG))
 687         {
 688           if (!searched_soa)
 689             {
 690               searched_soa = 1;
 691               ttl = find_soa(header, qlen, doctored);
 692             }
 693
 694           flags |= F_NEG | (secure ?  F_DNSSECOK : 0);
 695           if (name_encoding && ttl)
 696             {
 697               flags |= F_REVERSE | name_encoding;
 698               cache_insert(NULL, &addr, C_IN, now, ttl, flags);
 699             }
 700
 701           log_query(flags | F_UPSTREAM, name, &addr, NULL, 0);
 702         }
 703     }
 704   else
 705     {
 706       /* everything other than PTR */
 707       struct crec *newc;
 708       int addrlen = 0, insert = 1;
 709
 710       if (qtype == T_A)
 711         {
 712           addrlen = INADDRSZ;
 713           flags |= F_IPV4;
 714         }
 715       else if (qtype == T_AAAA)
 716         {
 717           addrlen = IN6ADDRSZ;
 718           flags |= F_IPV6;
 719         }
 720       else if (qtype == T_SRV)
 721         flags |= F_SRV;
 722       else
 723         insert = 0; /* NOTE: do not cache data from CNAME queries. */
 724
 725     cname_loop1:
 726       if (!(p1 = skip_questions(header, qlen)))
 727         return 2;
 728
 729       for (j = 0; j < ntohs(header->ancount); j++)
 730         {
 731           int secflag = 0;
 732
 733           if (!(res = extract_name(header, qlen, &p1, name, 0, 10)))
 734             return 2; /* bad packet */
 735
 736           GETSHORT(aqtype, p1);
 737           GETSHORT(aqclass, p1);
 738           GETLONG(attl, p1);
 739           if ((daemon->max_ttl != 0) && (attl > daemon->max_ttl) && !is_sign)
 740             {
 741               (p1) -= 4;
 742               PUTLONG(daemon->max_ttl, p1);
 743             }
 744           GETSHORT(ardlen, p1);
 745           endrr = p1+ardlen;
 746
 747           /* Not what we're looking for? */
 748           if (aqclass != C_IN || res == 2)
 749             {
 750               p1 = endrr;
 751               if (!CHECK_LEN(header, p1, qlen, 0))
 752                 return 2; /* bad packet */
 753               continue;
 754             }
 755
 756 #ifdef HAVE_DNSSEC
 757           if (option_bool(OPT_DNSSEC_VALID) && !no_cache_dnssec && daemon->rr_status[j] != 0)
 758             {
 759               secflag = F_DNSSECOK;
 760
 761               /* limit TTl based on sig. */
 762               if (daemon->rr_status[j] < attl)
 763                 attl = daemon->rr_status[j];
 764             }
 765 #endif
 766
 767           if (aqtype == T_CNAME)
 768             {
 769               if (!cname_count--)
 770                 return 0; /* looped CNAMES */
 771
 772               log_query(secflag | F_CNAME | F_FORWARD | F_UPSTREAM, name, NULL, NULL, 0);
 773
 774               if (insert)
 775                 {
 776                   if ((newc = cache_insert(name, NULL, C_IN, now, attl, F_CNAME | F_FORWARD | secflag)))
 777                     {
 778                       newc->addr.cname.target.cache = NULL;
 779                       newc->addr.cname.is_name_ptr = 0;
 780                       if (cpp)
 781                         {
 782                           next_uid(newc);
 783                           cpp->addr.cname.target.cache = newc;
 784                           cpp->addr.cname.uid = newc->uid;
 785                         }
 786                     }
 787
 788                   cpp = newc;
 789                   if (attl < cttl)
 790                     cttl = attl;
 791                 }
 792
 793               namep = p1;
 794               if (!extract_name(header, qlen, &p1, name, 1, 0))
 795                 return 2;
 796
 797               if (qtype != T_CNAME)
 798                 goto cname_loop1;
 799
 800               found = 1;
 801             }
 802           else if (aqtype != qtype)
 803             {
 804 #ifdef HAVE_DNSSEC
 805               if (!option_bool(OPT_DNSSEC_VALID) || aqtype != T_RRSIG)
 806 #endif
 807                 log_query(secflag | F_FORWARD | F_UPSTREAM, name, NULL, NULL, aqtype);
 808             }
 809           else if (!(flags & F_NXDOMAIN))
 810             {
 811               found = 1;
 812
 813               if (flags & F_SRV)
 814                 {
 815                   unsigned char *tmp = namep;
 816
 817                   if (!CHECK_LEN(header, p1, qlen, 6))
 818                     return 2; /* bad packet */
 819                   GETSHORT(addr.srv.priority, p1);
 820                   GETSHORT(addr.srv.weight, p1);
 821                   GETSHORT(addr.srv.srvport, p1);
 822                   if (!extract_name(header, qlen, &p1, name, 1, 0))
 823                     return 2;
 824                   addr.srv.targetlen = strlen(name) + 1; /* include terminating zero */
 825                   if (!(addr.srv.target = blockdata_alloc(name, addr.srv.targetlen)))
 826                     return 0;
 827
 828                   /* we overwrote the original name, so get it back here. */
 829                   if (!extract_name(header, qlen, &tmp, name, 1, 0))
 830                     return 2;
 831                 }
 832               else if (flags & (F_IPV4 | F_IPV6))
 833                 {
 834                   /* copy address into aligned storage */
 835                   if (!CHECK_LEN(header, p1, qlen, addrlen))
 836                     return 2; /* bad packet */
 837                   memcpy(&addr, p1, addrlen);
 838
 839                   /* check for returned address in private space */
 840                   if (check_rebind)
 841                     {
 842                       if ((flags & F_IPV4) &&
 843                           private_net(addr.addr4, !option_bool(OPT_LOCAL_REBIND)))
 844                         return 1;
 845
 846                       if ((flags & F_IPV6) &&
 847                           private_net6(&addr.addr6, !option_bool(OPT_LOCAL_REBIND)))
 848                         return 1;
 849                     }
 850
 851 #ifdef HAVE_IPSET
 852                   if (ipsets && (flags & (F_IPV4 | F_IPV6)))
 853                     for (ipsets_cur = ipsets->sets; *ipsets_cur; ipsets_cur++)
 854                       if (add_to_ipset(*ipsets_cur, &addr, flags, 0) == 0)
 855                         log_query((flags & (F_IPV4 | F_IPV6)) | F_IPSET, ipsets->domain, &addr, *ipsets_cur, 1);
 856 #endif
 857 #ifdef HAVE_NFTSET
 858                   if (nftsets && (flags & (F_IPV4 | F_IPV6)))
 859                     for (nftsets_cur = nftsets->sets; *nftsets_cur; nftsets_cur++)
 860                       if (add_to_nftset(*nftsets_cur, &addr, flags, 0) == 0)
 861                         log_query((flags & (F_IPV4 | F_IPV6)) | F_IPSET, nftsets->domain, &addr, *nftsets_cur, 0);
 862 #endif
 863                 }
 864
 865               if (insert)
 866                 {
 867                   newc = cache_insert(name, &addr, C_IN, now, attl, flags | F_FORWARD | secflag);
 868                   if (newc && cpp)
 869                     {
 870                       next_uid(newc);
 871                       cpp->addr.cname.target.cache = newc;
 872                       cpp->addr.cname.uid = newc->uid;
 873                     }
 874                   cpp = NULL;
 875                 }
 876
 877               if (aqtype == T_TXT)
 878                 {
 879                   if (!print_txt(header, qlen, name, p1, ardlen, secflag))
 880                     return 2;
 881                 }
 882               else
 883                 log_query(flags | F_FORWARD | secflag | F_UPSTREAM, name, &addr, NULL, aqtype);
 884             }
 885
 886           p1 = endrr;
 887           if (!CHECK_LEN(header, p1, qlen, 0))
 888             return 2; /* bad packet */
 889         }
 890
 891       if (!found && (qtype != T_ANY || (flags & F_NXDOMAIN)))
 892         {
 893           if (flags & F_NXDOMAIN)
 894             {
 895               flags &= ~(F_IPV4 | F_IPV6 | F_SRV);
 896
 897               /* Can store NXDOMAIN reply to CNAME or ANY query. */
 898               if (qtype == T_CNAME || qtype == T_ANY)
 899                 insert = 1;
 900             }
 901
 902           log_query(F_UPSTREAM | F_FORWARD | F_NEG | flags | (secure ? F_DNSSECOK : 0), name, NULL, NULL, 0);
 903
 904           if (!searched_soa)
 905             {
 906               searched_soa = 1;
 907               ttl = find_soa(header, qlen, doctored);
 908             }
 909
 910           /* If there's no SOA to get the TTL from, but there is a CNAME
 911              pointing at this, inherit its TTL */
 912           if (insert && !option_bool(OPT_NO_NEG) && (ttl || cpp))
 913             {
 914               if (ttl == 0)
 915                 ttl = cttl;
 916
 917               newc = cache_insert(name, NULL, C_IN, now, ttl, F_FORWARD | F_NEG | flags | (secure ? F_DNSSECOK : 0));
 918               if (newc && cpp)
 919                 {
 920                   next_uid(newc);
 921                   cpp->addr.cname.target.cache = newc;
 922                   cpp->addr.cname.uid = newc->uid;
 923                 }
 924             }
 925         }
 926     }
 927
 928   /* Don't put stuff from a truncated packet into the cache.
 929      Don't cache replies from non-recursive nameservers, since we may get a
 930      reply containing a CNAME but not its target, even though the target
 931      does exist. */
 932   if (!(header->hb3 & HB3_TC) &&
 933       !(header->hb4 & HB4_CD) &&
 934       (header->hb4 & HB4_RA) &&
 935       !no_cache_dnssec)
 936     cache_end_insert();
 937
 938   return 0;
 939 }
 940
 941 #if defined(HAVE_CONNTRACK) && defined(HAVE_UBUS)
 942 /* Don't pass control chars and weird escapes to UBus. */
 943 static int safe_name(char *name)
 944 {
 945   unsigned char *r;
 946
 947   for (r = (unsigned char *)name; *r; r++)
 948     if (!isprint((int)*r))
 949       return 0;
 950
 951   return 1;
 952 }
 953
 954 void report_addresses(struct dns_header *header, size_t len, u32 mark)
 955 {
 956   unsigned char *p, *endrr;
 957   int i;
 958   unsigned long attl;
 959   struct allowlist *allowlists;
 960   char **pattern_pos;
 961
 962   if (RCODE(header) != NOERROR)
 963     return;
 964
 965   for (allowlists = daemon->allowlists; allowlists; allowlists = allowlists->next)
 966     if (allowlists->mark == (mark & daemon->allowlist_mask & allowlists->mask))
 967       for (pattern_pos = allowlists->patterns; *pattern_pos; pattern_pos++)
 968         if (!strcmp(*pattern_pos, "*"))
 969           return;
 970
 971   if (!(p = skip_questions(header, len)))
 972     return;
 973   for (i = ntohs(header->ancount); i != 0; i--)
 974     {
 975       int aqtype, aqclass, ardlen;
 976
 977       if (!extract_name(header, len, &p, daemon->namebuff, 1, 10))
 978         return;
 979
 980       if (!CHECK_LEN(header, p, len, 10))
 981         return;
 982       GETSHORT(aqtype, p);
 983       GETSHORT(aqclass, p);
 984       GETLONG(attl, p);
 985       GETSHORT(ardlen, p);
 986
 987       if (!CHECK_LEN(header, p, len, ardlen))
 988         return;
 989       endrr = p+ardlen;
 990
 991       if (aqclass == C_IN)
 992         {
 993           if (aqtype == T_CNAME)
 994             {
 995               if (!extract_name(header, len, &p, daemon->workspacename, 1, 0))
 996                 return;
 997               if (safe_name(daemon->namebuff) && safe_name(daemon->workspacename))
 998                 ubus_event_bcast_connmark_allowlist_resolved(mark, daemon->namebuff, daemon->workspacename, attl);
 999             }
1000           if (aqtype == T_A)
1001             {
1002               struct in_addr addr;
1003               char ip[INET_ADDRSTRLEN];
1004               if (ardlen != INADDRSZ)
1005                 return;
1006               memcpy(&addr, p, ardlen);
1007               if (inet_ntop(AF_INET, &addr, ip, sizeof ip) && safe_name(daemon->namebuff))
1008                 ubus_event_bcast_connmark_allowlist_resolved(mark, daemon->namebuff, ip, attl);
1009             }
1010           else if (aqtype == T_AAAA)
1011             {
1012               struct in6_addr addr;
1013               char ip[INET6_ADDRSTRLEN];
1014               if (ardlen != IN6ADDRSZ)
1015                 return;
1016               memcpy(&addr, p, ardlen);
1017               if (inet_ntop(AF_INET6, &addr, ip, sizeof ip) && safe_name(daemon->namebuff))
1018                 ubus_event_bcast_connmark_allowlist_resolved(mark, daemon->namebuff, ip, attl);
1019             }
1020         }
1021
1022       p = endrr;
1023     }
1024 }
1025 #endif
1026
1027 /* If the packet holds exactly one query
1028    return F_IPV4 or F_IPV6  and leave the name from the query in name */
1029 unsigned int extract_request(struct dns_header *header, size_t qlen, char *name, unsigned short *typep)
1030 {
1031   unsigned char *p = (unsigned char *)(header+1);
1032   int qtype, qclass;
1033
1034   if (typep)
1035     *typep = 0;
1036
1037   *name = 0; /* return empty name if no query found. */
1038
1039   if (ntohs(header->qdcount) != 1 || OPCODE(header) != QUERY)
1040     return 0; /* must be exactly one query. */
1041
1042   if (!(header->hb3 & HB3_QR) && (ntohs(header->ancount) != 0 || ntohs(header->nscount) != 0))
1043     return 0; /* non-standard query. */
1044
1045   if (!extract_name(header, qlen, &p, name, 1, 4))
1046     return 0; /* bad packet */
1047
1048   GETSHORT(qtype, p);
1049   GETSHORT(qclass, p);
1050
1051   if (typep)
1052     *typep = qtype;
1053
1054   if (qclass == C_IN)
1055     {
1056       if (qtype == T_A)
1057         return F_IPV4;
1058       if (qtype == T_AAAA)
1059         return F_IPV6;
1060       if (qtype == T_ANY)
1061         return  F_IPV4 | F_IPV6;
1062     }
1063
1064 #ifdef HAVE_DNSSEC
1065   /* F_DNSSECOK as agument to search_servers() inhibits forwarding
1066      to servers for domains without a trust anchor. This make the
1067      behaviour for DS and DNSKEY queries we forward the same
1068      as for DS and DNSKEY queries we originate. */
1069   if (option_bool(OPT_DNSSEC_VALID) && (qtype == T_DS || qtype == T_DNSKEY))
1070     return F_DNSSECOK;
1071 #endif
1072
1073   return F_QUERY;
1074 }
1075
1076 void setup_reply(struct dns_header *header, unsigned int flags, int ede)
1077 {
1078   /* clear authoritative and truncated flags, set QR flag */
1079   header->hb3 = (header->hb3 & ~(HB3_AA | HB3_TC )) | HB3_QR;
1080   /* clear AD flag, set RA flag */
1081   header->hb4 = (header->hb4 & ~HB4_AD) | HB4_RA;
1082
1083   header->nscount = htons(0);
1084   header->arcount = htons(0);
1085   header->ancount = htons(0); /* no answers unless changed below */
1086   if (flags == F_NOERR)
1087     SET_RCODE(header, NOERROR); /* empty domain */
1088   else if (flags == F_NXDOMAIN)
1089     SET_RCODE(header, NXDOMAIN);
1090   else if (flags & ( F_IPV4 | F_IPV6))
1091     {
1092       SET_RCODE(header, NOERROR);
1093       header->hb3 |= HB3_AA;
1094     }
1095   else /* nowhere to forward to */
1096     {
1097       union all_addr a;
1098       a.log.rcode = REFUSED;
1099       a.log.ede = ede;
1100       log_query(F_CONFIG | F_RCODE, "error", &a, NULL, 0);
1101       SET_RCODE(header, REFUSED);
1102     }
1103 }
1104
1105 /* check if name matches local names ie from /etc/hosts or DHCP or local mx names. */
1106 int check_for_local_domain(char *name, time_t now)
1107 {
1108   struct mx_srv_record *mx;
1109   struct txt_record *txt;
1110   struct interface_name *intr;
1111   struct ptr_record *ptr;
1112   struct naptr *naptr;
1113
1114   for (naptr = daemon->naptr; naptr; naptr = naptr->next)
1115      if (hostname_issubdomain(name, naptr->name))
1116       return 1;
1117
1118    for (mx = daemon->mxnames; mx; mx = mx->next)
1119     if (hostname_issubdomain(name, mx->name))
1120       return 1;
1121
1122   for (txt = daemon->txt; txt; txt = txt->next)
1123     if (hostname_issubdomain(name, txt->name))
1124       return 1;
1125
1126   for (intr = daemon->int_names; intr; intr = intr->next)
1127     if (hostname_issubdomain(name, intr->name))
1128       return 1;
1129
1130   for (ptr = daemon->ptr; ptr; ptr = ptr->next)
1131     if (hostname_issubdomain(name, ptr->name))
1132       return 1;
1133
1134   if (cache_find_non_terminal(name, now))
1135     return 1;
1136
1137   return 0;
1138 }
1139
1140 static int check_bad_address(struct dns_header *header, size_t qlen, struct bogus_addr *baddr, char *name, unsigned long *ttlp)
1141 {
1142   unsigned char *p;
1143   int i, qtype, qclass, rdlen;
1144   unsigned long ttl;
1145   struct bogus_addr *baddrp;
1146
1147   /* skip over questions */
1148   if (!(p = skip_questions(header, qlen)))
1149     return 0; /* bad packet */
1150
1151   for (i = ntohs(header->ancount); i != 0; i--)
1152     {
1153       if (name && !extract_name(header, qlen, &p, name, 1, 10))
1154         return 0; /* bad packet */
1155
1156       if (!name && !(p = skip_name(p, header, qlen, 10)))
1157         return 0;
1158
1159       GETSHORT(qtype, p);
1160       GETSHORT(qclass, p);
1161       GETLONG(ttl, p);
1162       GETSHORT(rdlen, p);
1163
1164       if (ttlp)
1165         *ttlp = ttl;
1166
1167       if (qclass == C_IN)
1168         {
1169           if (qtype == T_A)
1170             {
1171               struct in_addr addr;
1172
1173               if (!CHECK_LEN(header, p, qlen, INADDRSZ))
1174                 return 0;
1175
1176               memcpy(&addr, p, INADDRSZ);
1177
1178               for (baddrp = baddr; baddrp; baddrp = baddrp->next)
1179                 if (!baddrp->is6 && is_same_net_prefix(addr, baddrp->addr.addr4, baddrp->prefix))
1180                   return 1;
1181             }
1182           else if (qtype == T_AAAA)
1183             {
1184               struct in6_addr addr;
1185
1186               if (!CHECK_LEN(header, p, qlen, IN6ADDRSZ))
1187                 return 0;
1188
1189               memcpy(&addr, p, IN6ADDRSZ);
1190
1191               for (baddrp = baddr; baddrp; baddrp = baddrp->next)
1192                 if (baddrp->is6 && is_same_net6(&addr, &baddrp->addr.addr6, baddrp->prefix))
1193                   return 1;
1194             }
1195         }
1196
1197       if (!ADD_RDLEN(header, p, qlen, rdlen))
1198         return 0;
1199     }
1200
1201   return 0;
1202 }
1203
1204 /* Is the packet a reply with the answer address equal to addr?
1205    If so mung is into an NXDOMAIN reply and also put that information
1206    in the cache. */
1207 int check_for_bogus_wildcard(struct dns_header *header, size_t qlen, char *name, time_t now)
1208 {
1209   unsigned long ttl;
1210
1211   if (check_bad_address(header, qlen, daemon->bogus_addr, name, &ttl))
1212     {
1213       /* Found a bogus address. Insert that info here, since there no SOA record
1214          to get the ttl from in the normal processing */
1215       cache_start_insert();
1216       cache_insert(name, NULL, C_IN, now, ttl, F_IPV4 | F_FORWARD | F_NEG | F_NXDOMAIN);
1217       cache_end_insert();
1218
1219       return 1;
1220     }
1221
1222   return 0;
1223 }
1224
1225 int check_for_ignored_address(struct dns_header *header, size_t qlen)
1226 {
1227   return check_bad_address(header, qlen, daemon->ignore_addr, NULL, NULL);
1228 }
1229
1230 int add_resource_record(struct dns_header *header, char *limit, int *truncp, int nameoffset, unsigned char **pp,
1231                         unsigned long ttl, int *offset, unsigned short type, unsigned short class, char *format, ...)
1232 {
1233   va_list ap;
1234   unsigned char *sav, *p = *pp;
1235   int j;
1236   unsigned short usval;
1237   long lval;
1238   char *sval;
1239
1240 #define CHECK_LIMIT(size) \
1241   if (limit && p + (size) > (unsigned char*)limit) goto truncated;
1242
1243   va_start(ap, format);   /* make ap point to 1st unamed argument */
1244
1245   if (truncp && *truncp)
1246     goto truncated;
1247
1248   if (nameoffset > 0)
1249     {
1250       CHECK_LIMIT(2);
1251       PUTSHORT(nameoffset | 0xc000, p);
1252     }
1253   else
1254     {
1255       char *name = va_arg(ap, char *);
1256       if (name && !(p = do_rfc1035_name(p, name, limit)))
1257         goto truncated;
1258
1259       if (nameoffset < 0)
1260         {
1261           CHECK_LIMIT(2);
1262           PUTSHORT(-nameoffset | 0xc000, p);
1263         }
1264       else
1265         {
1266           CHECK_LIMIT(1);
1267           *p++ = 0;
1268         }
1269     }
1270
1271   /* type (2) + class (2) + ttl (4) + rdlen (2) */
1272   CHECK_LIMIT(10);
1273
1274   PUTSHORT(type, p);
1275   PUTSHORT(class, p);
1276   PUTLONG(ttl, p);      /* TTL */
1277
1278   sav = p;              /* Save pointer to RDLength field */
1279   PUTSHORT(0, p);       /* Placeholder RDLength */
1280
1281   for (; *format; format++)
1282     switch (*format)
1283       {
1284       case '6':
1285         CHECK_LIMIT(IN6ADDRSZ);
1286         sval = va_arg(ap, char *);
1287         memcpy(p, sval, IN6ADDRSZ);
1288         p += IN6ADDRSZ;
1289         break;
1290
1291       case '4':
1292         CHECK_LIMIT(INADDRSZ);
1293         sval = va_arg(ap, char *);
1294         memcpy(p, sval, INADDRSZ);
1295         p += INADDRSZ;
1296         break;
1297
1298       case 'b':
1299         CHECK_LIMIT(1);
1300         usval = va_arg(ap, int);
1301         *p++ = usval;
1302         break;
1303
1304       case 's':
1305         CHECK_LIMIT(2);
1306         usval = va_arg(ap, int);
1307         PUTSHORT(usval, p);
1308         break;
1309
1310       case 'l':
1311         CHECK_LIMIT(4);
1312         lval = va_arg(ap, long);
1313         PUTLONG(lval, p);
1314         break;
1315
1316       case 'd':
1317         /* get domain-name answer arg and store it in RDATA field */
1318         if (offset)
1319           *offset = p - (unsigned char *)header;
1320         if (!(p = do_rfc1035_name(p, va_arg(ap, char *), limit)))
1321           goto truncated;
1322         CHECK_LIMIT(1);
1323         *p++ = 0;
1324         break;
1325
1326       case 't':
1327         usval = va_arg(ap, int);
1328         CHECK_LIMIT(usval);
1329         sval = va_arg(ap, char *);
1330         if (usval != 0)
1331           memcpy(p, sval, usval);
1332         p += usval;
1333         break;
1334
1335       case 'z':
1336         sval = va_arg(ap, char *);
1337         usval = sval ? strlen(sval) : 0;
1338         if (usval > 255)
1339           usval = 255;
1340         CHECK_LIMIT(usval + 1);
1341         *p++ = (unsigned char)usval;
1342         memcpy(p, sval, usval);
1343         p += usval;
1344         break;
1345       }
1346
1347   va_end(ap);   /* clean up variable argument pointer */
1348
1349   /* Now, store real RDLength. sav already checked against limit. */
1350   j = p - sav - 2;
1351   PUTSHORT(j, sav);
1352
1353   *pp = p;
1354   return 1;
1355
1356  truncated:
1357   va_end(ap);
1358   if (truncp)
1359     *truncp = 1;
1360   return 0;
1361
1362 #undef CHECK_LIMIT
1363 }
1364
1365 static int crec_isstale(struct crec *crecp, time_t now)
1366 {
1367   return (!(crecp->flags & F_IMMORTAL)) && difftime(crecp->ttd, now) < 0;
1368 }
1369
1370 static unsigned long crec_ttl(struct crec *crecp, time_t now)
1371 {
1372   signed long ttl = difftime(crecp->ttd, now);
1373
1374   /* Return 0 ttl for DHCP entries, which might change
1375      before the lease expires, unless configured otherwise. */
1376
1377   if (crecp->flags & F_DHCP)
1378     {
1379       int conf_ttl = daemon->use_dhcp_ttl ? daemon->dhcp_ttl : daemon->local_ttl;
1380
1381       /* Apply ceiling of actual lease length to configured TTL. */
1382       if (!(crecp->flags & F_IMMORTAL) && ttl < conf_ttl)
1383         return ttl;
1384
1385       return conf_ttl;
1386     }
1387
1388   /* Immortal entries other than DHCP are local, and hold TTL in TTD field. */
1389   if (crecp->flags & F_IMMORTAL)
1390     return crecp->ttd;
1391
1392   /* Stale cache entries. */
1393   if (ttl < 0)
1394     return 0;
1395
1396   /* Return the Max TTL value if it is lower than the actual TTL */
1397   if (daemon->max_ttl == 0 || ((unsigned)ttl < daemon->max_ttl))
1398     return ttl;
1399   else
1400     return daemon->max_ttl;
1401 }
1402
1403 static int cache_validated(const struct crec *crecp)
1404 {
1405   return (option_bool(OPT_DNSSEC_VALID) && !(crecp->flags & F_DNSSECOK));
1406 }
1407
1408 /* return zero if we can't answer from cache, or packet size if we can */
1409 size_t answer_request(struct dns_header *header, char *limit, size_t qlen,
1410                       struct in_addr local_addr, struct in_addr local_netmask,
1411                       time_t now, int ad_reqd, int do_bit, int have_pseudoheader,
1412                       int *stale)
1413 {
1414   char *name = daemon->namebuff;
1415   unsigned char *p, *ansp;
1416   unsigned int qtype, qclass;
1417   union all_addr addr;
1418   int nameoffset;
1419   unsigned short flag;
1420   int q, ans, anscount = 0, addncount = 0;
1421   int dryrun = 0;
1422   struct crec *crecp;
1423   int nxdomain = 0, notimp = 0, auth = 1, trunc = 0, sec_data = 1;
1424   struct mx_srv_record *rec;
1425   size_t len;
1426   int rd_bit = (header->hb3 & HB3_RD);
1427
1428   if (stale)
1429     *stale = 0;
1430
1431   /* never answer queries with RD unset, to avoid cache snooping. */
1432   if (ntohs(header->ancount) != 0 ||
1433       ntohs(header->nscount) != 0 ||
1434       ntohs(header->qdcount) == 0 ||
1435       OPCODE(header) != QUERY )
1436     return 0;
1437
1438   /* Don't return AD set if checking disabled. */
1439   if (header->hb4 & HB4_CD)
1440     sec_data = 0;
1441
1442   /* If there is an  additional data section then it will be overwritten by
1443      partial replies, so we have to do a dry run to see if we can answer
1444      the query. */
1445   if (ntohs(header->arcount) != 0)
1446     dryrun = 1;
1447
1448   for (rec = daemon->mxnames; rec; rec = rec->next)
1449     rec->offset = 0;
1450
1451  rerun:
1452   /* determine end of question section (we put answers there) */
1453   if (!(ansp = skip_questions(header, qlen)))
1454     return 0; /* bad packet */
1455
1456   /* now process each question, answers go in RRs after the question */
1457   p = (unsigned char *)(header+1);
1458
1459   for (q = ntohs(header->qdcount); q != 0; q--)
1460     {
1461       int count = 255; /* catch loops */
1462
1463       /* save pointer to name for copying into answers */
1464       nameoffset = p - (unsigned char *)header;
1465
1466       /* now extract name as .-concatenated string into name */
1467       if (!extract_name(header, qlen, &p, name, 1, 4))
1468         return 0; /* bad packet */
1469
1470       GETSHORT(qtype, p);
1471       GETSHORT(qclass, p);
1472
1473       ans = 0; /* have we answered this question */
1474
1475       if (qclass == C_IN)
1476         while (--count != 0 && (crecp = cache_find_by_name(NULL, name, now, F_CNAME | F_NXDOMAIN)))
1477           {
1478             char *cname_target;
1479             int stale_flag = 0;
1480
1481             if (crec_isstale(crecp, now))
1482               {
1483                 if (stale)
1484                   *stale = 1;
1485
1486                 stale_flag = F_STALE;
1487               }
1488
1489             if (crecp->flags & F_NXDOMAIN)
1490               {
1491                 if (qtype == T_CNAME)
1492                   {
1493                    if (!dryrun)
1494                      log_query(stale_flag | crecp->flags, name, NULL, record_source(crecp->uid), 0);
1495                     auth = 0;
1496                     nxdomain = 1;
1497                     ans = 1;
1498                   }
1499                 break;
1500               }
1501
1502             cname_target = cache_get_cname_target(crecp);
1503
1504             /* If the client asked for DNSSEC  don't use cached data. */
1505             if ((crecp->flags & (F_HOSTS | F_DHCP | F_CONFIG)) ||
1506                 (rd_bit && (!do_bit || cache_validated(crecp))))
1507               {
1508                 if (crecp->flags & F_CONFIG || qtype == T_CNAME)
1509                   ans = 1;
1510
1511                 if (!(crecp->flags & F_DNSSECOK))
1512                   sec_data = 0;
1513
1514                 if (!dryrun)
1515                   {
1516                     log_query(stale_flag | crecp->flags, name, NULL, record_source(crecp->uid), 0);
1517                     if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1518                                             crec_ttl(crecp, now), &nameoffset,
1519                                             T_CNAME, C_IN, "d", cname_target))
1520                       anscount++;
1521                   }
1522
1523               }
1524             else
1525               return 0; /* give up if any cached CNAME in chain can't be used for DNSSEC reasons. */
1526
1527             if (qtype == T_CNAME)
1528               break;
1529
1530             strcpy(name, cname_target);
1531           }
1532
1533       if (qtype == T_TXT || qtype == T_ANY)
1534         {
1535           struct txt_record *t;
1536           for(t = daemon->txt; t ; t = t->next)
1537             {
1538               if (t->class == qclass && hostname_isequal(name, t->name))
1539                 {
1540                   ans = 1, sec_data = 0;
1541                   if (!dryrun)
1542                     {
1543                       unsigned long ttl = daemon->local_ttl;
1544                       int ok = 1;
1545 #ifndef NO_ID
1546                       /* Dynamically generate stat record */
1547                       if (t->stat != 0)
1548                         {
1549                           ttl = 0;
1550                           if (!cache_make_stat(t))
1551                             ok = 0;
1552                         }
1553 #endif
1554                       if (ok)
1555                         {
1556                           log_query(F_CONFIG | F_RRNAME, name, NULL, "<TXT>", 0);
1557                           if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1558                                                   ttl, NULL,
1559                                                   T_TXT, t->class, "t", t->len, t->txt))
1560                             anscount++;
1561                         }
1562                     }
1563                 }
1564             }
1565         }
1566
1567       if (qclass == C_CHAOS)
1568         {
1569           /* don't forward *.bind and *.server chaos queries - always reply with NOTIMP */
1570           if (hostname_issubdomain("bind", name) || hostname_issubdomain("server", name))
1571             {
1572               if (!ans)
1573                 {
1574                   notimp = 1, auth = 0;
1575                   if (!dryrun)
1576                     {
1577                        addr.log.rcode = NOTIMP;
1578                        log_query(F_CONFIG | F_RCODE, name, &addr, NULL, 0);
1579                     }
1580                   ans = 1, sec_data = 0;
1581                 }
1582             }
1583         }
1584
1585       if (qclass == C_IN)
1586         {
1587           struct txt_record *t;
1588
1589           for (t = daemon->rr; t; t = t->next)
1590             if ((t->class == qtype || qtype == T_ANY) && hostname_isequal(name, t->name))
1591               {
1592                 ans = 1;
1593                 sec_data = 0;
1594                 if (!dryrun)
1595                   {
1596                     log_query(F_CONFIG | F_RRNAME, name, NULL, NULL, t->class);
1597                     if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1598                                             daemon->local_ttl, NULL,
1599                                             t->class, C_IN, "t", t->len, t->txt))
1600                       anscount++;
1601                   }
1602               }
1603
1604           if (qtype == T_PTR || qtype == T_ANY)
1605             {
1606               /* see if it's w.z.y.z.in-addr.arpa format */
1607               int is_arpa = in_arpa_name_2_addr(name, &addr);
1608               struct ptr_record *ptr;
1609               struct interface_name* intr = NULL;
1610
1611               for (ptr = daemon->ptr; ptr; ptr = ptr->next)
1612                 if (hostname_isequal(name, ptr->name))
1613                   break;
1614
1615               if (is_arpa == F_IPV4)
1616                 for (intr = daemon->int_names; intr; intr = intr->next)
1617                   {
1618                     struct addrlist *addrlist;
1619
1620                     for (addrlist = intr->addr; addrlist; addrlist = addrlist->next)
1621                       if (!(addrlist->flags & ADDRLIST_IPV6) && addr.addr4.s_addr == addrlist->addr.addr4.s_addr)
1622                         break;
1623
1624                     if (addrlist)
1625                       break;
1626                     else if (!(intr->flags & INP4))
1627                       while (intr->next && strcmp(intr->intr, intr->next->intr) == 0)
1628                         intr = intr->next;
1629                   }
1630               else if (is_arpa == F_IPV6)
1631                 for (intr = daemon->int_names; intr; intr = intr->next)
1632                   {
1633                     struct addrlist *addrlist;
1634
1635                     for (addrlist = intr->addr; addrlist; addrlist = addrlist->next)
1636                       if ((addrlist->flags & ADDRLIST_IPV6) && IN6_ARE_ADDR_EQUAL(&addr.addr6, &addrlist->addr.addr6))
1637                         break;
1638
1639                     if (addrlist)
1640                       break;
1641                     else if (!(intr->flags & INP6))
1642                       while (intr->next && strcmp(intr->intr, intr->next->intr) == 0)
1643                         intr = intr->next;
1644                   }
1645
1646               if (intr)
1647                 {
1648                   sec_data = 0;
1649                   ans = 1;
1650                   if (!dryrun)
1651                     {
1652                       log_query(is_arpa | F_REVERSE | F_CONFIG, intr->name, &addr, NULL, 0);
1653                       if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1654                                               daemon->local_ttl, NULL,
1655                                               T_PTR, C_IN, "d", intr->name))
1656                         anscount++;
1657                     }
1658                 }
1659               else if (ptr)
1660                 {
1661                   ans = 1;
1662                   sec_data = 0;
1663                   if (!dryrun)
1664                     {
1665                       log_query(F_CONFIG | F_RRNAME, name, NULL, "<PTR>", 0);
1666                       for (ptr = daemon->ptr; ptr; ptr = ptr->next)
1667                         if (hostname_isequal(name, ptr->name) &&
1668                             add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1669                                                 daemon->local_ttl, NULL,
1670                                                 T_PTR, C_IN, "d", ptr->ptr))
1671                           anscount++;
1672
1673                     }
1674                 }
1675               else if (is_arpa && (crecp = cache_find_by_addr(NULL, &addr, now, is_arpa)))
1676                 {
1677                   /* Don't use cache when DNSSEC data required, unless we know that
1678                      the zone is unsigned, which implies that we're doing
1679                      validation. */
1680                   if ((crecp->flags & (F_HOSTS | F_DHCP | F_CONFIG)) ||
1681                       (rd_bit && (!do_bit || cache_validated(crecp)) ))
1682                     {
1683                       do
1684                         {
1685                           int stale_flag = 0;
1686
1687                           if (crec_isstale(crecp, now))
1688                             {
1689                               if (stale)
1690                                 *stale = 1;
1691
1692                               stale_flag = F_STALE;
1693                             }
1694
1695                           /* don't answer wildcard queries with data not from /etc/hosts or dhcp leases */
1696                           if (qtype == T_ANY && !(crecp->flags & (F_HOSTS | F_DHCP)))
1697                             continue;
1698
1699
1700                           if (!(crecp->flags & F_DNSSECOK))
1701                             sec_data = 0;
1702
1703                           ans = 1;
1704
1705                           if (crecp->flags & F_NEG)
1706                             {
1707                               auth = 0;
1708                               if (crecp->flags & F_NXDOMAIN)
1709                                 nxdomain = 1;
1710                               if (!dryrun)
1711                                 log_query(stale_flag | (crecp->flags & ~F_FORWARD), name, &addr, NULL, 0);
1712                             }
1713                           else
1714                             {
1715                               if (!(crecp->flags & (F_HOSTS | F_DHCP)))
1716                                 auth = 0;
1717                               if (!dryrun)
1718                                 {
1719                                   log_query(stale_flag | (crecp->flags & ~F_FORWARD), cache_get_name(crecp), &addr,
1720                                             record_source(crecp->uid), 0);
1721
1722                                   if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1723                                                           crec_ttl(crecp, now), NULL,
1724                                                           T_PTR, C_IN, "d", cache_get_name(crecp)))
1725                                     anscount++;
1726                                 }
1727                             }
1728                         } while ((crecp = cache_find_by_addr(crecp, &addr, now, is_arpa)));
1729                     }
1730                 }
1731               else if (is_rev_synth(is_arpa, &addr, name))
1732                 {
1733                   ans = 1;
1734                   sec_data = 0;
1735                   if (!dryrun)
1736                     {
1737                       log_query(F_CONFIG | F_REVERSE | is_arpa, name, &addr, NULL, 0);
1738
1739                       if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1740                                               daemon->local_ttl, NULL,
1741                                               T_PTR, C_IN, "d", name))
1742                               anscount++;
1743                     }
1744                 }
1745               else if (option_bool(OPT_BOGUSPRIV) &&
1746                        ((is_arpa == F_IPV6 && private_net6(&addr.addr6, 1)) || (is_arpa == F_IPV4 && private_net(addr.addr4, 1))) &&
1747                        !lookup_domain(name, F_DOMAINSRV, NULL, NULL))
1748                 {
1749                   /* if no configured server, not in cache, enabled and private IPV4 address, return NXDOMAIN */
1750                   ans = 1;
1751                   sec_data = 0;
1752                   nxdomain = 1;
1753                   if (!dryrun)
1754                     log_query(F_CONFIG | F_REVERSE | is_arpa | F_NEG | F_NXDOMAIN,
1755                               name, &addr, NULL, 0);
1756                 }
1757             }
1758
1759           for (flag = F_IPV4; flag; flag = (flag == F_IPV4) ? F_IPV6 : 0)
1760             {
1761               unsigned short type = (flag == F_IPV6) ? T_AAAA : T_A;
1762               struct interface_name *intr;
1763
1764               if (qtype != type && qtype != T_ANY)
1765                 continue;
1766
1767               /* interface name stuff */
1768               for (intr = daemon->int_names; intr; intr = intr->next)
1769                 if (hostname_isequal(name, intr->name))
1770                   break;
1771
1772               if (intr)
1773                 {
1774                   struct addrlist *addrlist;
1775                   int gotit = 0, localise = 0;
1776
1777                   enumerate_interfaces(0);
1778
1779                   /* See if a putative address is on the network from which we received
1780                      the query, is so we'll filter other answers. */
1781                   if (local_addr.s_addr != 0 && option_bool(OPT_LOCALISE) && type == T_A)
1782                     for (intr = daemon->int_names; intr; intr = intr->next)
1783                       if (hostname_isequal(name, intr->name))
1784                         for (addrlist = intr->addr; addrlist; addrlist = addrlist->next)
1785                           if (!(addrlist->flags & ADDRLIST_IPV6) &&
1786                               is_same_net(addrlist->addr.addr4, local_addr, local_netmask))
1787                             {
1788                               localise = 1;
1789                               break;
1790                             }
1791
1792                   for (intr = daemon->int_names; intr; intr = intr->next)
1793                     if (hostname_isequal(name, intr->name))
1794                       {
1795                         for (addrlist = intr->addr; addrlist; addrlist = addrlist->next)
1796                           if (((addrlist->flags & ADDRLIST_IPV6) ? T_AAAA : T_A) == type)
1797                             {
1798                               if (localise &&
1799                                   !is_same_net(addrlist->addr.addr4, local_addr, local_netmask))
1800                                 continue;
1801
1802                               if (addrlist->flags & ADDRLIST_REVONLY)
1803                                 continue;
1804
1805                               ans = 1;
1806                               sec_data = 0;
1807                               if (!dryrun)
1808                                 {
1809                                   gotit = 1;
1810                                   log_query(F_FORWARD | F_CONFIG | flag, name, &addrlist->addr, NULL, 0);
1811                                   if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1812                                                           daemon->local_ttl, NULL, type, C_IN,
1813                                                           type == T_A ? "4" : "6", &addrlist->addr))
1814                                     anscount++;
1815                                 }
1816                             }
1817                       }
1818
1819                   if (!dryrun && !gotit)
1820                     log_query(F_FORWARD | F_CONFIG | flag | F_NEG, name, NULL, NULL, 0);
1821
1822                   continue;
1823                 }
1824
1825               if ((crecp = cache_find_by_name(NULL, name, now, flag | F_NXDOMAIN | (dryrun ? F_NO_RR : 0))))
1826                 {
1827                   int localise = 0;
1828
1829                   /* See if a putative address is on the network from which we received
1830                      the query, is so we'll filter other answers. */
1831                   if (local_addr.s_addr != 0 && option_bool(OPT_LOCALISE) && flag == F_IPV4)
1832                     {
1833                       struct crec *save = crecp;
1834                       do {
1835                         if ((crecp->flags & F_HOSTS) &&
1836                             is_same_net(crecp->addr.addr4, local_addr, local_netmask))
1837                           {
1838                             localise = 1;
1839                             break;
1840                           }
1841                         } while ((crecp = cache_find_by_name(crecp, name, now, flag)));
1842                       crecp = save;
1843                     }
1844
1845                   /* If the client asked for DNSSEC  don't use cached data. */
1846                   if ((crecp->flags & (F_HOSTS | F_DHCP | F_CONFIG)) ||
1847                       (rd_bit && (!do_bit || cache_validated(crecp)) ))
1848                     do
1849                       {
1850                         int stale_flag = 0;
1851
1852                         if (crec_isstale(crecp, now))
1853                           {
1854                             if (stale)
1855                               *stale = 1;
1856
1857                             stale_flag = F_STALE;
1858                           }
1859
1860                         /* don't answer wildcard queries with data not from /etc/hosts
1861                            or DHCP leases */
1862                         if (qtype == T_ANY && !(crecp->flags & (F_HOSTS | F_DHCP | F_CONFIG)))
1863                           break;
1864
1865                         if (!(crecp->flags & F_DNSSECOK))
1866                           sec_data = 0;
1867
1868                         if (crecp->flags & F_NEG)
1869                           {
1870                             ans = 1;
1871                             auth = 0;
1872                             if (crecp->flags & F_NXDOMAIN)
1873                               nxdomain = 1;
1874                             if (!dryrun)
1875                               log_query(stale_flag | crecp->flags, name, NULL, NULL, 0);
1876                           }
1877                         else
1878                           {
1879                             /* If we are returning local answers depending on network,
1880                                filter here. */
1881                             if (localise &&
1882                                 (crecp->flags & F_HOSTS) &&
1883                                 !is_same_net(crecp->addr.addr4, local_addr, local_netmask))
1884                               continue;
1885
1886                             if (!(crecp->flags & (F_HOSTS | F_DHCP)))
1887                               auth = 0;
1888
1889                             ans = 1;
1890                             if (!dryrun)
1891                               {
1892                                 log_query(stale_flag | (crecp->flags & ~F_REVERSE), name, &crecp->addr,
1893                                           record_source(crecp->uid), 0);
1894
1895                                 if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1896                                                         crec_ttl(crecp, now), NULL, type, C_IN,
1897                                                         type == T_A ? "4" : "6", &crecp->addr))
1898                                   anscount++;
1899                               }
1900                           }
1901                       } while ((crecp = cache_find_by_name(crecp, name, now, flag)));
1902                 }
1903               else if (is_name_synthetic(flag, name, &addr))
1904                 {
1905                   ans = 1, sec_data = 0;
1906                   if (!dryrun)
1907                     {
1908                       log_query(F_FORWARD | F_CONFIG | flag, name, &addr, NULL, 0);
1909                       if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
1910                                               daemon->local_ttl, NULL, type, C_IN, type == T_A ? "4" : "6", &addr))
1911                         anscount++;
1912                     }
1913                 }
1914             }
1915
1916           if (qtype == T_MX || qtype == T_ANY)
1917             {
1918               int found = 0;
1919               for (rec = daemon->mxnames; rec; rec = rec->next)
1920                 if (!rec->issrv && hostname_isequal(name, rec->name))
1921                   {
1922                     ans = found = 1;
1923                     sec_data = 0;
1924                     if (!dryrun)
1925                       {
1926                         int offset;
1927                         log_query(F_CONFIG | F_RRNAME, name, NULL, "<MX>", 0);
1928                         if (add_resource_record(header, limit, &trunc, nameoffset, &ansp, daemon->local_ttl,
1929                                                 &offset, T_MX, C_IN, "sd", rec->weight, rec->target))
1930                           {
1931                             anscount++;
1932                             if (rec->target)
1933                               rec->offset = offset;
1934                           }
1935                       }
1936                   }
1937
1938               if (!found && (option_bool(OPT_SELFMX) || option_bool(OPT_LOCALMX)) &&
1939                   cache_find_by_name(NULL, name, now, F_HOSTS | F_DHCP | F_NO_RR))
1940                 {
1941                   ans = 1;
1942                   sec_data = 0;
1943                   if (!dryrun)
1944                     {
1945                       log_query(F_CONFIG | F_RRNAME, name, NULL, "<MX>", 0);
1946                       if (add_resource_record(header, limit, &trunc, nameoffset, &ansp, daemon->local_ttl, NULL,
1947                                               T_MX, C_IN, "sd", 1,
1948                                               option_bool(OPT_SELFMX) ? name : daemon->mxtarget))
1949                         anscount++;
1950                     }
1951                 }
1952             }
1953
1954           if (qtype == T_SRV || qtype == T_ANY)
1955             {
1956               int found = 0;
1957               struct mx_srv_record *move = NULL, **up = &daemon->mxnames;
1958
1959               for (rec = daemon->mxnames; rec; rec = rec->next)
1960                 if (rec->issrv && hostname_isequal(name, rec->name))
1961                   {
1962                     found = ans = 1;
1963                     sec_data = 0;
1964                     if (!dryrun)
1965                       {
1966                         int offset;
1967                         log_query(F_CONFIG | F_RRNAME, name, NULL, "<SRV>", 0);
1968                         if (add_resource_record(header, limit, &trunc, nameoffset, &ansp, daemon->local_ttl,
1969                                                 &offset, T_SRV, C_IN, "sssd",
1970                                                 rec->priority, rec->weight, rec->srvport, rec->target))
1971                           {
1972                             anscount++;
1973                             if (rec->target)
1974                               rec->offset = offset;
1975                           }
1976                       }
1977
1978                     /* unlink first SRV record found */
1979                     if (!move)
1980                       {
1981                         move = rec;
1982                         *up = rec->next;
1983                       }
1984                     else
1985                       up = &rec->next;
1986                   }
1987                 else
1988                   up = &rec->next;
1989
1990               /* put first SRV record back at the end. */
1991               if (move)
1992                 {
1993                   *up = move;
1994                   move->next = NULL;
1995                 }
1996
1997               if (!found)
1998                 {
1999                   if ((crecp = cache_find_by_name(NULL, name, now, F_SRV | F_NXDOMAIN | (dryrun ? F_NO_RR : 0))) &&
2000                       rd_bit && (!do_bit || (option_bool(OPT_DNSSEC_VALID) && !(crecp->flags & F_DNSSECOK))))
2001                     do
2002                       {
2003                         int stale_flag = 0;
2004
2005                         if (crec_isstale(crecp, now))
2006                           {
2007                             if (stale)
2008                               *stale = 1;
2009
2010                             stale_flag = F_STALE;
2011                           }
2012                         /* don't answer wildcard queries with data not from /etc/hosts or dhcp leases, except for NXDOMAIN */
2013                         if (qtype == T_ANY && !(crecp->flags & (F_NXDOMAIN)))
2014                           break;
2015
2016                         if (!(crecp->flags & F_DNSSECOK))
2017                           sec_data = 0;
2018
2019                         auth = 0;
2020                         found = ans = 1;
2021
2022                         if (crecp->flags & F_NEG)
2023                           {
2024                             if (crecp->flags & F_NXDOMAIN)
2025                               nxdomain = 1;
2026                             if (!dryrun)
2027                               log_query(stale_flag | crecp->flags, name, NULL, NULL, 0);
2028                           }
2029                         else if (!dryrun)
2030                           {
2031                             char *target = blockdata_retrieve(crecp->addr.srv.target, crecp->addr.srv.targetlen, NULL);
2032                             log_query(stale_flag | crecp->flags, name, NULL, NULL, 0);
2033
2034                             if (add_resource_record(header, limit, &trunc, nameoffset, &ansp,
2035                                                     crec_ttl(crecp, now), NULL, T_SRV, C_IN, "sssd",
2036                                                     crecp->addr.srv.priority, crecp->addr.srv.weight, crecp->addr.srv.srvport,
2037                                                     target))
2038                               anscount++;
2039                           }
2040                       } while ((crecp = cache_find_by_name(crecp, name, now, F_SRV)));
2041                     }
2042
2043               if (!found && option_bool(OPT_FILTER) && (qtype == T_SRV || (qtype == T_ANY && strchr(name, '_'))))
2044                 {
2045                   ans = 1;
2046                   sec_data = 0;
2047                   if (!dryrun)
2048                     log_query(F_CONFIG | F_NEG, name, NULL, NULL, 0);
2049                 }
2050             }
2051
2052           if (qtype == T_NAPTR || qtype == T_ANY)
2053             {
2054               struct naptr *na;
2055               for (na = daemon->naptr; na; na = na->next)
2056                 if (hostname_isequal(name, na->name))
2057                   {
2058                     ans = 1;
2059                     sec_data = 0;
2060                     if (!dryrun)
2061                       {
2062                         log_query(F_CONFIG | F_RRNAME, name, NULL, "<NAPTR>", 0);
2063                         if (add_resource_record(header, limit, &trunc, nameoffset, &ansp, daemon->local_ttl,
2064                                                 NULL, T_NAPTR, C_IN, "sszzzd",
2065                                                 na->order, na->pref, na->flags, na->services, na->regexp, na->replace))
2066                           anscount++;
2067                       }
2068                   }
2069             }
2070
2071           if (qtype == T_MAILB)
2072             ans = 1, nxdomain = 1, sec_data = 0;
2073
2074           if (qtype == T_SOA && option_bool(OPT_FILTER))
2075             {
2076               ans = 1;
2077               sec_data = 0;
2078               if (!dryrun)
2079                 log_query(F_CONFIG | F_NEG, name, &addr, NULL, 0);
2080             }
2081         }
2082
2083       if (!ans)
2084         return 0; /* failed to answer a question */
2085     }
2086
2087   if (dryrun)
2088     {
2089       dryrun = 0;
2090       goto rerun;
2091     }
2092
2093   /* create an additional data section, for stuff in SRV and MX record replies. */
2094   for (rec = daemon->mxnames; rec; rec = rec->next)
2095     if (rec->offset != 0)
2096       {
2097         /* squash dupes */
2098         struct mx_srv_record *tmp;
2099         for (tmp = rec->next; tmp; tmp = tmp->next)
2100           if (tmp->offset != 0 && hostname_isequal(rec->target, tmp->target))
2101             tmp->offset = 0;
2102
2103         crecp = NULL;
2104         while ((crecp = cache_find_by_name(crecp, rec->target, now, F_IPV4 | F_IPV6)))
2105           {
2106             int type =  crecp->flags & F_IPV4 ? T_A : T_AAAA;
2107
2108             if (crecp->flags & F_NEG)
2109               continue;
2110
2111             if (add_resource_record(header, limit, NULL, rec->offset, &ansp,
2112                                     crec_ttl(crecp, now), NULL, type, C_IN,
2113                                     crecp->flags & F_IPV4 ? "4" : "6", &crecp->addr))
2114               addncount++;
2115           }
2116       }
2117
2118   /* done all questions, set up header and return length of result */
2119   /* clear authoritative and truncated flags, set QR flag */
2120   header->hb3 = (header->hb3 & ~(HB3_AA | HB3_TC)) | HB3_QR;
2121   /* set RA flag */
2122   header->hb4 |= HB4_RA;
2123
2124   /* authoritative - only hosts and DHCP derived names. */
2125   if (auth)
2126     header->hb3 |= HB3_AA;
2127
2128   /* truncation */
2129   if (trunc)
2130     header->hb3 |= HB3_TC;
2131
2132   if (nxdomain)
2133     SET_RCODE(header, NXDOMAIN);
2134   else if (notimp)
2135     SET_RCODE(header, NOTIMP);
2136   else
2137     SET_RCODE(header, NOERROR); /* no error */
2138   header->ancount = htons(anscount);
2139   header->nscount = htons(0);
2140   header->arcount = htons(addncount);
2141
2142   len = ansp - (unsigned char *)header;
2143
2144   /* Advertise our packet size limit in our reply */
2145   if (have_pseudoheader)
2146     len = add_pseudoheader(header, len, (unsigned char *)limit, daemon->edns_pktsz, 0, NULL, 0, do_bit, 0);
2147
2148   if (ad_reqd && sec_data)
2149     header->hb4 |= HB4_AD;
2150   else
2151     header->hb4 &= ~HB4_AD;
2152
2153   return len;
2154 }