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, |
88372443 |
61 | int nsstart, int *arstart_io, void *datap) { |
828d89bd |
62 | adns_addr *storeto= datap; |
63 | |
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 | |
e062dcae |
152 | static int di_mx_raw(const void *datap_a, const void *datap_b) { |
153 | const adns_rr_intstr *ap= datap_a, *bp= datap_b; |
ffbda80c |
154 | |
e062dcae |
155 | if (ap->i < bp->i) return 0; |
156 | if (ap->i > bp->i) return 1; |
157 | return 0; |
ffbda80c |
158 | } |
159 | |
e062dcae |
160 | static adns_status pa_txt(adns_query qu, int serv, |
161 | const byte *dgram, int dglen, int startbyte, int max, |
88372443 |
162 | int nsstart, int *arstart_io, void *datap) { |
e062dcae |
163 | adns_rr_intstr **rrp= datap, *table, *te; |
164 | int ti, tc, cbyte, l; |
ffbda80c |
165 | |
e062dcae |
166 | cbyte= startbyte; |
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(qu,sizeof(*table)*(tc+1)); |
176 | if (!table) return adns_s_nolocalmem; |
177 | |
178 | for (cbyte=startbyte, ti=0, te=table; ti<tc; ti++, te++) { |
179 | GET_B(cbyte,l); |
180 | te->str= adns__alloc_interim(qu,l+1); |
181 | if (!te->str) return adns_s_nolocalmem; |
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; |
ffbda80c |
193 | } |
194 | |
e062dcae |
195 | static int csp_textdata(vbuf *vb, const char *dp, int len) { |
1b644113 |
196 | unsigned char ch; |
197 | char buf[10]; |
e062dcae |
198 | int cn; |
1b644113 |
199 | |
200 | if (!adns__vbuf_append(vb,"\"",1)) return 0; |
201 | |
e062dcae |
202 | for (cn=0; cn<len; cn++) { |
203 | ch= *dp++; |
1b644113 |
204 | if (ch >= 32 && ch <= 126 && ch != '"' && ch != '\\') { |
205 | if (!adns__vbuf_append(vb,&ch,1)) return 0; |
206 | } else { |
207 | sprintf(buf,"\\%02x",ch); |
208 | if (!adns__vbuf_appendstr(vb,buf)) return 0; |
209 | } |
210 | } |
ffbda80c |
211 | |
1b644113 |
212 | if (!adns__vbuf_append(vb,"\"",1)) return 0; |
213 | return 1; |
214 | } |
215 | |
e062dcae |
216 | static int csp_qstring(vbuf *vb, const char *dp) { |
217 | return csp_textdata(vb, dp, strlen(dp)); |
218 | } |
219 | |
220 | static adns_status cs_str(vbuf *vb, const void *datap) { |
221 | const char *const *rrp= datap; |
222 | |
223 | return csp_qstring(vb,*rrp) ? adns_s_ok : adns_s_nolocalmem; |
224 | } |
225 | |
226 | static adns_status cs_intstr(vbuf *vb, const void *datap) { |
227 | const adns_rr_intstr *rrp= datap; |
228 | char buf[10]; |
229 | |
230 | sprintf(buf,"%u ",rrp->i); |
231 | return (adns__vbuf_appendstr(vb,buf) && |
232 | csp_qstring(vb,rrp->str)) ? adns_s_ok : adns_s_nolocalmem; |
233 | } |
234 | |
235 | static adns_status cs_manyistr(vbuf *vb, const void *datap) { |
236 | const adns_rr_intstr *const *rrp= datap; |
237 | const adns_rr_intstr *current; |
238 | int spc; |
239 | |
240 | for (spc=0, current= *rrp; current->i >= 0; current++) { |
241 | if (spc) |
242 | if (!adns__vbuf_append(vb," ",1)) goto x_nomem; |
243 | if (!csp_textdata(vb,current->str,current->i)) goto x_nomem; |
244 | } |
245 | return adns_s_ok; |
1b644113 |
246 | |
e062dcae |
247 | x_nomem: |
248 | return adns_s_nolocalmem; |
249 | } |
250 | |
251 | static void mf_str(adns_query qu, void *datap) { |
252 | char **rrp= datap; |
253 | |
254 | adns__makefinal_str(qu,rrp); |
255 | } |
256 | |
257 | static void mf_intstr(adns_query qu, void *datap) { |
258 | adns_rr_intstr *rrp= datap; |
259 | |
260 | adns__makefinal_str(qu,&rrp->str); |
261 | } |
262 | |
263 | static void mf_manyistr(adns_query qu, void *datap) { |
264 | adns_rr_intstr **rrp= datap; |
265 | adns_rr_intstr *te, *table; |
266 | void *tablev; |
267 | int tc; |
268 | |
269 | for (tc=0, te= *rrp; te->i >= 0; te++, tc++); |
270 | tablev= *rrp; |
271 | adns__makefinal_block(qu,&tablev,sizeof(*te)*(tc+1)); |
272 | *rrp= table= tablev; |
273 | for (te= *rrp; te->i >= 0; te++) |
274 | adns__makefinal_str(qu,&te->str); |
ffbda80c |
275 | } |
276 | |
277 | static void mf_flat(adns_query qu, void *data) { } |
278 | |
279 | #define TYPE_SF(size,func,cp,free) size, pa_##func, mf_##free, cs_##cp |
280 | #define TYPE_SN(size,func,cp) size, pa_##func, mf_flat, cs_##cp |
e062dcae |
281 | #define TYPESZ_M(member) (sizeof(*((adns_answer*)0)->rrs.member)) |
86e7b8d9 |
282 | #define TYPE_MF(memb,parse) TYPE_SF(TYPESZ_M(memb),parse,memb,memb) |
283 | #define TYPE_MN(memb,parse) TYPE_SN(TYPESZ_M(memb),parse,memb) |
284 | |
ffbda80c |
285 | #define DEEP_MEMB(memb) TYPESZ_M(memb), mf_##memb, cs_##memb |
286 | #define FLAT_MEMB(memb) TYPESZ_M(memb), mf_flat, cs_##memb |
98a3f706 |
287 | |
e7a9ca47 |
288 | /* TYPE_<ms><nf> |
289 | * ms is M specify member name |
290 | * or S specify size explicitly |
291 | * nf is F full memory management, dependent on member name or specified func |
292 | * N no memory management required |
293 | */ |
98a3f706 |
294 | |
295 | static const typeinfo typeinfos[] = { |
296 | /* Must be in ascending order of rrtype ! */ |
e062dcae |
297 | /* rr type code rrt fmt mem.mgmt member parser comparer */ |
98a3f706 |
298 | |
e062dcae |
299 | { adns_r_a, "A", 0, FLAT_MEMB(inaddr), pa_inaddr, di_inaddr }, |
828d89bd |
300 | { adns_r_ns_raw, "NS", "raw", DEEP_MEMB(str), pa_host_raw, 0 }, |
301 | { adns_r_cname, "CNAME", 0, DEEP_MEMB(str), pa_host_raw, 0 }, |
ffbda80c |
302 | #if 0 /*fixme*/ |
e062dcae |
303 | { adns_r_soa_raw, "SOA", "raw", DEEP_MEMB(soa), pa_soa, 0 }, |
ffbda80c |
304 | #endif |
828d89bd |
305 | { adns_r_ptr_raw, "PTR", "raw", DEEP_MEMB(str), pa_host_raw, 0 }, |
e062dcae |
306 | #if 0 /*fixme*/ |
307 | { adns_r_hinfo, "HINFO", 0, DEEP_MEMB(strpair), pa_hinfo, 0 }, |
308 | #endif |
309 | { adns_r_mx_raw, "MX", "raw", DEEP_MEMB(intstr), pa_mx_raw, di_mx_raw }, |
310 | { adns_r_txt, "TXT", 0, DEEP_MEMB(manyistr), pa_txt, 0 }, |
311 | #if 0 /*fixme*/ |
312 | { adns_r_rp_raw, "RP", "raw", DEEP_MEMB(strpair), pa_rp, 0 }, |
313 | #endif |
86e7b8d9 |
314 | |
828d89bd |
315 | { adns_r_addr, "A", "addr", FLAT_MEMB(addr), pa_addr, di_addr }, |
316 | #if 0 /*fixme*/ |
e062dcae |
317 | { adns_r_ns, "NS", "+addr", DEEP_MEMB(dmaddr), pa_dmaddr, di_dmaddr }, |
318 | { adns_r_ptr, "PTR","checked", DEEP_MEMB(str), pa_ptr, 0 }, |
319 | { adns_r_mx, "MX", "+addr", DEEP_MEMB(intdmaddr), pa_mx, di_mx }, |
86e7b8d9 |
320 | |
e062dcae |
321 | #endif |
322 | #if 0 /*fixme*/ |
88372443 |
323 | { adns_r_soa, "SOA","822", DEEP_MEMB(soa), pa_soa, 0 }, |
324 | { adns_r_rp, "RP", "822", DEEP_MEMB(strpair), pa_rp, 0 }, |
e7a9ca47 |
325 | #endif |
98a3f706 |
326 | }; |
327 | |
f759e52e |
328 | const typeinfo *adns__findtype(adns_rrtype type) { |
329 | const typeinfo *begin, *end, *mid; |
98a3f706 |
330 | |
331 | begin= typeinfos; end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo)); |
332 | |
333 | while (begin < end) { |
334 | mid= begin + ((end-begin)>>1); |
335 | if (mid->type == type) return mid; |
336 | if (type > mid->type) begin= mid+1; |
337 | else end= mid; |
338 | } |
339 | return 0; |
340 | } |