3 * - RR-type-specific code, and the machinery to call it
6 * This file is part of adns, which is Copyright (C) 1997, 1998 Ian Jackson
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)
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.
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.
26 #include <arpa/inet.h>
30 #define R_NOMEM return adns_s_nolocalmem
31 #define CSP_ADDSTR(s) if (!adns__vbuf_appendstr(vb,(s))) R_NOMEM; else;
33 static int dip_inaddr(struct in_addr a, struct in_addr b) {
34 /* fixme implement sortlist */
38 static adns_status pa_inaddr(const parseinfo *pai, int cbyte, int max, void *datap) {
39 struct in_addr *storeto= datap;
41 if (max-cbyte != 4) return adns_s_invaliddata;
42 memcpy(storeto, pai->dgram + cbyte, 4);
46 static int di_inaddr(const void *datap_a, const void *datap_b) {
47 const struct in_addr *ap= datap_a, *bp= datap_b;
49 return dip_inaddr(*ap,*bp);
52 static adns_status cs_inaddr(vbuf *vb, const void *datap) {
53 const struct in_addr *rrp= datap, rr= *rrp;
56 ia= inet_ntoa(rr); assert(ia);
61 static adns_status pa_addr(const parseinfo *pai, int cbyte, int max, void *datap) {
62 adns_addr *storeto= datap;
63 const byte *dgram= pai->dgram;
65 if (max-cbyte != 4) return adns_s_invaliddata;
66 storeto->len= sizeof(storeto->addr.inet);
67 memset(&storeto->addr,0,sizeof(storeto->addr.inet));
68 storeto->addr.inet.sin_family= AF_INET;
69 storeto->addr.inet.sin_port= 0;
70 memcpy(&storeto->addr.inet.sin_addr,dgram+cbyte,4);
74 static int di_addr(const void *datap_a, const void *datap_b) {
75 const adns_addr *ap= datap_a, *bp= datap_b;
77 assert(ap->addr.sa.sa_family == AF_INET);
78 return dip_inaddr(ap->addr.inet.sin_addr,bp->addr.inet.sin_addr);
81 static adns_status csp_addr(vbuf *vb, const adns_addr *rrp) {
85 switch (rrp->addr.inet.sin_family) {
87 CSP_ADDSTR("AF_INET ");
88 ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia);
92 sprintf(buf,"AF=%u",rrp->addr.sa.sa_family);
99 static adns_status cs_addr(vbuf *vb, const void *datap) {
100 const adns_addr *rrp= datap;
102 return csp_addr(vb,rrp);
105 static adns_status pap_domain(const parseinfo *pai, int *cbyte_io, int max,
106 char **domain_r, parsedomain_flags flags) {
110 st= adns__parse_domain(pai->qu->ads, pai->serv, pai->qu, &pai->qu->vb, flags,
111 pai->dgram,pai->dglen, cbyte_io, max);
113 if (!pai->qu->vb.used) return adns_s_invaliddata;
115 dm= adns__alloc_interim(pai->qu, pai->qu->vb.used+1);
118 dm[pai->qu->vb.used]= 0;
119 memcpy(dm,pai->qu->vb.buf,pai->qu->vb.used);
125 static adns_status pa_host_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
129 st= pap_domain(pai, &cbyte, max, rrp,
130 pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
133 if (cbyte != max) return adns_s_invaliddata;
137 static adns_status pa_mx_raw(const parseinfo *pai, int cbyte, int max, void *datap) {
138 const byte *dgram= pai->dgram;
139 adns_rr_intstr *rrp= datap;
143 if (cbyte+2 > max) return adns_s_invaliddata;
146 st= pap_domain(pai, &cbyte, max, &rrp->str,
147 pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
150 if (cbyte != max) return adns_s_invaliddata;
155 static adns_status pap_findaddrs(const parseinfo *pai, adns_rr_hostaddr *ha,
156 int *cbyte_io, int count, int dmstart) {
158 int type, class, rdlen, rdstart, ownermatched;
161 for (rri=0, naddrs=-1; rri<count; rri++) {
162 st= adns__findrr_anychk(pai->qu, pai->serv, pai->dgram, pai->dglen, cbyte_io,
163 &type, &class, &rdlen, &rdstart,
164 pai->dgram, pai->dglen, dmstart, &ownermatched);
166 if (!ownermatched || class != DNS_CLASS_IN || type != adns_r_a) {
167 if (naddrs>0) break; else continue;
172 if (!adns__vbuf_ensure(&pai->qu->vb, (naddrs+1)*sizeof(adns_addr))) R_NOMEM;
173 st= pa_addr(pai, rdstart,rdstart+rdlen, pai->qu->vb.buf + naddrs*sizeof(adns_addr));
178 ha->addrs= adns__alloc_interim(pai->qu, naddrs*sizeof(adns_addr));
179 if (!ha->addrs) R_NOMEM;
180 memcpy(ha->addrs, pai->qu->vb.buf, naddrs*sizeof(adns_addr));
182 ha->astatus= adns_s_ok;
184 adns__isort(ha->addrs, naddrs, sizeof(adns_addr), pai->qu->vb.buf, di_addr);
189 static adns_status pap_hostaddr(const parseinfo *pai, int *cbyte_io,
190 int max, adns_rr_hostaddr *rrp) {
194 dmstart= cbyte= *cbyte_io;
195 st= pap_domain(pai, &cbyte, max, &rrp->host,
196 pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
200 rrp->astatus= adns_s_ok;
206 st= pap_findaddrs(pai, rrp, &cbyte, pai->nscount, dmstart);
208 if (rrp->naddrs != -1) return adns_s_ok;
210 st= pap_findaddrs(pai, rrp, &cbyte, pai->arcount, dmstart);
212 if (rrp->naddrs != -1) return adns_s_ok;
214 rrp->naddrs= 0; /* fixme additional section didn't have required data */
215 rrp->astatus= adns_s_notimplemented;
220 static adns_status pa_hostaddr(const parseinfo *pai, int cbyte, int max, void *datap) {
221 adns_rr_hostaddr *rrp= datap;
224 st= pap_hostaddr(pai, &cbyte, max, rrp);
226 if (cbyte != max) return adns_s_invaliddata;
231 static adns_status pa_mx(const parseinfo *pai, int cbyte, int max, void *datap) {
232 const byte *dgram= pai->dgram;
233 adns_rr_inthostaddr *rrp= datap;
237 if (cbyte+2 > max) return adns_s_invaliddata;
240 st= pap_hostaddr(pai, &cbyte, max, &rrp->ha);
243 if (cbyte != max) return adns_s_invaliddata;
247 static int dip_hostaddr(const adns_rr_hostaddr *ap, const adns_rr_hostaddr *bp) {
248 if (ap->astatus != bp->astatus) return ap->astatus;
249 if (ap->astatus) return 0;
251 assert(ap->addrs[0].addr.sa.sa_family == AF_INET);
252 assert(bp->addrs[0].addr.sa.sa_family == AF_INET);
253 return dip_inaddr(ap->addrs[0].addr.inet.sin_addr, bp->addrs[0].addr.inet.sin_addr);
256 static int di_hostaddr(const void *datap_a, const void *datap_b) {
257 const adns_rr_hostaddr *ap= datap_a, *bp= datap_b;
259 return dip_hostaddr(ap,bp);
262 static int di_mx_raw(const void *datap_a, const void *datap_b) {
263 const adns_rr_intstr *ap= datap_a, *bp= datap_b;
265 if (ap->i < bp->i) return 0;
266 if (ap->i > bp->i) return 1;
270 static int di_mx(const void *datap_a, const void *datap_b) {
271 const adns_rr_inthostaddr *ap= datap_a, *bp= datap_b;
273 if (ap->i < bp->i) return 0;
274 if (ap->i > bp->i) return 1;
275 return dip_hostaddr(&ap->ha,&bp->ha);
278 static adns_status pa_txt(const parseinfo *pai, int cbyte, int max, void *datap) {
279 adns_rr_intstr **rrp= datap, *table, *te;
280 const byte *dgram= pai->dgram;
281 int ti, tc, l, startbyte;
284 if (cbyte >= max) return adns_s_invaliddata;
286 while (cbyte < max) {
290 if (cbyte != max) return adns_s_invaliddata;
292 table= adns__alloc_interim(pai->qu,sizeof(*table)*(tc+1));
295 for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) {
297 te->str= adns__alloc_interim(pai->qu, l+1);
298 if (!te->str) R_NOMEM;
300 memcpy(te->str,dgram+cbyte,l);
303 assert(cbyte == max);
312 static adns_status csp_textdata(vbuf *vb, const char *dp, int len) {
318 for (cn=0; cn<len; cn++) {
320 if (ch >= 32 && ch <= 126 && ch != '"' && ch != '\\') {
321 if (!adns__vbuf_append(vb,&ch,1)) R_NOMEM;
323 sprintf(buf,"\\%02x",ch);
332 static adns_status csp_qstring(vbuf *vb, const char *dp) {
333 return csp_textdata(vb, dp, strlen(dp));
336 static adns_status cs_str(vbuf *vb, const void *datap) {
337 const char *const *rrp= datap;
339 return csp_qstring(vb,*rrp);
342 static adns_status cs_intstr(vbuf *vb, const void *datap) {
343 const adns_rr_intstr *rrp= datap;
346 sprintf(buf,"%u ",rrp->i);
348 return csp_qstring(vb,rrp->str);
351 static adns_status cs_manyistr(vbuf *vb, const void *datap) {
352 const adns_rr_intstr *const *rrp= datap;
353 const adns_rr_intstr *current;
357 for (spc=0, current= *rrp; current->i >= 0; current++) {
358 if (spc) CSP_ADDSTR(" ");
359 st= csp_textdata(vb,current->str,current->i); if (st) return st;
364 static void mf_str(adns_query qu, void *datap) {
367 adns__makefinal_str(qu,rrp);
370 static void mf_intstr(adns_query qu, void *datap) {
371 adns_rr_intstr *rrp= datap;
373 adns__makefinal_str(qu,&rrp->str);
376 static adns_status csp_hostaddr(vbuf *vb, const adns_rr_hostaddr *rrp) {
381 st= csp_qstring(vb,rrp->host); if (st) return st;
385 CSP_ADDSTR(adns_strerror(rrp->astatus));
387 assert(rrp->naddrs > 0);
388 for (i=0, to_add= ": "; i<rrp->naddrs; i++, to_add= ", ") {
390 st= csp_addr(vb,&rrp->addrs[i]);
396 static adns_status cs_hostaddr(vbuf *vb, const void *datap) {
397 const adns_rr_hostaddr *rrp= datap;
399 return csp_hostaddr(vb,rrp);
402 static adns_status cs_inthostaddr(vbuf *vb, const void *datap) {
403 const adns_rr_inthostaddr *rrp= datap;
406 sprintf(buf,"%u ",rrp->i);
409 return csp_hostaddr(vb,&rrp->ha);
412 static void mfp_hostaddr(adns_query qu, adns_rr_hostaddr *rrp) {
415 adns__makefinal_str(qu,&rrp->host);
417 adns__makefinal_block(qu, &tablev, rrp->naddrs*sizeof(*rrp->addrs));
421 static void mf_hostaddr(adns_query qu, void *datap) {
422 adns_rr_hostaddr *rrp= datap;
424 mfp_hostaddr(qu,rrp);
427 static void mf_inthostaddr(adns_query qu, void *datap) {
428 adns_rr_inthostaddr *rrp= datap;
430 mfp_hostaddr(qu,&rrp->ha);
433 static void mf_manyistr(adns_query qu, void *datap) {
434 adns_rr_intstr **rrp= datap;
435 adns_rr_intstr *te, *table;
439 for (tc=0, te= *rrp; te->i >= 0; te++, tc++);
441 adns__makefinal_block(qu,&tablev,sizeof(*te)*(tc+1));
443 for (te= *rrp; te->i >= 0; te++)
444 adns__makefinal_str(qu,&te->str);
447 static void mf_flat(adns_query qu, void *data) { }
449 #define TYPE_SF(size,func,cp,free) size, pa_##func, mf_##free, cs_##cp
450 #define TYPE_SN(size,func,cp) size, pa_##func, mf_flat, cs_##cp
451 #define TYPESZ_M(member) (sizeof(*((adns_answer*)0)->rrs.member))
452 #define TYPE_MF(memb,parse) TYPE_SF(TYPESZ_M(memb),parse,memb,memb)
453 #define TYPE_MN(memb,parse) TYPE_SN(TYPESZ_M(memb),parse,memb)
455 #define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb
456 #define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb
459 * ms is M specify member name
460 * or S specify size explicitly
461 * nf is F full memory management, dependent on member name or specified func
462 * N no memory management required
465 static const typeinfo typeinfos[] = {
466 /* Must be in ascending order of rrtype ! */
467 /* rr type code rrt fmt mem.mgmt member parser comparer */
469 { adns_r_a, "A", 0, FLAT_MEMB(inaddr), pa_inaddr, di_inaddr },
470 { adns_r_ns_raw, "NS", "raw", DEEP_MEMB(str), pa_host_raw, 0 },
471 { adns_r_cname, "CNAME", 0, DEEP_MEMB(str), pa_host_raw, 0 },
473 { adns_r_soa_raw, "SOA", "raw", DEEP_MEMB(soa), pa_soa, 0 },
475 { adns_r_ptr_raw, "PTR", "raw", DEEP_MEMB(str), pa_host_raw, 0 },
477 { adns_r_hinfo, "HINFO", 0, DEEP_MEMB(strpair), pa_hinfo, 0 },
479 { adns_r_mx_raw, "MX", "raw", DEEP_MEMB(intstr), pa_mx_raw, di_mx_raw },
480 { adns_r_txt, "TXT", 0, DEEP_MEMB(manyistr), pa_txt, 0 },
482 { adns_r_rp_raw, "RP", "raw", DEEP_MEMB(strpair), pa_rp, 0 },
485 { adns_r_addr, "A", "addr", FLAT_MEMB(addr), pa_addr, di_addr },
486 { adns_r_ns, "NS", "+addr", DEEP_MEMB(hostaddr), pa_hostaddr, di_hostaddr },
488 { adns_r_ptr, "PTR","checked", DEEP_MEMB(str), pa_ptr, 0 },
490 { adns_r_mx, "MX", "+addr", DEEP_MEMB(inthostaddr), pa_mx, di_mx },
493 { adns_r_soa, "SOA","822", DEEP_MEMB(soa), pa_soa, 0 },
494 { adns_r_rp, "RP", "822", DEEP_MEMB(strpair), pa_rp, 0 },
498 const typeinfo *adns__findtype(adns_rrtype type) {
499 const typeinfo *begin, *end, *mid;
501 begin= typeinfos; end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo));
503 while (begin < end) {
504 mid= begin + ((end-begin)>>1);
505 if (mid->type == type) return mid;
506 if (type > mid->type) begin= mid+1;