mdw@git.distorted.org.uk Git - adns/blob - src/types.c

   1 /*
   2  * types.c
   3  * - RR-type-specific code, and the machinery to call it
   4  */
   5 /*
   6  *  This file is
   7  *    Copyright (C) 1997-1999 Ian Jackson <ian@davenant.greenend.org.uk>
   8  *
   9  *  It is part of adns, which is
  10  *    Copyright (C) 1997-2000 Ian Jackson <ian@davenant.greenend.org.uk>
  11  *    Copyright (C) 1999-2000 Tony Finch <dot@dotat.at>
  12  *
  13  *  This program is free software; you can redistribute it and/or modify
  14  *  it under the terms of the GNU General Public License as published by
  15  *  the Free Software Foundation; either version 2, or (at your option)
  16  *  any later version.
  17  *
  18  *  This program is distributed in the hope that it will be useful,
  19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *  GNU General Public License for more details.
  22  *
  23  *  You should have received a copy of the GNU General Public License
  24  *  along with this program; if not, write to the Free Software Foundation,
  25  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26  */
  27
  28 #include <stdlib.h>
  29
  30 #include <sys/types.h>
  31 #include <sys/socket.h>
  32 #include <netinet/in.h>
  33 #include <arpa/inet.h>
  34
  35 #include "internal.h"
  36
  37 #define R_NOMEM       return adns_s_nomemory
  38 #define CSP_ADDSTR(s) do {                      \
  39     if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; \
  40   } while (0)
  41
  42 /*
  43  * order of sections:
  44  *
  45  * _string                    (pap)
  46  * _textdata, _qstring        (csp)
  47  * _str                       (mf,cs)
  48  * _intstr                    (mf,csp,cs)
  49  * _manyistr                  (mf,cs)
  50  * _txt                       (pa)
  51  * _inaddr                    (pa,dip,di)
  52  * _addr                      (pa,di,csp,cs)
  53  * _domain                    (pap)
  54  * _host_raw                  (pa)
  55  * _hostaddr                  (pap,pa,dip,di,mfp,mf,csp,cs +pap_findaddrs)
  56  * _mx_raw                    (pa,di)
  57  * _mx                        (pa,di)
  58  * _inthostaddr               (mf,cs)
  59  * _ptr                       (pa)
  60  * _strpair                   (mf,cs)
  61  * _intstrpair                (mf,cs)
  62  * _hinfo                     (pa)
  63  * _mailbox                   (pap +pap_mailbox822)
  64  * _rp                        (pa)
  65  * _soa                       (pa,mf,cs)
  66  * _srv*                      (qdpl,(pap),pa,mf,di,(csp),cs)
  67  * _flat                      (mf)
  68  *
  69  * within each section:
  70  *    qdpl_*
  71  *    pap_*
  72  *    pa_*
  73  *    dip_*
  74  *    di_*
  75  *    mfp_*
  76  *    mf_*
  77  *    csp_*
  78  *    cs_*
  79  */
  80
  81 /*
  82  * _qstring               (pap,csp)
  83  */
  84
  85 static adns_status pap_qstring(const parseinfo *pai, int *cbyte_io, int max,
  86                               int *len_r, char **str_r) {
  87   /* Neither len_r nor str_r may be null.
  88    * End of datagram (overrun) is indicated by returning adns_s_invaliddata;
  89    */
  90   const byte *dgram= pai->dgram;
  91   int l, cbyte;
  92   char *str;
  93
  94   cbyte= *cbyte_io;
  95
  96   if (cbyte >= max) return adns_s_invaliddata;
  97   GET_B(cbyte,l);
  98   if (cbyte+l > max) return adns_s_invaliddata;
  99
 100   str= adns__alloc_interim(pai->qu, l+1);
 101   if (!str) R_NOMEM;
 102
 103   str[l]= 0;
 104   memcpy(str,dgram+cbyte,l);
 105
 106   *len_r= l;
 107   *str_r= str;
 108   *cbyte_io= cbyte+l;
 109
 110   return adns_s_ok;
 111 }
 112
 113 static adns_status csp_qstring(vbuf *vb, const char *dp, int len) {
 114   unsigned char ch;
 115   char buf[10];
 116   int cn;
 117
 118   CSP_ADDSTR("\"");
 119   for (cn=0; cn<len; cn++) {
 120     ch= *dp++;
 121     if (ch == '\\') {
 122       CSP_ADDSTR("\\\\");
 123     } else if (ch == '"') {
 124       CSP_ADDSTR("\\\"");
 125     } else if (ch >= 32 && ch <= 126) {
 126       if (!adns__vbuf_append(vb,&ch,1)) R_NOMEM;
 127     } else {
 128       sprintf(buf,"\\x%02x",ch);
 129       CSP_ADDSTR(buf);
 130     }
 131   }
 132   CSP_ADDSTR("\"");
 133
 134   return adns_s_ok;
 135 }
 136
 137 /*
 138  * _str  (mf)
 139  */
 140
 141 static void mf_str(adns_query qu, void *datap) {
 142   char **rrp= datap;
 143
 144   adns__makefinal_str(qu,rrp);
 145 }
 146
 147 /*
 148  * _intstr  (mf)
 149  */
 150
 151 static void mf_intstr(adns_query qu, void *datap) {
 152   adns_rr_intstr *rrp= datap;
 153
 154   adns__makefinal_str(qu,&rrp->str);
 155 }
 156
 157 /*
 158  * _manyistr   (mf)
 159  */
 160
 161 static void mf_manyistr(adns_query qu, void *datap) {
 162   adns_rr_intstr **rrp= datap;
 163   adns_rr_intstr *te, *table;
 164   void *tablev;
 165   int tc;
 166
 167   for (tc=0, te= *rrp; te->i >= 0; te++, tc++);
 168   tablev= *rrp;
 169   adns__makefinal_block(qu,&tablev,sizeof(*te)*(tc+1));
 170   *rrp= table= tablev;
 171   for (te= *rrp; te->i >= 0; te++)
 172     adns__makefinal_str(qu,&te->str);
 173 }
 174
 175 /*
 176  * _txt   (pa,cs)
 177  */
 178
 179 static adns_status pa_txt(const parseinfo *pai, int cbyte,
 180                           int max, void *datap) {
 181   adns_rr_intstr **rrp= datap, *table, *te;
 182   const byte *dgram= pai->dgram;
 183   int ti, tc, l, startbyte;
 184   adns_status st;
 185
 186   startbyte= cbyte;
 187   if (cbyte >= max) return adns_s_invaliddata;
 188   tc= 0;
 189   while (cbyte < max) {
 190     GET_B(cbyte,l);
 191     cbyte+= l;
 192     tc++;
 193   }
 194   if (cbyte != max || !tc) return adns_s_invaliddata;
 195
 196   table= adns__alloc_interim(pai->qu,sizeof(*table)*(tc+1));
 197   if (!table) R_NOMEM;
 198
 199   for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) {
 200     st= pap_qstring(pai, &cbyte, max, &te->i, &te->str);
 201     if (st) return st;
 202   }
 203   assert(cbyte == max);
 204
 205   te->i= -1;
 206   te->str= 0;
 207
 208   *rrp= table;
 209   return adns_s_ok;
 210 }
 211
 212 static adns_status cs_txt(vbuf *vb, const void *datap) {
 213   const adns_rr_intstr *const *rrp= datap;
 214   const adns_rr_intstr *current;
 215   adns_status st;
 216   int spc;
 217
 218   for (current= *rrp, spc=0;  current->i >= 0;  current++, spc=1) {
 219     if (spc) CSP_ADDSTR(" ");
 220     st= csp_qstring(vb,current->str,current->i); if (st) return st;
 221   }
 222   return adns_s_ok;
 223 }
 224
 225 /*
 226  * _hinfo   (cs)
 227  */
 228
 229 static adns_status cs_hinfo(vbuf *vb, const void *datap) {
 230   const adns_rr_intstrpair *rrp= datap;
 231   adns_status st;
 232
 233   st= csp_qstring(vb,rrp->array[0].str,rrp->array[0].i);  if (st) return st;
 234   CSP_ADDSTR(" ");
 235   st= csp_qstring(vb,rrp->array[1].str,rrp->array[1].i);  if (st) return st;
 236   return adns_s_ok;
 237 }
 238
 239 /*
 240  * _inaddr   (pa,dip,di)
 241  */
 242
 243 static adns_status pa_inaddr(const parseinfo *pai, int cbyte,
 244                              int max, void *datap) {
 245   struct in_addr *storeto= datap;
 246
 247   if (max-cbyte != 4) return adns_s_invaliddata;
 248   memcpy(storeto, pai->dgram + cbyte, 4);
 249   return adns_s_ok;
 250 }
 251
 252 static int search_sortlist(adns_state ads, struct in_addr ad) {
 253   const struct sortlist *slp;
 254   int i;
 255
 256   for (i=0, slp=ads->sortlist;
 257        i<ads->nsortlist &&
 258          !((ad.s_addr & slp->mask.s_addr) == slp->base.s_addr);
 259        i++, slp++);
 260   return i;
 261 }
 262
 263 static int dip_inaddr(adns_state ads, struct in_addr a, struct in_addr b) {
 264   int ai, bi;
 265
 266   if (!ads->nsortlist) return 0;
 267
 268   ai= search_sortlist(ads,a);
 269   bi= search_sortlist(ads,b);
 270   return bi<ai;
 271 }
 272
 273 static int di_inaddr(adns_state ads,
 274                      const void *datap_a, const void *datap_b) {
 275   const struct in_addr *ap= datap_a, *bp= datap_b;
 276
 277   return dip_inaddr(ads,*ap,*bp);
 278 }
 279
 280 static adns_status cs_inaddr(vbuf *vb, const void *datap) {
 281   const struct in_addr *rrp= datap, rr= *rrp;
 282   const char *ia;
 283
 284   ia= inet_ntoa(rr); assert(ia);
 285   CSP_ADDSTR(ia);
 286   return adns_s_ok;
 287 }
 288
 289 /*
 290  * _addr   (pa,di,csp,cs)
 291  */
 292
 293 static adns_status pa_addr(const parseinfo *pai, int cbyte,
 294                            int max, void *datap) {
 295   adns_rr_addr *storeto= datap;
 296   const byte *dgram= pai->dgram;
 297
 298   if (max-cbyte != 4) return adns_s_invaliddata;
 299   storeto->len= sizeof(storeto->addr.inet);
 300   memset(&storeto->addr,0,sizeof(storeto->addr.inet));
 301   storeto->addr.inet.sin_family= AF_INET;
 302   memcpy(&storeto->addr.inet.sin_addr,dgram+cbyte,4);
 303   return adns_s_ok;
 304 }
 305
 306 static int di_addr(adns_state ads, const void *datap_a, const void *datap_b) {
 307   const adns_rr_addr *ap= datap_a, *bp= datap_b;
 308
 309   assert(ap->addr.sa.sa_family == AF_INET);
 310   return dip_inaddr(ads, ap->addr.inet.sin_addr, bp->addr.inet.sin_addr);
 311 }
 312
 313 static int div_addr(void *context, const void *datap_a, const void *datap_b) {
 314   const adns_state ads= context;
 315
 316   return di_addr(ads, datap_a, datap_b);
 317 }
 318
 319 static adns_status csp_addr(vbuf *vb, const adns_rr_addr *rrp) {
 320   const char *ia;
 321   static char buf[30];
 322
 323   switch (rrp->addr.inet.sin_family) {
 324   case AF_INET:
 325     CSP_ADDSTR("INET ");
 326     ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia);
 327     CSP_ADDSTR(ia);
 328     break;
 329   default:
 330     sprintf(buf,"AF=%u",rrp->addr.sa.sa_family);
 331     CSP_ADDSTR(buf);
 332     break;
 333   }
 334   return adns_s_ok;
 335 }
 336
 337 static adns_status cs_addr(vbuf *vb, const void *datap) {
 338   const adns_rr_addr *rrp= datap;
 339
 340   return csp_addr(vb,rrp);
 341 }
 342
 343 /*
 344  * _domain      (pap,csp,cs)
 345  * _dom_raw     (pa)
 346  */
 347
 348 static adns_status pap_domain(const parseinfo *pai, int *cbyte_io, int max,
 349                               char **domain_r, parsedomain_flags flags) {
 350   adns_status st;
 351   char *dm;
 352
 353   st= adns__parse_domain(pai->qu->ads, pai->serv, pai->qu, &pai->qu->vb, flags,
 354                          pai->dgram,pai->dglen, cbyte_io, max);
 355   if (st) return st;
 356   if (!pai->qu->vb.used) return adns_s_invaliddata;
 357
 358   dm= adns__alloc_interim(pai->qu, pai->qu->vb.used+1);
 359   if (!dm) R_NOMEM;
 360
 361   dm[pai->qu->vb.used]= 0;
 362   memcpy(dm,pai->qu->vb.buf,pai->qu->vb.used);
 363
 364   *domain_r= dm;
 365   return adns_s_ok;
 366 }
 367
 368 static adns_status csp_domain(vbuf *vb, const char *domain) {
 369   CSP_ADDSTR(domain);
 370   if (!*domain) CSP_ADDSTR(".");
 371   return adns_s_ok;
 372 }
 373
 374 static adns_status cs_domain(vbuf *vb, const void *datap) {
 375   const char *const *domainp= datap;
 376   return csp_domain(vb,*domainp);
 377 }
 378
 379 static adns_status pa_dom_raw(const parseinfo *pai, int cbyte,
 380                               int max, void *datap) {
 381   char **rrp= datap;
 382   adns_status st;
 383
 384   st= pap_domain(pai, &cbyte, max, rrp, pdf_quoteok);
 385   if (st) return st;
 386
 387   if (cbyte != max) return adns_s_invaliddata;
 388   return adns_s_ok;
 389 }
 390
 391 /*
 392  * _host_raw   (pa)
 393  */
 394
 395 static adns_status pa_host_raw(const parseinfo *pai, int cbyte,
 396                                int max, void *datap) {
 397   char **rrp= datap;
 398   adns_status st;
 399
 400   st= pap_domain(pai, &cbyte, max, rrp,
 401                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 402   if (st) return st;
 403
 404   if (cbyte != max) return adns_s_invaliddata;
 405   return adns_s_ok;
 406 }
 407
 408 /*
 409  * _hostaddr   (pap,pa,dip,di,mfp,mf,csp,cs +icb_hostaddr, pap_findaddrs)
 410  */
 411
 412 static adns_status pap_findaddrs(const parseinfo *pai, adns_rr_hostaddr *ha,
 413                                  int *cbyte_io, int count, int dmstart) {
 414   int rri, naddrs;
 415   int type, class, rdlen, rdstart, ownermatched;
 416   unsigned long ttl;
 417   adns_status st;
 418
 419   for (rri=0, naddrs=-1; rri<count; rri++) {
 420     st= adns__findrr_anychk(pai->qu, pai->serv, pai->dgram,
 421                             pai->dglen, cbyte_io,
 422                             &type, &class, &ttl, &rdlen, &rdstart,
 423                             pai->dgram, pai->dglen, dmstart, &ownermatched);
 424     if (st) return st;
 425     if (!ownermatched || class != DNS_CLASS_IN || type != adns_r_a) {
 426       if (naddrs>0) break; else continue;
 427     }
 428     if (naddrs == -1) {
 429       naddrs= 0;
 430     }
 431     if (!adns__vbuf_ensure(&pai->qu->vb, (naddrs+1)*sizeof(adns_rr_addr)))
 432       R_NOMEM;
 433     adns__update_expires(pai->qu,ttl,pai->now);
 434     st= pa_addr(pai, rdstart,rdstart+rdlen,
 435                 pai->qu->vb.buf + naddrs*sizeof(adns_rr_addr));
 436     if (st) return st;
 437     naddrs++;
 438   }
 439   if (naddrs >= 0) {
 440     ha->addrs= adns__alloc_interim(pai->qu, naddrs*sizeof(adns_rr_addr));
 441     if (!ha->addrs) R_NOMEM;
 442     memcpy(ha->addrs, pai->qu->vb.buf, naddrs*sizeof(adns_rr_addr));
 443     ha->naddrs= naddrs;
 444     ha->astatus= adns_s_ok;
 445
 446     adns__isort(ha->addrs, naddrs, sizeof(adns_rr_addr), pai->qu->vb.buf,
 447                 div_addr, pai->ads);
 448   }
 449   return adns_s_ok;
 450 }
 451
 452 static void icb_hostaddr(adns_query parent, adns_query child) {
 453   adns_answer *cans= child->answer;
 454   adns_rr_hostaddr *rrp= child->ctx.info.hostaddr;
 455   adns_state ads= parent->ads;
 456   adns_status st;
 457
 458   st= cans->status;
 459   rrp->astatus= st;
 460   rrp->naddrs= (st>0 && st<=adns_s_max_tempfail) ? -1 : cans->nrrs;
 461   rrp->addrs= cans->rrs.addr;
 462   adns__transfer_interim(child, parent, rrp->addrs,
 463                          rrp->naddrs*sizeof(adns_rr_addr));
 464
 465   if (parent->children.head) {
 466     LIST_LINK_TAIL(ads->childw,parent);
 467   } else {
 468     adns__query_done(parent);
 469   }
 470 }
 471
 472 static adns_status pap_hostaddr(const parseinfo *pai, int *cbyte_io,
 473                                 int max, adns_rr_hostaddr *rrp) {
 474   adns_status st;
 475   int dmstart, cbyte;
 476   qcontext ctx;
 477   int id;
 478   adns_query nqu;
 479   adns_queryflags nflags;
 480
 481   dmstart= cbyte= *cbyte_io;
 482   st= pap_domain(pai, &cbyte, max, &rrp->host,
 483                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 484   if (st) return st;
 485   *cbyte_io= cbyte;
 486
 487   rrp->astatus= adns_s_ok;
 488   rrp->naddrs= -1;
 489   rrp->addrs= 0;
 490
 491   cbyte= pai->nsstart;
 492
 493   st= pap_findaddrs(pai, rrp, &cbyte, pai->nscount, dmstart);
 494   if (st) return st;
 495   if (rrp->naddrs != -1) return adns_s_ok;
 496
 497   st= pap_findaddrs(pai, rrp, &cbyte, pai->arcount, dmstart);
 498   if (st) return st;
 499   if (rrp->naddrs != -1) return adns_s_ok;
 500
 501   st= adns__mkquery_frdgram(pai->ads, &pai->qu->vb, &id,
 502                             pai->dgram, pai->dglen, dmstart,
 503                             adns_r_addr, adns_qf_quoteok_query);
 504   if (st) return st;
 505
 506   ctx.ext= 0;
 507   ctx.callback= icb_hostaddr;
 508   ctx.info.hostaddr= rrp;
 509
 510   nflags= adns_qf_quoteok_query;
 511   if (!(pai->qu->flags & adns_qf_cname_loose)) nflags |= adns_qf_cname_forbid;
 512
 513   st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_addr),
 514                             &pai->qu->vb, id, nflags, pai->now, &ctx);
 515   if (st) return st;
 516
 517   nqu->parent= pai->qu;
 518   LIST_LINK_TAIL_PART(pai->qu->children,nqu,siblings.);
 519
 520   return adns_s_ok;
 521 }
 522
 523 static adns_status pa_hostaddr(const parseinfo *pai, int cbyte,
 524                                int max, void *datap) {
 525   adns_rr_hostaddr *rrp= datap;
 526   adns_status st;
 527
 528   st= pap_hostaddr(pai, &cbyte, max, rrp);
 529   if (st) return st;
 530   if (cbyte != max) return adns_s_invaliddata;
 531
 532   return adns_s_ok;
 533 }
 534
 535 static int dip_hostaddr(adns_state ads,
 536                         const adns_rr_hostaddr *ap, const adns_rr_hostaddr *bp) {
 537   if (ap->astatus != bp->astatus) return ap->astatus;
 538   if (ap->astatus) return 0;
 539
 540   assert(ap->addrs[0].addr.sa.sa_family == AF_INET);
 541   assert(bp->addrs[0].addr.sa.sa_family == AF_INET);
 542   return dip_inaddr(ads,
 543                     ap->addrs[0].addr.inet.sin_addr,
 544                     bp->addrs[0].addr.inet.sin_addr);
 545 }
 546
 547 static int di_hostaddr(adns_state ads,
 548                        const void *datap_a, const void *datap_b) {
 549   const adns_rr_hostaddr *ap= datap_a, *bp= datap_b;
 550
 551   return dip_hostaddr(ads, ap,bp);
 552 }
 553
 554 static void mfp_hostaddr(adns_query qu, adns_rr_hostaddr *rrp) {
 555   void *tablev;
 556
 557   adns__makefinal_str(qu,&rrp->host);
 558   tablev= rrp->addrs;
 559   adns__makefinal_block(qu, &tablev, rrp->naddrs*sizeof(*rrp->addrs));
 560   rrp->addrs= tablev;
 561 }
 562
 563 static void mf_hostaddr(adns_query qu, void *datap) {
 564   adns_rr_hostaddr *rrp= datap;
 565
 566   mfp_hostaddr(qu,rrp);
 567 }
 568
 569 static adns_status csp_hostaddr(vbuf *vb, const adns_rr_hostaddr *rrp) {
 570   const char *errstr;
 571   adns_status st;
 572   char buf[20];
 573   int i;
 574
 575   st= csp_domain(vb,rrp->host);  if (st) return st;
 576
 577   CSP_ADDSTR(" ");
 578   CSP_ADDSTR(adns_errtypeabbrev(rrp->astatus));
 579
 580   sprintf(buf," %d ",rrp->astatus);
 581   CSP_ADDSTR(buf);
 582
 583   CSP_ADDSTR(adns_errabbrev(rrp->astatus));
 584   CSP_ADDSTR(" ");
 585
 586   errstr= adns_strerror(rrp->astatus);
 587   st= csp_qstring(vb,errstr,strlen(errstr));  if (st) return st;
 588
 589   if (rrp->naddrs >= 0) {
 590     CSP_ADDSTR(" (");
 591     for (i=0; i<rrp->naddrs; i++) {
 592       CSP_ADDSTR(" ");
 593       st= csp_addr(vb,&rrp->addrs[i]);
 594     }
 595     CSP_ADDSTR(" )");
 596   } else {
 597     CSP_ADDSTR(" ?");
 598   }
 599   return adns_s_ok;
 600 }
 601
 602 static adns_status cs_hostaddr(vbuf *vb, const void *datap) {
 603   const adns_rr_hostaddr *rrp= datap;
 604
 605   return csp_hostaddr(vb,rrp);
 606 }
 607
 608 /*
 609  * _mx_raw   (pa,di)
 610  */
 611
 612 static adns_status pa_mx_raw(const parseinfo *pai, int cbyte,
 613                              int max, void *datap) {
 614   const byte *dgram= pai->dgram;
 615   adns_rr_intstr *rrp= datap;
 616   adns_status st;
 617   int pref;
 618
 619   if (cbyte+2 > max) return adns_s_invaliddata;
 620   GET_W(cbyte,pref);
 621   rrp->i= pref;
 622   st= pap_domain(pai, &cbyte, max, &rrp->str,
 623                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 624   if (st) return st;
 625
 626   if (cbyte != max) return adns_s_invaliddata;
 627   return adns_s_ok;
 628 }
 629
 630 static int di_mx_raw(adns_state ads, const void *datap_a, const void *datap_b) {
 631   const adns_rr_intstr *ap= datap_a, *bp= datap_b;
 632
 633   if (ap->i < bp->i) return 0;
 634   if (ap->i > bp->i) return 1;
 635   return 0;
 636 }
 637
 638 /*
 639  * _mx   (pa,di)
 640  */
 641
 642 static adns_status pa_mx(const parseinfo *pai, int cbyte,
 643                          int max, void *datap) {
 644   const byte *dgram= pai->dgram;
 645   adns_rr_inthostaddr *rrp= datap;
 646   adns_status st;
 647   int pref;
 648
 649   if (cbyte+2 > max) return adns_s_invaliddata;
 650   GET_W(cbyte,pref);
 651   rrp->i= pref;
 652   st= pap_hostaddr(pai, &cbyte, max, &rrp->ha);
 653   if (st) return st;
 654
 655   if (cbyte != max) return adns_s_invaliddata;
 656   return adns_s_ok;
 657 }
 658
 659 static int di_mx(adns_state ads, const void *datap_a, const void *datap_b) {
 660   const adns_rr_inthostaddr *ap= datap_a, *bp= datap_b;
 661
 662   if (ap->i < bp->i) return 0;
 663   if (ap->i > bp->i) return 1;
 664   return dip_hostaddr(ads, &ap->ha, &bp->ha);
 665 }
 666
 667 /*
 668  * _inthostaddr  (mf,cs)
 669  */
 670
 671 static void mf_inthostaddr(adns_query qu, void *datap) {
 672   adns_rr_inthostaddr *rrp= datap;
 673
 674   mfp_hostaddr(qu,&rrp->ha);
 675 }
 676
 677 static adns_status cs_inthostaddr(vbuf *vb, const void *datap) {
 678   const adns_rr_inthostaddr *rrp= datap;
 679   char buf[10];
 680
 681   sprintf(buf,"%u ",rrp->i);
 682   CSP_ADDSTR(buf);
 683
 684   return csp_hostaddr(vb,&rrp->ha);
 685 }
 686
 687 /*
 688  * _inthost  (cs)
 689  */
 690
 691 static adns_status cs_inthost(vbuf *vb, const void *datap) {
 692   const adns_rr_intstr *rrp= datap;
 693   char buf[10];
 694
 695   sprintf(buf,"%u ",rrp->i);
 696   CSP_ADDSTR(buf);
 697   return csp_domain(vb,rrp->str);
 698 }
 699
 700 /*
 701  * _ptr   (pa, +icb_ptr)
 702  */
 703
 704 static void icb_ptr(adns_query parent, adns_query child) {
 705   adns_answer *cans= child->answer;
 706   const adns_rr_addr *queried, *found;
 707   adns_state ads= parent->ads;
 708   int i;
 709
 710   if (cans->status == adns_s_nxdomain || cans->status == adns_s_nodata) {
 711     adns__query_fail(parent,adns_s_inconsistent);
 712     return;
 713   } else if (cans->status) {
 714     adns__query_fail(parent,cans->status);
 715     return;
 716   }
 717
 718   queried= &parent->ctx.info.ptr_parent_addr;
 719   for (i=0, found=cans->rrs.addr; i<cans->nrrs; i++, found++) {
 720     if (queried->len == found->len &&
 721         !memcmp(&queried->addr,&found->addr,queried->len)) {
 722       if (!parent->children.head) {
 723         adns__query_done(parent);
 724         return;
 725       } else {
 726         LIST_LINK_TAIL(ads->childw,parent);
 727         return;
 728       }
 729     }
 730   }
 731
 732   adns__query_fail(parent,adns_s_inconsistent);
 733 }
 734
 735 static adns_status pa_ptr(const parseinfo *pai, int dmstart,
 736                           int max, void *datap) {
 737   static const char *(expectdomain[])= { DNS_INADDR_ARPA };
 738
 739   char **rrp= datap;
 740   adns_status st;
 741   adns_rr_addr *ap;
 742   findlabel_state fls;
 743   char *ep;
 744   byte ipv[4];
 745   char labbuf[4];
 746   int cbyte, i, lablen, labstart, l, id;
 747   adns_query nqu;
 748   qcontext ctx;
 749
 750   cbyte= dmstart;
 751   st= pap_domain(pai, &cbyte, max, rrp,
 752                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 753   if (st) return st;
 754   if (cbyte != max) return adns_s_invaliddata;
 755
 756   ap= &pai->qu->ctx.info.ptr_parent_addr;
 757   if (!ap->len) {
 758     adns__findlabel_start(&fls, pai->ads, -1, pai->qu,
 759                           pai->qu->query_dgram, pai->qu->query_dglen,
 760                           pai->qu->query_dglen, DNS_HDRSIZE, 0);
 761     for (i=0; i<4; i++) {
 762       st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
 763       if (lablen<=0 || lablen>3) return adns_s_querydomainwrong;
 764       memcpy(labbuf, pai->qu->query_dgram + labstart, lablen);
 765       labbuf[lablen]= 0;
 766       ipv[3-i]= strtoul(labbuf,&ep,10);
 767       if (*ep) return adns_s_querydomainwrong;
 768       if (lablen>1 && pai->qu->query_dgram[labstart]=='0')
 769         return adns_s_querydomainwrong;
 770     }
 771     for (i=0; i<sizeof(expectdomain)/sizeof(*expectdomain); i++) {
 772       st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
 773       l= strlen(expectdomain[i]);
 774       if (lablen != l ||
 775           memcmp(pai->qu->query_dgram + labstart, expectdomain[i], l))
 776         return adns_s_querydomainwrong;
 777     }
 778     st= adns__findlabel_next(&fls,&lablen,0); assert(!st);
 779     if (lablen) return adns_s_querydomainwrong;
 780
 781     ap->len= sizeof(struct sockaddr_in);
 782     memset(&ap->addr,0,sizeof(ap->addr.inet));
 783     ap->addr.inet.sin_family= AF_INET;
 784     ap->addr.inet.sin_addr.s_addr=
 785       htonl((ipv[0]<<24) | (ipv[1]<<16) | (ipv[2]<<8) | (ipv[3]));
 786   }
 787
 788   st= adns__mkquery_frdgram(pai->ads, &pai->qu->vb, &id,
 789                             pai->dgram, pai->dglen, dmstart,
 790                             adns_r_addr, adns_qf_quoteok_query);
 791   if (st) return st;
 792
 793   ctx.ext= 0;
 794   ctx.callback= icb_ptr;
 795   memset(&ctx.info,0,sizeof(ctx.info));
 796   st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_addr),
 797                             &pai->qu->vb, id,
 798                             adns_qf_quoteok_query, pai->now, &ctx);
 799   if (st) return st;
 800
 801   nqu->parent= pai->qu;
 802   LIST_LINK_TAIL_PART(pai->qu->children,nqu,siblings.);
 803   return adns_s_ok;
 804 }
 805
 806 /*
 807  * _strpair   (mf)
 808  */
 809
 810 static void mf_strpair(adns_query qu, void *datap) {
 811   adns_rr_strpair *rrp= datap;
 812
 813   adns__makefinal_str(qu,&rrp->array[0]);
 814   adns__makefinal_str(qu,&rrp->array[1]);
 815 }
 816
 817 /*
 818  * _intstrpair   (mf)
 819  */
 820
 821 static void mf_intstrpair(adns_query qu, void *datap) {
 822   adns_rr_intstrpair *rrp= datap;
 823
 824   adns__makefinal_str(qu,&rrp->array[0].str);
 825   adns__makefinal_str(qu,&rrp->array[1].str);
 826 }
 827
 828 /*
 829  * _hinfo   (pa)
 830  */
 831
 832 static adns_status pa_hinfo(const parseinfo *pai, int cbyte,
 833                             int max, void *datap) {
 834   adns_rr_intstrpair *rrp= datap;
 835   adns_status st;
 836   int i;
 837
 838   for (i=0; i<2; i++) {
 839     st= pap_qstring(pai, &cbyte, max, &rrp->array[i].i, &rrp->array[i].str);
 840     if (st) return st;
 841   }
 842
 843   if (cbyte != max) return adns_s_invaliddata;
 844
 845   return adns_s_ok;
 846 }
 847
 848 /*
 849  * _mailbox   (pap,cs)
 850  */
 851
 852 static adns_status pap_mailbox822(const parseinfo *pai,
 853                                   int *cbyte_io, int max, char **mb_r) {
 854   int lablen, labstart, i, needquote, c, r, neednorm;
 855   const unsigned char *p;
 856   char *str;
 857   findlabel_state fls;
 858   adns_status st;
 859   vbuf *vb;
 860
 861   vb= &pai->qu->vb;
 862   vb->used= 0;
 863   adns__findlabel_start(&fls, pai->ads,
 864                         -1, pai->qu,
 865                         pai->dgram, pai->dglen, max,
 866                         *cbyte_io, cbyte_io);
 867   st= adns__findlabel_next(&fls,&lablen,&labstart);
 868   if (!lablen) {
 869     adns__vbuf_appendstr(vb,".");
 870     goto x_ok;
 871   }
 872
 873   neednorm= 1;
 874   for (i=0, needquote=0, p= pai->dgram+labstart; i<lablen; i++) {
 875     c= *p++;
 876     if ((c&~128) < 32 || (c&~128) == 127) return adns_s_invaliddata;
 877     if (c == '.' && !neednorm) neednorm= 1;
 878     else if (c==' ' || c>=127 || ctype_822special(c)) needquote++;
 879     else neednorm= 0;
 880   }
 881
 882   if (needquote || neednorm) {
 883     r= adns__vbuf_ensure(vb, lablen+needquote+4); if (!r) R_NOMEM;
 884     adns__vbuf_appendq(vb,"\"",1);
 885     for (i=0, needquote=0, p= pai->dgram+labstart; i<lablen; i++, p++) {
 886       c= *p;
 887       if (c == '"' || c=='\\') adns__vbuf_appendq(vb,"\\",1);
 888       adns__vbuf_appendq(vb,p,1);
 889     }
 890     adns__vbuf_appendq(vb,"\"",1);
 891   } else {
 892     r= adns__vbuf_append(vb, pai->dgram+labstart, lablen); if (!r) R_NOMEM;
 893   }
 894
 895   r= adns__vbuf_appendstr(vb,"@"); if (!r) R_NOMEM;
 896
 897   st= adns__parse_domain_more(&fls,pai->ads, pai->qu,vb,0, pai->dgram);
 898   if (st) return st;
 899
 900  x_ok:
 901   str= adns__alloc_interim(pai->qu, vb->used+1); if (!str) R_NOMEM;
 902   memcpy(str,vb->buf,vb->used);
 903   str[vb->used]= 0;
 904   *mb_r= str;
 905   return adns_s_ok;
 906 }
 907
 908 static adns_status pap_mailbox(const parseinfo *pai, int *cbyte_io, int max,
 909                                char **mb_r) {
 910   if (pai->qu->typei->type & adns__qtf_mail822) {
 911     return pap_mailbox822(pai, cbyte_io, max, mb_r);
 912   } else {
 913     return pap_domain(pai, cbyte_io, max, mb_r, pdf_quoteok);
 914   }
 915 }
 916
 917 static adns_status csp_mailbox(vbuf *vb, const char *mailbox) {
 918   return csp_domain(vb,mailbox);
 919 }
 920
 921 /*
 922  * _rp   (pa,cs)
 923  */
 924
 925 static adns_status pa_rp(const parseinfo *pai, int cbyte,
 926                          int max, void *datap) {
 927   adns_rr_strpair *rrp= datap;
 928   adns_status st;
 929
 930   st= pap_mailbox(pai, &cbyte, max, &rrp->array[0]);
 931   if (st) return st;
 932
 933   st= pap_domain(pai, &cbyte, max, &rrp->array[1], pdf_quoteok);
 934   if (st) return st;
 935
 936   if (cbyte != max) return adns_s_invaliddata;
 937   return adns_s_ok;
 938 }
 939
 940 static adns_status cs_rp(vbuf *vb, const void *datap) {
 941   const adns_rr_strpair *rrp= datap;
 942   adns_status st;
 943
 944   st= csp_mailbox(vb,rrp->array[0]);  if (st) return st;
 945   CSP_ADDSTR(" ");
 946   st= csp_domain(vb,rrp->array[1]);  if (st) return st;
 947
 948   return adns_s_ok;
 949 }
 950
 951 /*
 952  * _soa   (pa,mf,cs)
 953  */
 954
 955 static adns_status pa_soa(const parseinfo *pai, int cbyte,
 956                           int max, void *datap) {
 957   adns_rr_soa *rrp= datap;
 958   const byte *dgram= pai->dgram;
 959   adns_status st;
 960   int msw, lsw, i;
 961
 962   st= pap_domain(pai, &cbyte, max, &rrp->mname,
 963                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 964   if (st) return st;
 965
 966   st= pap_mailbox(pai, &cbyte, max, &rrp->rname);
 967   if (st) return st;
 968
 969   if (cbyte+20 != max) return adns_s_invaliddata;
 970
 971   for (i=0; i<5; i++) {
 972     GET_W(cbyte,msw);
 973     GET_W(cbyte,lsw);
 974     (&rrp->serial)[i]= (msw<<16) | lsw;
 975   }
 976
 977   return adns_s_ok;
 978 }
 979
 980 static void mf_soa(adns_query qu, void *datap) {
 981   adns_rr_soa *rrp= datap;
 982
 983   adns__makefinal_str(qu,&rrp->mname);
 984   adns__makefinal_str(qu,&rrp->rname);
 985 }
 986
 987 static adns_status cs_soa(vbuf *vb, const void *datap) {
 988   const adns_rr_soa *rrp= datap;
 989   char buf[20];
 990   int i;
 991   adns_status st;
 992
 993   st= csp_domain(vb,rrp->mname);  if (st) return st;
 994   CSP_ADDSTR(" ");
 995   st= csp_mailbox(vb,rrp->rname);  if (st) return st;
 996
 997   for (i=0; i<5; i++) {
 998     sprintf(buf," %lu",(&rrp->serial)[i]);
 999     CSP_ADDSTR(buf);
1000   }
1001
1002   return adns_s_ok;
1003 }
1004
1005 /*
1006  * _srv*  (pa*2,di,cs*2,qdpl)
1007  */
1008
1009 static adns_status qdpl_srv(adns_state ads,
1010                             const char **p_io, const char *pe, int labelnum,
1011                             char label_r[DNS_MAXDOMAIN], int *ll_io,
1012                             adns_queryflags flags,
1013                             const typeinfo *typei) {
1014   int useflags;
1015   const char *p_orig;
1016   adns_status st;
1017
1018   if (labelnum < 2 && !(flags & adns_qf_quoteok_query)) {
1019     useflags= adns_qf_quoteok_query;
1020     p_orig= *p_io;
1021   } else {
1022     useflags= flags;
1023     p_orig= 0;
1024   }
1025   st= adns__qdpl_normal(ads, p_io,pe, labelnum,label_r, ll_io, useflags,typei);
1026   if (st) return st;
1027
1028   if (p_orig) {
1029     int ll= *ll_io;
1030     if (!ll || label_r[0]!='_')
1031       return adns_s_querydomaininvalid;
1032     if (memchr(p_orig+1, '\\', pe - (p_orig+1)))
1033       return adns_s_querydomaininvalid;
1034   }
1035   return adns_s_ok;
1036 }
1037
1038 static adns_status pap_srv_begin(const parseinfo *pai, int *cbyte_io, int max,
1039                                  adns_rr_srvraw *rrp
1040                                    /* might be adns_rr_srvha* */) {
1041   const byte *dgram= pai->dgram;
1042   int ti, cbyte;
1043
1044   cbyte= *cbyte_io;
1045   if ((*cbyte_io += 6) > max) return adns_s_invaliddata;
1046
1047   rrp->priority= GET_W(cbyte, ti);
1048   rrp->weight=   GET_W(cbyte, ti);
1049   rrp->port=     GET_W(cbyte, ti);
1050   return adns_s_ok;
1051 }
1052
1053 static adns_status pa_srvraw(const parseinfo *pai, int cbyte,
1054                              int max, void *datap) {
1055   adns_rr_srvraw *rrp= datap;
1056   adns_status st;
1057
1058   st= pap_srv_begin(pai,&cbyte,max,datap);
1059   if (st) return st;
1060
1061   st= pap_domain(pai, &cbyte, max, &rrp->host,
1062                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
1063   if (st) return st;
1064
1065   if (cbyte != max) return adns_s_invaliddata;
1066   return adns_s_ok;
1067 }
1068
1069 static adns_status pa_srvha(const parseinfo *pai, int cbyte,
1070                             int max, void *datap) {
1071   adns_rr_srvha *rrp= datap;
1072   adns_status st;
1073
1074   st= pap_srv_begin(pai,&cbyte,max,datap);       if (st) return st;
1075   st= pap_hostaddr(pai, &cbyte, max, &rrp->ha);  if (st) return st;
1076   if (cbyte != max) return adns_s_invaliddata;
1077   return adns_s_ok;
1078 }
1079
1080 static void mf_srvraw(adns_query qu, void *datap) {
1081   adns_rr_srvraw *rrp= datap;
1082   adns__makefinal_str(qu, &rrp->host);
1083 }
1084
1085 static void mf_srvha(adns_query qu, void *datap) {
1086   adns_rr_srvha *rrp= datap;
1087   mfp_hostaddr(qu,&rrp->ha);
1088 }
1089
1090 static int di_srv(adns_state ads, const void *datap_a, const void *datap_b) {
1091   const adns_rr_srvraw *ap= datap_a, *bp= datap_b;
1092     /* might be const adns_rr_svhostaddr* */
1093
1094   if (ap->priority < bp->priority) return 0;
1095   if (ap->priority > bp->priority) return 1;
1096   return 0;
1097 }
1098
1099 static adns_status csp_srv_begin(vbuf *vb, const adns_rr_srvraw *rrp
1100                                    /* might be adns_rr_srvha* */) {
1101   char buf[30];
1102   sprintf(buf,"%u %u %u ", rrp->priority, rrp->weight, rrp->port);
1103   CSP_ADDSTR(buf);
1104   return adns_s_ok;
1105 }
1106
1107 static adns_status cs_srvraw(vbuf *vb, const void *datap) {
1108   const adns_rr_srvraw *rrp= datap;
1109   adns_status st;
1110
1111   st= csp_srv_begin(vb,rrp);  if (st) return st;
1112   return csp_domain(vb,rrp->host);
1113 }
1114
1115 static adns_status cs_srvha(vbuf *vb, const void *datap) {
1116   const adns_rr_srvha *rrp= datap;
1117   adns_status st;
1118
1119   st= csp_srv_begin(vb,datap);  if (st) return st;
1120   return csp_hostaddr(vb,&rrp->ha);
1121 }
1122
1123 /*
1124  * _flat   (mf)
1125  */
1126
1127 static void mf_flat(adns_query qu, void *data) { }
1128
1129 /*
1130  * Now the table.
1131  */
1132
1133 #define TYPESZ_M(member)           (sizeof(*((adns_answer*)0)->rrs.member))
1134
1135 #define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb
1136 #define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb
1137
1138 #define DEEP_TYPE(code,rrt,fmt,memb,parser,comparer,printer)    \
1139  { adns_r_##code, rrt,fmt,TYPESZ_M(memb), mf_##memb,            \
1140       printer,parser,comparer, adns__qdpl_normal }
1141 #define FLAT_TYPE(code,rrt,fmt,memb,parser,comparer,printer)    \
1142  { adns_r_##code, rrt,fmt,TYPESZ_M(memb), mf_flat,              \
1143      printer,parser,comparer, adns__qdpl_normal }
1144 #define XTRA_TYPE(code,rrt,fmt,memb,parser,comparer,printer,qdpl)       \
1145  { adns_r_##code, rrt,fmt,TYPESZ_M(memb), mf_##memb,                    \
1146     printer,parser,comparer,qdpl }
1147
1148 static const typeinfo typeinfos[] = {
1149 /* Must be in ascending order of rrtype ! */
1150 /* mem-mgmt code  rrt     fmt   member   parser      comparer  printer */
1151
1152 FLAT_TYPE(a,      "A",     0,   inaddr,  pa_inaddr,  di_inaddr,cs_inaddr     ),
1153 DEEP_TYPE(ns_raw, "NS",   "raw",str,     pa_host_raw,0,        cs_domain     ),
1154 DEEP_TYPE(cname,  "CNAME", 0,   str,     pa_dom_raw, 0,        cs_domain     ),
1155 DEEP_TYPE(soa_raw,"SOA",  "raw",soa,     pa_soa,     0,        cs_soa        ),
1156 DEEP_TYPE(ptr_raw,"PTR",  "raw",str,     pa_host_raw,0,        cs_domain     ),
1157 DEEP_TYPE(hinfo,  "HINFO", 0, intstrpair,pa_hinfo,   0,        cs_hinfo      ),
1158 DEEP_TYPE(mx_raw, "MX",   "raw",intstr,  pa_mx_raw,  di_mx_raw,cs_inthost    ),
1159 DEEP_TYPE(txt,    "TXT",   0,   manyistr,pa_txt,     0,        cs_txt        ),
1160 DEEP_TYPE(rp_raw, "RP",   "raw",strpair, pa_rp,      0,        cs_rp         ),
1161 XTRA_TYPE(srv_raw,"SRV",  "raw",srvraw , pa_srvraw, di_srv,cs_srvraw,qdpl_srv),
1162
1163 FLAT_TYPE(addr,   "A",  "addr", addr,    pa_addr,    di_addr,  cs_addr       ),
1164 DEEP_TYPE(ns,     "NS", "+addr",hostaddr,pa_hostaddr,di_hostaddr,cs_hostaddr ),
1165 DEEP_TYPE(ptr,    "PTR","checked",str,   pa_ptr,     0,        cs_domain     ),
1166 DEEP_TYPE(mx,     "MX", "+addr",inthostaddr,pa_mx,   di_mx,    cs_inthostaddr),
1167 XTRA_TYPE(srv,    "SRV","+addr",srvha,   pa_srvha,  di_srv,cs_srvha, qdpl_srv),
1168
1169 DEEP_TYPE(soa,    "SOA","822",  soa,     pa_soa,     0,        cs_soa        ),
1170 DEEP_TYPE(rp,     "RP", "822",  strpair, pa_rp,      0,        cs_rp         ),
1171 };
1172
1173 const typeinfo *adns__findtype(adns_rrtype type) {
1174   const typeinfo *begin, *end, *mid;
1175
1176   begin= typeinfos;  end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo));
1177
1178   while (begin < end) {
1179     mid= begin + ((end-begin)>>1);
1180     if (mid->type == type) return mid;
1181     if (type > mid->type) begin= mid+1;
1182     else end= mid;
1183   }
1184   return 0;
1185 }