1 /* $NetBSD: rdata_test.c,v 1.8 2014/12/10 04:37:53 christos Exp $ */
2
3 /*
4 * Copyright (C) 2004-2007, 2011, 2012, 2014 Internet Systems Consortium, Inc. ("ISC")
5 * Copyright (C) 1998-2003 Internet Software Consortium.
6 *
7 * Permission to use, copy, modify, and/or distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
12 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
13 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
14 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
15 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
16 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17 * PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 #include <config.h>
21
22 #include <stdlib.h>
23
24 #include <isc/buffer.h>
25 #include <isc/commandline.h>
26 #include <isc/lex.h>
27 #include <isc/mem.h>
28 #include <isc/string.h>
29 #include <isc/util.h>
30
31 #include <dns/rdata.h>
32 #include <dns/compress.h>
33 #include <dns/rdataclass.h>
34 #include <dns/rdatastruct.h>
35 #include <dns/rdatatype.h>
36 #include <dns/result.h>
37
38 isc_mem_t *mctx;
39 isc_lex_t *lex;
40
41 isc_lexspecials_t specials;
42
43 static void
viastruct(dns_rdata_t * rdata,isc_mem_t * mctx,dns_rdata_t * rdata2,isc_buffer_t * b)44 viastruct(dns_rdata_t *rdata, isc_mem_t *mctx,
45 dns_rdata_t *rdata2, isc_buffer_t *b)
46 {
47 isc_result_t result;
48 void *sp = NULL;
49 isc_boolean_t need_free = ISC_FALSE;
50 dns_rdatatype_t rdt;
51 dns_rdataclass_t rdc;
52
53 UNUSED(rdata2); /* XXXMPA remove when fromstruct is ready. */
54 UNUSED(b);
55
56 switch (rdata->type) {
57 case dns_rdatatype_a6: {
58 static dns_rdata_in_a6_t in_a6;
59 result = dns_rdata_tostruct(rdata, sp = &in_a6, NULL);
60 break;
61 }
62 case dns_rdatatype_a: {
63 switch (rdata->rdclass) {
64 case dns_rdataclass_hs: {
65 static dns_rdata_hs_a_t hs_a;
66 result = dns_rdata_tostruct(rdata, sp = &hs_a, NULL);
67 break;
68 }
69 case dns_rdataclass_in: {
70 static dns_rdata_in_a_t in_a;
71 result = dns_rdata_tostruct(rdata, sp = &in_a, NULL);
72 break;
73 }
74 default:
75 result = ISC_R_NOTIMPLEMENTED;
76 break;
77 }
78 break;
79 }
80 case dns_rdatatype_aaaa: {
81 static dns_rdata_in_aaaa_t in_aaaa;
82 result = dns_rdata_tostruct(rdata, sp = &in_aaaa, NULL);
83 break;
84 }
85 case dns_rdatatype_afsdb: {
86 static dns_rdata_afsdb_t afsdb;
87 result = dns_rdata_tostruct(rdata, sp = &afsdb, NULL);
88 break;
89 }
90 case dns_rdatatype_any: {
91 result = ISC_R_NOTIMPLEMENTED;
92 break;
93 }
94 case dns_rdatatype_apl: {
95 switch (rdata->rdclass) {
96 case dns_rdataclass_in: {
97 static dns_rdata_in_apl_t in_apl;
98 result = dns_rdata_tostruct(rdata, sp = &in_apl, NULL);
99 break;
100 }
101 default:
102 result = ISC_R_NOTIMPLEMENTED;
103 break;
104 }
105 break;
106 }
107 case dns_rdatatype_cert: {
108 static dns_rdata_cert_t cert;
109 result = dns_rdata_tostruct(rdata, sp = &cert, NULL);
110 break;
111 }
112 case dns_rdatatype_cname: {
113 static dns_rdata_cname_t cname;
114 result = dns_rdata_tostruct(rdata, sp = &cname, NULL);
115 break;
116 }
117 case dns_rdatatype_dname: {
118 static dns_rdata_dname_t dname;
119 result = dns_rdata_tostruct(rdata, sp = &dname, NULL);
120 break;
121 }
122 case dns_rdatatype_gpos: {
123 static dns_rdata_gpos_t gpos;
124 result = dns_rdata_tostruct(rdata, sp = &gpos, NULL);
125 break;
126 }
127 case dns_rdatatype_hinfo: {
128 static dns_rdata_hinfo_t hinfo;
129 result = dns_rdata_tostruct(rdata, sp = &hinfo, NULL);
130 break;
131 }
132 case dns_rdatatype_isdn: {
133 static dns_rdata_isdn_t isdn;
134 result = dns_rdata_tostruct(rdata, sp = &isdn, NULL);
135 break;
136 }
137 case dns_rdatatype_key: {
138 static dns_rdata_key_t key;
139 result = dns_rdata_tostruct(rdata, sp = &key, NULL);
140 break;
141 }
142 case dns_rdatatype_kx: {
143 static dns_rdata_in_kx_t in_kx;
144 result = dns_rdata_tostruct(rdata, sp = &in_kx, NULL);
145 break;
146 }
147 case dns_rdatatype_loc: {
148 static dns_rdata_loc_t loc;
149 result = dns_rdata_tostruct(rdata, sp = &loc, NULL);
150 break;
151 }
152 case dns_rdatatype_mb: {
153 static dns_rdata_mb_t mb;
154 result = dns_rdata_tostruct(rdata, sp = &mb, NULL);
155 break;
156 }
157 case dns_rdatatype_md: {
158 static dns_rdata_md_t md;
159 result = dns_rdata_tostruct(rdata, sp = &md, NULL);
160 break;
161 }
162 case dns_rdatatype_mf: {
163 static dns_rdata_mf_t mf;
164 result = dns_rdata_tostruct(rdata, sp = &mf, NULL);
165 break;
166 }
167 case dns_rdatatype_mg: {
168 static dns_rdata_mg_t mg;
169 result = dns_rdata_tostruct(rdata, sp = &mg, NULL);
170 break;
171 }
172 case dns_rdatatype_minfo: {
173 static dns_rdata_minfo_t minfo;
174 result = dns_rdata_tostruct(rdata, sp = &minfo, NULL);
175 break;
176 }
177 case dns_rdatatype_mr: {
178 static dns_rdata_mr_t mr;
179 result = dns_rdata_tostruct(rdata, sp = &mr, NULL);
180 break;
181 }
182 case dns_rdatatype_mx: {
183 static dns_rdata_mx_t mx;
184 result = dns_rdata_tostruct(rdata, sp = &mx, NULL);
185 break;
186 }
187 case dns_rdatatype_naptr: {
188 static dns_rdata_naptr_t naptr;
189 result = dns_rdata_tostruct(rdata, sp = &naptr, NULL);
190 break;
191 }
192 case dns_rdatatype_ns: {
193 static dns_rdata_ns_t ns;
194 result = dns_rdata_tostruct(rdata, sp = &ns, NULL);
195 break;
196 }
197 case dns_rdatatype_nsap: {
198 static dns_rdata_in_nsap_t in_nsap;
199 result = dns_rdata_tostruct(rdata, sp = &in_nsap, NULL);
200 break;
201 }
202 case dns_rdatatype_nsap_ptr: {
203 static dns_rdata_in_nsap_ptr_t in_nsap_ptr;
204 result = dns_rdata_tostruct(rdata, sp = &in_nsap_ptr, NULL);
205 break;
206 }
207 case dns_rdatatype_null: {
208 static dns_rdata_null_t null;
209 result = dns_rdata_tostruct(rdata, sp = &null, NULL);
210 break;
211 }
212 case dns_rdatatype_nxt: {
213 static dns_rdata_nxt_t nxt;
214 result = dns_rdata_tostruct(rdata, sp = &nxt, NULL);
215 break;
216 }
217 case dns_rdatatype_opt: {
218 static dns_rdata_opt_t opt;
219 result = dns_rdata_tostruct(rdata, sp = &opt, NULL);
220 break;
221 }
222 case dns_rdatatype_ptr: {
223 static dns_rdata_ptr_t ptr;
224 result = dns_rdata_tostruct(rdata, sp = &ptr, NULL);
225 break;
226 }
227 case dns_rdatatype_px: {
228 static dns_rdata_in_px_t in_px;
229 result = dns_rdata_tostruct(rdata, sp = &in_px, NULL);
230 break;
231 }
232 case dns_rdatatype_rp: {
233 static dns_rdata_rp_t rp;
234 result = dns_rdata_tostruct(rdata, sp = &rp, NULL);
235 break;
236 }
237 case dns_rdatatype_rt: {
238 static dns_rdata_rt_t rt;
239 result = dns_rdata_tostruct(rdata, sp = &rt, NULL);
240 break;
241 }
242 case dns_rdatatype_sig: {
243 static dns_rdata_sig_t sig;
244 result = dns_rdata_tostruct(rdata, sp = &sig, NULL);
245 break;
246 }
247 case dns_rdatatype_soa: {
248 static dns_rdata_soa_t soa;
249 result = dns_rdata_tostruct(rdata, sp = &soa, NULL);
250 break;
251 }
252 case dns_rdatatype_srv: {
253 static dns_rdata_in_srv_t in_srv;
254 result = dns_rdata_tostruct(rdata, sp = &in_srv, NULL);
255 break;
256 }
257 case dns_rdatatype_tkey: {
258 static dns_rdata_tkey_t tkey;
259 result = dns_rdata_tostruct(rdata, sp = &tkey, NULL);
260 break;
261 }
262 case dns_rdatatype_tsig: {
263 static dns_rdata_any_tsig_t tsig;
264 result = dns_rdata_tostruct(rdata, sp = &tsig, NULL);
265 break;
266 }
267 case dns_rdatatype_txt: {
268 static dns_rdata_txt_t txt;
269 result = dns_rdata_tostruct(rdata, sp = &txt, NULL);
270 break;
271 }
272 case dns_rdatatype_spf: {
273 static dns_rdata_spf_t spf;
274 result = dns_rdata_tostruct(rdata, sp = &spf, NULL);
275 break;
276 }
277 case dns_rdatatype_unspec: {
278 static dns_rdata_unspec_t unspec;
279 result = dns_rdata_tostruct(rdata, sp = &unspec, NULL);
280 break;
281 }
282 case dns_rdatatype_uri: {
283 static dns_rdata_uri_t uri;
284 result = dns_rdata_tostruct(rdata, sp = &uri, NULL);
285 break;
286 }
287 case dns_rdatatype_caa: {
288 static dns_rdata_caa_t caa;
289 result = dns_rdata_tostruct(rdata, sp = &caa, NULL);
290 break;
291 }
292 case dns_rdatatype_wks: {
293 static dns_rdata_in_wks_t in_wks;
294 result = dns_rdata_tostruct(rdata, sp = &in_wks, NULL);
295 break;
296 }
297 case dns_rdatatype_x25: {
298 static dns_rdata_x25_t x25;
299 result = dns_rdata_tostruct(rdata, sp = &x25, NULL);
300 break;
301 }
302 case dns_rdatatype_nsec: {
303 static dns_rdata_nsec_t nsec;
304 result = dns_rdata_tostruct(rdata, sp = &nsec, NULL);
305 break;
306 }
307 case dns_rdatatype_rrsig: {
308 static dns_rdata_rrsig_t rrsig;
309 result = dns_rdata_tostruct(rdata, sp = &rrsig, NULL);
310 break;
311 }
312 case dns_rdatatype_dnskey: {
313 static dns_rdata_dnskey_t dnskey;
314 result = dns_rdata_tostruct(rdata, sp = &dnskey, NULL);
315 break;
316 }
317 default:
318 result = ISC_R_NOTIMPLEMENTED;
319 break;
320 }
321 if (result != ISC_R_SUCCESS)
322 fprintf(stdout, "viastruct: tostruct %d %d return %s\n",
323 rdata->type, rdata->rdclass,
324 dns_result_totext(result));
325 else
326 dns_rdata_freestruct(sp);
327
328 switch (rdata->type) {
329 case dns_rdatatype_a6: {
330 static dns_rdata_in_a6_t in_a6;
331 result = dns_rdata_tostruct(rdata, sp = &in_a6, mctx);
332 break;
333 }
334 case dns_rdatatype_a: {
335 switch (rdata->rdclass) {
336 case dns_rdataclass_hs: {
337 static dns_rdata_hs_a_t hs_a;
338 result = dns_rdata_tostruct(rdata, sp = &hs_a, mctx);
339 break;
340 }
341 case dns_rdataclass_in: {
342 static dns_rdata_in_a_t in_a;
343 result = dns_rdata_tostruct(rdata, sp = &in_a, mctx);
344 break;
345 }
346 default:
347 result = ISC_R_NOTIMPLEMENTED;
348 break;
349 }
350 break;
351 }
352 case dns_rdatatype_aaaa: {
353 static dns_rdata_in_aaaa_t in_aaaa;
354 result = dns_rdata_tostruct(rdata, sp = &in_aaaa, mctx);
355 break;
356 }
357 case dns_rdatatype_afsdb: {
358 static dns_rdata_afsdb_t afsdb;
359 result = dns_rdata_tostruct(rdata, sp = &afsdb, mctx);
360 break;
361 }
362 case dns_rdatatype_any: {
363 result = ISC_R_NOTIMPLEMENTED;
364 break;
365 }
366 case dns_rdatatype_apl: {
367 switch (rdata->rdclass) {
368 case dns_rdataclass_in: {
369 static dns_rdata_in_apl_t in_apl;
370 result = dns_rdata_tostruct(rdata, sp = &in_apl, mctx);
371 break;
372 }
373 default:
374 result = ISC_R_NOTIMPLEMENTED;
375 break;
376 }
377 break;
378 }
379 case dns_rdatatype_cert: {
380 static dns_rdata_cert_t cert;
381 result = dns_rdata_tostruct(rdata, sp = &cert, mctx);
382 break;
383 }
384 case dns_rdatatype_cname: {
385 static dns_rdata_cname_t cname;
386 result = dns_rdata_tostruct(rdata, sp = &cname, mctx);
387 break;
388 }
389 case dns_rdatatype_dname: {
390 static dns_rdata_dname_t dname;
391 result = dns_rdata_tostruct(rdata, sp = &dname, mctx);
392 break;
393 }
394 case dns_rdatatype_gpos: {
395 static dns_rdata_gpos_t gpos;
396 result = dns_rdata_tostruct(rdata, sp = &gpos, mctx);
397 break;
398 }
399 case dns_rdatatype_hinfo: {
400 static dns_rdata_hinfo_t hinfo;
401 result = dns_rdata_tostruct(rdata, sp = &hinfo, mctx);
402 break;
403 }
404 case dns_rdatatype_isdn: {
405 static dns_rdata_isdn_t isdn;
406 result = dns_rdata_tostruct(rdata, sp = &isdn, mctx);
407 break;
408 }
409 case dns_rdatatype_key: {
410 static dns_rdata_key_t key;
411 result = dns_rdata_tostruct(rdata, sp = &key, mctx);
412 break;
413 }
414 case dns_rdatatype_kx: {
415 static dns_rdata_in_kx_t in_kx;
416 result = dns_rdata_tostruct(rdata, sp = &in_kx, mctx);
417 break;
418 }
419 case dns_rdatatype_loc: {
420 static dns_rdata_loc_t loc;
421 result = dns_rdata_tostruct(rdata, sp = &loc, mctx);
422 break;
423 }
424 case dns_rdatatype_mb: {
425 static dns_rdata_mb_t mb;
426 result = dns_rdata_tostruct(rdata, sp = &mb, mctx);
427 break;
428 }
429 case dns_rdatatype_md: {
430 static dns_rdata_md_t md;
431 result = dns_rdata_tostruct(rdata, sp = &md, mctx);
432 break;
433 }
434 case dns_rdatatype_mf: {
435 static dns_rdata_mf_t mf;
436 result = dns_rdata_tostruct(rdata, sp = &mf, mctx);
437 break;
438 }
439 case dns_rdatatype_mg: {
440 static dns_rdata_mg_t mg;
441 result = dns_rdata_tostruct(rdata, sp = &mg, mctx);
442 break;
443 }
444 case dns_rdatatype_minfo: {
445 static dns_rdata_minfo_t minfo;
446 result = dns_rdata_tostruct(rdata, sp = &minfo, mctx);
447 break;
448 }
449 case dns_rdatatype_mr: {
450 static dns_rdata_mr_t mr;
451 result = dns_rdata_tostruct(rdata, sp = &mr, mctx);
452 break;
453 }
454 case dns_rdatatype_mx: {
455 static dns_rdata_mx_t mx;
456 result = dns_rdata_tostruct(rdata, sp = &mx, mctx);
457 break;
458 }
459 case dns_rdatatype_naptr: {
460 static dns_rdata_naptr_t naptr;
461 result = dns_rdata_tostruct(rdata, sp = &naptr, mctx);
462 break;
463 }
464 case dns_rdatatype_ns: {
465 static dns_rdata_ns_t ns;
466 result = dns_rdata_tostruct(rdata, sp = &ns, mctx);
467 break;
468 }
469 case dns_rdatatype_nsap: {
470 static dns_rdata_in_nsap_t in_nsap;
471 result = dns_rdata_tostruct(rdata, sp = &in_nsap, mctx);
472 break;
473 }
474 case dns_rdatatype_nsap_ptr: {
475 static dns_rdata_in_nsap_ptr_t in_nsap_ptr;
476 result = dns_rdata_tostruct(rdata, sp = &in_nsap_ptr, mctx);
477 break;
478 }
479 case dns_rdatatype_null: {
480 static dns_rdata_null_t null;
481 result = dns_rdata_tostruct(rdata, sp = &null, mctx);
482 break;
483 }
484 case dns_rdatatype_nxt: {
485 static dns_rdata_nxt_t nxt;
486 result = dns_rdata_tostruct(rdata, sp = &nxt, mctx);
487 break;
488 }
489 case dns_rdatatype_opt: {
490 static dns_rdata_opt_t opt;
491 result = dns_rdata_tostruct(rdata, sp = &opt, mctx);
492 break;
493 }
494 case dns_rdatatype_ptr: {
495 static dns_rdata_ptr_t ptr;
496 result = dns_rdata_tostruct(rdata, sp = &ptr, mctx);
497 break;
498 }
499 case dns_rdatatype_px: {
500 static dns_rdata_in_px_t in_px;
501 result = dns_rdata_tostruct(rdata, sp = &in_px, mctx);
502 break;
503 }
504 case dns_rdatatype_rp: {
505 static dns_rdata_rp_t rp;
506 result = dns_rdata_tostruct(rdata, sp = &rp, mctx);
507 break;
508 }
509 case dns_rdatatype_rt: {
510 static dns_rdata_rt_t rt;
511 result = dns_rdata_tostruct(rdata, sp = &rt, mctx);
512 break;
513 }
514 case dns_rdatatype_sig: {
515 static dns_rdata_sig_t sig;
516 result = dns_rdata_tostruct(rdata, sp = &sig, mctx);
517 break;
518 }
519 case dns_rdatatype_soa: {
520 static dns_rdata_soa_t soa;
521 result = dns_rdata_tostruct(rdata, sp = &soa, mctx);
522 break;
523 }
524 case dns_rdatatype_srv: {
525 static dns_rdata_in_srv_t in_srv;
526 result = dns_rdata_tostruct(rdata, sp = &in_srv, mctx);
527 break;
528 }
529 case dns_rdatatype_tkey: {
530 static dns_rdata_tkey_t tkey;
531 result = dns_rdata_tostruct(rdata, sp = &tkey, mctx);
532 break;
533 }
534 case dns_rdatatype_tsig: {
535 static dns_rdata_any_tsig_t tsig;
536 result = dns_rdata_tostruct(rdata, sp = &tsig, mctx);
537 break;
538 }
539 case dns_rdatatype_txt: {
540 static dns_rdata_txt_t txt;
541 result = dns_rdata_tostruct(rdata, sp = &txt, mctx);
542 break;
543 }
544 case dns_rdatatype_spf: {
545 static dns_rdata_spf_t spf;
546 result = dns_rdata_tostruct(rdata, sp = &spf, mctx);
547 break;
548 }
549 case dns_rdatatype_unspec: {
550 static dns_rdata_unspec_t unspec;
551 result = dns_rdata_tostruct(rdata, sp = &unspec, mctx);
552 break;
553 }
554 case dns_rdatatype_uri: {
555 static dns_rdata_uri_t uri;
556 result = dns_rdata_tostruct(rdata, sp = &uri, mctx);
557 break;
558 }
559 case dns_rdatatype_caa: {
560 static dns_rdata_caa_t caa;
561 result = dns_rdata_tostruct(rdata, sp = &caa, mctx);
562 break;
563 }
564 case dns_rdatatype_wks: {
565 static dns_rdata_in_wks_t in_wks;
566 result = dns_rdata_tostruct(rdata, sp = &in_wks, mctx);
567 break;
568 }
569 case dns_rdatatype_x25: {
570 static dns_rdata_x25_t x25;
571 result = dns_rdata_tostruct(rdata, sp = &x25, mctx);
572 break;
573 }
574 case dns_rdatatype_nsec: {
575 static dns_rdata_nsec_t nsec;
576 result = dns_rdata_tostruct(rdata, sp = &nsec, mctx);
577 break;
578 }
579 case dns_rdatatype_rrsig: {
580 static dns_rdata_rrsig_t rrsig;
581 result = dns_rdata_tostruct(rdata, sp = &rrsig, mctx);
582 break;
583 }
584 case dns_rdatatype_dnskey: {
585 static dns_rdata_dnskey_t dnskey;
586 result = dns_rdata_tostruct(rdata, sp = &dnskey, mctx);
587 break;
588 }
589 default:
590 result = ISC_R_NOTIMPLEMENTED;
591 break;
592 }
593 if (result != ISC_R_SUCCESS)
594 fprintf(stdout, "viastruct: tostruct %d %d return %s\n",
595 rdata->type, rdata->rdclass,
596 dns_result_totext(result));
597 else {
598 need_free = ISC_TRUE;
599
600 rdc = rdata->rdclass;
601 rdt = rdata->type;
602 result = dns_rdata_fromstruct(rdata2, rdc, rdt, sp, b);
603 if (result != ISC_R_SUCCESS)
604 fprintf(stdout,
605 "viastruct: fromstruct %d %d return %s\n",
606 rdata->type, rdata->rdclass,
607 dns_result_totext(result));
608 else if (rdata->length != rdata2->length ||
609 memcmp(rdata->data, rdata2->data, rdata->length) != 0)
610 {
611 isc_uint32_t i;
612 isc_uint32_t l;
613
614 fprintf(stdout, "viastruct: memcmp failed\n");
615
616 fprintf(stdout, "%d %d\n",
617 rdata->length, rdata2->length);
618 l = rdata->length;
619 if (rdata2->length < l)
620 l = rdata2->length;
621 for (i = 0; i < l; i++)
622 fprintf(stdout, "%02x %02x\n",
623 rdata->data[i], rdata2->data[i]);
624 }
625 }
626 #if 0
627 switch (rdata->type) {
628 case dns_rdatatype_a6: {
629 dns_rdata_in_a6_t in_a6;
630 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &in_a6, b);
631 break;
632 }
633 case dns_rdatatype_a: {
634 switch (rdata->rdclass) {
635 case dns_rdataclass_hs: {
636 dns_rdata_hs_a_t hs_a;
637 result = dns_rdata_fromstruct(rdata2, rdc, rdt,
638 &hs_a, b);
639 break;
640 }
641 case dns_rdataclass_in: {
642 dns_rdata_in_a_t in_a;
643 result = dns_rdata_fromstruct(rdata2, rdc, rdt,
644 &in_a, b);
645 break;
646 }
647 default:
648 result = ISC_R_NOTIMPLEMENTED;
649 break;
650 }
651 break;
652 }
653 case dns_rdatatype_aaaa: {
654 dns_rdata_in_aaaa_t in_aaaa;
655 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &in_aaaa, b);
656 break;
657 }
658 case dns_rdatatype_afsdb: {
659 dns_rdata_afsdb_t afsdb;
660 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &afsdb, b);
661 break;
662 }
663 case dns_rdatatype_any: {
664 result = ISC_R_NOTIMPLEMENTED;
665 break;
666 }
667 case dns_rdatatype_apl: {
668 switch (rdata->rdclass) {
669 case dns_rdataclass_in: {
670 dns_rdata_in_apl_t in_apl;
671 result = dns_rdata_fromstruct(rdata, rdc, rdt, &in_apl, b);
672 break;
673 }
674 default:
675 result = ISC_R_NOTIMPLEMENTED;
676 break;
677 }
678 break;
679 }
680 case dns_rdatatype_cert: {
681 dns_rdata_cert_t cert;
682 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &cert, b);
683 break;
684 }
685 case dns_rdatatype_cname: {
686 dns_rdata_cname_t cname;
687 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &cname, b);
688 break;
689 }
690 case dns_rdatatype_dname: {
691 dns_rdata_dname_t dname;
692 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &dname, b);
693 break;
694 }
695 case dns_rdatatype_gpos: {
696 dns_rdata_gpos_t gpos;
697 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &gpos, b);
698 break;
699 }
700 case dns_rdatatype_hinfo: {
701 dns_rdata_hinfo_t hinfo;
702 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &hinfo, b);
703 break;
704 }
705 case dns_rdatatype_isdn: {
706 dns_rdata_isdn_t isdn;
707 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &isdn, b);
708 break;
709 }
710 case dns_rdatatype_key: {
711 dns_rdata_key_t key;
712 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &key, b);
713 break;
714 }
715 case dns_rdatatype_kx: {
716 dns_rdata_in_kx_t in_kx;
717 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &in_kx, b);
718 break;
719 }
720 case dns_rdatatype_loc: {
721 dns_rdata_loc_t loc;
722 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &loc, b);
723 break;
724 }
725 case dns_rdatatype_mb: {
726 dns_rdata_mb_t mb;
727 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &mb, b);
728 break;
729 }
730 case dns_rdatatype_md: {
731 dns_rdata_md_t md;
732 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &md, b);
733 break;
734 }
735 case dns_rdatatype_mf: {
736 dns_rdata_mf_t mf;
737 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &mf, b);
738 break;
739 }
740 case dns_rdatatype_mg: {
741 dns_rdata_mg_t mg;
742 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &mg, b);
743 break;
744 }
745 case dns_rdatatype_minfo: {
746 dns_rdata_minfo_t minfo;
747 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &minfo, b);
748 break;
749 }
750 case dns_rdatatype_mr: {
751 dns_rdata_mr_t mr;
752 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &mr, b);
753 break;
754 }
755 case dns_rdatatype_mx: {
756 dns_rdata_mx_t mx;
757 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &mx, b);
758 break;
759 }
760 case dns_rdatatype_naptr: {
761 dns_rdata_naptr_t naptr;
762 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &naptr, b);
763 break;
764 }
765 case dns_rdatatype_ns: {
766 dns_rdata_ns_t ns;
767 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &ns, b);
768 break;
769 }
770 case dns_rdatatype_nsap: {
771 dns_rdata_in_nsap_t in_nsap;
772 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &in_nsap, b);
773 break;
774 }
775 case dns_rdatatype_nsap_ptr: {
776 dns_rdata_in_nsap_ptr_t in_nsap_ptr;
777 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &in_nsap_ptr,
778 b);
779 break;
780 }
781 case dns_rdatatype_null: {
782 dns_rdata_null_t null;
783 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &null, b);
784 break;
785 }
786 case dns_rdatatype_nxt: {
787 dns_rdata_nxt_t nxt;
788 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &nxt, b);
789 break;
790 }
791 case dns_rdatatype_opt: {
792 dns_rdata_opt_t opt;
793 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &opt, b);
794 break;
795 }
796 case dns_rdatatype_ptr: {
797 dns_rdata_ptr_t ptr;
798 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &ptr, b);
799 break;
800 }
801 case dns_rdatatype_px: {
802 dns_rdata_in_px_t in_px;
803 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &in_px, b);
804 break;
805 }
806 case dns_rdatatype_rp: {
807 dns_rdata_rp_t rp;
808 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &rp, b);
809 break;
810 }
811 case dns_rdatatype_rt: {
812 dns_rdata_rt_t rt;
813 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &rt, b);
814 break;
815 }
816 case dns_rdatatype_sig: {
817 dns_rdata_sig_t sig;
818 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &sig, b);
819 break;
820 }
821 case dns_rdatatype_soa: {
822 dns_rdata_soa_t soa;
823 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &soa, b);
824 break;
825 }
826 case dns_rdatatype_srv: {
827 dns_rdata_in_srv_t in_srv;
828 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &in_srv, b);
829 break;
830 }
831 case dns_rdatatype_tkey: {
832 dns_rdata_tkey_t tkey;
833 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &tkey, b);
834 break;
835 }
836 case dns_rdatatype_tsig: {
837 dns_rdata_any_tsig_t tsig;
838 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &tsig, b);
839 break;
840 }
841 case dns_rdatatype_txt: {
842 dns_rdata_txt_t txt;
843 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &txt, b);
844 break;
845 }
846 case dns_rdatatype_spf: {
847 dns_rdata_spf_t spf;
848 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &spf, b);
849 break;
850 }
851 case dns_rdatatype_unspec: {
852 dns_rdata_unspec_t unspec;
853 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &unspec, b);
854 break;
855 }
856 case dns_rdatatype_uri: {
857 dns_rdata_uri_t uri;
858 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &uri, b);
859 break;
860 }
861 case dns_rdatatype_caa: {
862 dns_rdata_caa_t caa;
863 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &caa, b);
864 break;
865 }
866 case dns_rdatatype_wks: {
867 dns_rdata_in_wks_t in_wks;
868 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &in_wks, b);
869 break;
870 }
871 case dns_rdatatype_x25: {
872 dns_rdata_x25_t x25;
873 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &x25, b);
874 break;
875 }
876 case dns_rdatatype_nsec: {
877 dns_rdata_nsec_t nsec;
878 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &nsec, b);
879 break;
880 }
881 case dns_rdatatype_rrsig: {
882 dns_rdata_rrsig_t rrsig;
883 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &rrsig, b);
884 break;
885 }
886 case dns_rdatatype_dnskey: {
887 dns_rdata_dnskey_t dnskey;
888 result = dns_rdata_fromstruct(rdata2, rdc, rdt, &dnskey, b);
889 break;
890 }
891 default:
892 result = ISC_R_NOTIMPLEMENTED;
893 break;
894 }
895 #endif
896 if (need_free)
897 dns_rdata_freestruct(sp);
898 }
899
900 int
main(int argc,char * argv[])901 main(int argc, char *argv[]) {
902 isc_token_t token;
903 isc_result_t result;
904 int quiet = 0;
905 int c;
906 int stats = 0;
907 unsigned int options = 0;
908 dns_rdatatype_t type;
909 dns_rdataclass_t class;
910 dns_rdatatype_t lasttype = 0;
911 char outbuf[16*1024];
912 char inbuf[16*1024];
913 char wirebuf[16*1024];
914 char viabuf[16*1024];
915 isc_buffer_t dbuf;
916 isc_buffer_t tbuf;
917 isc_buffer_t wbuf;
918 dns_rdata_t rdata = DNS_RDATA_INIT;
919 dns_rdata_t last = DNS_RDATA_INIT;
920 int need_eol = 0;
921 int wire = 0;
922 dns_compress_t cctx;
923 dns_decompress_t dctx;
924 int trunc = 0;
925 int add = 0;
926 int len;
927 int zero = 0;
928 int debug = 0;
929 isc_region_t region;
930 int first = 1;
931 int raw = 0;
932 int tostruct = 0;
933
934 while ((c = isc_commandline_parse(argc, argv, "dqswtarzS")) != -1) {
935 switch (c) {
936 case 'd':
937 debug = 1;
938 quiet = 0;
939 break;
940 case 'q':
941 quiet = 1;
942 debug = 0;
943 break;
944 case 's':
945 stats = 1;
946 break;
947 case 'w':
948 wire = 1;
949 break;
950 case 't':
951 trunc = 1;
952 break;
953 case 'a':
954 add = 1;
955 break;
956 case 'z':
957 zero = 1;
958 break;
959 case 'r':
960 raw++;
961 break;
962 case 'S':
963 tostruct++;
964 break;
965 }
966 }
967
968 memset(&dctx, 0, sizeof(dctx));
969 dctx.allowed = DNS_COMPRESS_ALL;
970
971 RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
972 RUNTIME_CHECK(isc_lex_create(mctx, 256, &lex) == ISC_R_SUCCESS);
973
974 /*
975 * Set up to lex DNS master file.
976 */
977
978 specials['('] = 1;
979 specials[')'] = 1;
980 specials['"'] = 1;
981 isc_lex_setspecials(lex, specials);
982 options = ISC_LEXOPT_EOL;
983 isc_lex_setcomments(lex, ISC_LEXCOMMENT_DNSMASTERFILE);
984
985 RUNTIME_CHECK(isc_lex_openstream(lex, stdin) == ISC_R_SUCCESS);
986
987 dns_rdata_init(&last);
988 while ((result = isc_lex_gettoken(lex, options | ISC_LEXOPT_NUMBER,
989 &token)) == ISC_R_SUCCESS) {
990 if (debug) fprintf(stdout, "token.type = %d\n", token.type);
991 if (need_eol) {
992 if (token.type == isc_tokentype_eol)
993 need_eol = 0;
994 continue;
995 }
996 if (token.type == isc_tokentype_eof)
997 break;
998
999 /*
1000 * Get type.
1001 */
1002 if (token.type == isc_tokentype_number) {
1003 type = token.value.as_ulong;
1004 isc_buffer_init(&tbuf, outbuf, sizeof(outbuf));
1005 result = dns_rdatatype_totext(type, &tbuf);
1006 if (result != ISC_R_SUCCESS) {
1007 fprintf(stdout,
1008 "dns_rdatatype_totext "
1009 "returned %s(%d)\n",
1010 dns_result_totext(result), result);
1011 fflush(stdout);
1012 need_eol = 1;
1013 continue;
1014 }
1015 fprintf(stdout, "type = %.*s(%d)\n",
1016 (int)tbuf.used, (char*)tbuf.base, type);
1017 } else if (token.type == isc_tokentype_string) {
1018 result = dns_rdatatype_fromtext(&type,
1019 &token.value.as_textregion);
1020 if (result != ISC_R_SUCCESS) {
1021 fprintf(stdout,
1022 "dns_rdatatype_fromtext "
1023 "returned %s(%d)\n",
1024 dns_result_totext(result), result);
1025 fflush(stdout);
1026 need_eol = 1;
1027 continue;
1028 }
1029 fprintf(stdout, "type = %.*s(%d)\n",
1030 (int)token.value.as_textregion.length,
1031 token.value.as_textregion.base, type);
1032 } else
1033 continue;
1034
1035 result = isc_lex_gettoken(lex, options | ISC_LEXOPT_NUMBER,
1036 &token);
1037 if (result != ISC_R_SUCCESS)
1038 break;
1039 if (token.type == isc_tokentype_eol)
1040 continue;
1041 if (token.type == isc_tokentype_eof)
1042 break;
1043 if (token.type == isc_tokentype_number) {
1044 class = token.value.as_ulong;
1045 isc_buffer_init(&tbuf, outbuf, sizeof(outbuf));
1046 result = dns_rdatatype_totext(class, &tbuf);
1047 if (result != ISC_R_SUCCESS) {
1048 fprintf(stdout, "dns_rdatatype_totext "
1049 "returned %s(%d)\n",
1050 dns_result_totext(result), result);
1051 fflush(stdout);
1052 need_eol = 1;
1053 continue;
1054 }
1055 fprintf(stdout, "class = %.*s(%d)\n",
1056 (int)tbuf.used, (char*)tbuf.base, class);
1057 } else if (token.type == isc_tokentype_string) {
1058 result = dns_rdataclass_fromtext(&class,
1059 &token.value.as_textregion);
1060 if (result != ISC_R_SUCCESS) {
1061 fprintf(stdout, "dns_rdataclass_fromtext "
1062 "returned %s(%d)\n",
1063 dns_result_totext(result), result);
1064 fflush(stdout);
1065 need_eol = 1;
1066 continue;
1067 }
1068 fprintf(stdout, "class = %.*s(%d)\n",
1069 (int)token.value.as_textregion.length,
1070 token.value.as_textregion.base, class);
1071 } else
1072 continue;
1073
1074 fflush(stdout);
1075 dns_rdata_init(&rdata);
1076 isc_buffer_init(&dbuf, inbuf, sizeof(inbuf));
1077 result = dns_rdata_fromtext(&rdata, class, type, lex,
1078 NULL, 0, mctx, &dbuf,
1079 NULL);
1080 if (result != ISC_R_SUCCESS) {
1081 fprintf(stdout,
1082 "dns_rdata_fromtext returned %s(%d)\n",
1083 dns_result_totext(result), result);
1084 fflush(stdout);
1085 continue;
1086 }
1087 if (raw) {
1088 unsigned int i;
1089 for (i = 0; i < rdata.length; /* */ ) {
1090 fprintf(stdout, "%02x", rdata.data[i]);
1091 if ((++i % 20) == 0)
1092 fputs("\n", stdout);
1093 else
1094 if (i == rdata.length)
1095 fputs("\n", stdout);
1096 else
1097 fputs(" ", stdout);
1098 }
1099 }
1100
1101 /*
1102 * Convert to wire and back?
1103 */
1104 if (wire) {
1105 result = dns_compress_init(&cctx, -1, mctx);
1106 if (result != ISC_R_SUCCESS) {
1107 fprintf(stdout,
1108 "dns_compress_init returned %s(%d)\n",
1109 dns_result_totext(result), result);
1110 continue;
1111 }
1112 isc_buffer_init(&wbuf, wirebuf, sizeof(wirebuf));
1113 result = dns_rdata_towire(&rdata, &cctx, &wbuf);
1114 dns_compress_invalidate(&cctx);
1115 if (result != ISC_R_SUCCESS) {
1116 fprintf(stdout,
1117 "dns_rdata_towire returned %s(%d)\n",
1118 dns_result_totext(result), result);
1119 continue;
1120 }
1121 len = wbuf.used - wbuf.current;
1122 if (raw > 2) {
1123 unsigned int i;
1124 fputs("\n", stdout);
1125 for (i = 0; i < (unsigned int)len; /* */ ) {
1126 fprintf(stdout, "%02x",
1127 ((unsigned char*)wbuf.base)[i + wbuf.current]);
1128 if ((++i % 20) == 0)
1129 fputs("\n", stdout);
1130 else
1131 if (i == wbuf.used)
1132 fputs("\n", stdout);
1133 else
1134 fputs(" ", stdout);
1135 }
1136 }
1137 if (zero)
1138 len = 0;
1139 if (trunc)
1140 len = (len * 3) / 4;
1141 if (add) {
1142 isc_buffer_add(&wbuf, len / 4 + 1);
1143 len += len / 4 + 1;
1144 }
1145
1146 isc_buffer_setactive(&wbuf, len);
1147 dns_rdata_init(&rdata);
1148 isc_buffer_init(&dbuf, inbuf, sizeof(inbuf));
1149 dns_decompress_init(&dctx, -1, DNS_DECOMPRESS_ANY);
1150 result = dns_rdata_fromwire(&rdata, class, type, &wbuf,
1151 &dctx, 0, &dbuf);
1152 dns_decompress_invalidate(&dctx);
1153 if (result != ISC_R_SUCCESS) {
1154 fprintf(stdout,
1155 "dns_rdata_fromwire returned %s(%d)\n",
1156 dns_result_totext(result), result);
1157 fflush(stdout);
1158 continue;
1159 }
1160 }
1161 if (raw > 1) {
1162 unsigned int i;
1163 fputs("\n", stdout);
1164 for (i = 0; i < rdata.length; /* */ ) {
1165 fprintf(stdout, "%02x", rdata.data[i]);
1166 if ((++i % 20) == 0)
1167 fputs("\n", stdout);
1168 else
1169 if (i == rdata.length)
1170 fputs("\n", stdout);
1171 else
1172 fputs(" ", stdout);
1173 }
1174 }
1175 if (tostruct) {
1176 isc_mem_t *mctx2 = NULL;
1177 dns_rdata_t rdata2 = DNS_RDATA_INIT;
1178 isc_buffer_t vbuf;
1179
1180 RUNTIME_CHECK(isc_mem_create(0, 0, &mctx2)
1181 == ISC_R_SUCCESS);
1182
1183 isc_buffer_init(&vbuf, viabuf, sizeof(viabuf));
1184 dns_rdata_init(&rdata2);
1185 viastruct(&rdata, mctx2, &rdata2, &vbuf);
1186 if (!quiet && stats)
1187 isc_mem_stats(mctx2, stdout);
1188 isc_mem_destroy(&mctx2);
1189 }
1190
1191 isc_buffer_init(&tbuf, outbuf, sizeof(outbuf));
1192 result = dns_rdata_totext(&rdata, NULL, &tbuf);
1193 if (result != ISC_R_SUCCESS)
1194 fprintf(stdout, "dns_rdata_totext returned %s(%d)\n",
1195 dns_result_totext(result), result);
1196 else
1197 fprintf(stdout, "\"%.*s\"\n",
1198 (int)tbuf.used, (char*)tbuf.base);
1199 fflush(stdout);
1200 if (lasttype == type) {
1201 fprintf(stdout, "dns_rdata_compare = %d\n",
1202 dns_rdata_compare(&rdata, &last));
1203
1204 }
1205 if (!first) {
1206 free(last.data);
1207 }
1208 dns_rdata_init(&last);
1209 region.base = malloc(region.length = rdata.length);
1210 if (region.base) {
1211 memmove(region.base, rdata.data, rdata.length);
1212 dns_rdata_fromregion(&last, class, type, ®ion);
1213 lasttype = type;
1214 first = 0;
1215 } else
1216 first = 1;
1217
1218 }
1219 if (result != ISC_R_EOF)
1220 printf("Result: %s\n", isc_result_totext(result));
1221
1222 isc_lex_close(lex);
1223 isc_lex_destroy(&lex);
1224 if (!quiet && stats)
1225 isc_mem_stats(mctx, stdout);
1226 isc_mem_destroy(&mctx);
1227
1228 return (0);
1229 }
1230