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