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   adns_status st;
 549   int i;
 550
 551   st= csp_domain(vb,rrp->host); if (st) return st;
 552
 553   CSP_ADDSTR(" ");
 554   CSP_ADDSTR(adns_errabbrev(rrp->astatus));
 555
 556   if (rrp->naddrs >= 0) {
 557     CSP_ADDSTR(" (");
 558     for (i=0; i<rrp->naddrs; i++) {
 559       CSP_ADDSTR(" ");
 560       st= csp_addr(vb,&rrp->addrs[i]);
 561     }
 562     CSP_ADDSTR(" )");
 563   } else {
 564     CSP_ADDSTR(" ?");
 565   }
 566   return adns_s_ok;
 567 }
 568
 569 static adns_status cs_hostaddr(vbuf *vb, const void *datap) {
 570   const adns_rr_hostaddr *rrp= datap;
 571
 572   return csp_hostaddr(vb,rrp);
 573 }
 574
 575 /*
 576  * _mx_raw   (pa,di)
 577  */
 578
 579 static adns_status pa_mx_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
 580   const byte *dgram= pai->dgram;
 581   adns_rr_intstr *rrp= datap;
 582   adns_status st;
 583   int pref;
 584
 585   if (cbyte+2 > max) return adns_s_invaliddata;
 586   GET_W(cbyte,pref);
 587   rrp->i= pref;
 588   st= pap_domain(pai, &cbyte, max, &rrp->str,
 589                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 590   if (st) return st;
 591
 592   if (cbyte != max) return adns_s_invaliddata;
 593   return adns_s_ok;
 594 }
 595
 596 static int di_mx_raw(adns_state ads, const void *datap_a, const void *datap_b) {
 597   const adns_rr_intstr *ap= datap_a, *bp= datap_b;
 598
 599   if (ap->i < bp->i) return 0;
 600   if (ap->i > bp->i) return 1;
 601   return 0;
 602 }
 603
 604 /*
 605  * _mx   (pa,di)
 606  */
 607
 608 static adns_status pa_mx(const parseinfo *pai, int cbyte, int max, void *datap) {
 609   const byte *dgram= pai->dgram;
 610   adns_rr_inthostaddr *rrp= datap;
 611   adns_status st;
 612   int pref;
 613
 614   if (cbyte+2 > max) return adns_s_invaliddata;
 615   GET_W(cbyte,pref);
 616   rrp->i= pref;
 617   st= pap_hostaddr(pai, &cbyte, max, &rrp->ha);
 618   if (st) return st;
 619
 620   if (cbyte != max) return adns_s_invaliddata;
 621   return adns_s_ok;
 622 }
 623
 624 static int di_mx(adns_state ads, const void *datap_a, const void *datap_b) {
 625   const adns_rr_inthostaddr *ap= datap_a, *bp= datap_b;
 626
 627   if (ap->i < bp->i) return 0;
 628   if (ap->i > bp->i) return 1;
 629   return dip_hostaddr(ads, &ap->ha, &bp->ha);
 630 }
 631
 632 /*
 633  * _inthostaddr  (mf,cs)
 634  */
 635
 636 static void mf_inthostaddr(adns_query qu, void *datap) {
 637   adns_rr_inthostaddr *rrp= datap;
 638
 639   mfp_hostaddr(qu,&rrp->ha);
 640 }
 641
 642 static adns_status cs_inthostaddr(vbuf *vb, const void *datap) {
 643   const adns_rr_inthostaddr *rrp= datap;
 644   char buf[10];
 645
 646   sprintf(buf,"%u ",rrp->i);
 647   CSP_ADDSTR(buf);
 648
 649   return csp_hostaddr(vb,&rrp->ha);
 650 }
 651
 652 /*
 653  * _inthost  (cs)
 654  */
 655
 656 static adns_status cs_inthost(vbuf *vb, const void *datap) {
 657   const adns_rr_intstr *rrp= datap;
 658   char buf[10];
 659
 660   sprintf(buf,"%u ",rrp->i);
 661   CSP_ADDSTR(buf);
 662   return csp_domain(vb,rrp->str);
 663 }
 664
 665 /*
 666  * _ptr   (pa, +icb_ptr)
 667  */
 668
 669 static void icb_ptr(adns_query parent, adns_query child) {
 670   adns_answer *cans= child->answer;
 671   const adns_rr_addr *queried, *found;
 672   adns_state ads= parent->ads;
 673   int i;
 674
 675   if (cans->status == adns_s_nxdomain || cans->status == adns_s_nodata) {
 676     adns__query_fail(parent,adns_s_inconsistent);
 677     return;
 678   } else if (cans->status) {
 679     adns__query_fail(parent,cans->status);
 680     return;
 681   }
 682
 683   queried= &parent->ctx.info.ptr_parent_addr;
 684   for (i=0, found=cans->rrs.addr; i<cans->nrrs; i++, found++) {
 685     if (queried->len == found->len &&
 686         !memcmp(&queried->addr,&found->addr,queried->len)) {
 687       if (!parent->children.head) {
 688         adns__query_done(parent);
 689         return;
 690       } else {
 691         LIST_LINK_TAIL(ads->childw,parent);
 692         return;
 693       }
 694     }
 695   }
 696
 697   adns__query_fail(parent,adns_s_inconsistent);
 698 }
 699
 700 static adns_status pa_ptr(const parseinfo *pai, int dmstart, int max, void *datap) {
 701   static const char *(expectdomain[])= { DNS_INADDR_ARPA };
 702
 703   char **rrp= datap;
 704   adns_status st;
 705   adns_rr_addr *ap;
 706   findlabel_state fls;
 707   char *ep;
 708   byte ipv[4];
 709   char labbuf[4];
 710   int cbyte, i, lablen, labstart, l, id;
 711   adns_query nqu;
 712   qcontext ctx;
 713
 714   cbyte= dmstart;
 715   st= pap_domain(pai, &cbyte, max, rrp,
 716                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 717   if (st) return st;
 718   if (cbyte != max) return adns_s_invaliddata;
 719
 720   ap= &pai->qu->ctx.info.ptr_parent_addr;
 721   if (!ap->len) {
 722     adns__findlabel_start(&fls, pai->ads, -1, pai->qu,
 723                           pai->qu->query_dgram, pai->qu->query_dglen,
 724                           pai->qu->query_dglen, DNS_HDRSIZE, 0);
 725     for (i=0; i<4; i++) {
 726       st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
 727       if (lablen<=0 || lablen>3) return adns_s_querydomainwrong;
 728       memcpy(labbuf, pai->qu->query_dgram + labstart, lablen);  labbuf[lablen]= 0;
 729       ipv[3-i]= strtoul(labbuf,&ep,10);  if (*ep) return adns_s_querydomainwrong;
 730       if (lablen>1 && pai->qu->query_dgram[labstart]=='0')
 731         return adns_s_querydomainwrong;
 732     }
 733     for (i=0; i<sizeof(expectdomain)/sizeof(*expectdomain); i++) {
 734       st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
 735       l= strlen(expectdomain[i]);
 736       if (lablen != l || memcmp(pai->qu->query_dgram + labstart, expectdomain[i], l))
 737         return adns_s_querydomainwrong;
 738     }
 739     st= adns__findlabel_next(&fls,&lablen,0); assert(!st);
 740     if (lablen) return adns_s_querydomainwrong;
 741
 742     ap->len= sizeof(struct sockaddr_in);
 743     memset(&ap->addr,0,sizeof(ap->addr.inet));
 744     ap->addr.inet.sin_family= AF_INET;
 745     ap->addr.inet.sin_addr.s_addr=
 746       htonl((ipv[0]<<24) | (ipv[1]<<16) | (ipv[2]<<8) | (ipv[3]));
 747   }
 748
 749   st= adns__mkquery_frdgram(pai->ads, &pai->qu->vb, &id,
 750                             pai->dgram, pai->dglen, dmstart,
 751                             adns_r_addr, adns_qf_quoteok_query);
 752   if (st) return st;
 753
 754   ctx.ext= 0;
 755   ctx.callback= icb_ptr;
 756   memset(&ctx.info,0,sizeof(ctx.info));
 757   st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_addr),
 758                             &pai->qu->vb, id,
 759                             adns_qf_quoteok_query, pai->now, &ctx);
 760   if (st) return st;
 761
 762   nqu->parent= pai->qu;
 763   LIST_LINK_TAIL_PART(pai->qu->children,nqu,siblings.);
 764   return adns_s_ok;
 765 }
 766
 767 /*
 768  * _strpair   (mf)
 769  */
 770
 771 static void mf_strpair(adns_query qu, void *datap) {
 772   adns_rr_strpair *rrp= datap;
 773
 774   adns__makefinal_str(qu,&rrp->array[0]);
 775   adns__makefinal_str(qu,&rrp->array[1]);
 776 }
 777
 778 /*
 779  * _intstrpair   (mf)
 780  */
 781
 782 static void mf_intstrpair(adns_query qu, void *datap) {
 783   adns_rr_intstrpair *rrp= datap;
 784
 785   adns__makefinal_str(qu,&rrp->array[0].str);
 786   adns__makefinal_str(qu,&rrp->array[1].str);
 787 }
 788
 789 /*
 790  * _hinfo   (pa)
 791  */
 792
 793 static adns_status pa_hinfo(const parseinfo *pai, int cbyte, int max, void *datap) {
 794   adns_rr_intstrpair *rrp= datap;
 795   adns_status st;
 796   int i;
 797
 798   for (i=0; i<2; i++) {
 799     st= pap_qstring(pai, &cbyte, max, &rrp->array[i].i, &rrp->array[i].str);
 800     if (st) return st;
 801   }
 802
 803   if (cbyte != max) return adns_s_invaliddata;
 804
 805   return adns_s_ok;
 806 }
 807
 808 /*
 809  * _mailbox   (pap,cs)
 810  */
 811
 812 static adns_status pap_mailbox822(const parseinfo *pai, int *cbyte_io, int max,
 813                                   char **mb_r) {
 814   int lablen, labstart, i, needquote, c, r, neednorm;
 815   const unsigned char *p;
 816   char *str;
 817   findlabel_state fls;
 818   adns_status st;
 819   vbuf *vb;
 820
 821   vb= &pai->qu->vb;
 822   vb->used= 0;
 823   adns__findlabel_start(&fls, pai->ads,
 824                         -1, pai->qu,
 825                         pai->dgram, pai->dglen, max,
 826                         *cbyte_io, cbyte_io);
 827   st= adns__findlabel_next(&fls,&lablen,&labstart);
 828   if (!lablen) {
 829     adns__vbuf_appendstr(vb,".");
 830     goto x_ok;
 831   }
 832
 833   neednorm= 1;
 834   for (i=0, needquote=0, p= pai->dgram+labstart; i<lablen; i++) {
 835     c= *p++;
 836     if ((c&~128) < 32 || (c&~128) == 127) return adns_s_invaliddata;
 837     if (c == '.' && !neednorm) neednorm= 1;
 838     else if (c==' ' || ctype_822special(c)) needquote++;
 839     else neednorm= 0;
 840   }
 841
 842   if (needquote || neednorm) {
 843     r= adns__vbuf_ensure(vb, lablen+needquote+4); if (!r) R_NOMEM;
 844     adns__vbuf_appendq(vb,"\"",1);
 845     for (i=0, needquote=0, p= pai->dgram+labstart; i<lablen; i++, p++) {
 846       c= *p;
 847       if (c == '"' || c=='\\') adns__vbuf_appendq(vb,"\\",1);
 848       adns__vbuf_appendq(vb,p,1);
 849     }
 850     adns__vbuf_appendq(vb,"\"",1);
 851   } else {
 852     r= adns__vbuf_append(vb, pai->dgram+labstart, lablen); if (!r) R_NOMEM;
 853   }
 854
 855   r= adns__vbuf_appendstr(vb,"@"); if (!r) R_NOMEM;
 856
 857   st= adns__parse_domain_more(&fls,pai->ads, pai->qu,vb,0, pai->dgram);
 858   if (st) return st;
 859
 860  x_ok:
 861   str= adns__alloc_interim(pai->qu, vb->used+1); if (!str) R_NOMEM;
 862   memcpy(str,vb->buf,vb->used);
 863   str[vb->used]= 0;
 864   *mb_r= str;
 865   return adns_s_ok;
 866 }
 867
 868 static adns_status pap_mailbox(const parseinfo *pai, int *cbyte_io, int max,
 869                                char **mb_r) {
 870   if (pai->qu->typei->type & adns__qtf_mail822) {
 871     return pap_mailbox822(pai, cbyte_io, max, mb_r);
 872   } else {
 873     return pap_domain(pai, cbyte_io, max, mb_r, pdf_quoteok);
 874   }
 875 }
 876
 877 static adns_status csp_mailbox(vbuf *vb, const char *mailbox) {
 878   return csp_domain(vb,mailbox);
 879 }
 880
 881 /*
 882  * _rp   (pa,cs)
 883  */
 884
 885 static adns_status pa_rp(const parseinfo *pai, int cbyte, int max, void *datap) {
 886   adns_rr_strpair *rrp= datap;
 887   adns_status st;
 888
 889   st= pap_mailbox(pai, &cbyte, max, &rrp->array[0]);
 890   if (st) return st;
 891
 892   st= pap_domain(pai, &cbyte, max, &rrp->array[1], pdf_quoteok);
 893   if (st) return st;
 894
 895   if (cbyte != max) return adns_s_invaliddata;
 896   return adns_s_ok;
 897 }
 898
 899 static adns_status cs_rp(vbuf *vb, const void *datap) {
 900   const adns_rr_strpair *rrp= datap;
 901   adns_status st;
 902
 903   st= csp_mailbox(vb,rrp->array[0]);  if (st) return st;
 904   CSP_ADDSTR(" ");
 905   st= csp_domain(vb,rrp->array[1]);  if (st) return st;
 906
 907   return adns_s_ok;
 908 }
 909
 910 /*
 911  * _soa   (pa,mf,cs)
 912  */
 913
 914 static adns_status pa_soa(const parseinfo *pai, int cbyte, int max, void *datap) {
 915   adns_rr_soa *rrp= datap;
 916   const byte *dgram= pai->dgram;
 917   adns_status st;
 918   int msw, lsw, i;
 919
 920   st= pap_domain(pai, &cbyte, max, &rrp->mname,
 921                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 922   if (st) return st;
 923
 924   st= pap_mailbox(pai, &cbyte, max, &rrp->rname);
 925   if (st) return st;
 926
 927   if (cbyte+20 != max) return adns_s_invaliddata;
 928
 929   for (i=0; i<5; i++) {
 930     GET_W(cbyte,msw);
 931     GET_W(cbyte,lsw);
 932     (&rrp->serial)[i]= (msw<<16) | lsw;
 933   }
 934
 935   return adns_s_ok;
 936 }
 937
 938 static void mf_soa(adns_query qu, void *datap) {
 939   adns_rr_soa *rrp= datap;
 940
 941   adns__makefinal_str(qu,&rrp->mname);
 942   adns__makefinal_str(qu,&rrp->rname);
 943 }
 944
 945 static adns_status cs_soa(vbuf *vb, const void *datap) {
 946   const adns_rr_soa *rrp= datap;
 947   char buf[20];
 948   int i;
 949   adns_status st;
 950
 951   st= csp_domain(vb,rrp->mname);  if (st) return st;
 952   CSP_ADDSTR(" ");
 953   st= csp_mailbox(vb,rrp->rname);  if (st) return st;
 954
 955   for (i=0; i<5; i++) {
 956     sprintf(buf," %lu",(&rrp->serial)[i]);
 957     CSP_ADDSTR(buf);
 958   }
 959
 960   return adns_s_ok;
 961 }
 962
 963 /*
 964  * _flat   (mf)
 965  */
 966
 967 static void mf_flat(adns_query qu, void *data) { }
 968
 969 /*
 970  * Now the table.
 971  */
 972
 973 #define TYPESZ_M(member)           (sizeof(*((adns_answer*)0)->rrs.member))
 974
 975 #define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb
 976 #define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb
 977
 978 #define DEEP_TYPE(code,rrt,fmt,memb,parser,comparer,printer) \
 979  { adns_r_##code, rrt, fmt, TYPESZ_M(memb), mf_##memb, printer, parser, comparer }
 980 #define FLAT_TYPE(code,rrt,fmt,memb,parser,comparer,printer) \
 981  { adns_r_##code, rrt, fmt, TYPESZ_M(memb), mf_flat, printer, parser, comparer }
 982
 983 static const typeinfo typeinfos[] = {
 984 /* Must be in ascending order of rrtype ! */
 985 /* mem-mgmt code  rrt     fmt     member      parser      comparer    printer       */
 986
 987 FLAT_TYPE(a,      "A",     0,     inaddr,     pa_inaddr,  di_inaddr,  cs_inaddr     ),
 988 DEEP_TYPE(ns_raw, "NS",   "raw",  str,        pa_host_raw,0,          cs_domain     ),
 989 DEEP_TYPE(cname,  "CNAME", 0,     str,        pa_dom_raw, 0,          cs_domain     ),
 990 DEEP_TYPE(soa_raw,"SOA",  "raw",  soa,        pa_soa,     0,          cs_soa        ),
 991 DEEP_TYPE(ptr_raw,"PTR",  "raw",  str,        pa_host_raw,0,          cs_domain     ),
 992 DEEP_TYPE(hinfo,  "HINFO", 0,     intstrpair, pa_hinfo,   0,          cs_hinfo      ),
 993 DEEP_TYPE(mx_raw, "MX",   "raw",  intstr,     pa_mx_raw,  di_mx_raw,  cs_inthost    ),
 994 DEEP_TYPE(txt,    "TXT",   0,     manyistr,   pa_txt,     0,          cs_txt        ),
 995 DEEP_TYPE(rp_raw, "RP",   "raw",  strpair,    pa_rp,      0,          cs_rp         ),
 996
 997 FLAT_TYPE(addr,   "A",  "addr",   addr,       pa_addr,    di_addr,    cs_addr       ),
 998 DEEP_TYPE(ns,     "NS", "+addr",  hostaddr,   pa_hostaddr,di_hostaddr,cs_hostaddr   ),
 999 DEEP_TYPE(ptr,    "PTR","checked",str,        pa_ptr,     0,          cs_domain     ),
1000 DEEP_TYPE(mx,     "MX", "+addr",  inthostaddr,pa_mx,      di_mx,      cs_inthostaddr),
1001
1002 DEEP_TYPE(soa,    "SOA","822",    soa,        pa_soa,     0,          cs_soa        ),
1003 DEEP_TYPE(rp,     "RP", "822",    strpair,    pa_rp,      0,          cs_rp         ),
1004 };
1005
1006 const typeinfo *adns__findtype(adns_rrtype type) {
1007   const typeinfo *begin, *end, *mid;
1008
1009   begin= typeinfos;  end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo));
1010
1011   while (begin < end) {
1012     mid= begin + ((end-begin)>>1);
1013     if (mid->type == type) return mid;
1014     if (type > mid->type) begin= mid+1;
1015     else end= mid;
1016   }
1017   return 0;
1018 }