src/types.c

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