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