e576be50 |
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 | */ |
98a3f706 |
22 | |
1b644113 |
23 | #include <stdlib.h> |
828d89bd |
24 | #include <string.h> |
1b644113 |
25 | |
86e7b8d9 |
26 | #include <arpa/inet.h> |
27 | |
98a3f706 |
28 | #include "internal.h" |
29 | |
828d89bd |
30 | static int dip_inaddr(struct in_addr a, struct in_addr b) { |
31 | /* fixme implement sortlist */ |
32 | return 0; |
33 | } |
34 | |
86e7b8d9 |
35 | static adns_status pa_inaddr(adns_query qu, int serv, |
e7a9ca47 |
36 | const byte *dgram, int dglen, int cbyte, int max, |
88372443 |
37 | int nsstart, int *arstart_io, void *datap) { |
e062dcae |
38 | struct in_addr *storeto= datap; |
e7a9ca47 |
39 | |
40 | if (max-cbyte != 4) return adns_s_invaliddata; |
e062dcae |
41 | memcpy(storeto,dgram+cbyte,4); |
e7a9ca47 |
42 | return adns_s_ok; |
43 | } |
44 | |
e062dcae |
45 | static int di_inaddr(const void *datap_a, const void *datap_b) { |
46 | const struct in_addr *ap= datap_a, *bp= datap_b; |
47 | |
48 | return dip_inaddr(*ap,*bp); |
49 | } |
50 | |
51 | static adns_status cs_inaddr(vbuf *vb, const void *datap) { |
52 | const struct in_addr *rrp= datap, rr= *rrp; |
86e7b8d9 |
53 | const char *ia; |
54 | |
e062dcae |
55 | ia= inet_ntoa(rr); assert(ia); |
86e7b8d9 |
56 | return adns__vbuf_appendstr(vb,ia) ? adns_s_ok : adns_s_nolocalmem; |
57 | } |
e7a9ca47 |
58 | |
828d89bd |
59 | static adns_status pa_addr(adns_query qu, int serv, |
60 | const byte *dgram, int dglen, int cbyte, int max, |
c7836bc9 |
61 | void *datap) { |
828d89bd |
62 | adns_addr *storeto= datap; |
c7836bc9 |
63 | |
828d89bd |
64 | if (max-cbyte != 4) return adns_s_invaliddata; |
65 | storeto->len= sizeof(storeto->addr.inet); |
66 | memset(&storeto->addr,0,sizeof(storeto->addr.inet)); |
67 | storeto->addr.inet.sin_family= AF_INET; |
68 | storeto->addr.inet.sin_port= 0; |
69 | memcpy(&storeto->addr.inet.sin_addr,dgram+cbyte,4); |
70 | return adns_s_ok; |
71 | } |
72 | |
73 | static int di_addr(const void *datap_a, const void *datap_b) { |
74 | const adns_addr *ap= datap_a, *bp= datap_b; |
75 | |
76 | return dip_inaddr(ap->addr.inet.sin_addr,bp->addr.inet.sin_addr); |
77 | } |
78 | |
79 | static adns_status cs_addr(vbuf *vb, const void *datap) { |
80 | const adns_addr *rrp= datap; |
81 | const char *ia; |
82 | static char buf[30]; |
83 | |
84 | switch (rrp->addr.inet.sin_family) { |
85 | case AF_INET: |
86 | if (!adns__vbuf_appendstr(vb,"AF_INET ")) return adns_s_nolocalmem; |
87 | ia= inet_ntoa(rrp->addr.inet.sin_addr); assert(ia); |
88 | if (!adns__vbuf_appendstr(vb,ia)) return adns_s_nolocalmem; |
89 | break; |
90 | default: |
91 | sprintf(buf,"AF=%u",rrp->addr.sa.sa_family); |
92 | if (!adns__vbuf_appendstr(vb,buf)) return adns_s_nolocalmem; |
93 | break; |
94 | } |
95 | return adns_s_ok; |
96 | } |
97 | |
98 | static adns_status pap_domain(adns_query qu, int serv, parsedomain_flags flags, |
e062dcae |
99 | const byte *dgram, int dglen, int *cbyte_io, int max, |
100 | char **domain_r) { |
101 | adns_status st; |
102 | char *dm; |
103 | |
828d89bd |
104 | st= adns__parse_domain(qu->ads,serv,qu,&qu->vb,flags, dgram,dglen, cbyte_io,max); |
e062dcae |
105 | if (st) return st; |
106 | if (!qu->vb.used) return adns_s_invaliddata; |
107 | |
108 | dm= adns__alloc_interim(qu,qu->vb.used+1); |
109 | if (!dm) return adns_s_nolocalmem; |
110 | |
111 | dm[qu->vb.used]= 0; |
112 | memcpy(dm,qu->vb.buf,qu->vb.used); |
113 | |
114 | *domain_r= dm; |
115 | return adns_s_ok; |
116 | } |
117 | |
828d89bd |
118 | static adns_status pa_host_raw(adns_query qu, int serv, |
119 | const byte *dgram, int dglen, int cbyte, int max, |
88372443 |
120 | int nsstart, int *arstart_io, void *datap) { |
e062dcae |
121 | char **rrp= datap; |
ffbda80c |
122 | adns_status st; |
86e7b8d9 |
123 | |
828d89bd |
124 | st= pap_domain(qu,serv, |
125 | qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0, |
126 | dgram,dglen,&cbyte,max,rrp); |
e062dcae |
127 | if (st) return st; |
128 | |
129 | if (cbyte != max) return adns_s_invaliddata; |
130 | return adns_s_ok; |
131 | } |
ffbda80c |
132 | |
e062dcae |
133 | static adns_status pa_mx_raw(adns_query qu, int serv, |
134 | const byte *dgram, int dglen, int cbyte, int max, |
88372443 |
135 | int nsstart, int *arstart_io, void *datap) { |
e062dcae |
136 | adns_rr_intstr *rrp= datap; |
137 | adns_status st; |
138 | int pref; |
ffbda80c |
139 | |
e062dcae |
140 | if (cbyte+2 > max) return adns_s_invaliddata; |
141 | GET_W(cbyte,pref); |
142 | rrp->i= pref; |
828d89bd |
143 | st= pap_domain(qu,serv, |
144 | qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0, |
145 | dgram,dglen,&cbyte,max,&rrp->str); |
e062dcae |
146 | if (st) return st; |
147 | |
148 | if (cbyte != max) return adns_s_invaliddata; |
149 | return adns_s_ok; |
150 | } |
ffbda80c |
151 | |
c7836bc9 |
152 | |
153 | static adns_status pap_findaddrs(adns_query qu, int serv, adns_rr_hostaddr *ha, |
154 | const byte *dgram, int dglen, int *cbyte_io, |
155 | int dmstart, int count) { |
156 | int rri, nrrs; |
157 | int type, class, rdlen, rdstart, ownermatched; |
158 | |
159 | for (rri=0, nrrs=-1; rri<count; rri++) { |
160 | st= adns__findrr_anychk(qu,serv,dgram,dglen,cbyte_io, |
161 | &type,&class,&rdlen,&rdstart, |
162 | dgram,dglen,dmstart, |
163 | &ownermatched); |
164 | if (st) return st; |
165 | if (class != DNS_CLASS_IN) continue; |
166 | if (type != adns_r_a) continue; |
167 | if (nrrs == -1) { |
168 | qu->vb.used= 0; |
169 | nrrs= 0; |
170 | } |
171 | if (!adns__vbuf_ensure(&qu->vb,qu->vb.used+sizeof(adns_addr))) |
172 | return adns_s_nolocalmem; |
173 | st= pa_addr(qu,serv, dgram,dglen, rdstart,rdstart+rdlen, |
174 | qu->vb.buf + qu->vb.used); |
175 | if (st) return st; |
176 | qu->vb.used += sizeof(adns_addr); |
177 | nrrs++; |
178 | } |
179 | if (nrrs >= 0) { |
180 | ha->rrs= adns__alloc_interim(qu,qu->vb.used); |
181 | if (!ha->rrs) return adns_s_nolocalmem; |
182 | ha->nrrs= nrrs; |
183 | ha->astatus= adns_s_ok; |
184 | } |
185 | return adns_s_ok; |
186 | } |
187 | |
188 | static adns_status pap_hostaddr(adns_query qu, int serv, |
189 | const byte *dgram, int dglen, int *cbyte_io, int max, |
190 | int nsstart, int nscount, int arcount, void *datap) { |
191 | adns_rr_hostaddr **rrp= datap; |
192 | adns_status st; |
193 | int dmstart, cbyte; |
194 | |
195 | dmstart= cbyte= *cbyte_io; |
196 | st= pap_domain(qu,serv, |
197 | qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0, |
198 | dgram,dglen,&cbyte,max,&rrp->dm); |
199 | if (st) return st; |
200 | *cbyte_io= cbyte; |
201 | |
202 | rrp->astatus= adns_s_ok; |
203 | rrp->naddrs= -1; |
204 | rrp->addrs= 0; |
205 | |
206 | cbyte= nsstart; |
207 | |
208 | st= pap_findaddrs(qu, rrp, dgram,dglen,&cbyte, dmstart); |
209 | if (st) return st; |
210 | if (rrp->naddrs != -1) return adns_s_ok; |
211 | |
212 | st= pap_findaddrs(qu, rrp, dgram,dglen,&cbyte, dmstart); |
213 | if (st) return st; |
214 | if (rrp->naddrs != -1) return adns_s_ok; |
215 | } |
216 | |
217 | static adns_status pa_hostaddr(adns_query qu, int serv, |
218 | const byte *dgram, int dglen, int cbyte, int max, |
219 | int nsstart, void *datap) { |
220 | adns_rr_hostaddr **rrp= datap; |
221 | adns_status st; |
222 | int dmstart; |
223 | |
224 | dmstart= cbyte; |
225 | st= pap_domain(qu,serv, |
226 | qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0, |
227 | dgram,dglen,&cbyte,max,&rrp->dm); |
228 | if (st) return st; |
229 | if (cbyte != max) return adns_s_invaliddata; |
230 | |
231 | rrp->astatus= adns_s_ok; |
232 | rrp->naddrs= -1; |
233 | rrp->addrs= 0; |
234 | |
235 | cbyte= nsstart; |
236 | |
237 | st= pap_findaddrs(qu, rrp, dgram,dglen, dmstart,&cbyte); |
238 | if (st) return st; |
239 | if (rrp->naddrs != -1) return adns_s_ok; |
240 | |
241 | st= pap_findaddrs(qu, rrp, dgram,dglen, dmstart,&cbyte); |
242 | if (st) return st; |
243 | if (rrp->naddrs != -1) return adns_s_ok; |
244 | |
245 | assert(!"additional section didn't have required data"); |
246 | } |
247 | |
e062dcae |
248 | static int di_mx_raw(const void *datap_a, const void *datap_b) { |
249 | const adns_rr_intstr *ap= datap_a, *bp= datap_b; |
ffbda80c |
250 | |
e062dcae |
251 | if (ap->i < bp->i) return 0; |
252 | if (ap->i > bp->i) return 1; |
253 | return 0; |
ffbda80c |
254 | } |
255 | |
e062dcae |
256 | static adns_status pa_txt(adns_query qu, int serv, |
257 | const byte *dgram, int dglen, int startbyte, int max, |
88372443 |
258 | int nsstart, int *arstart_io, void *datap) { |
e062dcae |
259 | adns_rr_intstr **rrp= datap, *table, *te; |
260 | int ti, tc, cbyte, l; |
ffbda80c |
261 | |
e062dcae |
262 | cbyte= startbyte; |
263 | if (cbyte >= max) return adns_s_invaliddata; |
264 | tc= 0; |
265 | while (cbyte < max) { |
266 | GET_B(cbyte,l); |
267 | cbyte+= l; |
268 | } |
269 | if (cbyte != max) return adns_s_invaliddata; |
270 | |
271 | table= adns__alloc_interim(qu,sizeof(*table)*(tc+1)); |
272 | if (!table) return adns_s_nolocalmem; |
273 | |
274 | for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) { |
275 | GET_B(cbyte,l); |
276 | te->str= adns__alloc_interim(qu,l+1); |
277 | if (!te->str) return adns_s_nolocalmem; |
278 | te->str[l]= 0; |
279 | memcpy(te->str,dgram+cbyte,l); |
280 | te->i= l; |
281 | } |
282 | assert(cbyte == max); |
283 | |
284 | te->i= -1; |
285 | te->str= 0; |
286 | |
287 | *rrp= table; |
288 | return adns_s_ok; |
ffbda80c |
289 | } |
290 | |
e062dcae |
291 | static int csp_textdata(vbuf *vb, const char *dp, int len) { |
1b644113 |
292 | unsigned char ch; |
293 | char buf[10]; |
e062dcae |
294 | int cn; |
1b644113 |
295 | |
296 | if (!adns__vbuf_append(vb,"\"",1)) return 0; |
297 | |
e062dcae |
298 | for (cn=0; cn<len; cn++) { |
299 | ch= *dp++; |
1b644113 |
300 | if (ch >= 32 && ch <= 126 && ch != '"' && ch != '\\') { |
301 | if (!adns__vbuf_append(vb,&ch,1)) return 0; |
302 | } else { |
303 | sprintf(buf,"\\%02x",ch); |
304 | if (!adns__vbuf_appendstr(vb,buf)) return 0; |
305 | } |
306 | } |
ffbda80c |
307 | |
1b644113 |
308 | if (!adns__vbuf_append(vb,"\"",1)) return 0; |
309 | return 1; |
310 | } |
311 | |
e062dcae |
312 | static int csp_qstring(vbuf *vb, const char *dp) { |
313 | return csp_textdata(vb, dp, strlen(dp)); |
314 | } |
315 | |
316 | static adns_status cs_str(vbuf *vb, const void *datap) { |
317 | const char *const *rrp= datap; |
318 | |
319 | return csp_qstring(vb,*rrp) ? adns_s_ok : adns_s_nolocalmem; |
320 | } |
321 | |
322 | static adns_status cs_intstr(vbuf *vb, const void *datap) { |
323 | const adns_rr_intstr *rrp= datap; |
324 | char buf[10]; |
325 | |
326 | sprintf(buf,"%u ",rrp->i); |
327 | return (adns__vbuf_appendstr(vb,buf) && |
328 | csp_qstring(vb,rrp->str)) ? adns_s_ok : adns_s_nolocalmem; |
329 | } |
330 | |
331 | static adns_status cs_manyistr(vbuf *vb, const void *datap) { |
332 | const adns_rr_intstr *const *rrp= datap; |
333 | const adns_rr_intstr *current; |
334 | int spc; |
335 | |
336 | for (spc=0, current= *rrp; current->i >= 0; current++) { |
337 | if (spc) |
338 | if (!adns__vbuf_append(vb," ",1)) goto x_nomem; |
339 | if (!csp_textdata(vb,current->str,current->i)) goto x_nomem; |
340 | } |
341 | return adns_s_ok; |
1b644113 |
342 | |
e062dcae |
343 | x_nomem: |
344 | return adns_s_nolocalmem; |
345 | } |
346 | |
347 | static void mf_str(adns_query qu, void *datap) { |
348 | char **rrp= datap; |
349 | |
350 | adns__makefinal_str(qu,rrp); |
351 | } |
352 | |
353 | static void mf_intstr(adns_query qu, void *datap) { |
354 | adns_rr_intstr *rrp= datap; |
355 | |
356 | adns__makefinal_str(qu,&rrp->str); |
357 | } |
358 | |
359 | static void mf_manyistr(adns_query qu, void *datap) { |
360 | adns_rr_intstr **rrp= datap; |
361 | adns_rr_intstr *te, *table; |
362 | void *tablev; |
363 | int tc; |
364 | |
365 | for (tc=0, te= *rrp; te->i >= 0; te++, tc++); |
366 | tablev= *rrp; |
367 | adns__makefinal_block(qu,&tablev,sizeof(*te)*(tc+1)); |
368 | *rrp= table= tablev; |
369 | for (te= *rrp; te->i >= 0; te++) |
370 | adns__makefinal_str(qu,&te->str); |
ffbda80c |
371 | } |
372 | |
373 | static void mf_flat(adns_query qu, void *data) { } |
374 | |
375 | #define TYPE_SF(size,func,cp,free) size, pa_##func, mf_##free, cs_##cp |
376 | #define TYPE_SN(size,func,cp) size, pa_##func, mf_flat, cs_##cp |
e062dcae |
377 | #define TYPESZ_M(member) (sizeof(*((adns_answer*)0)->rrs.member)) |
86e7b8d9 |
378 | #define TYPE_MF(memb,parse) TYPE_SF(TYPESZ_M(memb),parse,memb,memb) |
379 | #define TYPE_MN(memb,parse) TYPE_SN(TYPESZ_M(memb),parse,memb) |
380 | |
ffbda80c |
381 | #define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb |
382 | #define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb |
98a3f706 |
383 | |
e7a9ca47 |
384 | /* TYPE_<ms><nf> |
385 | * ms is M specify member name |
386 | * or S specify size explicitly |
387 | * nf is F full memory management, dependent on member name or specified func |
388 | * N no memory management required |
389 | */ |
98a3f706 |
390 | |
391 | static const typeinfo typeinfos[] = { |
392 | /* Must be in ascending order of rrtype ! */ |
e062dcae |
393 | /* rr type code rrt fmt mem.mgmt member parser comparer */ |
98a3f706 |
394 | |
c7836bc9 |
395 | { adns_r_a, "A", 0, FLAT_MEMB(inaddr), pa_inaddr, di_inaddr }, |
396 | { adns_r_ns_raw, "NS", "raw", DEEP_MEMB(str), pa_host_raw, 0 }, |
397 | { adns_r_cname, "CNAME", 0, DEEP_MEMB(str), pa_host_raw, 0 }, |
398 | #if 0 /*fixme*/ |
399 | { adns_r_soa_raw, "SOA", "raw", DEEP_MEMB(soa), pa_soa, 0 }, |
400 | #endif |
401 | { adns_r_ptr_raw, "PTR", "raw", DEEP_MEMB(str), pa_host_raw, 0 }, |
402 | #if 0 /*fixme*/ |
403 | { adns_r_hinfo, "HINFO", 0, DEEP_MEMB(strpair), pa_hinfo, 0 }, |
404 | #endif |
405 | { adns_r_mx_raw, "MX", "raw", DEEP_MEMB(intstr), pa_mx_raw, di_mx_raw }, |
406 | { adns_r_txt, "TXT", 0, DEEP_MEMB(manyistr), pa_txt, 0 }, |
407 | #if 0 /*fixme*/ |
408 | { adns_r_rp_raw, "RP", "raw", DEEP_MEMB(strpair), pa_rp, 0 }, |
409 | #endif |
410 | |
411 | { adns_r_addr, "A", "addr", FLAT_MEMB(addr), pa_addr, di_addr }, |
412 | { adns_r_ns, "NS", "+addr", DEEP_MEMB(dmaddr), pa_hostaddr, di_hostaddr }, |
413 | #if 0 /*fixme*/ |
414 | { adns_r_ptr, "PTR","checked", DEEP_MEMB(str), pa_ptr, 0 }, |
415 | { adns_r_mx, "MX", "+addr", DEEP_MEMB(intdmaddr), pa_mx, di_mx }, |
86e7b8d9 |
416 | |
e062dcae |
417 | #endif |
418 | #if 0 /*fixme*/ |
88372443 |
419 | { adns_r_soa, "SOA","822", DEEP_MEMB(soa), pa_soa, 0 }, |
420 | { adns_r_rp, "RP", "822", DEEP_MEMB(strpair), pa_rp, 0 }, |
e7a9ca47 |
421 | #endif |
98a3f706 |
422 | }; |
423 | |
f759e52e |
424 | const typeinfo *adns__findtype(adns_rrtype type) { |
425 | const typeinfo *begin, *end, *mid; |
98a3f706 |
426 | |
427 | begin= typeinfos; end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo)); |
428 | |
429 | while (begin < end) { |
430 | mid= begin + ((end-begin)>>1); |
431 | if (mid->type == type) return mid; |
432 | if (type > mid->type) begin= mid+1; |
433 | else end= mid; |
434 | } |
435 | return 0; |
436 | } |