| 1 |
< |
/* $FreeBSD$ */ |
| 1 |
> |
/* $MidnightBSD$ */ |
| 2 |
|
|
| 3 |
|
/* |
| 4 |
< |
* Copyright (C) 2004-2012 Internet Systems Consortium, Inc. ("ISC") |
| 4 |
> |
* Copyright (C) 2004-2016 Internet Systems Consortium, Inc. ("ISC") |
| 5 |
|
* Copyright (C) 1998-2003 Internet Software Consortium. |
| 6 |
|
* |
| 7 |
|
* Permission to use, copy, modify, and distribute this software for any |
| 67 |
|
#include "rdata/generic/loc_29.c" |
| 68 |
|
#include "rdata/generic/nxt_30.c" |
| 69 |
|
#include "rdata/in_1/srv_33.c" |
| 70 |
< |
#include "rdata/in_1/naptr_35.c" |
| 70 |
> |
#include "rdata/generic/naptr_35.c" |
| 71 |
|
#include "rdata/in_1/kx_36.c" |
| 72 |
|
#include "rdata/generic/cert_37.c" |
| 73 |
|
#include "rdata/in_1/a6_38.c" |
| 74 |
|
#include "rdata/generic/dname_39.c" |
| 75 |
+ |
#include "rdata/generic/sink_40.c" |
| 76 |
|
#include "rdata/generic/opt_41.c" |
| 77 |
|
#include "rdata/in_1/apl_42.c" |
| 78 |
|
#include "rdata/generic/ds_43.c" |
| 85 |
|
#include "rdata/generic/nsec3_50.c" |
| 86 |
|
#include "rdata/generic/nsec3param_51.c" |
| 87 |
|
#include "rdata/generic/tlsa_52.c" |
| 88 |
+ |
#include "rdata/generic/smimea_53.c" |
| 89 |
|
#include "rdata/generic/hip_55.c" |
| 90 |
+ |
#include "rdata/generic/ninfo_56.c" |
| 91 |
+ |
#include "rdata/generic/rkey_57.c" |
| 92 |
+ |
#include "rdata/generic/talink_58.c" |
| 93 |
+ |
#include "rdata/generic/cds_59.c" |
| 94 |
+ |
#include "rdata/generic/cdnskey_60.c" |
| 95 |
+ |
#include "rdata/generic/openpgpkey_61.c" |
| 96 |
+ |
#include "rdata/generic/csync_62.c" |
| 97 |
|
#include "rdata/generic/spf_99.c" |
| 98 |
|
#include "rdata/generic/unspec_103.c" |
| 99 |
+ |
#include "rdata/generic/nid_104.c" |
| 100 |
+ |
#include "rdata/generic/l32_105.c" |
| 101 |
+ |
#include "rdata/generic/l64_106.c" |
| 102 |
+ |
#include "rdata/generic/lp_107.c" |
| 103 |
+ |
#include "rdata/generic/eui48_108.c" |
| 104 |
+ |
#include "rdata/generic/eui64_109.c" |
| 105 |
|
#include "rdata/generic/tkey_249.c" |
| 106 |
|
#include "rdata/any_255/tsig_250.c" |
| 107 |
+ |
#include "rdata/generic/uri_256.c" |
| 108 |
+ |
#include "rdata/generic/caa_257.c" |
| 109 |
+ |
#include "rdata/generic/avc_258.c" |
| 110 |
+ |
#include "rdata/generic/ta_32768.c" |
| 111 |
|
#include "rdata/generic/dlv_32769.c" |
| 112 |
|
#include "rdata/generic/keydata_65533.c" |
| 113 |
|
|
| 176 |
|
default: result = DNS_R_UNKNOWN; break; \ |
| 177 |
|
} \ |
| 178 |
|
break; \ |
| 179 |
< |
case 35: switch (rdclass) { \ |
| 161 |
< |
case 1: result = fromtext_in_naptr(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 162 |
< |
default: result = DNS_R_UNKNOWN; break; \ |
| 163 |
< |
} \ |
| 164 |
< |
break; \ |
| 179 |
> |
case 35: result = fromtext_naptr(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 180 |
|
case 36: switch (rdclass) { \ |
| 181 |
|
case 1: result = fromtext_in_kx(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 182 |
|
default: result = DNS_R_UNKNOWN; break; \ |
| 189 |
|
} \ |
| 190 |
|
break; \ |
| 191 |
|
case 39: result = fromtext_dname(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 192 |
+ |
case 40: result = fromtext_sink(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 193 |
|
case 41: result = fromtext_opt(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 194 |
|
case 42: switch (rdclass) { \ |
| 195 |
|
case 1: result = fromtext_in_apl(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 210 |
|
case 50: result = fromtext_nsec3(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 211 |
|
case 51: result = fromtext_nsec3param(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 212 |
|
case 52: result = fromtext_tlsa(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 213 |
+ |
case 53: result = fromtext_smimea(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 214 |
|
case 55: result = fromtext_hip(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 215 |
+ |
case 56: result = fromtext_ninfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 216 |
+ |
case 57: result = fromtext_rkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 217 |
+ |
case 58: result = fromtext_talink(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 218 |
+ |
case 59: result = fromtext_cds(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 219 |
+ |
case 60: result = fromtext_cdnskey(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 220 |
+ |
case 61: result = fromtext_openpgpkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 221 |
+ |
case 62: result = fromtext_csync(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 222 |
|
case 99: result = fromtext_spf(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 223 |
|
case 103: result = fromtext_unspec(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 224 |
+ |
case 104: result = fromtext_nid(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 225 |
+ |
case 105: result = fromtext_l32(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 226 |
+ |
case 106: result = fromtext_l64(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 227 |
+ |
case 107: result = fromtext_lp(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 228 |
+ |
case 108: result = fromtext_eui48(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 229 |
+ |
case 109: result = fromtext_eui64(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 230 |
|
case 249: result = fromtext_tkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 231 |
|
case 250: switch (rdclass) { \ |
| 232 |
|
case 255: result = fromtext_any_tsig(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 233 |
|
default: result = DNS_R_UNKNOWN; break; \ |
| 234 |
|
} \ |
| 235 |
|
break; \ |
| 236 |
+ |
case 256: result = fromtext_uri(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 237 |
+ |
case 257: result = fromtext_caa(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 238 |
+ |
case 258: result = fromtext_avc(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 239 |
+ |
case 32768: result = fromtext_ta(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 240 |
|
case 32769: result = fromtext_dlv(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 241 |
|
case 65533: result = fromtext_keydata(rdclass, type, lexer, origin, options, target, callbacks); break; \ |
| 242 |
|
default: result = DNS_R_UNKNOWN; break; \ |
| 305 |
|
default: use_default = ISC_TRUE; break; \ |
| 306 |
|
} \ |
| 307 |
|
break; \ |
| 308 |
< |
case 35: switch (rdata->rdclass) { \ |
| 275 |
< |
case 1: result = totext_in_naptr(rdata, tctx, target); break; \ |
| 276 |
< |
default: use_default = ISC_TRUE; break; \ |
| 277 |
< |
} \ |
| 278 |
< |
break; \ |
| 308 |
> |
case 35: result = totext_naptr(rdata, tctx, target); break; \ |
| 309 |
|
case 36: switch (rdata->rdclass) { \ |
| 310 |
|
case 1: result = totext_in_kx(rdata, tctx, target); break; \ |
| 311 |
|
default: use_default = ISC_TRUE; break; \ |
| 318 |
|
} \ |
| 319 |
|
break; \ |
| 320 |
|
case 39: result = totext_dname(rdata, tctx, target); break; \ |
| 321 |
+ |
case 40: result = totext_sink(rdata, tctx, target); break; \ |
| 322 |
|
case 41: result = totext_opt(rdata, tctx, target); break; \ |
| 323 |
|
case 42: switch (rdata->rdclass) { \ |
| 324 |
|
case 1: result = totext_in_apl(rdata, tctx, target); break; \ |
| 339 |
|
case 50: result = totext_nsec3(rdata, tctx, target); break; \ |
| 340 |
|
case 51: result = totext_nsec3param(rdata, tctx, target); break; \ |
| 341 |
|
case 52: result = totext_tlsa(rdata, tctx, target); break; \ |
| 342 |
+ |
case 53: result = totext_smimea(rdata, tctx, target); break; \ |
| 343 |
|
case 55: result = totext_hip(rdata, tctx, target); break; \ |
| 344 |
+ |
case 56: result = totext_ninfo(rdata, tctx, target); break; \ |
| 345 |
+ |
case 57: result = totext_rkey(rdata, tctx, target); break; \ |
| 346 |
+ |
case 58: result = totext_talink(rdata, tctx, target); break; \ |
| 347 |
+ |
case 59: result = totext_cds(rdata, tctx, target); break; \ |
| 348 |
+ |
case 60: result = totext_cdnskey(rdata, tctx, target); break; \ |
| 349 |
+ |
case 61: result = totext_openpgpkey(rdata, tctx, target); break; \ |
| 350 |
+ |
case 62: result = totext_csync(rdata, tctx, target); break; \ |
| 351 |
|
case 99: result = totext_spf(rdata, tctx, target); break; \ |
| 352 |
|
case 103: result = totext_unspec(rdata, tctx, target); break; \ |
| 353 |
+ |
case 104: result = totext_nid(rdata, tctx, target); break; \ |
| 354 |
+ |
case 105: result = totext_l32(rdata, tctx, target); break; \ |
| 355 |
+ |
case 106: result = totext_l64(rdata, tctx, target); break; \ |
| 356 |
+ |
case 107: result = totext_lp(rdata, tctx, target); break; \ |
| 357 |
+ |
case 108: result = totext_eui48(rdata, tctx, target); break; \ |
| 358 |
+ |
case 109: result = totext_eui64(rdata, tctx, target); break; \ |
| 359 |
|
case 249: result = totext_tkey(rdata, tctx, target); break; \ |
| 360 |
|
case 250: switch (rdata->rdclass) { \ |
| 361 |
|
case 255: result = totext_any_tsig(rdata, tctx, target); break; \ |
| 362 |
|
default: use_default = ISC_TRUE; break; \ |
| 363 |
|
} \ |
| 364 |
|
break; \ |
| 365 |
+ |
case 256: result = totext_uri(rdata, tctx, target); break; \ |
| 366 |
+ |
case 257: result = totext_caa(rdata, tctx, target); break; \ |
| 367 |
+ |
case 258: result = totext_avc(rdata, tctx, target); break; \ |
| 368 |
+ |
case 32768: result = totext_ta(rdata, tctx, target); break; \ |
| 369 |
|
case 32769: result = totext_dlv(rdata, tctx, target); break; \ |
| 370 |
|
case 65533: result = totext_keydata(rdata, tctx, target); break; \ |
| 371 |
|
default: use_default = ISC_TRUE; break; \ |
| 434 |
|
default: use_default = ISC_TRUE; break; \ |
| 435 |
|
} \ |
| 436 |
|
break; \ |
| 437 |
< |
case 35: switch (rdclass) { \ |
| 389 |
< |
case 1: result = fromwire_in_naptr(rdclass, type, source, dctx, options, target); break; \ |
| 390 |
< |
default: use_default = ISC_TRUE; break; \ |
| 391 |
< |
} \ |
| 392 |
< |
break; \ |
| 437 |
> |
case 35: result = fromwire_naptr(rdclass, type, source, dctx, options, target); break; \ |
| 438 |
|
case 36: switch (rdclass) { \ |
| 439 |
|
case 1: result = fromwire_in_kx(rdclass, type, source, dctx, options, target); break; \ |
| 440 |
|
default: use_default = ISC_TRUE; break; \ |
| 447 |
|
} \ |
| 448 |
|
break; \ |
| 449 |
|
case 39: result = fromwire_dname(rdclass, type, source, dctx, options, target); break; \ |
| 450 |
+ |
case 40: result = fromwire_sink(rdclass, type, source, dctx, options, target); break; \ |
| 451 |
|
case 41: result = fromwire_opt(rdclass, type, source, dctx, options, target); break; \ |
| 452 |
|
case 42: switch (rdclass) { \ |
| 453 |
|
case 1: result = fromwire_in_apl(rdclass, type, source, dctx, options, target); break; \ |
| 468 |
|
case 50: result = fromwire_nsec3(rdclass, type, source, dctx, options, target); break; \ |
| 469 |
|
case 51: result = fromwire_nsec3param(rdclass, type, source, dctx, options, target); break; \ |
| 470 |
|
case 52: result = fromwire_tlsa(rdclass, type, source, dctx, options, target); break; \ |
| 471 |
+ |
case 53: result = fromwire_smimea(rdclass, type, source, dctx, options, target); break; \ |
| 472 |
|
case 55: result = fromwire_hip(rdclass, type, source, dctx, options, target); break; \ |
| 473 |
+ |
case 56: result = fromwire_ninfo(rdclass, type, source, dctx, options, target); break; \ |
| 474 |
+ |
case 57: result = fromwire_rkey(rdclass, type, source, dctx, options, target); break; \ |
| 475 |
+ |
case 58: result = fromwire_talink(rdclass, type, source, dctx, options, target); break; \ |
| 476 |
+ |
case 59: result = fromwire_cds(rdclass, type, source, dctx, options, target); break; \ |
| 477 |
+ |
case 60: result = fromwire_cdnskey(rdclass, type, source, dctx, options, target); break; \ |
| 478 |
+ |
case 61: result = fromwire_openpgpkey(rdclass, type, source, dctx, options, target); break; \ |
| 479 |
+ |
case 62: result = fromwire_csync(rdclass, type, source, dctx, options, target); break; \ |
| 480 |
|
case 99: result = fromwire_spf(rdclass, type, source, dctx, options, target); break; \ |
| 481 |
|
case 103: result = fromwire_unspec(rdclass, type, source, dctx, options, target); break; \ |
| 482 |
+ |
case 104: result = fromwire_nid(rdclass, type, source, dctx, options, target); break; \ |
| 483 |
+ |
case 105: result = fromwire_l32(rdclass, type, source, dctx, options, target); break; \ |
| 484 |
+ |
case 106: result = fromwire_l64(rdclass, type, source, dctx, options, target); break; \ |
| 485 |
+ |
case 107: result = fromwire_lp(rdclass, type, source, dctx, options, target); break; \ |
| 486 |
+ |
case 108: result = fromwire_eui48(rdclass, type, source, dctx, options, target); break; \ |
| 487 |
+ |
case 109: result = fromwire_eui64(rdclass, type, source, dctx, options, target); break; \ |
| 488 |
|
case 249: result = fromwire_tkey(rdclass, type, source, dctx, options, target); break; \ |
| 489 |
|
case 250: switch (rdclass) { \ |
| 490 |
|
case 255: result = fromwire_any_tsig(rdclass, type, source, dctx, options, target); break; \ |
| 491 |
|
default: use_default = ISC_TRUE; break; \ |
| 492 |
|
} \ |
| 493 |
|
break; \ |
| 494 |
+ |
case 256: result = fromwire_uri(rdclass, type, source, dctx, options, target); break; \ |
| 495 |
+ |
case 257: result = fromwire_caa(rdclass, type, source, dctx, options, target); break; \ |
| 496 |
+ |
case 258: result = fromwire_avc(rdclass, type, source, dctx, options, target); break; \ |
| 497 |
+ |
case 32768: result = fromwire_ta(rdclass, type, source, dctx, options, target); break; \ |
| 498 |
|
case 32769: result = fromwire_dlv(rdclass, type, source, dctx, options, target); break; \ |
| 499 |
|
case 65533: result = fromwire_keydata(rdclass, type, source, dctx, options, target); break; \ |
| 500 |
|
default: use_default = ISC_TRUE; break; \ |
| 563 |
|
default: use_default = ISC_TRUE; break; \ |
| 564 |
|
} \ |
| 565 |
|
break; \ |
| 566 |
< |
case 35: switch (rdata->rdclass) { \ |
| 503 |
< |
case 1: result = towire_in_naptr(rdata, cctx, target); break; \ |
| 504 |
< |
default: use_default = ISC_TRUE; break; \ |
| 505 |
< |
} \ |
| 506 |
< |
break; \ |
| 566 |
> |
case 35: result = towire_naptr(rdata, cctx, target); break; \ |
| 567 |
|
case 36: switch (rdata->rdclass) { \ |
| 568 |
|
case 1: result = towire_in_kx(rdata, cctx, target); break; \ |
| 569 |
|
default: use_default = ISC_TRUE; break; \ |
| 576 |
|
} \ |
| 577 |
|
break; \ |
| 578 |
|
case 39: result = towire_dname(rdata, cctx, target); break; \ |
| 579 |
+ |
case 40: result = towire_sink(rdata, cctx, target); break; \ |
| 580 |
|
case 41: result = towire_opt(rdata, cctx, target); break; \ |
| 581 |
|
case 42: switch (rdata->rdclass) { \ |
| 582 |
|
case 1: result = towire_in_apl(rdata, cctx, target); break; \ |
| 597 |
|
case 50: result = towire_nsec3(rdata, cctx, target); break; \ |
| 598 |
|
case 51: result = towire_nsec3param(rdata, cctx, target); break; \ |
| 599 |
|
case 52: result = towire_tlsa(rdata, cctx, target); break; \ |
| 600 |
+ |
case 53: result = towire_smimea(rdata, cctx, target); break; \ |
| 601 |
|
case 55: result = towire_hip(rdata, cctx, target); break; \ |
| 602 |
+ |
case 56: result = towire_ninfo(rdata, cctx, target); break; \ |
| 603 |
+ |
case 57: result = towire_rkey(rdata, cctx, target); break; \ |
| 604 |
+ |
case 58: result = towire_talink(rdata, cctx, target); break; \ |
| 605 |
+ |
case 59: result = towire_cds(rdata, cctx, target); break; \ |
| 606 |
+ |
case 60: result = towire_cdnskey(rdata, cctx, target); break; \ |
| 607 |
+ |
case 61: result = towire_openpgpkey(rdata, cctx, target); break; \ |
| 608 |
+ |
case 62: result = towire_csync(rdata, cctx, target); break; \ |
| 609 |
|
case 99: result = towire_spf(rdata, cctx, target); break; \ |
| 610 |
|
case 103: result = towire_unspec(rdata, cctx, target); break; \ |
| 611 |
+ |
case 104: result = towire_nid(rdata, cctx, target); break; \ |
| 612 |
+ |
case 105: result = towire_l32(rdata, cctx, target); break; \ |
| 613 |
+ |
case 106: result = towire_l64(rdata, cctx, target); break; \ |
| 614 |
+ |
case 107: result = towire_lp(rdata, cctx, target); break; \ |
| 615 |
+ |
case 108: result = towire_eui48(rdata, cctx, target); break; \ |
| 616 |
+ |
case 109: result = towire_eui64(rdata, cctx, target); break; \ |
| 617 |
|
case 249: result = towire_tkey(rdata, cctx, target); break; \ |
| 618 |
|
case 250: switch (rdata->rdclass) { \ |
| 619 |
|
case 255: result = towire_any_tsig(rdata, cctx, target); break; \ |
| 620 |
|
default: use_default = ISC_TRUE; break; \ |
| 621 |
|
} \ |
| 622 |
|
break; \ |
| 623 |
+ |
case 256: result = towire_uri(rdata, cctx, target); break; \ |
| 624 |
+ |
case 257: result = towire_caa(rdata, cctx, target); break; \ |
| 625 |
+ |
case 258: result = towire_avc(rdata, cctx, target); break; \ |
| 626 |
+ |
case 32768: result = towire_ta(rdata, cctx, target); break; \ |
| 627 |
|
case 32769: result = towire_dlv(rdata, cctx, target); break; \ |
| 628 |
|
case 65533: result = towire_keydata(rdata, cctx, target); break; \ |
| 629 |
|
default: use_default = ISC_TRUE; break; \ |
| 692 |
|
default: use_default = ISC_TRUE; break; \ |
| 693 |
|
} \ |
| 694 |
|
break; \ |
| 695 |
< |
case 35: switch (rdata1->rdclass) { \ |
| 617 |
< |
case 1: result = compare_in_naptr(rdata1, rdata2); break; \ |
| 618 |
< |
default: use_default = ISC_TRUE; break; \ |
| 619 |
< |
} \ |
| 620 |
< |
break; \ |
| 695 |
> |
case 35: result = compare_naptr(rdata1, rdata2); break; \ |
| 696 |
|
case 36: switch (rdata1->rdclass) { \ |
| 697 |
|
case 1: result = compare_in_kx(rdata1, rdata2); break; \ |
| 698 |
|
default: use_default = ISC_TRUE; break; \ |
| 705 |
|
} \ |
| 706 |
|
break; \ |
| 707 |
|
case 39: result = compare_dname(rdata1, rdata2); break; \ |
| 708 |
+ |
case 40: result = compare_sink(rdata1, rdata2); break; \ |
| 709 |
|
case 41: result = compare_opt(rdata1, rdata2); break; \ |
| 710 |
|
case 42: switch (rdata1->rdclass) { \ |
| 711 |
|
case 1: result = compare_in_apl(rdata1, rdata2); break; \ |
| 726 |
|
case 50: result = compare_nsec3(rdata1, rdata2); break; \ |
| 727 |
|
case 51: result = compare_nsec3param(rdata1, rdata2); break; \ |
| 728 |
|
case 52: result = compare_tlsa(rdata1, rdata2); break; \ |
| 729 |
+ |
case 53: result = compare_smimea(rdata1, rdata2); break; \ |
| 730 |
|
case 55: result = compare_hip(rdata1, rdata2); break; \ |
| 731 |
+ |
case 56: result = compare_ninfo(rdata1, rdata2); break; \ |
| 732 |
+ |
case 57: result = compare_rkey(rdata1, rdata2); break; \ |
| 733 |
+ |
case 58: result = compare_talink(rdata1, rdata2); break; \ |
| 734 |
+ |
case 59: result = compare_cds(rdata1, rdata2); break; \ |
| 735 |
+ |
case 60: result = compare_cdnskey(rdata1, rdata2); break; \ |
| 736 |
+ |
case 61: result = compare_openpgpkey(rdata1, rdata2); break; \ |
| 737 |
+ |
case 62: result = compare_csync(rdata1, rdata2); break; \ |
| 738 |
|
case 99: result = compare_spf(rdata1, rdata2); break; \ |
| 739 |
|
case 103: result = compare_unspec(rdata1, rdata2); break; \ |
| 740 |
+ |
case 104: result = compare_nid(rdata1, rdata2); break; \ |
| 741 |
+ |
case 105: result = compare_l32(rdata1, rdata2); break; \ |
| 742 |
+ |
case 106: result = compare_l64(rdata1, rdata2); break; \ |
| 743 |
+ |
case 107: result = compare_lp(rdata1, rdata2); break; \ |
| 744 |
+ |
case 108: result = compare_eui48(rdata1, rdata2); break; \ |
| 745 |
+ |
case 109: result = compare_eui64(rdata1, rdata2); break; \ |
| 746 |
|
case 249: result = compare_tkey(rdata1, rdata2); break; \ |
| 747 |
|
case 250: switch (rdata1->rdclass) { \ |
| 748 |
|
case 255: result = compare_any_tsig(rdata1, rdata2); break; \ |
| 749 |
|
default: use_default = ISC_TRUE; break; \ |
| 750 |
|
} \ |
| 751 |
|
break; \ |
| 752 |
+ |
case 256: result = compare_uri(rdata1, rdata2); break; \ |
| 753 |
+ |
case 257: result = compare_caa(rdata1, rdata2); break; \ |
| 754 |
+ |
case 258: result = compare_avc(rdata1, rdata2); break; \ |
| 755 |
+ |
case 32768: result = compare_ta(rdata1, rdata2); break; \ |
| 756 |
|
case 32769: result = compare_dlv(rdata1, rdata2); break; \ |
| 757 |
|
case 65533: result = compare_keydata(rdata1, rdata2); break; \ |
| 758 |
|
default: use_default = ISC_TRUE; break; \ |
| 821 |
|
default: use_default = ISC_TRUE; break; \ |
| 822 |
|
} \ |
| 823 |
|
break; \ |
| 824 |
< |
case 35: switch (rdata1->rdclass) { \ |
| 731 |
< |
case 1: result = casecompare_in_naptr(rdata1, rdata2); break; \ |
| 732 |
< |
default: use_default = ISC_TRUE; break; \ |
| 733 |
< |
} \ |
| 734 |
< |
break; \ |
| 824 |
> |
case 35: result = casecompare_naptr(rdata1, rdata2); break; \ |
| 825 |
|
case 36: switch (rdata1->rdclass) { \ |
| 826 |
|
case 1: result = casecompare_in_kx(rdata1, rdata2); break; \ |
| 827 |
|
default: use_default = ISC_TRUE; break; \ |
| 834 |
|
} \ |
| 835 |
|
break; \ |
| 836 |
|
case 39: result = casecompare_dname(rdata1, rdata2); break; \ |
| 837 |
+ |
case 40: result = casecompare_sink(rdata1, rdata2); break; \ |
| 838 |
|
case 41: result = casecompare_opt(rdata1, rdata2); break; \ |
| 839 |
|
case 42: switch (rdata1->rdclass) { \ |
| 840 |
|
case 1: result = casecompare_in_apl(rdata1, rdata2); break; \ |
| 855 |
|
case 50: result = casecompare_nsec3(rdata1, rdata2); break; \ |
| 856 |
|
case 51: result = casecompare_nsec3param(rdata1, rdata2); break; \ |
| 857 |
|
case 52: result = casecompare_tlsa(rdata1, rdata2); break; \ |
| 858 |
+ |
case 53: result = casecompare_smimea(rdata1, rdata2); break; \ |
| 859 |
|
case 55: result = casecompare_hip(rdata1, rdata2); break; \ |
| 860 |
+ |
case 56: result = casecompare_ninfo(rdata1, rdata2); break; \ |
| 861 |
+ |
case 57: result = casecompare_rkey(rdata1, rdata2); break; \ |
| 862 |
+ |
case 58: result = casecompare_talink(rdata1, rdata2); break; \ |
| 863 |
+ |
case 59: result = casecompare_cds(rdata1, rdata2); break; \ |
| 864 |
+ |
case 60: result = casecompare_cdnskey(rdata1, rdata2); break; \ |
| 865 |
+ |
case 61: result = casecompare_openpgpkey(rdata1, rdata2); break; \ |
| 866 |
+ |
case 62: result = casecompare_csync(rdata1, rdata2); break; \ |
| 867 |
|
case 99: result = casecompare_spf(rdata1, rdata2); break; \ |
| 868 |
|
case 103: result = casecompare_unspec(rdata1, rdata2); break; \ |
| 869 |
+ |
case 104: result = casecompare_nid(rdata1, rdata2); break; \ |
| 870 |
+ |
case 105: result = casecompare_l32(rdata1, rdata2); break; \ |
| 871 |
+ |
case 106: result = casecompare_l64(rdata1, rdata2); break; \ |
| 872 |
+ |
case 107: result = casecompare_lp(rdata1, rdata2); break; \ |
| 873 |
+ |
case 108: result = casecompare_eui48(rdata1, rdata2); break; \ |
| 874 |
+ |
case 109: result = casecompare_eui64(rdata1, rdata2); break; \ |
| 875 |
|
case 249: result = casecompare_tkey(rdata1, rdata2); break; \ |
| 876 |
|
case 250: switch (rdata1->rdclass) { \ |
| 877 |
|
case 255: result = casecompare_any_tsig(rdata1, rdata2); break; \ |
| 878 |
|
default: use_default = ISC_TRUE; break; \ |
| 879 |
|
} \ |
| 880 |
|
break; \ |
| 881 |
+ |
case 256: result = casecompare_uri(rdata1, rdata2); break; \ |
| 882 |
+ |
case 257: result = casecompare_caa(rdata1, rdata2); break; \ |
| 883 |
+ |
case 258: result = casecompare_avc(rdata1, rdata2); break; \ |
| 884 |
+ |
case 32768: result = casecompare_ta(rdata1, rdata2); break; \ |
| 885 |
|
case 32769: result = casecompare_dlv(rdata1, rdata2); break; \ |
| 886 |
|
case 65533: result = casecompare_keydata(rdata1, rdata2); break; \ |
| 887 |
|
default: use_default = ISC_TRUE; break; \ |
| 950 |
|
default: use_default = ISC_TRUE; break; \ |
| 951 |
|
} \ |
| 952 |
|
break; \ |
| 953 |
< |
case 35: switch (rdclass) { \ |
| 845 |
< |
case 1: result = fromstruct_in_naptr(rdclass, type, source, target); break; \ |
| 846 |
< |
default: use_default = ISC_TRUE; break; \ |
| 847 |
< |
} \ |
| 848 |
< |
break; \ |
| 953 |
> |
case 35: result = fromstruct_naptr(rdclass, type, source, target); break; \ |
| 954 |
|
case 36: switch (rdclass) { \ |
| 955 |
|
case 1: result = fromstruct_in_kx(rdclass, type, source, target); break; \ |
| 956 |
|
default: use_default = ISC_TRUE; break; \ |
| 963 |
|
} \ |
| 964 |
|
break; \ |
| 965 |
|
case 39: result = fromstruct_dname(rdclass, type, source, target); break; \ |
| 966 |
+ |
case 40: result = fromstruct_sink(rdclass, type, source, target); break; \ |
| 967 |
|
case 41: result = fromstruct_opt(rdclass, type, source, target); break; \ |
| 968 |
|
case 42: switch (rdclass) { \ |
| 969 |
|
case 1: result = fromstruct_in_apl(rdclass, type, source, target); break; \ |
| 984 |
|
case 50: result = fromstruct_nsec3(rdclass, type, source, target); break; \ |
| 985 |
|
case 51: result = fromstruct_nsec3param(rdclass, type, source, target); break; \ |
| 986 |
|
case 52: result = fromstruct_tlsa(rdclass, type, source, target); break; \ |
| 987 |
+ |
case 53: result = fromstruct_smimea(rdclass, type, source, target); break; \ |
| 988 |
|
case 55: result = fromstruct_hip(rdclass, type, source, target); break; \ |
| 989 |
+ |
case 56: result = fromstruct_ninfo(rdclass, type, source, target); break; \ |
| 990 |
+ |
case 57: result = fromstruct_rkey(rdclass, type, source, target); break; \ |
| 991 |
+ |
case 58: result = fromstruct_talink(rdclass, type, source, target); break; \ |
| 992 |
+ |
case 59: result = fromstruct_cds(rdclass, type, source, target); break; \ |
| 993 |
+ |
case 60: result = fromstruct_cdnskey(rdclass, type, source, target); break; \ |
| 994 |
+ |
case 61: result = fromstruct_openpgpkey(rdclass, type, source, target); break; \ |
| 995 |
+ |
case 62: result = fromstruct_csync(rdclass, type, source, target); break; \ |
| 996 |
|
case 99: result = fromstruct_spf(rdclass, type, source, target); break; \ |
| 997 |
|
case 103: result = fromstruct_unspec(rdclass, type, source, target); break; \ |
| 998 |
+ |
case 104: result = fromstruct_nid(rdclass, type, source, target); break; \ |
| 999 |
+ |
case 105: result = fromstruct_l32(rdclass, type, source, target); break; \ |
| 1000 |
+ |
case 106: result = fromstruct_l64(rdclass, type, source, target); break; \ |
| 1001 |
+ |
case 107: result = fromstruct_lp(rdclass, type, source, target); break; \ |
| 1002 |
+ |
case 108: result = fromstruct_eui48(rdclass, type, source, target); break; \ |
| 1003 |
+ |
case 109: result = fromstruct_eui64(rdclass, type, source, target); break; \ |
| 1004 |
|
case 249: result = fromstruct_tkey(rdclass, type, source, target); break; \ |
| 1005 |
|
case 250: switch (rdclass) { \ |
| 1006 |
|
case 255: result = fromstruct_any_tsig(rdclass, type, source, target); break; \ |
| 1007 |
|
default: use_default = ISC_TRUE; break; \ |
| 1008 |
|
} \ |
| 1009 |
|
break; \ |
| 1010 |
+ |
case 256: result = fromstruct_uri(rdclass, type, source, target); break; \ |
| 1011 |
+ |
case 257: result = fromstruct_caa(rdclass, type, source, target); break; \ |
| 1012 |
+ |
case 258: result = fromstruct_avc(rdclass, type, source, target); break; \ |
| 1013 |
+ |
case 32768: result = fromstruct_ta(rdclass, type, source, target); break; \ |
| 1014 |
|
case 32769: result = fromstruct_dlv(rdclass, type, source, target); break; \ |
| 1015 |
|
case 65533: result = fromstruct_keydata(rdclass, type, source, target); break; \ |
| 1016 |
|
default: use_default = ISC_TRUE; break; \ |
| 1079 |
|
default: use_default = ISC_TRUE; break; \ |
| 1080 |
|
} \ |
| 1081 |
|
break; \ |
| 1082 |
< |
case 35: switch (rdata->rdclass) { \ |
| 959 |
< |
case 1: result = tostruct_in_naptr(rdata, target, mctx); break; \ |
| 960 |
< |
default: use_default = ISC_TRUE; break; \ |
| 961 |
< |
} \ |
| 962 |
< |
break; \ |
| 1082 |
> |
case 35: result = tostruct_naptr(rdata, target, mctx); break; \ |
| 1083 |
|
case 36: switch (rdata->rdclass) { \ |
| 1084 |
|
case 1: result = tostruct_in_kx(rdata, target, mctx); break; \ |
| 1085 |
|
default: use_default = ISC_TRUE; break; \ |
| 1092 |
|
} \ |
| 1093 |
|
break; \ |
| 1094 |
|
case 39: result = tostruct_dname(rdata, target, mctx); break; \ |
| 1095 |
+ |
case 40: result = tostruct_sink(rdata, target, mctx); break; \ |
| 1096 |
|
case 41: result = tostruct_opt(rdata, target, mctx); break; \ |
| 1097 |
|
case 42: switch (rdata->rdclass) { \ |
| 1098 |
|
case 1: result = tostruct_in_apl(rdata, target, mctx); break; \ |
| 1113 |
|
case 50: result = tostruct_nsec3(rdata, target, mctx); break; \ |
| 1114 |
|
case 51: result = tostruct_nsec3param(rdata, target, mctx); break; \ |
| 1115 |
|
case 52: result = tostruct_tlsa(rdata, target, mctx); break; \ |
| 1116 |
+ |
case 53: result = tostruct_smimea(rdata, target, mctx); break; \ |
| 1117 |
|
case 55: result = tostruct_hip(rdata, target, mctx); break; \ |
| 1118 |
+ |
case 56: result = tostruct_ninfo(rdata, target, mctx); break; \ |
| 1119 |
+ |
case 57: result = tostruct_rkey(rdata, target, mctx); break; \ |
| 1120 |
+ |
case 58: result = tostruct_talink(rdata, target, mctx); break; \ |
| 1121 |
+ |
case 59: result = tostruct_cds(rdata, target, mctx); break; \ |
| 1122 |
+ |
case 60: result = tostruct_cdnskey(rdata, target, mctx); break; \ |
| 1123 |
+ |
case 61: result = tostruct_openpgpkey(rdata, target, mctx); break; \ |
| 1124 |
+ |
case 62: result = tostruct_csync(rdata, target, mctx); break; \ |
| 1125 |
|
case 99: result = tostruct_spf(rdata, target, mctx); break; \ |
| 1126 |
|
case 103: result = tostruct_unspec(rdata, target, mctx); break; \ |
| 1127 |
+ |
case 104: result = tostruct_nid(rdata, target, mctx); break; \ |
| 1128 |
+ |
case 105: result = tostruct_l32(rdata, target, mctx); break; \ |
| 1129 |
+ |
case 106: result = tostruct_l64(rdata, target, mctx); break; \ |
| 1130 |
+ |
case 107: result = tostruct_lp(rdata, target, mctx); break; \ |
| 1131 |
+ |
case 108: result = tostruct_eui48(rdata, target, mctx); break; \ |
| 1132 |
+ |
case 109: result = tostruct_eui64(rdata, target, mctx); break; \ |
| 1133 |
|
case 249: result = tostruct_tkey(rdata, target, mctx); break; \ |
| 1134 |
|
case 250: switch (rdata->rdclass) { \ |
| 1135 |
|
case 255: result = tostruct_any_tsig(rdata, target, mctx); break; \ |
| 1136 |
|
default: use_default = ISC_TRUE; break; \ |
| 1137 |
|
} \ |
| 1138 |
|
break; \ |
| 1139 |
+ |
case 256: result = tostruct_uri(rdata, target, mctx); break; \ |
| 1140 |
+ |
case 257: result = tostruct_caa(rdata, target, mctx); break; \ |
| 1141 |
+ |
case 258: result = tostruct_avc(rdata, target, mctx); break; \ |
| 1142 |
+ |
case 32768: result = tostruct_ta(rdata, target, mctx); break; \ |
| 1143 |
|
case 32769: result = tostruct_dlv(rdata, target, mctx); break; \ |
| 1144 |
|
case 65533: result = tostruct_keydata(rdata, target, mctx); break; \ |
| 1145 |
|
default: use_default = ISC_TRUE; break; \ |
| 1208 |
|
default: break; \ |
| 1209 |
|
} \ |
| 1210 |
|
break; \ |
| 1211 |
< |
case 35: switch (common->rdclass) { \ |
| 1073 |
< |
case 1: freestruct_in_naptr(source); break; \ |
| 1074 |
< |
default: break; \ |
| 1075 |
< |
} \ |
| 1076 |
< |
break; \ |
| 1211 |
> |
case 35: freestruct_naptr(source); break; \ |
| 1212 |
|
case 36: switch (common->rdclass) { \ |
| 1213 |
|
case 1: freestruct_in_kx(source); break; \ |
| 1214 |
|
default: break; \ |
| 1221 |
|
} \ |
| 1222 |
|
break; \ |
| 1223 |
|
case 39: freestruct_dname(source); break; \ |
| 1224 |
+ |
case 40: freestruct_sink(source); break; \ |
| 1225 |
|
case 41: freestruct_opt(source); break; \ |
| 1226 |
|
case 42: switch (common->rdclass) { \ |
| 1227 |
|
case 1: freestruct_in_apl(source); break; \ |
| 1242 |
|
case 50: freestruct_nsec3(source); break; \ |
| 1243 |
|
case 51: freestruct_nsec3param(source); break; \ |
| 1244 |
|
case 52: freestruct_tlsa(source); break; \ |
| 1245 |
+ |
case 53: freestruct_smimea(source); break; \ |
| 1246 |
|
case 55: freestruct_hip(source); break; \ |
| 1247 |
+ |
case 56: freestruct_ninfo(source); break; \ |
| 1248 |
+ |
case 57: freestruct_rkey(source); break; \ |
| 1249 |
+ |
case 58: freestruct_talink(source); break; \ |
| 1250 |
+ |
case 59: freestruct_cds(source); break; \ |
| 1251 |
+ |
case 60: freestruct_cdnskey(source); break; \ |
| 1252 |
+ |
case 61: freestruct_openpgpkey(source); break; \ |
| 1253 |
+ |
case 62: freestruct_csync(source); break; \ |
| 1254 |
|
case 99: freestruct_spf(source); break; \ |
| 1255 |
|
case 103: freestruct_unspec(source); break; \ |
| 1256 |
+ |
case 104: freestruct_nid(source); break; \ |
| 1257 |
+ |
case 105: freestruct_l32(source); break; \ |
| 1258 |
+ |
case 106: freestruct_l64(source); break; \ |
| 1259 |
+ |
case 107: freestruct_lp(source); break; \ |
| 1260 |
+ |
case 108: freestruct_eui48(source); break; \ |
| 1261 |
+ |
case 109: freestruct_eui64(source); break; \ |
| 1262 |
|
case 249: freestruct_tkey(source); break; \ |
| 1263 |
|
case 250: switch (common->rdclass) { \ |
| 1264 |
|
case 255: freestruct_any_tsig(source); break; \ |
| 1265 |
|
default: break; \ |
| 1266 |
|
} \ |
| 1267 |
|
break; \ |
| 1268 |
+ |
case 256: freestruct_uri(source); break; \ |
| 1269 |
+ |
case 257: freestruct_caa(source); break; \ |
| 1270 |
+ |
case 258: freestruct_avc(source); break; \ |
| 1271 |
+ |
case 32768: freestruct_ta(source); break; \ |
| 1272 |
|
case 32769: freestruct_dlv(source); break; \ |
| 1273 |
|
case 65533: freestruct_keydata(source); break; \ |
| 1274 |
|
default: break; \ |
| 1337 |
|
default: use_default = ISC_TRUE; break; \ |
| 1338 |
|
} \ |
| 1339 |
|
break; \ |
| 1340 |
< |
case 35: switch (rdata->rdclass) { \ |
| 1187 |
< |
case 1: result = additionaldata_in_naptr(rdata, add, arg); break; \ |
| 1188 |
< |
default: use_default = ISC_TRUE; break; \ |
| 1189 |
< |
} \ |
| 1190 |
< |
break; \ |
| 1340 |
> |
case 35: result = additionaldata_naptr(rdata, add, arg); break; \ |
| 1341 |
|
case 36: switch (rdata->rdclass) { \ |
| 1342 |
|
case 1: result = additionaldata_in_kx(rdata, add, arg); break; \ |
| 1343 |
|
default: use_default = ISC_TRUE; break; \ |
| 1350 |
|
} \ |
| 1351 |
|
break; \ |
| 1352 |
|
case 39: result = additionaldata_dname(rdata, add, arg); break; \ |
| 1353 |
+ |
case 40: result = additionaldata_sink(rdata, add, arg); break; \ |
| 1354 |
|
case 41: result = additionaldata_opt(rdata, add, arg); break; \ |
| 1355 |
|
case 42: switch (rdata->rdclass) { \ |
| 1356 |
|
case 1: result = additionaldata_in_apl(rdata, add, arg); break; \ |
| 1371 |
|
case 50: result = additionaldata_nsec3(rdata, add, arg); break; \ |
| 1372 |
|
case 51: result = additionaldata_nsec3param(rdata, add, arg); break; \ |
| 1373 |
|
case 52: result = additionaldata_tlsa(rdata, add, arg); break; \ |
| 1374 |
+ |
case 53: result = additionaldata_smimea(rdata, add, arg); break; \ |
| 1375 |
|
case 55: result = additionaldata_hip(rdata, add, arg); break; \ |
| 1376 |
+ |
case 56: result = additionaldata_ninfo(rdata, add, arg); break; \ |
| 1377 |
+ |
case 57: result = additionaldata_rkey(rdata, add, arg); break; \ |
| 1378 |
+ |
case 58: result = additionaldata_talink(rdata, add, arg); break; \ |
| 1379 |
+ |
case 59: result = additionaldata_cds(rdata, add, arg); break; \ |
| 1380 |
+ |
case 60: result = additionaldata_cdnskey(rdata, add, arg); break; \ |
| 1381 |
+ |
case 61: result = additionaldata_openpgpkey(rdata, add, arg); break; \ |
| 1382 |
+ |
case 62: result = additionaldata_csync(rdata, add, arg); break; \ |
| 1383 |
|
case 99: result = additionaldata_spf(rdata, add, arg); break; \ |
| 1384 |
|
case 103: result = additionaldata_unspec(rdata, add, arg); break; \ |
| 1385 |
+ |
case 104: result = additionaldata_nid(rdata, add, arg); break; \ |
| 1386 |
+ |
case 105: result = additionaldata_l32(rdata, add, arg); break; \ |
| 1387 |
+ |
case 106: result = additionaldata_l64(rdata, add, arg); break; \ |
| 1388 |
+ |
case 107: result = additionaldata_lp(rdata, add, arg); break; \ |
| 1389 |
+ |
case 108: result = additionaldata_eui48(rdata, add, arg); break; \ |
| 1390 |
+ |
case 109: result = additionaldata_eui64(rdata, add, arg); break; \ |
| 1391 |
|
case 249: result = additionaldata_tkey(rdata, add, arg); break; \ |
| 1392 |
|
case 250: switch (rdata->rdclass) { \ |
| 1393 |
|
case 255: result = additionaldata_any_tsig(rdata, add, arg); break; \ |
| 1394 |
|
default: use_default = ISC_TRUE; break; \ |
| 1395 |
|
} \ |
| 1396 |
|
break; \ |
| 1397 |
+ |
case 256: result = additionaldata_uri(rdata, add, arg); break; \ |
| 1398 |
+ |
case 257: result = additionaldata_caa(rdata, add, arg); break; \ |
| 1399 |
+ |
case 258: result = additionaldata_avc(rdata, add, arg); break; \ |
| 1400 |
+ |
case 32768: result = additionaldata_ta(rdata, add, arg); break; \ |
| 1401 |
|
case 32769: result = additionaldata_dlv(rdata, add, arg); break; \ |
| 1402 |
|
case 65533: result = additionaldata_keydata(rdata, add, arg); break; \ |
| 1403 |
|
default: use_default = ISC_TRUE; break; \ |
| 1466 |
|
default: use_default = ISC_TRUE; break; \ |
| 1467 |
|
} \ |
| 1468 |
|
break; \ |
| 1469 |
< |
case 35: switch (rdata->rdclass) { \ |
| 1301 |
< |
case 1: result = digest_in_naptr(rdata, digest, arg); break; \ |
| 1302 |
< |
default: use_default = ISC_TRUE; break; \ |
| 1303 |
< |
} \ |
| 1304 |
< |
break; \ |
| 1469 |
> |
case 35: result = digest_naptr(rdata, digest, arg); break; \ |
| 1470 |
|
case 36: switch (rdata->rdclass) { \ |
| 1471 |
|
case 1: result = digest_in_kx(rdata, digest, arg); break; \ |
| 1472 |
|
default: use_default = ISC_TRUE; break; \ |
| 1479 |
|
} \ |
| 1480 |
|
break; \ |
| 1481 |
|
case 39: result = digest_dname(rdata, digest, arg); break; \ |
| 1482 |
+ |
case 40: result = digest_sink(rdata, digest, arg); break; \ |
| 1483 |
|
case 41: result = digest_opt(rdata, digest, arg); break; \ |
| 1484 |
|
case 42: switch (rdata->rdclass) { \ |
| 1485 |
|
case 1: result = digest_in_apl(rdata, digest, arg); break; \ |
| 1500 |
|
case 50: result = digest_nsec3(rdata, digest, arg); break; \ |
| 1501 |
|
case 51: result = digest_nsec3param(rdata, digest, arg); break; \ |
| 1502 |
|
case 52: result = digest_tlsa(rdata, digest, arg); break; \ |
| 1503 |
+ |
case 53: result = digest_smimea(rdata, digest, arg); break; \ |
| 1504 |
|
case 55: result = digest_hip(rdata, digest, arg); break; \ |
| 1505 |
+ |
case 56: result = digest_ninfo(rdata, digest, arg); break; \ |
| 1506 |
+ |
case 57: result = digest_rkey(rdata, digest, arg); break; \ |
| 1507 |
+ |
case 58: result = digest_talink(rdata, digest, arg); break; \ |
| 1508 |
+ |
case 59: result = digest_cds(rdata, digest, arg); break; \ |
| 1509 |
+ |
case 60: result = digest_cdnskey(rdata, digest, arg); break; \ |
| 1510 |
+ |
case 61: result = digest_openpgpkey(rdata, digest, arg); break; \ |
| 1511 |
+ |
case 62: result = digest_csync(rdata, digest, arg); break; \ |
| 1512 |
|
case 99: result = digest_spf(rdata, digest, arg); break; \ |
| 1513 |
|
case 103: result = digest_unspec(rdata, digest, arg); break; \ |
| 1514 |
+ |
case 104: result = digest_nid(rdata, digest, arg); break; \ |
| 1515 |
+ |
case 105: result = digest_l32(rdata, digest, arg); break; \ |
| 1516 |
+ |
case 106: result = digest_l64(rdata, digest, arg); break; \ |
| 1517 |
+ |
case 107: result = digest_lp(rdata, digest, arg); break; \ |
| 1518 |
+ |
case 108: result = digest_eui48(rdata, digest, arg); break; \ |
| 1519 |
+ |
case 109: result = digest_eui64(rdata, digest, arg); break; \ |
| 1520 |
|
case 249: result = digest_tkey(rdata, digest, arg); break; \ |
| 1521 |
|
case 250: switch (rdata->rdclass) { \ |
| 1522 |
|
case 255: result = digest_any_tsig(rdata, digest, arg); break; \ |
| 1523 |
|
default: use_default = ISC_TRUE; break; \ |
| 1524 |
|
} \ |
| 1525 |
|
break; \ |
| 1526 |
+ |
case 256: result = digest_uri(rdata, digest, arg); break; \ |
| 1527 |
+ |
case 257: result = digest_caa(rdata, digest, arg); break; \ |
| 1528 |
+ |
case 258: result = digest_avc(rdata, digest, arg); break; \ |
| 1529 |
+ |
case 32768: result = digest_ta(rdata, digest, arg); break; \ |
| 1530 |
|
case 32769: result = digest_dlv(rdata, digest, arg); break; \ |
| 1531 |
|
case 65533: result = digest_keydata(rdata, digest, arg); break; \ |
| 1532 |
|
default: use_default = ISC_TRUE; break; \ |
| 1595 |
|
default: result = ISC_TRUE; break; \ |
| 1596 |
|
} \ |
| 1597 |
|
break; \ |
| 1598 |
< |
case 35: switch (rdclass) { \ |
| 1415 |
< |
case 1: result = checkowner_in_naptr(name, rdclass, type, wildcard); break; \ |
| 1416 |
< |
default: result = ISC_TRUE; break; \ |
| 1417 |
< |
} \ |
| 1418 |
< |
break; \ |
| 1598 |
> |
case 35: result = checkowner_naptr(name, rdclass, type, wildcard); break; \ |
| 1599 |
|
case 36: switch (rdclass) { \ |
| 1600 |
|
case 1: result = checkowner_in_kx(name, rdclass, type, wildcard); break; \ |
| 1601 |
|
default: result = ISC_TRUE; break; \ |
| 1608 |
|
} \ |
| 1609 |
|
break; \ |
| 1610 |
|
case 39: result = checkowner_dname(name, rdclass, type, wildcard); break; \ |
| 1611 |
+ |
case 40: result = checkowner_sink(name, rdclass, type, wildcard); break; \ |
| 1612 |
|
case 41: result = checkowner_opt(name, rdclass, type, wildcard); break; \ |
| 1613 |
|
case 42: switch (rdclass) { \ |
| 1614 |
|
case 1: result = checkowner_in_apl(name, rdclass, type, wildcard); break; \ |
| 1629 |
|
case 50: result = checkowner_nsec3(name, rdclass, type, wildcard); break; \ |
| 1630 |
|
case 51: result = checkowner_nsec3param(name, rdclass, type, wildcard); break; \ |
| 1631 |
|
case 52: result = checkowner_tlsa(name, rdclass, type, wildcard); break; \ |
| 1632 |
+ |
case 53: result = checkowner_smimea(name, rdclass, type, wildcard); break; \ |
| 1633 |
|
case 55: result = checkowner_hip(name, rdclass, type, wildcard); break; \ |
| 1634 |
+ |
case 56: result = checkowner_ninfo(name, rdclass, type, wildcard); break; \ |
| 1635 |
+ |
case 57: result = checkowner_rkey(name, rdclass, type, wildcard); break; \ |
| 1636 |
+ |
case 58: result = checkowner_talink(name, rdclass, type, wildcard); break; \ |
| 1637 |
+ |
case 59: result = checkowner_cds(name, rdclass, type, wildcard); break; \ |
| 1638 |
+ |
case 60: result = checkowner_cdnskey(name, rdclass, type, wildcard); break; \ |
| 1639 |
+ |
case 61: result = checkowner_openpgpkey(name, rdclass, type, wildcard); break; \ |
| 1640 |
+ |
case 62: result = checkowner_csync(name, rdclass, type, wildcard); break; \ |
| 1641 |
|
case 99: result = checkowner_spf(name, rdclass, type, wildcard); break; \ |
| 1642 |
|
case 103: result = checkowner_unspec(name, rdclass, type, wildcard); break; \ |
| 1643 |
+ |
case 104: result = checkowner_nid(name, rdclass, type, wildcard); break; \ |
| 1644 |
+ |
case 105: result = checkowner_l32(name, rdclass, type, wildcard); break; \ |
| 1645 |
+ |
case 106: result = checkowner_l64(name, rdclass, type, wildcard); break; \ |
| 1646 |
+ |
case 107: result = checkowner_lp(name, rdclass, type, wildcard); break; \ |
| 1647 |
+ |
case 108: result = checkowner_eui48(name, rdclass, type, wildcard); break; \ |
| 1648 |
+ |
case 109: result = checkowner_eui64(name, rdclass, type, wildcard); break; \ |
| 1649 |
|
case 249: result = checkowner_tkey(name, rdclass, type, wildcard); break; \ |
| 1650 |
|
case 250: switch (rdclass) { \ |
| 1651 |
|
case 255: result = checkowner_any_tsig(name, rdclass, type, wildcard); break; \ |
| 1652 |
|
default: result = ISC_TRUE; break; \ |
| 1653 |
|
} \ |
| 1654 |
|
break; \ |
| 1655 |
+ |
case 256: result = checkowner_uri(name, rdclass, type, wildcard); break; \ |
| 1656 |
+ |
case 257: result = checkowner_caa(name, rdclass, type, wildcard); break; \ |
| 1657 |
+ |
case 258: result = checkowner_avc(name, rdclass, type, wildcard); break; \ |
| 1658 |
+ |
case 32768: result = checkowner_ta(name, rdclass, type, wildcard); break; \ |
| 1659 |
|
case 32769: result = checkowner_dlv(name, rdclass, type, wildcard); break; \ |
| 1660 |
|
case 65533: result = checkowner_keydata(name, rdclass, type, wildcard); break; \ |
| 1661 |
|
default: result = ISC_TRUE; break; \ |
| 1724 |
|
default: result = ISC_TRUE; break; \ |
| 1725 |
|
} \ |
| 1726 |
|
break; \ |
| 1727 |
< |
case 35: switch (rdata->rdclass) { \ |
| 1529 |
< |
case 1: result = checknames_in_naptr(rdata, owner, bad); break; \ |
| 1530 |
< |
default: result = ISC_TRUE; break; \ |
| 1531 |
< |
} \ |
| 1532 |
< |
break; \ |
| 1727 |
> |
case 35: result = checknames_naptr(rdata, owner, bad); break; \ |
| 1728 |
|
case 36: switch (rdata->rdclass) { \ |
| 1729 |
|
case 1: result = checknames_in_kx(rdata, owner, bad); break; \ |
| 1730 |
|
default: result = ISC_TRUE; break; \ |
| 1737 |
|
} \ |
| 1738 |
|
break; \ |
| 1739 |
|
case 39: result = checknames_dname(rdata, owner, bad); break; \ |
| 1740 |
+ |
case 40: result = checknames_sink(rdata, owner, bad); break; \ |
| 1741 |
|
case 41: result = checknames_opt(rdata, owner, bad); break; \ |
| 1742 |
|
case 42: switch (rdata->rdclass) { \ |
| 1743 |
|
case 1: result = checknames_in_apl(rdata, owner, bad); break; \ |
| 1758 |
|
case 50: result = checknames_nsec3(rdata, owner, bad); break; \ |
| 1759 |
|
case 51: result = checknames_nsec3param(rdata, owner, bad); break; \ |
| 1760 |
|
case 52: result = checknames_tlsa(rdata, owner, bad); break; \ |
| 1761 |
+ |
case 53: result = checknames_smimea(rdata, owner, bad); break; \ |
| 1762 |
|
case 55: result = checknames_hip(rdata, owner, bad); break; \ |
| 1763 |
+ |
case 56: result = checknames_ninfo(rdata, owner, bad); break; \ |
| 1764 |
+ |
case 57: result = checknames_rkey(rdata, owner, bad); break; \ |
| 1765 |
+ |
case 58: result = checknames_talink(rdata, owner, bad); break; \ |
| 1766 |
+ |
case 59: result = checknames_cds(rdata, owner, bad); break; \ |
| 1767 |
+ |
case 60: result = checknames_cdnskey(rdata, owner, bad); break; \ |
| 1768 |
+ |
case 61: result = checknames_openpgpkey(rdata, owner, bad); break; \ |
| 1769 |
+ |
case 62: result = checknames_csync(rdata, owner, bad); break; \ |
| 1770 |
|
case 99: result = checknames_spf(rdata, owner, bad); break; \ |
| 1771 |
|
case 103: result = checknames_unspec(rdata, owner, bad); break; \ |
| 1772 |
+ |
case 104: result = checknames_nid(rdata, owner, bad); break; \ |
| 1773 |
+ |
case 105: result = checknames_l32(rdata, owner, bad); break; \ |
| 1774 |
+ |
case 106: result = checknames_l64(rdata, owner, bad); break; \ |
| 1775 |
+ |
case 107: result = checknames_lp(rdata, owner, bad); break; \ |
| 1776 |
+ |
case 108: result = checknames_eui48(rdata, owner, bad); break; \ |
| 1777 |
+ |
case 109: result = checknames_eui64(rdata, owner, bad); break; \ |
| 1778 |
|
case 249: result = checknames_tkey(rdata, owner, bad); break; \ |
| 1779 |
|
case 250: switch (rdata->rdclass) { \ |
| 1780 |
|
case 255: result = checknames_any_tsig(rdata, owner, bad); break; \ |
| 1781 |
|
default: result = ISC_TRUE; break; \ |
| 1782 |
|
} \ |
| 1783 |
|
break; \ |
| 1784 |
+ |
case 256: result = checknames_uri(rdata, owner, bad); break; \ |
| 1785 |
+ |
case 257: result = checknames_caa(rdata, owner, bad); break; \ |
| 1786 |
+ |
case 258: result = checknames_avc(rdata, owner, bad); break; \ |
| 1787 |
+ |
case 32768: result = checknames_ta(rdata, owner, bad); break; \ |
| 1788 |
|
case 32769: result = checknames_dlv(rdata, owner, bad); break; \ |
| 1789 |
|
case 65533: result = checknames_keydata(rdata, owner, bad); break; \ |
| 1790 |
|
default: result = ISC_TRUE; break; \ |
| 1823 |
|
break; \ |
| 1824 |
|
case 182: \ |
| 1825 |
|
RDATATYPE_COMPARE("soa", 6, _typename, _length, _typep); \ |
| 1826 |
+ |
RDATATYPE_COMPARE("ta", 32768, _typename, _length, _typep); \ |
| 1827 |
|
break; \ |
| 1828 |
|
case 126: \ |
| 1829 |
|
RDATATYPE_COMPARE("mb", 7, _typename, _length, _typep); \ |
| 1874 |
|
break; \ |
| 1875 |
|
case 140: \ |
| 1876 |
|
RDATATYPE_COMPARE("nsap-ptr", 23, _typename, _length, _typep); \ |
| 1877 |
+ |
RDATATYPE_COMPARE("l64", 106, _typename, _length, _typep); \ |
| 1878 |
|
break; \ |
| 1879 |
|
case 122: \ |
| 1880 |
|
RDATATYPE_COMPARE("sig", 24, _typename, _length, _typep); \ |
| 1882 |
|
break; \ |
| 1883 |
|
case 254: \ |
| 1884 |
|
RDATATYPE_COMPARE("key", 25, _typename, _length, _typep); \ |
| 1885 |
+ |
RDATATYPE_COMPARE("talink", 58, _typename, _length, _typep); \ |
| 1886 |
|
break; \ |
| 1887 |
|
case 112: \ |
| 1888 |
|
RDATATYPE_COMPARE("px", 26, _typename, _length, _typep); \ |
| 1911 |
|
break; \ |
| 1912 |
|
case 172: \ |
| 1913 |
|
RDATATYPE_COMPARE("cert", 37, _typename, _length, _typep); \ |
| 1914 |
+ |
RDATATYPE_COMPARE("avc", 258, _typename, _length, _typep); \ |
| 1915 |
|
break; \ |
| 1916 |
|
case 226: \ |
| 1917 |
|
RDATATYPE_COMPARE("a6", 38, _typename, _length, _typep); \ |
| 1919 |
|
case 109: \ |
| 1920 |
|
RDATATYPE_COMPARE("dname", 39, _typename, _length, _typep); \ |
| 1921 |
|
break; \ |
| 1922 |
+ |
case 189: \ |
| 1923 |
+ |
RDATATYPE_COMPARE("sink", 40, _typename, _length, _typep); \ |
| 1924 |
+ |
break; \ |
| 1925 |
|
case 168: \ |
| 1926 |
|
RDATATYPE_COMPARE("opt", 41, _typename, _length, _typep); \ |
| 1927 |
|
break; \ |
| 1928 |
|
case 48: \ |
| 1929 |
|
RDATATYPE_COMPARE("apl", 42, _typename, _length, _typep); \ |
| 1930 |
+ |
RDATATYPE_COMPARE("eui48", 108, _typename, _length, _typep); \ |
| 1931 |
|
break; \ |
| 1932 |
|
case 210: \ |
| 1933 |
|
RDATATYPE_COMPARE("ds", 43, _typename, _length, _typep); \ |
| 1934 |
+ |
RDATATYPE_COMPARE("cds", 59, _typename, _length, _typep); \ |
| 1935 |
|
break; \ |
| 1936 |
|
case 128: \ |
| 1937 |
|
RDATATYPE_COMPARE("sshfp", 44, _typename, _length, _typep); \ |
| 1947 |
|
break; \ |
| 1948 |
|
case 26: \ |
| 1949 |
|
RDATATYPE_COMPARE("dnskey", 48, _typename, _length, _typep); \ |
| 1950 |
+ |
RDATATYPE_COMPARE("cdnskey", 60, _typename, _length, _typep); \ |
| 1951 |
|
break; \ |
| 1952 |
|
case 4: \ |
| 1953 |
|
RDATATYPE_COMPARE("dhcid", 49, _typename, _length, _typep); \ |
| 1959 |
|
case 120: \ |
| 1960 |
|
RDATATYPE_COMPARE("tlsa", 52, _typename, _length, _typep); \ |
| 1961 |
|
break; \ |
| 1962 |
+ |
case 217: \ |
| 1963 |
+ |
RDATATYPE_COMPARE("smimea", 53, _typename, _length, _typep); \ |
| 1964 |
+ |
break; \ |
| 1965 |
|
case 208: \ |
| 1966 |
|
RDATATYPE_COMPARE("hip", 55, _typename, _length, _typep); \ |
| 1967 |
|
break; \ |
| 1968 |
+ |
case 221: \ |
| 1969 |
+ |
RDATATYPE_COMPARE("ninfo", 56, _typename, _length, _typep); \ |
| 1970 |
+ |
break; \ |
| 1971 |
+ |
case 198: \ |
| 1972 |
+ |
RDATATYPE_COMPARE("rkey", 57, _typename, _length, _typep); \ |
| 1973 |
+ |
break; \ |
| 1974 |
+ |
case 49: \ |
| 1975 |
+ |
RDATATYPE_COMPARE("openpgpkey", 61, _typename, _length, _typep); \ |
| 1976 |
+ |
break; \ |
| 1977 |
+ |
case 56: \ |
| 1978 |
+ |
RDATATYPE_COMPARE("csync", 62, _typename, _length, _typep); \ |
| 1979 |
+ |
RDATATYPE_COMPARE("uri", 256, _typename, _length, _typep); \ |
| 1980 |
+ |
break; \ |
| 1981 |
|
case 230: \ |
| 1982 |
|
RDATATYPE_COMPARE("uinfo", 100, _typename, _length, _typep); \ |
| 1983 |
|
break; \ |
| 1987 |
|
case 145: \ |
| 1988 |
|
RDATATYPE_COMPARE("unspec", 103, _typename, _length, _typep); \ |
| 1989 |
|
break; \ |
| 1990 |
+ |
case 36: \ |
| 1991 |
+ |
RDATATYPE_COMPARE("nid", 104, _typename, _length, _typep); \ |
| 1992 |
+ |
break; \ |
| 1993 |
+ |
case 174: \ |
| 1994 |
+ |
RDATATYPE_COMPARE("l32", 105, _typename, _length, _typep); \ |
| 1995 |
+ |
break; \ |
| 1996 |
+ |
case 32: \ |
| 1997 |
+ |
RDATATYPE_COMPARE("lp", 107, _typename, _length, _typep); \ |
| 1998 |
+ |
break; \ |
| 1999 |
+ |
case 136: \ |
| 2000 |
+ |
RDATATYPE_COMPARE("eui64", 109, _typename, _length, _typep); \ |
| 2001 |
+ |
break; \ |
| 2002 |
|
case 184: \ |
| 2003 |
|
RDATATYPE_COMPARE("tkey", 249, _typename, _length, _typep); \ |
| 2004 |
|
break; \ |
| 2021 |
|
case 68: \ |
| 2022 |
|
RDATATYPE_COMPARE("any", 255, _typename, _length, _typep); \ |
| 2023 |
|
break; \ |
| 2024 |
+ |
case 166: \ |
| 2025 |
+ |
RDATATYPE_COMPARE("caa", 257, _typename, _length, _typep); \ |
| 2026 |
+ |
break; \ |
| 2027 |
|
} |
| 2028 |
|
#define RDATATYPE_ATTRIBUTE_SW \ |
| 2029 |
|
switch (type) { \ |
| 2067 |
|
case 37: return (RRTYPE_CERT_ATTRIBUTES); \ |
| 2068 |
|
case 38: return (RRTYPE_A6_ATTRIBUTES); \ |
| 2069 |
|
case 39: return (RRTYPE_DNAME_ATTRIBUTES); \ |
| 2070 |
+ |
case 40: return (RRTYPE_SINK_ATTRIBUTES); \ |
| 2071 |
|
case 41: return (RRTYPE_OPT_ATTRIBUTES); \ |
| 2072 |
|
case 42: return (RRTYPE_APL_ATTRIBUTES); \ |
| 2073 |
|
case 43: return (RRTYPE_DS_ATTRIBUTES); \ |
| 2080 |
|
case 50: return (RRTYPE_NSEC3_ATTRIBUTES); \ |
| 2081 |
|
case 51: return (RRTYPE_NSEC3PARAM_ATTRIBUTES); \ |
| 2082 |
|
case 52: return (RRTYPE_TLSA_ATTRIBUTES); \ |
| 2083 |
+ |
case 53: return (RRTYPE_SMIMEA_ATTRIBUTES); \ |
| 2084 |
|
case 55: return (RRTYPE_HIP_ATTRIBUTES); \ |
| 2085 |
+ |
case 56: return (RRTYPE_NINFO_ATTRIBUTES); \ |
| 2086 |
+ |
case 57: return (RRTYPE_RKEY_ATTRIBUTES); \ |
| 2087 |
+ |
case 58: return (RRTYPE_TALINK_ATTRIBUTES); \ |
| 2088 |
+ |
case 59: return (RRTYPE_CDS_ATTRIBUTES); \ |
| 2089 |
+ |
case 60: return (RRTYPE_CDNSKEY_ATTRIBUTES); \ |
| 2090 |
+ |
case 61: return (RRTYPE_OPENPGPKEY_ATTRIBUTES); \ |
| 2091 |
+ |
case 62: return (RRTYPE_CSYNC_ATTRIBUTES); \ |
| 2092 |
|
case 99: return (RRTYPE_SPF_ATTRIBUTES); \ |
| 2093 |
|
case 100: return (DNS_RDATATYPEATTR_RESERVED); \ |
| 2094 |
|
case 101: return (DNS_RDATATYPEATTR_RESERVED); \ |
| 2095 |
|
case 102: return (DNS_RDATATYPEATTR_RESERVED); \ |
| 2096 |
|
case 103: return (RRTYPE_UNSPEC_ATTRIBUTES); \ |
| 2097 |
+ |
case 104: return (RRTYPE_NID_ATTRIBUTES); \ |
| 2098 |
+ |
case 105: return (RRTYPE_L32_ATTRIBUTES); \ |
| 2099 |
+ |
case 106: return (RRTYPE_L64_ATTRIBUTES); \ |
| 2100 |
+ |
case 107: return (RRTYPE_LP_ATTRIBUTES); \ |
| 2101 |
+ |
case 108: return (RRTYPE_EUI48_ATTRIBUTES); \ |
| 2102 |
+ |
case 109: return (RRTYPE_EUI64_ATTRIBUTES); \ |
| 2103 |
|
case 249: return (RRTYPE_TKEY_ATTRIBUTES); \ |
| 2104 |
|
case 250: return (RRTYPE_TSIG_ATTRIBUTES); \ |
| 2105 |
|
case 251: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ |
| 2107 |
|
case 253: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ |
| 2108 |
|
case 254: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ |
| 2109 |
|
case 255: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ |
| 2110 |
+ |
case 256: return (RRTYPE_URI_ATTRIBUTES); \ |
| 2111 |
+ |
case 257: return (RRTYPE_CAA_ATTRIBUTES); \ |
| 2112 |
+ |
case 258: return (RRTYPE_AVC_ATTRIBUTES); \ |
| 2113 |
+ |
case 32768: return (RRTYPE_TA_ATTRIBUTES); \ |
| 2114 |
|
case 32769: return (RRTYPE_DLV_ATTRIBUTES); \ |
| 2115 |
|
case 65533: return (RRTYPE_KEYDATA_ATTRIBUTES); \ |
| 2116 |
|
} |
| 2156 |
|
case 37: return (str_totext("CERT", target)); \ |
| 2157 |
|
case 38: return (str_totext("A6", target)); \ |
| 2158 |
|
case 39: return (str_totext("DNAME", target)); \ |
| 2159 |
+ |
case 40: return (str_totext("SINK", target)); \ |
| 2160 |
|
case 41: return (str_totext("OPT", target)); \ |
| 2161 |
|
case 42: return (str_totext("APL", target)); \ |
| 2162 |
|
case 43: return (str_totext("DS", target)); \ |
| 2169 |
|
case 50: return (str_totext("NSEC3", target)); \ |
| 2170 |
|
case 51: return (str_totext("NSEC3PARAM", target)); \ |
| 2171 |
|
case 52: return (str_totext("TLSA", target)); \ |
| 2172 |
+ |
case 53: return (str_totext("SMIMEA", target)); \ |
| 2173 |
|
case 55: return (str_totext("HIP", target)); \ |
| 2174 |
+ |
case 56: return (str_totext("NINFO", target)); \ |
| 2175 |
+ |
case 57: return (str_totext("RKEY", target)); \ |
| 2176 |
+ |
case 58: return (str_totext("TALINK", target)); \ |
| 2177 |
+ |
case 59: return (str_totext("CDS", target)); \ |
| 2178 |
+ |
case 60: return (str_totext("CDNSKEY", target)); \ |
| 2179 |
+ |
case 61: return (str_totext("OPENPGPKEY", target)); \ |
| 2180 |
+ |
case 62: return (str_totext("CSYNC", target)); \ |
| 2181 |
|
case 99: return (str_totext("SPF", target)); \ |
| 2182 |
|
case 100: return (str_totext("UINFO", target)); \ |
| 2183 |
|
case 101: return (str_totext("UID", target)); \ |
| 2184 |
|
case 102: return (str_totext("GID", target)); \ |
| 2185 |
|
case 103: return (str_totext("UNSPEC", target)); \ |
| 2186 |
+ |
case 104: return (str_totext("NID", target)); \ |
| 2187 |
+ |
case 105: return (str_totext("L32", target)); \ |
| 2188 |
+ |
case 106: return (str_totext("L64", target)); \ |
| 2189 |
+ |
case 107: return (str_totext("LP", target)); \ |
| 2190 |
+ |
case 108: return (str_totext("EUI48", target)); \ |
| 2191 |
+ |
case 109: return (str_totext("EUI64", target)); \ |
| 2192 |
|
case 249: return (str_totext("TKEY", target)); \ |
| 2193 |
|
case 250: return (str_totext("TSIG", target)); \ |
| 2194 |
|
case 251: return (str_totext("IXFR", target)); \ |
| 2196 |
|
case 253: return (str_totext("MAILB", target)); \ |
| 2197 |
|
case 254: return (str_totext("MAILA", target)); \ |
| 2198 |
|
case 255: return (str_totext("ANY", target)); \ |
| 2199 |
+ |
case 256: return (str_totext("URI", target)); \ |
| 2200 |
+ |
case 257: return (str_totext("CAA", target)); \ |
| 2201 |
+ |
case 258: return (str_totext("AVC", target)); \ |
| 2202 |
+ |
case 32768: return (str_totext("TA", target)); \ |
| 2203 |
|
case 32769: return (str_totext("DLV", target)); \ |
| 1911 |
– |
case 65533: return (str_totext("KEYDATA", target)); \ |
| 2204 |
|
} |
| 2205 |
|
#endif /* DNS_CODE_H */ |
