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