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, 1998 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 #include <string.h>
  25
  26 #include <arpa/inet.h>
  27
  28 #include "internal.h"
  29
  30 #define R_NOMEM           return adns_s_nolocalmem
  31 #define CSP_ADDSTR(s)     if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; else;
  32
  33 /*
  34  * order of sections:
  35  *
  36  * _textdata, _qstring        (csp)
  37  * _str                       (mf,cs)
  38  * _intstr                    (mf,cs)
  39  * _manyistr                  (mf,cs)
  40  * _txt                       (pa)
  41  * _inaddr                    (pa,dip,di)
  42  * _addr                      (pa,di,csp,cs)
  43  * _domain                    (pap)
  44  * _host_raw                  (pa)
  45  * _hostaddr                  (pap,pa,dip,di,mfp,mf,csp,cs +pap_findaddrs)
  46  * _mx_raw                    (pa,di)
  47  * _mx                        (pa,di)
  48  * _inthostaddr               (mf,cs)
  49  * _ptr                       (pa)
  50  * _flat                      (mf)
  51  *
  52  * within each section:
  53  *    pap_*
  54  *    pa_*
  55  *    dip_*
  56  *    di_*
  57  *    mfp_*
  58  *    mf_*
  59  *    csp_*
  60  *    cs_*
  61  */
  62
  63 /*
  64  * _textdata, _qstring   (csp)
  65  */
  66
  67 static adns_status csp_textdata(vbuf *vb, const char *dp, int len) {
  68   unsigned char ch;
  69   char buf[10];
  70   int cn;
  71
  72   CSP_ADDSTR("\"");
  73   for (cn=0; cn<len; cn++) {
  74     ch= *dp++;
  75     if (ch >= 32 && ch <= 126 && ch != '"' && ch != '\\') {
  76       if (!adns__vbuf_append(vb,&ch,1)) R_NOMEM;
  77     } else {
  78       sprintf(buf,"\\%02x",ch);
  79       CSP_ADDSTR(buf);
  80     }
  81   }
  82   CSP_ADDSTR("\"");
  83
  84   return adns_s_ok;
  85 }
  86
  87 static adns_status csp_qstring(vbuf *vb, const char *dp) {
  88   return csp_textdata(vb, dp, strlen(dp));
  89 }
  90
  91 /*
  92  * _str  (mf,cs)
  93  */
  94
  95 static void mf_str(adns_query qu, void *datap) {
  96   char **rrp= datap;
  97
  98   adns__makefinal_str(qu,rrp);
  99 }
 100
 101 static adns_status cs_str(vbuf *vb, const void *datap) {
 102   const char *const *rrp= datap;
 103
 104   return csp_qstring(vb,*rrp);
 105 }
 106
 107 /*
 108  * _intstr  (mf,cs)
 109  */
 110
 111 static void mf_intstr(adns_query qu, void *datap) {
 112   adns_rr_intstr *rrp= datap;
 113
 114   adns__makefinal_str(qu,&rrp->str);
 115 }
 116
 117 static adns_status cs_intstr(vbuf *vb, const void *datap) {
 118   const adns_rr_intstr *rrp= datap;
 119   char buf[10];
 120
 121   sprintf(buf,"%u ",rrp->i);
 122   CSP_ADDSTR(buf);
 123   return csp_qstring(vb,rrp->str);
 124 }
 125
 126 /*
 127  * _manyistr   (mf,cs)
 128  */
 129
 130 static void mf_manyistr(adns_query qu, void *datap) {
 131   adns_rr_intstr **rrp= datap;
 132   adns_rr_intstr *te, *table;
 133   void *tablev;
 134   int tc;
 135
 136   for (tc=0, te= *rrp; te->i >= 0; te++, tc++);
 137   tablev= *rrp;
 138   adns__makefinal_block(qu,&tablev,sizeof(*te)*(tc+1));
 139   *rrp= table= tablev;
 140   for (te= *rrp; te->i >= 0; te++)
 141     adns__makefinal_str(qu,&te->str);
 142 }
 143
 144 static adns_status cs_manyistr(vbuf *vb, const void *datap) {
 145   const adns_rr_intstr *const *rrp= datap;
 146   const adns_rr_intstr *current;
 147   adns_status st;
 148   int spc;
 149
 150   for (spc=0, current= *rrp; current->i >= 0; current++) {
 151     if (spc) CSP_ADDSTR(" ");
 152     st= csp_textdata(vb,current->str,current->i); if (st) return st;
 153   }
 154   return adns_s_ok;
 155 }
 156
 157 /*
 158  * _txt   (pa)
 159  */
 160
 161 static adns_status pa_txt(const parseinfo *pai, int cbyte, int max, void *datap) {
 162   adns_rr_intstr **rrp= datap, *table, *te;
 163   const byte *dgram= pai->dgram;
 164   int ti, tc, l, startbyte;
 165
 166   startbyte= cbyte;
 167   if (cbyte >= max) return adns_s_invaliddata;
 168   tc= 0;
 169   while (cbyte < max) {
 170     GET_B(cbyte,l);
 171     cbyte+= l;
 172   }
 173   if (cbyte != max) return adns_s_invaliddata;
 174
 175   table= adns__alloc_interim(pai->qu,sizeof(*table)*(tc+1));
 176   if (!table) R_NOMEM;
 177
 178   for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) {
 179     GET_B(cbyte,l);
 180     te->str= adns__alloc_interim(pai->qu, l+1);
 181     if (!te->str) R_NOMEM;
 182     te->str[l]= 0;
 183     memcpy(te->str,dgram+cbyte,l);
 184     te->i= l;
 185   }
 186   assert(cbyte == max);
 187
 188   te->i= -1;
 189   te->str= 0;
 190
 191   *rrp= table;
 192   return adns_s_ok;
 193 }
 194
 195 /*
 196  * _inaddr   (pa,dip,di)
 197  */
 198
 199 static adns_status pa_inaddr(const parseinfo *pai, int cbyte, int max, void *datap) {
 200   struct in_addr *storeto= datap;
 201
 202   if (max-cbyte != 4) return adns_s_invaliddata;
 203   memcpy(storeto, pai->dgram + cbyte, 4);
 204   return adns_s_ok;
 205 }
 206
 207 static int dip_inaddr(struct in_addr a, struct in_addr b) {
 208   /* fixme implement sortlist */
 209   return 0;
 210 }
 211
 212 static int di_inaddr(const void *datap_a, const void *datap_b) {
 213   const struct in_addr *ap= datap_a, *bp= datap_b;
 214
 215   return dip_inaddr(*ap,*bp);
 216 }
 217
 218 static adns_status cs_inaddr(vbuf *vb, const void *datap) {
 219   const struct in_addr *rrp= datap, rr= *rrp;
 220   const char *ia;
 221
 222   ia= inet_ntoa(rr); assert(ia);
 223   CSP_ADDSTR(ia);
 224   return adns_s_ok;
 225 }
 226
 227 /*
 228  * _addr   (pa,di,csp,cs)
 229  */
 230
 231 static adns_status pa_addr(const parseinfo *pai, int cbyte, int max, void *datap) {
 232   adns_rr_addr *storeto= datap;
 233   const byte *dgram= pai->dgram;
 234
 235   if (max-cbyte != 4) return adns_s_invaliddata;
 236   storeto->len= sizeof(storeto->addr.inet);
 237   memset(&storeto->addr,0,sizeof(storeto->addr.inet));
 238   storeto->addr.inet.sin_family= AF_INET;
 239   memcpy(&storeto->addr.inet.sin_addr,dgram+cbyte,4);
 240   return adns_s_ok;
 241 }
 242
 243 static int di_addr(const void *datap_a, const void *datap_b) {
 244   const adns_rr_addr *ap= datap_a, *bp= datap_b;
 245
 246   assert(ap->addr.sa.sa_family == AF_INET);
 247   return dip_inaddr(ap->addr.inet.sin_addr,bp->addr.inet.sin_addr);
 248 }
 249
 250 static adns_status csp_addr(vbuf *vb, const adns_rr_addr *rrp) {
 251   const char *ia;
 252   static char buf[30];
 253
 254   switch (rrp->addr.inet.sin_family) {
 255   case AF_INET:
 256     CSP_ADDSTR("AF_INET ");
 257     ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia);
 258     CSP_ADDSTR(ia);
 259     break;
 260   default:
 261     sprintf(buf,"AF=%u",rrp->addr.sa.sa_family);
 262     CSP_ADDSTR(buf);
 263     break;
 264   }
 265   return adns_s_ok;
 266 }
 267
 268 static adns_status cs_addr(vbuf *vb, const void *datap) {
 269   const adns_rr_addr *rrp= datap;
 270
 271   return csp_addr(vb,rrp);
 272 }
 273
 274 /*
 275  * _domain  (pap)
 276  */
 277
 278 static adns_status pap_domain(const parseinfo *pai, int *cbyte_io, int max,
 279                               char **domain_r, parsedomain_flags flags) {
 280   adns_status st;
 281   char *dm;
 282
 283   st= adns__parse_domain(pai->qu->ads, pai->serv, pai->qu, &pai->qu->vb, flags,
 284                          pai->dgram,pai->dglen, cbyte_io, max);
 285   if (st) return st;
 286   if (!pai->qu->vb.used) return adns_s_invaliddata;
 287
 288   dm= adns__alloc_interim(pai->qu, pai->qu->vb.used+1);
 289   if (!dm) R_NOMEM;
 290
 291   dm[pai->qu->vb.used]= 0;
 292   memcpy(dm,pai->qu->vb.buf,pai->qu->vb.used);
 293
 294   *domain_r= dm;
 295   return adns_s_ok;
 296 }
 297
 298 /*
 299  * _host_raw   (pa)
 300  */
 301
 302 static adns_status pa_host_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
 303   char **rrp= datap;
 304   adns_status st;
 305
 306   st= pap_domain(pai, &cbyte, max, rrp,
 307                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 308   if (st) return st;
 309
 310   if (cbyte != max) return adns_s_invaliddata;
 311   return adns_s_ok;
 312 }
 313
 314 /*
 315  * _hostaddr   (pap,pa,dip,di,mfp,mf,csp,cs +icb_hostaddr, pap_findaddrs)
 316  */
 317
 318 static adns_status pap_findaddrs(const parseinfo *pai, adns_rr_hostaddr *ha,
 319                                  int *cbyte_io, int count, int dmstart) {
 320   int rri, naddrs;
 321   int type, class, rdlen, rdstart, ownermatched;
 322   adns_status st;
 323
 324   for (rri=0, naddrs=-1; rri<count; rri++) {
 325     st= adns__findrr_anychk(pai->qu, pai->serv, pai->dgram, pai->dglen, cbyte_io,
 326                             &type, &class, &rdlen, &rdstart,
 327                             pai->dgram, pai->dglen, dmstart, &ownermatched);
 328     if (st) return st;
 329     if (!ownermatched || class != DNS_CLASS_IN || type != adns_r_a) {
 330       if (naddrs>0) break; else continue;
 331     }
 332     if (naddrs == -1) {
 333       naddrs= 0;
 334     }
 335     if (!adns__vbuf_ensure(&pai->qu->vb, (naddrs+1)*sizeof(adns_rr_addr))) R_NOMEM;
 336     st= pa_addr(pai, rdstart,rdstart+rdlen,
 337                 pai->qu->vb.buf + naddrs*sizeof(adns_rr_addr));
 338     if (st) return st;
 339     naddrs++;
 340   }
 341   if (naddrs >= 0) {
 342     ha->addrs= adns__alloc_interim(pai->qu, naddrs*sizeof(adns_rr_addr));
 343     if (!ha->addrs) R_NOMEM;
 344     memcpy(ha->addrs, pai->qu->vb.buf, naddrs*sizeof(adns_rr_addr));
 345     ha->naddrs= naddrs;
 346     ha->astatus= adns_s_ok;
 347
 348     adns__isort(ha->addrs, naddrs, sizeof(adns_rr_addr), pai->qu->vb.buf, di_addr);
 349   }
 350   return adns_s_ok;
 351 }
 352
 353 static void icb_hostaddr(adns_query parent, adns_query child) {
 354   adns_answer *cans= child->answer;
 355   adns_rr_hostaddr *rrp= child->ctx.info.hostaddr;
 356
 357   rrp->astatus= cans->status;
 358   rrp->naddrs= cans->nrrs;
 359   rrp->addrs= cans->rrs.addr;
 360   adns__transfer_interim(child, parent, rrp->addrs, rrp->naddrs*sizeof(adns_rr_addr));
 361
 362   if (!parent->children.head) adns__query_done(parent);
 363 }
 364
 365 static adns_status pap_hostaddr(const parseinfo *pai, int *cbyte_io,
 366                                 int max, adns_rr_hostaddr *rrp) {
 367   adns_status st;
 368   int dmstart, cbyte;
 369   qcontext ctx;
 370   int id;
 371   adns_query nqu;
 372
 373   dmstart= cbyte= *cbyte_io;
 374   st= pap_domain(pai, &cbyte, max, &rrp->host,
 375                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 376   if (st) return st;
 377   *cbyte_io= cbyte;
 378
 379   rrp->astatus= adns_s_ok;
 380   rrp->naddrs= -1;
 381   rrp->addrs= 0;
 382
 383   cbyte= pai->nsstart;
 384
 385   st= pap_findaddrs(pai, rrp, &cbyte, pai->nscount, dmstart);
 386   if (st) return st;
 387   if (rrp->naddrs != -1) return adns_s_ok;
 388
 389   st= pap_findaddrs(pai, rrp, &cbyte, pai->arcount, dmstart);
 390   if (st) return st;
 391   if (rrp->naddrs != -1) return adns_s_ok;
 392
 393   st= adns__mkquery_frdgram(pai->ads, &pai->qu->vb, &id,
 394                             pai->dgram, pai->dglen, dmstart,
 395                             adns_r_addr, adns_qf_quoteok_query);
 396   if (st) return st;
 397
 398   ctx.ext= 0;
 399   ctx.callback= icb_hostaddr;
 400   ctx.info.hostaddr= rrp;
 401   st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_addr),
 402                             &pai->qu->vb, id,
 403                             adns_qf_quoteok_query, pai->now, 0, &ctx);
 404   if (st) return st;
 405
 406   nqu->parent= pai->qu;
 407   LIST_LINK_TAIL_PART(pai->qu->children,nqu,siblings.);
 408
 409   return adns_s_ok;
 410 }
 411
 412 static adns_status pa_hostaddr(const parseinfo *pai, int cbyte, int max, void *datap) {
 413   adns_rr_hostaddr *rrp= datap;
 414   adns_status st;
 415
 416   st= pap_hostaddr(pai, &cbyte, max, rrp);
 417   if (st) return st;
 418   if (cbyte != max) return adns_s_invaliddata;
 419
 420   return adns_s_ok;
 421 }
 422
 423 static int dip_hostaddr(const adns_rr_hostaddr *ap, const adns_rr_hostaddr *bp) {
 424   if (ap->astatus != bp->astatus) return ap->astatus;
 425   if (ap->astatus) return 0;
 426
 427   assert(ap->addrs[0].addr.sa.sa_family == AF_INET);
 428   assert(bp->addrs[0].addr.sa.sa_family == AF_INET);
 429   return dip_inaddr(ap->addrs[0].addr.inet.sin_addr, bp->addrs[0].addr.inet.sin_addr);
 430 }
 431
 432 static int di_hostaddr(const void *datap_a, const void *datap_b) {
 433   const adns_rr_hostaddr *ap= datap_a, *bp= datap_b;
 434
 435   return dip_hostaddr(ap,bp);
 436 }
 437
 438 static void mfp_hostaddr(adns_query qu, adns_rr_hostaddr *rrp) {
 439   void *tablev;
 440
 441   adns__makefinal_str(qu,&rrp->host);
 442   tablev= rrp->addrs;
 443   adns__makefinal_block(qu, &tablev, rrp->naddrs*sizeof(*rrp->addrs));
 444   rrp->addrs= tablev;
 445 }
 446
 447 static void mf_hostaddr(adns_query qu, void *datap) {
 448   adns_rr_hostaddr *rrp= datap;
 449
 450   mfp_hostaddr(qu,rrp);
 451 }
 452
 453 static adns_status csp_hostaddr(vbuf *vb, const adns_rr_hostaddr *rrp) {
 454   const char *to_add;
 455   adns_status st;
 456   int i;
 457
 458   st= csp_qstring(vb,rrp->host); if (st) return st;
 459
 460   if (rrp->astatus) {
 461     CSP_ADDSTR(" - ");
 462     CSP_ADDSTR(adns_strerror(rrp->astatus));
 463   } else {
 464     assert(rrp->naddrs > 0);
 465     for (i=0, to_add= ": "; i<rrp->naddrs; i++, to_add= ", ") {
 466       CSP_ADDSTR(to_add);
 467       st= csp_addr(vb,&rrp->addrs[i]);
 468     }
 469   }
 470   return adns_s_ok;
 471 }
 472
 473 static adns_status cs_hostaddr(vbuf *vb, const void *datap) {
 474   const adns_rr_hostaddr *rrp= datap;
 475
 476   return csp_hostaddr(vb,rrp);
 477 }
 478
 479 /*
 480  * _mx_raw   (pa,di)
 481  */
 482
 483 static adns_status pa_mx_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
 484   const byte *dgram= pai->dgram;
 485   adns_rr_intstr *rrp= datap;
 486   adns_status st;
 487   int pref;
 488
 489   if (cbyte+2 > max) return adns_s_invaliddata;
 490   GET_W(cbyte,pref);
 491   rrp->i= pref;
 492   st= pap_domain(pai, &cbyte, max, &rrp->str,
 493                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 494   if (st) return st;
 495
 496   if (cbyte != max) return adns_s_invaliddata;
 497   return adns_s_ok;
 498 }
 499
 500 static int di_mx_raw(const void *datap_a, const void *datap_b) {
 501   const adns_rr_intstr *ap= datap_a, *bp= datap_b;
 502
 503   if (ap->i < bp->i) return 0;
 504   if (ap->i > bp->i) return 1;
 505   return 0;
 506 }
 507
 508 /*
 509  * _mx   (pa,di)
 510  */
 511
 512 static adns_status pa_mx(const parseinfo *pai, int cbyte, int max, void *datap) {
 513   const byte *dgram= pai->dgram;
 514   adns_rr_inthostaddr *rrp= datap;
 515   adns_status st;
 516   int pref;
 517
 518   if (cbyte+2 > max) return adns_s_invaliddata;
 519   GET_W(cbyte,pref);
 520   rrp->i= pref;
 521   st= pap_hostaddr(pai, &cbyte, max, &rrp->ha);
 522   if (st) return st;
 523
 524   if (cbyte != max) return adns_s_invaliddata;
 525   return adns_s_ok;
 526 }
 527
 528 static int di_mx(const void *datap_a, const void *datap_b) {
 529   const adns_rr_inthostaddr *ap= datap_a, *bp= datap_b;
 530
 531   if (ap->i < bp->i) return 0;
 532   if (ap->i > bp->i) return 1;
 533   return dip_hostaddr(&ap->ha,&bp->ha);
 534 }
 535
 536 /*
 537  * _inthostaddr  (mf,cs)
 538  */
 539
 540 static void mf_inthostaddr(adns_query qu, void *datap) {
 541   adns_rr_inthostaddr *rrp= datap;
 542
 543   mfp_hostaddr(qu,&rrp->ha);
 544 }
 545
 546 static adns_status cs_inthostaddr(vbuf *vb, const void *datap) {
 547   const adns_rr_inthostaddr *rrp= datap;
 548   char buf[10];
 549
 550   sprintf(buf,"%u ",rrp->i);
 551   CSP_ADDSTR(buf);
 552
 553   return csp_hostaddr(vb,&rrp->ha);
 554 }
 555
 556 /*
 557  * _ptr   (pa, +icb_ptr)
 558  */
 559
 560 static void icb_ptr(adns_query parent, adns_query child) {
 561   adns_answer *cans= child->answer;
 562   const adns_rr_addr *queried, *found;
 563   int i;
 564
 565   if (cans->status == adns_s_nxdomain || cans->status == adns_s_nodata) {
 566     adns__query_fail(parent,adns_s_inconsistent);
 567     return;
 568   } else if (cans->status) {
 569     adns__query_fail(parent,cans->status);
 570     return;
 571   }
 572
 573   queried= &parent->ctx.info.ptr_parent_addr;
 574   for (i=0, found=cans->rrs.addr; i<cans->nrrs; i++, found++) {
 575     if (queried->len == found->len &&
 576         !memcmp(&queried->addr,&found->addr,queried->len)) {
 577       if (!parent->children.head) adns__query_done(parent);
 578       return;
 579     }
 580   }
 581
 582   adns__query_fail(parent,adns_s_inconsistent);
 583 }
 584
 585 static adns_status pa_ptr(const parseinfo *pai, int dmstart, int max, void *datap) {
 586   static const char *(expectdomain[])= { DNS_INADDR_ARPA };
 587
 588   char **rrp= datap;
 589   adns_status st;
 590   adns_rr_addr *ap;
 591   findlabel_state fls;
 592   char *ep;
 593   byte ipv[4];
 594   char labbuf[4];
 595   int cbyte, i, lablen, labstart, l, id;
 596   adns_query nqu;
 597   qcontext ctx;
 598
 599   cbyte= dmstart;
 600   st= pap_domain(pai, &cbyte, max, rrp,
 601                  pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
 602   if (st) return st;
 603   if (cbyte != max) return adns_s_invaliddata;
 604
 605   ap= &pai->qu->ctx.info.ptr_parent_addr;
 606   if (!ap->len) {
 607     adns__findlabel_start(&fls, pai->ads, -1, pai->qu,
 608                           pai->qu->query_dgram, pai->qu->query_dglen,
 609                           pai->qu->query_dglen, DNS_HDRSIZE, 0);
 610     for (i=0; i<4; i++) {
 611       st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
 612       if (lablen<=0 || lablen>3) return adns_s_invalidquerydomain;
 613       memcpy(labbuf, pai->qu->query_dgram + labstart, lablen);  labbuf[lablen]= 0;
 614       ipv[3-i]= strtoul(labbuf,&ep,10);  if (*ep) return adns_s_invalidquerydomain;
 615       if (lablen>1 && pai->qu->query_dgram[labstart]=='0')
 616         return adns_s_invalidquerydomain;
 617     }
 618     for (i=0; i<sizeof(expectdomain)/sizeof(*expectdomain); i++) {
 619       st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
 620       l= strlen(expectdomain[i]);
 621       if (lablen != l || memcmp(pai->qu->query_dgram + labstart, expectdomain[i], l))
 622         return adns_s_invalidquerydomain;
 623     }
 624     st= adns__findlabel_next(&fls,&lablen,0); assert(!st);
 625     if (lablen) return adns_s_invalidquerydomain;
 626
 627     ap->len= sizeof(struct sockaddr_in);
 628     memset(&ap->addr,0,sizeof(ap->addr.inet));
 629     ap->addr.inet.sin_family= AF_INET;
 630     ap->addr.inet.sin_addr.s_addr=
 631       htonl((ipv[0]<<24) | (ipv[1]<<16) | (ipv[2]<<8) | (ipv[3]));
 632   }
 633
 634   st= adns__mkquery_frdgram(pai->ads, &pai->qu->vb, &id,
 635                             pai->dgram, pai->dglen, dmstart,
 636                             adns_r_addr, adns_qf_quoteok_query);
 637   if (st) return st;
 638
 639   ctx.ext= 0;
 640   ctx.callback= icb_ptr;
 641   memset(&ctx.info,0,sizeof(ctx.info));
 642   st= adns__internal_submit(pai->ads, &nqu, adns__findtype(adns_r_addr),
 643                             &pai->qu->vb, id,
 644                             adns_qf_quoteok_query, pai->now, 0, &ctx);
 645   if (st) return st;
 646
 647   nqu->parent= pai->qu;
 648   LIST_LINK_TAIL_PART(pai->qu->children,nqu,siblings.);
 649
 650   return adns_s_ok;
 651 }
 652
 653 /*
 654  * _flat   (mf)
 655  */
 656
 657 static void mf_flat(adns_query qu, void *data) { }
 658
 659 /*
 660  * Now the table.
 661  */
 662
 663 #define TYPESZ_M(member)           (sizeof(*((adns_answer*)0)->rrs.member))
 664
 665 #define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb
 666 #define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb
 667
 668 #define DEEP_TYPE(code,rrt,fmt,memb,parser,comparer) \
 669  { adns_r_##code, rrt, fmt, TYPESZ_M(memb), mf_##memb, cs_##memb, parser, comparer }
 670 #define FLAT_TYPE(code,rrt,fmt,memb,parser,comparer) \
 671  { adns_r_##code, rrt, fmt, TYPESZ_M(memb), mf_flat, cs_##memb, parser, comparer }
 672
 673 static const typeinfo typeinfos[] = {
 674 /* Must be in ascending order of rrtype ! */
 675 /* mem-mgmt code     rrt     fmt      member       parser        comparer    */
 676
 677   FLAT_TYPE(a,       "A",     0,      inaddr,      pa_inaddr,    di_inaddr   ),
 678   DEEP_TYPE(ns_raw,  "NS",   "raw",   str,         pa_host_raw,  0           ),
 679   DEEP_TYPE(cname,   "CNAME", 0,      str,         pa_host_raw,  0           ),
 680 #if 0
 681   DEEP_TYPE(soa_raw, "SOA",  "raw",   soa,         pa_soa,       0           ),
 682 #endif
 683   DEEP_TYPE(ptr_raw, "PTR",  "raw",   str,         pa_host_raw,  0           ),
 684 #if 0
 685   DEEP_TYPE(hinfo,   "HINFO", 0,      strpair,     pa_hinfo,     0           ),
 686 #endif
 687   DEEP_TYPE(mx_raw,  "MX",   "raw",   intstr,      pa_mx_raw,    di_mx_raw   ),
 688   DEEP_TYPE(txt,     "TXT",   0,      manyistr,    pa_txt,       0           ),
 689 #if 0
 690   DEEP_TYPE(rp_raw,  "RP",   "raw",   strpair,     pa_rp,        0           ),
 691 #endif
 692
 693   FLAT_TYPE(addr,    "A",  "addr",    addr,        pa_addr,      di_addr     ),
 694   DEEP_TYPE(ns,      "NS", "+addr",   hostaddr,    pa_hostaddr,  di_hostaddr ),
 695   DEEP_TYPE(ptr,     "PTR","checked", str,         pa_ptr,       0           ),
 696   DEEP_TYPE(mx,      "MX", "+addr",   inthostaddr, pa_mx,        di_mx       ),
 697
 698 #if 0
 699   DEEP_TYPE(soa,     "SOA","822",     soa,         pa_soa,        0          ),
 700   DEEP_TYPE(rp,      "RP", "822",     strpair,     pa_rp,         0          ),
 701 #endif /* fixme - implement all types */
 702 };
 703
 704 const typeinfo *adns__findtype(adns_rrtype type) {
 705   const typeinfo *begin, *end, *mid;
 706
 707   begin= typeinfos;  end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo));
 708
 709   while (begin < end) {
 710     mid= begin + ((end-begin)>>1);
 711     if (mid->type == type) return mid;
 712     if (type > mid->type) begin= mid+1;
 713     else end= mid;
 714   }
 715   return 0;
 716 }