bin/tests/rdata_test.c

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