lib/bind/dns/code.h

   1 /* $FreeBSD$ */
   2
   3 /*
   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
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  12  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  13  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  14  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  15  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  16  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 /***************
  21  ***************
  22  ***************   THIS FILE IS AUTOMATICALLY GENERATED BY gen.c.
  23  ***************   DO NOT EDIT!
  24  ***************
  25  ***************/
  26
  27 /*! \file */
  28
  29 #ifndef DNS_CODE_H
  30 #define DNS_CODE_H 1
  31
  32 #include <isc/boolean.h>
  33 #include <isc/result.h>
  34
  35 #include <dns/name.h>
  36
  37 #include "rdata/in_1/a_1.c"
  38 #include "rdata/ch_3/a_1.c"
  39 #include "rdata/hs_4/a_1.c"
  40 #include "rdata/generic/ns_2.c"
  41 #include "rdata/generic/md_3.c"
  42 #include "rdata/generic/mf_4.c"
  43 #include "rdata/generic/cname_5.c"
  44 #include "rdata/generic/soa_6.c"
  45 #include "rdata/generic/mb_7.c"
  46 #include "rdata/generic/mg_8.c"
  47 #include "rdata/generic/mr_9.c"
  48 #include "rdata/generic/null_10.c"
  49 #include "rdata/in_1/wks_11.c"
  50 #include "rdata/generic/ptr_12.c"
  51 #include "rdata/generic/hinfo_13.c"
  52 #include "rdata/generic/minfo_14.c"
  53 #include "rdata/generic/mx_15.c"
  54 #include "rdata/generic/txt_16.c"
  55 #include "rdata/generic/rp_17.c"
  56 #include "rdata/generic/afsdb_18.c"
  57 #include "rdata/generic/x25_19.c"
  58 #include "rdata/generic/isdn_20.c"
  59 #include "rdata/generic/rt_21.c"
  60 #include "rdata/in_1/nsap_22.c"
  61 #include "rdata/in_1/nsap-ptr_23.c"
  62 #include "rdata/generic/sig_24.c"
  63 #include "rdata/generic/key_25.c"
  64 #include "rdata/in_1/px_26.c"
  65 #include "rdata/generic/gpos_27.c"
  66 #include "rdata/in_1/aaaa_28.c"
  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/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"
  79 #include "rdata/generic/sshfp_44.c"
  80 #include "rdata/generic/ipseckey_45.c"
  81 #include "rdata/generic/rrsig_46.c"
  82 #include "rdata/generic/nsec_47.c"
  83 #include "rdata/generic/dnskey_48.c"
  84 #include "rdata/in_1/dhcid_49.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
 114
 115
 116 #define FROMTEXTSWITCH \
 117         switch (type) { \
 118         case 1: switch (rdclass) { \
 119                 case 1: result = fromtext_in_a(rdclass, type, lexer, origin, options, target, callbacks); break; \
 120                 case 3: result = fromtext_ch_a(rdclass, type, lexer, origin, options, target, callbacks); break; \
 121                 case 4: result = fromtext_hs_a(rdclass, type, lexer, origin, options, target, callbacks); break; \
 122                 default: result = DNS_R_UNKNOWN; break; \
 123                 } \
 124                 break; \
 125         case 2: result = fromtext_ns(rdclass, type, lexer, origin, options, target, callbacks); break; \
 126         case 3: result = fromtext_md(rdclass, type, lexer, origin, options, target, callbacks); break; \
 127         case 4: result = fromtext_mf(rdclass, type, lexer, origin, options, target, callbacks); break; \
 128         case 5: result = fromtext_cname(rdclass, type, lexer, origin, options, target, callbacks); break; \
 129         case 6: result = fromtext_soa(rdclass, type, lexer, origin, options, target, callbacks); break; \
 130         case 7: result = fromtext_mb(rdclass, type, lexer, origin, options, target, callbacks); break; \
 131         case 8: result = fromtext_mg(rdclass, type, lexer, origin, options, target, callbacks); break; \
 132         case 9: result = fromtext_mr(rdclass, type, lexer, origin, options, target, callbacks); break; \
 133         case 10: result = fromtext_null(rdclass, type, lexer, origin, options, target, callbacks); break; \
 134         case 11: switch (rdclass) { \
 135                 case 1: result = fromtext_in_wks(rdclass, type, lexer, origin, options, target, callbacks); break; \
 136                 default: result = DNS_R_UNKNOWN; break; \
 137                 } \
 138                 break; \
 139         case 12: result = fromtext_ptr(rdclass, type, lexer, origin, options, target, callbacks); break; \
 140         case 13: result = fromtext_hinfo(rdclass, type, lexer, origin, options, target, callbacks); break; \
 141         case 14: result = fromtext_minfo(rdclass, type, lexer, origin, options, target, callbacks); break; \
 142         case 15: result = fromtext_mx(rdclass, type, lexer, origin, options, target, callbacks); break; \
 143         case 16: result = fromtext_txt(rdclass, type, lexer, origin, options, target, callbacks); break; \
 144         case 17: result = fromtext_rp(rdclass, type, lexer, origin, options, target, callbacks); break; \
 145         case 18: result = fromtext_afsdb(rdclass, type, lexer, origin, options, target, callbacks); break; \
 146         case 19: result = fromtext_x25(rdclass, type, lexer, origin, options, target, callbacks); break; \
 147         case 20: result = fromtext_isdn(rdclass, type, lexer, origin, options, target, callbacks); break; \
 148         case 21: result = fromtext_rt(rdclass, type, lexer, origin, options, target, callbacks); break; \
 149         case 22: switch (rdclass) { \
 150                 case 1: result = fromtext_in_nsap(rdclass, type, lexer, origin, options, target, callbacks); break; \
 151                 default: result = DNS_R_UNKNOWN; break; \
 152                 } \
 153                 break; \
 154         case 23: switch (rdclass) { \
 155                 case 1: result = fromtext_in_nsap_ptr(rdclass, type, lexer, origin, options, target, callbacks); break; \
 156                 default: result = DNS_R_UNKNOWN; break; \
 157                 } \
 158                 break; \
 159         case 24: result = fromtext_sig(rdclass, type, lexer, origin, options, target, callbacks); break; \
 160         case 25: result = fromtext_key(rdclass, type, lexer, origin, options, target, callbacks); break; \
 161         case 26: switch (rdclass) { \
 162                 case 1: result = fromtext_in_px(rdclass, type, lexer, origin, options, target, callbacks); break; \
 163                 default: result = DNS_R_UNKNOWN; break; \
 164                 } \
 165                 break; \
 166         case 27: result = fromtext_gpos(rdclass, type, lexer, origin, options, target, callbacks); break; \
 167         case 28: switch (rdclass) { \
 168                 case 1: result = fromtext_in_aaaa(rdclass, type, lexer, origin, options, target, callbacks); break; \
 169                 default: result = DNS_R_UNKNOWN; break; \
 170                 } \
 171                 break; \
 172         case 29: result = fromtext_loc(rdclass, type, lexer, origin, options, target, callbacks); break; \
 173         case 30: result = fromtext_nxt(rdclass, type, lexer, origin, options, target, callbacks); break; \
 174         case 33: switch (rdclass) { \
 175                 case 1: result = fromtext_in_srv(rdclass, type, lexer, origin, options, target, callbacks); break; \
 176                 default: result = DNS_R_UNKNOWN; break; \
 177                 } \
 178                 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; \
 183                 } \
 184                 break; \
 185         case 37: result = fromtext_cert(rdclass, type, lexer, origin, options, target, callbacks); break; \
 186         case 38: switch (rdclass) { \
 187                 case 1: result = fromtext_in_a6(rdclass, type, lexer, origin, options, target, callbacks); break; \
 188                 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; \
 196                 default: result = DNS_R_UNKNOWN; break; \
 197                 } \
 198                 break; \
 199         case 43: result = fromtext_ds(rdclass, type, lexer, origin, options, target, callbacks); break; \
 200         case 44: result = fromtext_sshfp(rdclass, type, lexer, origin, options, target, callbacks); break; \
 201         case 45: result = fromtext_ipseckey(rdclass, type, lexer, origin, options, target, callbacks); break; \
 202         case 46: result = fromtext_rrsig(rdclass, type, lexer, origin, options, target, callbacks); break; \
 203         case 47: result = fromtext_nsec(rdclass, type, lexer, origin, options, target, callbacks); break; \
 204         case 48: result = fromtext_dnskey(rdclass, type, lexer, origin, options, target, callbacks); break; \
 205         case 49: switch (rdclass) { \
 206                 case 1: result = fromtext_in_dhcid(rdclass, type, lexer, origin, options, target, callbacks); break; \
 207                 default: result = DNS_R_UNKNOWN; break; \
 208                 } \
 209                 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; \
 243         }
 244
 245 #define TOTEXTSWITCH \
 246         switch (rdata->type) { \
 247         case 1: switch (rdata->rdclass) { \
 248                 case 1: result = totext_in_a(rdata, tctx, target); break; \
 249                 case 3: result = totext_ch_a(rdata, tctx, target); break; \
 250                 case 4: result = totext_hs_a(rdata, tctx, target); break; \
 251                 default: use_default = ISC_TRUE; break; \
 252                 } \
 253                 break; \
 254         case 2: result = totext_ns(rdata, tctx, target); break; \
 255         case 3: result = totext_md(rdata, tctx, target); break; \
 256         case 4: result = totext_mf(rdata, tctx, target); break; \
 257         case 5: result = totext_cname(rdata, tctx, target); break; \
 258         case 6: result = totext_soa(rdata, tctx, target); break; \
 259         case 7: result = totext_mb(rdata, tctx, target); break; \
 260         case 8: result = totext_mg(rdata, tctx, target); break; \
 261         case 9: result = totext_mr(rdata, tctx, target); break; \
 262         case 10: result = totext_null(rdata, tctx, target); break; \
 263         case 11: switch (rdata->rdclass) { \
 264                 case 1: result = totext_in_wks(rdata, tctx, target); break; \
 265                 default: use_default = ISC_TRUE; break; \
 266                 } \
 267                 break; \
 268         case 12: result = totext_ptr(rdata, tctx, target); break; \
 269         case 13: result = totext_hinfo(rdata, tctx, target); break; \
 270         case 14: result = totext_minfo(rdata, tctx, target); break; \
 271         case 15: result = totext_mx(rdata, tctx, target); break; \
 272         case 16: result = totext_txt(rdata, tctx, target); break; \
 273         case 17: result = totext_rp(rdata, tctx, target); break; \
 274         case 18: result = totext_afsdb(rdata, tctx, target); break; \
 275         case 19: result = totext_x25(rdata, tctx, target); break; \
 276         case 20: result = totext_isdn(rdata, tctx, target); break; \
 277         case 21: result = totext_rt(rdata, tctx, target); break; \
 278         case 22: switch (rdata->rdclass) { \
 279                 case 1: result = totext_in_nsap(rdata, tctx, target); break; \
 280                 default: use_default = ISC_TRUE; break; \
 281                 } \
 282                 break; \
 283         case 23: switch (rdata->rdclass) { \
 284                 case 1: result = totext_in_nsap_ptr(rdata, tctx, target); break; \
 285                 default: use_default = ISC_TRUE; break; \
 286                 } \
 287                 break; \
 288         case 24: result = totext_sig(rdata, tctx, target); break; \
 289         case 25: result = totext_key(rdata, tctx, target); break; \
 290         case 26: switch (rdata->rdclass) { \
 291                 case 1: result = totext_in_px(rdata, tctx, target); break; \
 292                 default: use_default = ISC_TRUE; break; \
 293                 } \
 294                 break; \
 295         case 27: result = totext_gpos(rdata, tctx, target); break; \
 296         case 28: switch (rdata->rdclass) { \
 297                 case 1: result = totext_in_aaaa(rdata, tctx, target); break; \
 298                 default: use_default = ISC_TRUE; break; \
 299                 } \
 300                 break; \
 301         case 29: result = totext_loc(rdata, tctx, target); break; \
 302         case 30: result = totext_nxt(rdata, tctx, target); break; \
 303         case 33: switch (rdata->rdclass) { \
 304                 case 1: result = totext_in_srv(rdata, tctx, target); break; \
 305                 default: use_default = ISC_TRUE; break; \
 306                 } \
 307                 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; \
 312                 } \
 313                 break; \
 314         case 37: result = totext_cert(rdata, tctx, target); break; \
 315         case 38: switch (rdata->rdclass) { \
 316                 case 1: result = totext_in_a6(rdata, tctx, target); break; \
 317                 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; \
 325                 default: use_default = ISC_TRUE; break; \
 326                 } \
 327                 break; \
 328         case 43: result = totext_ds(rdata, tctx, target); break; \
 329         case 44: result = totext_sshfp(rdata, tctx, target); break; \
 330         case 45: result = totext_ipseckey(rdata, tctx, target); break; \
 331         case 46: result = totext_rrsig(rdata, tctx, target); break; \
 332         case 47: result = totext_nsec(rdata, tctx, target); break; \
 333         case 48: result = totext_dnskey(rdata, tctx, target); break; \
 334         case 49: switch (rdata->rdclass) { \
 335                 case 1: result = totext_in_dhcid(rdata, tctx, target); break; \
 336                 default: use_default = ISC_TRUE; break; \
 337                 } \
 338                 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; \
 372         }
 373
 374 #define FROMWIRESWITCH \
 375         switch (type) { \
 376         case 1: switch (rdclass) { \
 377                 case 1: result = fromwire_in_a(rdclass, type, source, dctx, options, target); break; \
 378                 case 3: result = fromwire_ch_a(rdclass, type, source, dctx, options, target); break; \
 379                 case 4: result = fromwire_hs_a(rdclass, type, source, dctx, options, target); break; \
 380                 default: use_default = ISC_TRUE; break; \
 381                 } \
 382                 break; \
 383         case 2: result = fromwire_ns(rdclass, type, source, dctx, options, target); break; \
 384         case 3: result = fromwire_md(rdclass, type, source, dctx, options, target); break; \
 385         case 4: result = fromwire_mf(rdclass, type, source, dctx, options, target); break; \
 386         case 5: result = fromwire_cname(rdclass, type, source, dctx, options, target); break; \
 387         case 6: result = fromwire_soa(rdclass, type, source, dctx, options, target); break; \
 388         case 7: result = fromwire_mb(rdclass, type, source, dctx, options, target); break; \
 389         case 8: result = fromwire_mg(rdclass, type, source, dctx, options, target); break; \
 390         case 9: result = fromwire_mr(rdclass, type, source, dctx, options, target); break; \
 391         case 10: result = fromwire_null(rdclass, type, source, dctx, options, target); break; \
 392         case 11: switch (rdclass) { \
 393                 case 1: result = fromwire_in_wks(rdclass, type, source, dctx, options, target); break; \
 394                 default: use_default = ISC_TRUE; break; \
 395                 } \
 396                 break; \
 397         case 12: result = fromwire_ptr(rdclass, type, source, dctx, options, target); break; \
 398         case 13: result = fromwire_hinfo(rdclass, type, source, dctx, options, target); break; \
 399         case 14: result = fromwire_minfo(rdclass, type, source, dctx, options, target); break; \
 400         case 15: result = fromwire_mx(rdclass, type, source, dctx, options, target); break; \
 401         case 16: result = fromwire_txt(rdclass, type, source, dctx, options, target); break; \
 402         case 17: result = fromwire_rp(rdclass, type, source, dctx, options, target); break; \
 403         case 18: result = fromwire_afsdb(rdclass, type, source, dctx, options, target); break; \
 404         case 19: result = fromwire_x25(rdclass, type, source, dctx, options, target); break; \
 405         case 20: result = fromwire_isdn(rdclass, type, source, dctx, options, target); break; \
 406         case 21: result = fromwire_rt(rdclass, type, source, dctx, options, target); break; \
 407         case 22: switch (rdclass) { \
 408                 case 1: result = fromwire_in_nsap(rdclass, type, source, dctx, options, target); break; \
 409                 default: use_default = ISC_TRUE; break; \
 410                 } \
 411                 break; \
 412         case 23: switch (rdclass) { \
 413                 case 1: result = fromwire_in_nsap_ptr(rdclass, type, source, dctx, options, target); break; \
 414                 default: use_default = ISC_TRUE; break; \
 415                 } \
 416                 break; \
 417         case 24: result = fromwire_sig(rdclass, type, source, dctx, options, target); break; \
 418         case 25: result = fromwire_key(rdclass, type, source, dctx, options, target); break; \
 419         case 26: switch (rdclass) { \
 420                 case 1: result = fromwire_in_px(rdclass, type, source, dctx, options, target); break; \
 421                 default: use_default = ISC_TRUE; break; \
 422                 } \
 423                 break; \
 424         case 27: result = fromwire_gpos(rdclass, type, source, dctx, options, target); break; \
 425         case 28: switch (rdclass) { \
 426                 case 1: result = fromwire_in_aaaa(rdclass, type, source, dctx, options, target); break; \
 427                 default: use_default = ISC_TRUE; break; \
 428                 } \
 429                 break; \
 430         case 29: result = fromwire_loc(rdclass, type, source, dctx, options, target); break; \
 431         case 30: result = fromwire_nxt(rdclass, type, source, dctx, options, target); break; \
 432         case 33: switch (rdclass) { \
 433                 case 1: result = fromwire_in_srv(rdclass, type, source, dctx, options, target); break; \
 434                 default: use_default = ISC_TRUE; break; \
 435                 } \
 436                 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; \
 441                 } \
 442                 break; \
 443         case 37: result = fromwire_cert(rdclass, type, source, dctx, options, target); break; \
 444         case 38: switch (rdclass) { \
 445                 case 1: result = fromwire_in_a6(rdclass, type, source, dctx, options, target); break; \
 446                 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; \
 454                 default: use_default = ISC_TRUE; break; \
 455                 } \
 456                 break; \
 457         case 43: result = fromwire_ds(rdclass, type, source, dctx, options, target); break; \
 458         case 44: result = fromwire_sshfp(rdclass, type, source, dctx, options, target); break; \
 459         case 45: result = fromwire_ipseckey(rdclass, type, source, dctx, options, target); break; \
 460         case 46: result = fromwire_rrsig(rdclass, type, source, dctx, options, target); break; \
 461         case 47: result = fromwire_nsec(rdclass, type, source, dctx, options, target); break; \
 462         case 48: result = fromwire_dnskey(rdclass, type, source, dctx, options, target); break; \
 463         case 49: switch (rdclass) { \
 464                 case 1: result = fromwire_in_dhcid(rdclass, type, source, dctx, options, target); break; \
 465                 default: use_default = ISC_TRUE; break; \
 466                 } \
 467                 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; \
 501         }
 502
 503 #define TOWIRESWITCH \
 504         switch (rdata->type) { \
 505         case 1: switch (rdata->rdclass) { \
 506                 case 1: result = towire_in_a(rdata, cctx, target); break; \
 507                 case 3: result = towire_ch_a(rdata, cctx, target); break; \
 508                 case 4: result = towire_hs_a(rdata, cctx, target); break; \
 509                 default: use_default = ISC_TRUE; break; \
 510                 } \
 511                 break; \
 512         case 2: result = towire_ns(rdata, cctx, target); break; \
 513         case 3: result = towire_md(rdata, cctx, target); break; \
 514         case 4: result = towire_mf(rdata, cctx, target); break; \
 515         case 5: result = towire_cname(rdata, cctx, target); break; \
 516         case 6: result = towire_soa(rdata, cctx, target); break; \
 517         case 7: result = towire_mb(rdata, cctx, target); break; \
 518         case 8: result = towire_mg(rdata, cctx, target); break; \
 519         case 9: result = towire_mr(rdata, cctx, target); break; \
 520         case 10: result = towire_null(rdata, cctx, target); break; \
 521         case 11: switch (rdata->rdclass) { \
 522                 case 1: result = towire_in_wks(rdata, cctx, target); break; \
 523                 default: use_default = ISC_TRUE; break; \
 524                 } \
 525                 break; \
 526         case 12: result = towire_ptr(rdata, cctx, target); break; \
 527         case 13: result = towire_hinfo(rdata, cctx, target); break; \
 528         case 14: result = towire_minfo(rdata, cctx, target); break; \
 529         case 15: result = towire_mx(rdata, cctx, target); break; \
 530         case 16: result = towire_txt(rdata, cctx, target); break; \
 531         case 17: result = towire_rp(rdata, cctx, target); break; \
 532         case 18: result = towire_afsdb(rdata, cctx, target); break; \
 533         case 19: result = towire_x25(rdata, cctx, target); break; \
 534         case 20: result = towire_isdn(rdata, cctx, target); break; \
 535         case 21: result = towire_rt(rdata, cctx, target); break; \
 536         case 22: switch (rdata->rdclass) { \
 537                 case 1: result = towire_in_nsap(rdata, cctx, target); break; \
 538                 default: use_default = ISC_TRUE; break; \
 539                 } \
 540                 break; \
 541         case 23: switch (rdata->rdclass) { \
 542                 case 1: result = towire_in_nsap_ptr(rdata, cctx, target); break; \
 543                 default: use_default = ISC_TRUE; break; \
 544                 } \
 545                 break; \
 546         case 24: result = towire_sig(rdata, cctx, target); break; \
 547         case 25: result = towire_key(rdata, cctx, target); break; \
 548         case 26: switch (rdata->rdclass) { \
 549                 case 1: result = towire_in_px(rdata, cctx, target); break; \
 550                 default: use_default = ISC_TRUE; break; \
 551                 } \
 552                 break; \
 553         case 27: result = towire_gpos(rdata, cctx, target); break; \
 554         case 28: switch (rdata->rdclass) { \
 555                 case 1: result = towire_in_aaaa(rdata, cctx, target); break; \
 556                 default: use_default = ISC_TRUE; break; \
 557                 } \
 558                 break; \
 559         case 29: result = towire_loc(rdata, cctx, target); break; \
 560         case 30: result = towire_nxt(rdata, cctx, target); break; \
 561         case 33: switch (rdata->rdclass) { \
 562                 case 1: result = towire_in_srv(rdata, cctx, target); break; \
 563                 default: use_default = ISC_TRUE; break; \
 564                 } \
 565                 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; \
 570                 } \
 571                 break; \
 572         case 37: result = towire_cert(rdata, cctx, target); break; \
 573         case 38: switch (rdata->rdclass) { \
 574                 case 1: result = towire_in_a6(rdata, cctx, target); break; \
 575                 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; \
 583                 default: use_default = ISC_TRUE; break; \
 584                 } \
 585                 break; \
 586         case 43: result = towire_ds(rdata, cctx, target); break; \
 587         case 44: result = towire_sshfp(rdata, cctx, target); break; \
 588         case 45: result = towire_ipseckey(rdata, cctx, target); break; \
 589         case 46: result = towire_rrsig(rdata, cctx, target); break; \
 590         case 47: result = towire_nsec(rdata, cctx, target); break; \
 591         case 48: result = towire_dnskey(rdata, cctx, target); break; \
 592         case 49: switch (rdata->rdclass) { \
 593                 case 1: result = towire_in_dhcid(rdata, cctx, target); break; \
 594                 default: use_default = ISC_TRUE; break; \
 595                 } \
 596                 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; \
 630         }
 631
 632 #define COMPARESWITCH \
 633         switch (rdata1->type) { \
 634         case 1: switch (rdata1->rdclass) { \
 635                 case 1: result = compare_in_a(rdata1, rdata2); break; \
 636                 case 3: result = compare_ch_a(rdata1, rdata2); break; \
 637                 case 4: result = compare_hs_a(rdata1, rdata2); break; \
 638                 default: use_default = ISC_TRUE; break; \
 639                 } \
 640                 break; \
 641         case 2: result = compare_ns(rdata1, rdata2); break; \
 642         case 3: result = compare_md(rdata1, rdata2); break; \
 643         case 4: result = compare_mf(rdata1, rdata2); break; \
 644         case 5: result = compare_cname(rdata1, rdata2); break; \
 645         case 6: result = compare_soa(rdata1, rdata2); break; \
 646         case 7: result = compare_mb(rdata1, rdata2); break; \
 647         case 8: result = compare_mg(rdata1, rdata2); break; \
 648         case 9: result = compare_mr(rdata1, rdata2); break; \
 649         case 10: result = compare_null(rdata1, rdata2); break; \
 650         case 11: switch (rdata1->rdclass) { \
 651                 case 1: result = compare_in_wks(rdata1, rdata2); break; \
 652                 default: use_default = ISC_TRUE; break; \
 653                 } \
 654                 break; \
 655         case 12: result = compare_ptr(rdata1, rdata2); break; \
 656         case 13: result = compare_hinfo(rdata1, rdata2); break; \
 657         case 14: result = compare_minfo(rdata1, rdata2); break; \
 658         case 15: result = compare_mx(rdata1, rdata2); break; \
 659         case 16: result = compare_txt(rdata1, rdata2); break; \
 660         case 17: result = compare_rp(rdata1, rdata2); break; \
 661         case 18: result = compare_afsdb(rdata1, rdata2); break; \
 662         case 19: result = compare_x25(rdata1, rdata2); break; \
 663         case 20: result = compare_isdn(rdata1, rdata2); break; \
 664         case 21: result = compare_rt(rdata1, rdata2); break; \
 665         case 22: switch (rdata1->rdclass) { \
 666                 case 1: result = compare_in_nsap(rdata1, rdata2); break; \
 667                 default: use_default = ISC_TRUE; break; \
 668                 } \
 669                 break; \
 670         case 23: switch (rdata1->rdclass) { \
 671                 case 1: result = compare_in_nsap_ptr(rdata1, rdata2); break; \
 672                 default: use_default = ISC_TRUE; break; \
 673                 } \
 674                 break; \
 675         case 24: result = compare_sig(rdata1, rdata2); break; \
 676         case 25: result = compare_key(rdata1, rdata2); break; \
 677         case 26: switch (rdata1->rdclass) { \
 678                 case 1: result = compare_in_px(rdata1, rdata2); break; \
 679                 default: use_default = ISC_TRUE; break; \
 680                 } \
 681                 break; \
 682         case 27: result = compare_gpos(rdata1, rdata2); break; \
 683         case 28: switch (rdata1->rdclass) { \
 684                 case 1: result = compare_in_aaaa(rdata1, rdata2); break; \
 685                 default: use_default = ISC_TRUE; break; \
 686                 } \
 687                 break; \
 688         case 29: result = compare_loc(rdata1, rdata2); break; \
 689         case 30: result = compare_nxt(rdata1, rdata2); break; \
 690         case 33: switch (rdata1->rdclass) { \
 691                 case 1: result = compare_in_srv(rdata1, rdata2); break; \
 692                 default: use_default = ISC_TRUE; break; \
 693                 } \
 694                 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; \
 699                 } \
 700                 break; \
 701         case 37: result = compare_cert(rdata1, rdata2); break; \
 702         case 38: switch (rdata1->rdclass) { \
 703                 case 1: result = compare_in_a6(rdata1, rdata2); break; \
 704                 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; \
 712                 default: use_default = ISC_TRUE; break; \
 713                 } \
 714                 break; \
 715         case 43: result = compare_ds(rdata1, rdata2); break; \
 716         case 44: result = compare_sshfp(rdata1, rdata2); break; \
 717         case 45: result = compare_ipseckey(rdata1, rdata2); break; \
 718         case 46: result = compare_rrsig(rdata1, rdata2); break; \
 719         case 47: result = compare_nsec(rdata1, rdata2); break; \
 720         case 48: result = compare_dnskey(rdata1, rdata2); break; \
 721         case 49: switch (rdata1->rdclass) { \
 722                 case 1: result = compare_in_dhcid(rdata1, rdata2); break; \
 723                 default: use_default = ISC_TRUE; break; \
 724                 } \
 725                 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; \
 759         }
 760
 761 #define CASECOMPARESWITCH \
 762         switch (rdata1->type) { \
 763         case 1: switch (rdata1->rdclass) { \
 764                 case 1: result = casecompare_in_a(rdata1, rdata2); break; \
 765                 case 3: result = casecompare_ch_a(rdata1, rdata2); break; \
 766                 case 4: result = casecompare_hs_a(rdata1, rdata2); break; \
 767                 default: use_default = ISC_TRUE; break; \
 768                 } \
 769                 break; \
 770         case 2: result = casecompare_ns(rdata1, rdata2); break; \
 771         case 3: result = casecompare_md(rdata1, rdata2); break; \
 772         case 4: result = casecompare_mf(rdata1, rdata2); break; \
 773         case 5: result = casecompare_cname(rdata1, rdata2); break; \
 774         case 6: result = casecompare_soa(rdata1, rdata2); break; \
 775         case 7: result = casecompare_mb(rdata1, rdata2); break; \
 776         case 8: result = casecompare_mg(rdata1, rdata2); break; \
 777         case 9: result = casecompare_mr(rdata1, rdata2); break; \
 778         case 10: result = casecompare_null(rdata1, rdata2); break; \
 779         case 11: switch (rdata1->rdclass) { \
 780                 case 1: result = casecompare_in_wks(rdata1, rdata2); break; \
 781                 default: use_default = ISC_TRUE; break; \
 782                 } \
 783                 break; \
 784         case 12: result = casecompare_ptr(rdata1, rdata2); break; \
 785         case 13: result = casecompare_hinfo(rdata1, rdata2); break; \
 786         case 14: result = casecompare_minfo(rdata1, rdata2); break; \
 787         case 15: result = casecompare_mx(rdata1, rdata2); break; \
 788         case 16: result = casecompare_txt(rdata1, rdata2); break; \
 789         case 17: result = casecompare_rp(rdata1, rdata2); break; \
 790         case 18: result = casecompare_afsdb(rdata1, rdata2); break; \
 791         case 19: result = casecompare_x25(rdata1, rdata2); break; \
 792         case 20: result = casecompare_isdn(rdata1, rdata2); break; \
 793         case 21: result = casecompare_rt(rdata1, rdata2); break; \
 794         case 22: switch (rdata1->rdclass) { \
 795                 case 1: result = casecompare_in_nsap(rdata1, rdata2); break; \
 796                 default: use_default = ISC_TRUE; break; \
 797                 } \
 798                 break; \
 799         case 23: switch (rdata1->rdclass) { \
 800                 case 1: result = casecompare_in_nsap_ptr(rdata1, rdata2); break; \
 801                 default: use_default = ISC_TRUE; break; \
 802                 } \
 803                 break; \
 804         case 24: result = casecompare_sig(rdata1, rdata2); break; \
 805         case 25: result = casecompare_key(rdata1, rdata2); break; \
 806         case 26: switch (rdata1->rdclass) { \
 807                 case 1: result = casecompare_in_px(rdata1, rdata2); break; \
 808                 default: use_default = ISC_TRUE; break; \
 809                 } \
 810                 break; \
 811         case 27: result = casecompare_gpos(rdata1, rdata2); break; \
 812         case 28: switch (rdata1->rdclass) { \
 813                 case 1: result = casecompare_in_aaaa(rdata1, rdata2); break; \
 814                 default: use_default = ISC_TRUE; break; \
 815                 } \
 816                 break; \
 817         case 29: result = casecompare_loc(rdata1, rdata2); break; \
 818         case 30: result = casecompare_nxt(rdata1, rdata2); break; \
 819         case 33: switch (rdata1->rdclass) { \
 820                 case 1: result = casecompare_in_srv(rdata1, rdata2); break; \
 821                 default: use_default = ISC_TRUE; break; \
 822                 } \
 823                 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; \
 828                 } \
 829                 break; \
 830         case 37: result = casecompare_cert(rdata1, rdata2); break; \
 831         case 38: switch (rdata1->rdclass) { \
 832                 case 1: result = casecompare_in_a6(rdata1, rdata2); break; \
 833                 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; \
 841                 default: use_default = ISC_TRUE; break; \
 842                 } \
 843                 break; \
 844         case 43: result = casecompare_ds(rdata1, rdata2); break; \
 845         case 44: result = casecompare_sshfp(rdata1, rdata2); break; \
 846         case 45: result = casecompare_ipseckey(rdata1, rdata2); break; \
 847         case 46: result = casecompare_rrsig(rdata1, rdata2); break; \
 848         case 47: result = casecompare_nsec(rdata1, rdata2); break; \
 849         case 48: result = casecompare_dnskey(rdata1, rdata2); break; \
 850         case 49: switch (rdata1->rdclass) { \
 851                 case 1: result = casecompare_in_dhcid(rdata1, rdata2); break; \
 852                 default: use_default = ISC_TRUE; break; \
 853                 } \
 854                 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; \
 888         }
 889
 890 #define FROMSTRUCTSWITCH \
 891         switch (type) { \
 892         case 1: switch (rdclass) { \
 893                 case 1: result = fromstruct_in_a(rdclass, type, source, target); break; \
 894                 case 3: result = fromstruct_ch_a(rdclass, type, source, target); break; \
 895                 case 4: result = fromstruct_hs_a(rdclass, type, source, target); break; \
 896                 default: use_default = ISC_TRUE; break; \
 897                 } \
 898                 break; \
 899         case 2: result = fromstruct_ns(rdclass, type, source, target); break; \
 900         case 3: result = fromstruct_md(rdclass, type, source, target); break; \
 901         case 4: result = fromstruct_mf(rdclass, type, source, target); break; \
 902         case 5: result = fromstruct_cname(rdclass, type, source, target); break; \
 903         case 6: result = fromstruct_soa(rdclass, type, source, target); break; \
 904         case 7: result = fromstruct_mb(rdclass, type, source, target); break; \
 905         case 8: result = fromstruct_mg(rdclass, type, source, target); break; \
 906         case 9: result = fromstruct_mr(rdclass, type, source, target); break; \
 907         case 10: result = fromstruct_null(rdclass, type, source, target); break; \
 908         case 11: switch (rdclass) { \
 909                 case 1: result = fromstruct_in_wks(rdclass, type, source, target); break; \
 910                 default: use_default = ISC_TRUE; break; \
 911                 } \
 912                 break; \
 913         case 12: result = fromstruct_ptr(rdclass, type, source, target); break; \
 914         case 13: result = fromstruct_hinfo(rdclass, type, source, target); break; \
 915         case 14: result = fromstruct_minfo(rdclass, type, source, target); break; \
 916         case 15: result = fromstruct_mx(rdclass, type, source, target); break; \
 917         case 16: result = fromstruct_txt(rdclass, type, source, target); break; \
 918         case 17: result = fromstruct_rp(rdclass, type, source, target); break; \
 919         case 18: result = fromstruct_afsdb(rdclass, type, source, target); break; \
 920         case 19: result = fromstruct_x25(rdclass, type, source, target); break; \
 921         case 20: result = fromstruct_isdn(rdclass, type, source, target); break; \
 922         case 21: result = fromstruct_rt(rdclass, type, source, target); break; \
 923         case 22: switch (rdclass) { \
 924                 case 1: result = fromstruct_in_nsap(rdclass, type, source, target); break; \
 925                 default: use_default = ISC_TRUE; break; \
 926                 } \
 927                 break; \
 928         case 23: switch (rdclass) { \
 929                 case 1: result = fromstruct_in_nsap_ptr(rdclass, type, source, target); break; \
 930                 default: use_default = ISC_TRUE; break; \
 931                 } \
 932                 break; \
 933         case 24: result = fromstruct_sig(rdclass, type, source, target); break; \
 934         case 25: result = fromstruct_key(rdclass, type, source, target); break; \
 935         case 26: switch (rdclass) { \
 936                 case 1: result = fromstruct_in_px(rdclass, type, source, target); break; \
 937                 default: use_default = ISC_TRUE; break; \
 938                 } \
 939                 break; \
 940         case 27: result = fromstruct_gpos(rdclass, type, source, target); break; \
 941         case 28: switch (rdclass) { \
 942                 case 1: result = fromstruct_in_aaaa(rdclass, type, source, target); break; \
 943                 default: use_default = ISC_TRUE; break; \
 944                 } \
 945                 break; \
 946         case 29: result = fromstruct_loc(rdclass, type, source, target); break; \
 947         case 30: result = fromstruct_nxt(rdclass, type, source, target); break; \
 948         case 33: switch (rdclass) { \
 949                 case 1: result = fromstruct_in_srv(rdclass, type, source, target); break; \
 950                 default: use_default = ISC_TRUE; break; \
 951                 } \
 952                 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; \
 957                 } \
 958                 break; \
 959         case 37: result = fromstruct_cert(rdclass, type, source, target); break; \
 960         case 38: switch (rdclass) { \
 961                 case 1: result = fromstruct_in_a6(rdclass, type, source, target); break; \
 962                 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; \
 970                 default: use_default = ISC_TRUE; break; \
 971                 } \
 972                 break; \
 973         case 43: result = fromstruct_ds(rdclass, type, source, target); break; \
 974         case 44: result = fromstruct_sshfp(rdclass, type, source, target); break; \
 975         case 45: result = fromstruct_ipseckey(rdclass, type, source, target); break; \
 976         case 46: result = fromstruct_rrsig(rdclass, type, source, target); break; \
 977         case 47: result = fromstruct_nsec(rdclass, type, source, target); break; \
 978         case 48: result = fromstruct_dnskey(rdclass, type, source, target); break; \
 979         case 49: switch (rdclass) { \
 980                 case 1: result = fromstruct_in_dhcid(rdclass, type, source, target); break; \
 981                 default: use_default = ISC_TRUE; break; \
 982                 } \
 983                 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; \
1017         }
1018
1019 #define TOSTRUCTSWITCH \
1020         switch (rdata->type) { \
1021         case 1: switch (rdata->rdclass) { \
1022                 case 1: result = tostruct_in_a(rdata, target, mctx); break; \
1023                 case 3: result = tostruct_ch_a(rdata, target, mctx); break; \
1024                 case 4: result = tostruct_hs_a(rdata, target, mctx); break; \
1025                 default: use_default = ISC_TRUE; break; \
1026                 } \
1027                 break; \
1028         case 2: result = tostruct_ns(rdata, target, mctx); break; \
1029         case 3: result = tostruct_md(rdata, target, mctx); break; \
1030         case 4: result = tostruct_mf(rdata, target, mctx); break; \
1031         case 5: result = tostruct_cname(rdata, target, mctx); break; \
1032         case 6: result = tostruct_soa(rdata, target, mctx); break; \
1033         case 7: result = tostruct_mb(rdata, target, mctx); break; \
1034         case 8: result = tostruct_mg(rdata, target, mctx); break; \
1035         case 9: result = tostruct_mr(rdata, target, mctx); break; \
1036         case 10: result = tostruct_null(rdata, target, mctx); break; \
1037         case 11: switch (rdata->rdclass) { \
1038                 case 1: result = tostruct_in_wks(rdata, target, mctx); break; \
1039                 default: use_default = ISC_TRUE; break; \
1040                 } \
1041                 break; \
1042         case 12: result = tostruct_ptr(rdata, target, mctx); break; \
1043         case 13: result = tostruct_hinfo(rdata, target, mctx); break; \
1044         case 14: result = tostruct_minfo(rdata, target, mctx); break; \
1045         case 15: result = tostruct_mx(rdata, target, mctx); break; \
1046         case 16: result = tostruct_txt(rdata, target, mctx); break; \
1047         case 17: result = tostruct_rp(rdata, target, mctx); break; \
1048         case 18: result = tostruct_afsdb(rdata, target, mctx); break; \
1049         case 19: result = tostruct_x25(rdata, target, mctx); break; \
1050         case 20: result = tostruct_isdn(rdata, target, mctx); break; \
1051         case 21: result = tostruct_rt(rdata, target, mctx); break; \
1052         case 22: switch (rdata->rdclass) { \
1053                 case 1: result = tostruct_in_nsap(rdata, target, mctx); break; \
1054                 default: use_default = ISC_TRUE; break; \
1055                 } \
1056                 break; \
1057         case 23: switch (rdata->rdclass) { \
1058                 case 1: result = tostruct_in_nsap_ptr(rdata, target, mctx); break; \
1059                 default: use_default = ISC_TRUE; break; \
1060                 } \
1061                 break; \
1062         case 24: result = tostruct_sig(rdata, target, mctx); break; \
1063         case 25: result = tostruct_key(rdata, target, mctx); break; \
1064         case 26: switch (rdata->rdclass) { \
1065                 case 1: result = tostruct_in_px(rdata, target, mctx); break; \
1066                 default: use_default = ISC_TRUE; break; \
1067                 } \
1068                 break; \
1069         case 27: result = tostruct_gpos(rdata, target, mctx); break; \
1070         case 28: switch (rdata->rdclass) { \
1071                 case 1: result = tostruct_in_aaaa(rdata, target, mctx); break; \
1072                 default: use_default = ISC_TRUE; break; \
1073                 } \
1074                 break; \
1075         case 29: result = tostruct_loc(rdata, target, mctx); break; \
1076         case 30: result = tostruct_nxt(rdata, target, mctx); break; \
1077         case 33: switch (rdata->rdclass) { \
1078                 case 1: result = tostruct_in_srv(rdata, target, mctx); break; \
1079                 default: use_default = ISC_TRUE; break; \
1080                 } \
1081                 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; \
1086                 } \
1087                 break; \
1088         case 37: result = tostruct_cert(rdata, target, mctx); break; \
1089         case 38: switch (rdata->rdclass) { \
1090                 case 1: result = tostruct_in_a6(rdata, target, mctx); break; \
1091                 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; \
1099                 default: use_default = ISC_TRUE; break; \
1100                 } \
1101                 break; \
1102         case 43: result = tostruct_ds(rdata, target, mctx); break; \
1103         case 44: result = tostruct_sshfp(rdata, target, mctx); break; \
1104         case 45: result = tostruct_ipseckey(rdata, target, mctx); break; \
1105         case 46: result = tostruct_rrsig(rdata, target, mctx); break; \
1106         case 47: result = tostruct_nsec(rdata, target, mctx); break; \
1107         case 48: result = tostruct_dnskey(rdata, target, mctx); break; \
1108         case 49: switch (rdata->rdclass) { \
1109                 case 1: result = tostruct_in_dhcid(rdata, target, mctx); break; \
1110                 default: use_default = ISC_TRUE; break; \
1111                 } \
1112                 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; \
1146         }
1147
1148 #define FREESTRUCTSWITCH \
1149         switch (common->rdtype) { \
1150         case 1: switch (common->rdclass) { \
1151                 case 1: freestruct_in_a(source); break; \
1152                 case 3: freestruct_ch_a(source); break; \
1153                 case 4: freestruct_hs_a(source); break; \
1154                 default: break; \
1155                 } \
1156                 break; \
1157         case 2: freestruct_ns(source); break; \
1158         case 3: freestruct_md(source); break; \
1159         case 4: freestruct_mf(source); break; \
1160         case 5: freestruct_cname(source); break; \
1161         case 6: freestruct_soa(source); break; \
1162         case 7: freestruct_mb(source); break; \
1163         case 8: freestruct_mg(source); break; \
1164         case 9: freestruct_mr(source); break; \
1165         case 10: freestruct_null(source); break; \
1166         case 11: switch (common->rdclass) { \
1167                 case 1: freestruct_in_wks(source); break; \
1168                 default: break; \
1169                 } \
1170                 break; \
1171         case 12: freestruct_ptr(source); break; \
1172         case 13: freestruct_hinfo(source); break; \
1173         case 14: freestruct_minfo(source); break; \
1174         case 15: freestruct_mx(source); break; \
1175         case 16: freestruct_txt(source); break; \
1176         case 17: freestruct_rp(source); break; \
1177         case 18: freestruct_afsdb(source); break; \
1178         case 19: freestruct_x25(source); break; \
1179         case 20: freestruct_isdn(source); break; \
1180         case 21: freestruct_rt(source); break; \
1181         case 22: switch (common->rdclass) { \
1182                 case 1: freestruct_in_nsap(source); break; \
1183                 default: break; \
1184                 } \
1185                 break; \
1186         case 23: switch (common->rdclass) { \
1187                 case 1: freestruct_in_nsap_ptr(source); break; \
1188                 default: break; \
1189                 } \
1190                 break; \
1191         case 24: freestruct_sig(source); break; \
1192         case 25: freestruct_key(source); break; \
1193         case 26: switch (common->rdclass) { \
1194                 case 1: freestruct_in_px(source); break; \
1195                 default: break; \
1196                 } \
1197                 break; \
1198         case 27: freestruct_gpos(source); break; \
1199         case 28: switch (common->rdclass) { \
1200                 case 1: freestruct_in_aaaa(source); break; \
1201                 default: break; \
1202                 } \
1203                 break; \
1204         case 29: freestruct_loc(source); break; \
1205         case 30: freestruct_nxt(source); break; \
1206         case 33: switch (common->rdclass) { \
1207                 case 1: freestruct_in_srv(source); break; \
1208                 default: break; \
1209                 } \
1210                 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; \
1215                 } \
1216                 break; \
1217         case 37: freestruct_cert(source); break; \
1218         case 38: switch (common->rdclass) { \
1219                 case 1: freestruct_in_a6(source); break; \
1220                 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; \
1228                 default: break; \
1229                 } \
1230                 break; \
1231         case 43: freestruct_ds(source); break; \
1232         case 44: freestruct_sshfp(source); break; \
1233         case 45: freestruct_ipseckey(source); break; \
1234         case 46: freestruct_rrsig(source); break; \
1235         case 47: freestruct_nsec(source); break; \
1236         case 48: freestruct_dnskey(source); break; \
1237         case 49: switch (common->rdclass) { \
1238                 case 1: freestruct_in_dhcid(source); break; \
1239                 default: break; \
1240                 } \
1241                 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; \
1275         }
1276
1277 #define ADDITIONALDATASWITCH \
1278         switch (rdata->type) { \
1279         case 1: switch (rdata->rdclass) { \
1280                 case 1: result = additionaldata_in_a(rdata, add, arg); break; \
1281                 case 3: result = additionaldata_ch_a(rdata, add, arg); break; \
1282                 case 4: result = additionaldata_hs_a(rdata, add, arg); break; \
1283                 default: use_default = ISC_TRUE; break; \
1284                 } \
1285                 break; \
1286         case 2: result = additionaldata_ns(rdata, add, arg); break; \
1287         case 3: result = additionaldata_md(rdata, add, arg); break; \
1288         case 4: result = additionaldata_mf(rdata, add, arg); break; \
1289         case 5: result = additionaldata_cname(rdata, add, arg); break; \
1290         case 6: result = additionaldata_soa(rdata, add, arg); break; \
1291         case 7: result = additionaldata_mb(rdata, add, arg); break; \
1292         case 8: result = additionaldata_mg(rdata, add, arg); break; \
1293         case 9: result = additionaldata_mr(rdata, add, arg); break; \
1294         case 10: result = additionaldata_null(rdata, add, arg); break; \
1295         case 11: switch (rdata->rdclass) { \
1296                 case 1: result = additionaldata_in_wks(rdata, add, arg); break; \
1297                 default: use_default = ISC_TRUE; break; \
1298                 } \
1299                 break; \
1300         case 12: result = additionaldata_ptr(rdata, add, arg); break; \
1301         case 13: result = additionaldata_hinfo(rdata, add, arg); break; \
1302         case 14: result = additionaldata_minfo(rdata, add, arg); break; \
1303         case 15: result = additionaldata_mx(rdata, add, arg); break; \
1304         case 16: result = additionaldata_txt(rdata, add, arg); break; \
1305         case 17: result = additionaldata_rp(rdata, add, arg); break; \
1306         case 18: result = additionaldata_afsdb(rdata, add, arg); break; \
1307         case 19: result = additionaldata_x25(rdata, add, arg); break; \
1308         case 20: result = additionaldata_isdn(rdata, add, arg); break; \
1309         case 21: result = additionaldata_rt(rdata, add, arg); break; \
1310         case 22: switch (rdata->rdclass) { \
1311                 case 1: result = additionaldata_in_nsap(rdata, add, arg); break; \
1312                 default: use_default = ISC_TRUE; break; \
1313                 } \
1314                 break; \
1315         case 23: switch (rdata->rdclass) { \
1316                 case 1: result = additionaldata_in_nsap_ptr(rdata, add, arg); break; \
1317                 default: use_default = ISC_TRUE; break; \
1318                 } \
1319                 break; \
1320         case 24: result = additionaldata_sig(rdata, add, arg); break; \
1321         case 25: result = additionaldata_key(rdata, add, arg); break; \
1322         case 26: switch (rdata->rdclass) { \
1323                 case 1: result = additionaldata_in_px(rdata, add, arg); break; \
1324                 default: use_default = ISC_TRUE; break; \
1325                 } \
1326                 break; \
1327         case 27: result = additionaldata_gpos(rdata, add, arg); break; \
1328         case 28: switch (rdata->rdclass) { \
1329                 case 1: result = additionaldata_in_aaaa(rdata, add, arg); break; \
1330                 default: use_default = ISC_TRUE; break; \
1331                 } \
1332                 break; \
1333         case 29: result = additionaldata_loc(rdata, add, arg); break; \
1334         case 30: result = additionaldata_nxt(rdata, add, arg); break; \
1335         case 33: switch (rdata->rdclass) { \
1336                 case 1: result = additionaldata_in_srv(rdata, add, arg); break; \
1337                 default: use_default = ISC_TRUE; break; \
1338                 } \
1339                 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; \
1344                 } \
1345                 break; \
1346         case 37: result = additionaldata_cert(rdata, add, arg); break; \
1347         case 38: switch (rdata->rdclass) { \
1348                 case 1: result = additionaldata_in_a6(rdata, add, arg); break; \
1349                 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; \
1357                 default: use_default = ISC_TRUE; break; \
1358                 } \
1359                 break; \
1360         case 43: result = additionaldata_ds(rdata, add, arg); break; \
1361         case 44: result = additionaldata_sshfp(rdata, add, arg); break; \
1362         case 45: result = additionaldata_ipseckey(rdata, add, arg); break; \
1363         case 46: result = additionaldata_rrsig(rdata, add, arg); break; \
1364         case 47: result = additionaldata_nsec(rdata, add, arg); break; \
1365         case 48: result = additionaldata_dnskey(rdata, add, arg); break; \
1366         case 49: switch (rdata->rdclass) { \
1367                 case 1: result = additionaldata_in_dhcid(rdata, add, arg); break; \
1368                 default: use_default = ISC_TRUE; break; \
1369                 } \
1370                 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; \
1404         }
1405
1406 #define DIGESTSWITCH \
1407         switch (rdata->type) { \
1408         case 1: switch (rdata->rdclass) { \
1409                 case 1: result = digest_in_a(rdata, digest, arg); break; \
1410                 case 3: result = digest_ch_a(rdata, digest, arg); break; \
1411                 case 4: result = digest_hs_a(rdata, digest, arg); break; \
1412                 default: use_default = ISC_TRUE; break; \
1413                 } \
1414                 break; \
1415         case 2: result = digest_ns(rdata, digest, arg); break; \
1416         case 3: result = digest_md(rdata, digest, arg); break; \
1417         case 4: result = digest_mf(rdata, digest, arg); break; \
1418         case 5: result = digest_cname(rdata, digest, arg); break; \
1419         case 6: result = digest_soa(rdata, digest, arg); break; \
1420         case 7: result = digest_mb(rdata, digest, arg); break; \
1421         case 8: result = digest_mg(rdata, digest, arg); break; \
1422         case 9: result = digest_mr(rdata, digest, arg); break; \
1423         case 10: result = digest_null(rdata, digest, arg); break; \
1424         case 11: switch (rdata->rdclass) { \
1425                 case 1: result = digest_in_wks(rdata, digest, arg); break; \
1426                 default: use_default = ISC_TRUE; break; \
1427                 } \
1428                 break; \
1429         case 12: result = digest_ptr(rdata, digest, arg); break; \
1430         case 13: result = digest_hinfo(rdata, digest, arg); break; \
1431         case 14: result = digest_minfo(rdata, digest, arg); break; \
1432         case 15: result = digest_mx(rdata, digest, arg); break; \
1433         case 16: result = digest_txt(rdata, digest, arg); break; \
1434         case 17: result = digest_rp(rdata, digest, arg); break; \
1435         case 18: result = digest_afsdb(rdata, digest, arg); break; \
1436         case 19: result = digest_x25(rdata, digest, arg); break; \
1437         case 20: result = digest_isdn(rdata, digest, arg); break; \
1438         case 21: result = digest_rt(rdata, digest, arg); break; \
1439         case 22: switch (rdata->rdclass) { \
1440                 case 1: result = digest_in_nsap(rdata, digest, arg); break; \
1441                 default: use_default = ISC_TRUE; break; \
1442                 } \
1443                 break; \
1444         case 23: switch (rdata->rdclass) { \
1445                 case 1: result = digest_in_nsap_ptr(rdata, digest, arg); break; \
1446                 default: use_default = ISC_TRUE; break; \
1447                 } \
1448                 break; \
1449         case 24: result = digest_sig(rdata, digest, arg); break; \
1450         case 25: result = digest_key(rdata, digest, arg); break; \
1451         case 26: switch (rdata->rdclass) { \
1452                 case 1: result = digest_in_px(rdata, digest, arg); break; \
1453                 default: use_default = ISC_TRUE; break; \
1454                 } \
1455                 break; \
1456         case 27: result = digest_gpos(rdata, digest, arg); break; \
1457         case 28: switch (rdata->rdclass) { \
1458                 case 1: result = digest_in_aaaa(rdata, digest, arg); break; \
1459                 default: use_default = ISC_TRUE; break; \
1460                 } \
1461                 break; \
1462         case 29: result = digest_loc(rdata, digest, arg); break; \
1463         case 30: result = digest_nxt(rdata, digest, arg); break; \
1464         case 33: switch (rdata->rdclass) { \
1465                 case 1: result = digest_in_srv(rdata, digest, arg); break; \
1466                 default: use_default = ISC_TRUE; break; \
1467                 } \
1468                 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; \
1473                 } \
1474                 break; \
1475         case 37: result = digest_cert(rdata, digest, arg); break; \
1476         case 38: switch (rdata->rdclass) { \
1477                 case 1: result = digest_in_a6(rdata, digest, arg); break; \
1478                 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; \
1486                 default: use_default = ISC_TRUE; break; \
1487                 } \
1488                 break; \
1489         case 43: result = digest_ds(rdata, digest, arg); break; \
1490         case 44: result = digest_sshfp(rdata, digest, arg); break; \
1491         case 45: result = digest_ipseckey(rdata, digest, arg); break; \
1492         case 46: result = digest_rrsig(rdata, digest, arg); break; \
1493         case 47: result = digest_nsec(rdata, digest, arg); break; \
1494         case 48: result = digest_dnskey(rdata, digest, arg); break; \
1495         case 49: switch (rdata->rdclass) { \
1496                 case 1: result = digest_in_dhcid(rdata, digest, arg); break; \
1497                 default: use_default = ISC_TRUE; break; \
1498                 } \
1499                 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; \
1533         }
1534
1535 #define CHECKOWNERSWITCH \
1536         switch (type) { \
1537         case 1: switch (rdclass) { \
1538                 case 1: result = checkowner_in_a(name, rdclass, type, wildcard); break; \
1539                 case 3: result = checkowner_ch_a(name, rdclass, type, wildcard); break; \
1540                 case 4: result = checkowner_hs_a(name, rdclass, type, wildcard); break; \
1541                 default: result = ISC_TRUE; break; \
1542                 } \
1543                 break; \
1544         case 2: result = checkowner_ns(name, rdclass, type, wildcard); break; \
1545         case 3: result = checkowner_md(name, rdclass, type, wildcard); break; \
1546         case 4: result = checkowner_mf(name, rdclass, type, wildcard); break; \
1547         case 5: result = checkowner_cname(name, rdclass, type, wildcard); break; \
1548         case 6: result = checkowner_soa(name, rdclass, type, wildcard); break; \
1549         case 7: result = checkowner_mb(name, rdclass, type, wildcard); break; \
1550         case 8: result = checkowner_mg(name, rdclass, type, wildcard); break; \
1551         case 9: result = checkowner_mr(name, rdclass, type, wildcard); break; \
1552         case 10: result = checkowner_null(name, rdclass, type, wildcard); break; \
1553         case 11: switch (rdclass) { \
1554                 case 1: result = checkowner_in_wks(name, rdclass, type, wildcard); break; \
1555                 default: result = ISC_TRUE; break; \
1556                 } \
1557                 break; \
1558         case 12: result = checkowner_ptr(name, rdclass, type, wildcard); break; \
1559         case 13: result = checkowner_hinfo(name, rdclass, type, wildcard); break; \
1560         case 14: result = checkowner_minfo(name, rdclass, type, wildcard); break; \
1561         case 15: result = checkowner_mx(name, rdclass, type, wildcard); break; \
1562         case 16: result = checkowner_txt(name, rdclass, type, wildcard); break; \
1563         case 17: result = checkowner_rp(name, rdclass, type, wildcard); break; \
1564         case 18: result = checkowner_afsdb(name, rdclass, type, wildcard); break; \
1565         case 19: result = checkowner_x25(name, rdclass, type, wildcard); break; \
1566         case 20: result = checkowner_isdn(name, rdclass, type, wildcard); break; \
1567         case 21: result = checkowner_rt(name, rdclass, type, wildcard); break; \
1568         case 22: switch (rdclass) { \
1569                 case 1: result = checkowner_in_nsap(name, rdclass, type, wildcard); break; \
1570                 default: result = ISC_TRUE; break; \
1571                 } \
1572                 break; \
1573         case 23: switch (rdclass) { \
1574                 case 1: result = checkowner_in_nsap_ptr(name, rdclass, type, wildcard); break; \
1575                 default: result = ISC_TRUE; break; \
1576                 } \
1577                 break; \
1578         case 24: result = checkowner_sig(name, rdclass, type, wildcard); break; \
1579         case 25: result = checkowner_key(name, rdclass, type, wildcard); break; \
1580         case 26: switch (rdclass) { \
1581                 case 1: result = checkowner_in_px(name, rdclass, type, wildcard); break; \
1582                 default: result = ISC_TRUE; break; \
1583                 } \
1584                 break; \
1585         case 27: result = checkowner_gpos(name, rdclass, type, wildcard); break; \
1586         case 28: switch (rdclass) { \
1587                 case 1: result = checkowner_in_aaaa(name, rdclass, type, wildcard); break; \
1588                 default: result = ISC_TRUE; break; \
1589                 } \
1590                 break; \
1591         case 29: result = checkowner_loc(name, rdclass, type, wildcard); break; \
1592         case 30: result = checkowner_nxt(name, rdclass, type, wildcard); break; \
1593         case 33: switch (rdclass) { \
1594                 case 1: result = checkowner_in_srv(name, rdclass, type, wildcard); break; \
1595                 default: result = ISC_TRUE; break; \
1596                 } \
1597                 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; \
1602                 } \
1603                 break; \
1604         case 37: result = checkowner_cert(name, rdclass, type, wildcard); break; \
1605         case 38: switch (rdclass) { \
1606                 case 1: result = checkowner_in_a6(name, rdclass, type, wildcard); break; \
1607                 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; \
1615                 default: result = ISC_TRUE; break; \
1616                 } \
1617                 break; \
1618         case 43: result = checkowner_ds(name, rdclass, type, wildcard); break; \
1619         case 44: result = checkowner_sshfp(name, rdclass, type, wildcard); break; \
1620         case 45: result = checkowner_ipseckey(name, rdclass, type, wildcard); break; \
1621         case 46: result = checkowner_rrsig(name, rdclass, type, wildcard); break; \
1622         case 47: result = checkowner_nsec(name, rdclass, type, wildcard); break; \
1623         case 48: result = checkowner_dnskey(name, rdclass, type, wildcard); break; \
1624         case 49: switch (rdclass) { \
1625                 case 1: result = checkowner_in_dhcid(name, rdclass, type, wildcard); break; \
1626                 default: result = ISC_TRUE; break; \
1627                 } \
1628                 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; \
1662         }
1663
1664 #define CHECKNAMESSWITCH \
1665         switch (rdata->type) { \
1666         case 1: switch (rdata->rdclass) { \
1667                 case 1: result = checknames_in_a(rdata, owner, bad); break; \
1668                 case 3: result = checknames_ch_a(rdata, owner, bad); break; \
1669                 case 4: result = checknames_hs_a(rdata, owner, bad); break; \
1670                 default: result = ISC_TRUE; break; \
1671                 } \
1672                 break; \
1673         case 2: result = checknames_ns(rdata, owner, bad); break; \
1674         case 3: result = checknames_md(rdata, owner, bad); break; \
1675         case 4: result = checknames_mf(rdata, owner, bad); break; \
1676         case 5: result = checknames_cname(rdata, owner, bad); break; \
1677         case 6: result = checknames_soa(rdata, owner, bad); break; \
1678         case 7: result = checknames_mb(rdata, owner, bad); break; \
1679         case 8: result = checknames_mg(rdata, owner, bad); break; \
1680         case 9: result = checknames_mr(rdata, owner, bad); break; \
1681         case 10: result = checknames_null(rdata, owner, bad); break; \
1682         case 11: switch (rdata->rdclass) { \
1683                 case 1: result = checknames_in_wks(rdata, owner, bad); break; \
1684                 default: result = ISC_TRUE; break; \
1685                 } \
1686                 break; \
1687         case 12: result = checknames_ptr(rdata, owner, bad); break; \
1688         case 13: result = checknames_hinfo(rdata, owner, bad); break; \
1689         case 14: result = checknames_minfo(rdata, owner, bad); break; \
1690         case 15: result = checknames_mx(rdata, owner, bad); break; \
1691         case 16: result = checknames_txt(rdata, owner, bad); break; \
1692         case 17: result = checknames_rp(rdata, owner, bad); break; \
1693         case 18: result = checknames_afsdb(rdata, owner, bad); break; \
1694         case 19: result = checknames_x25(rdata, owner, bad); break; \
1695         case 20: result = checknames_isdn(rdata, owner, bad); break; \
1696         case 21: result = checknames_rt(rdata, owner, bad); break; \
1697         case 22: switch (rdata->rdclass) { \
1698                 case 1: result = checknames_in_nsap(rdata, owner, bad); break; \
1699                 default: result = ISC_TRUE; break; \
1700                 } \
1701                 break; \
1702         case 23: switch (rdata->rdclass) { \
1703                 case 1: result = checknames_in_nsap_ptr(rdata, owner, bad); break; \
1704                 default: result = ISC_TRUE; break; \
1705                 } \
1706                 break; \
1707         case 24: result = checknames_sig(rdata, owner, bad); break; \
1708         case 25: result = checknames_key(rdata, owner, bad); break; \
1709         case 26: switch (rdata->rdclass) { \
1710                 case 1: result = checknames_in_px(rdata, owner, bad); break; \
1711                 default: result = ISC_TRUE; break; \
1712                 } \
1713                 break; \
1714         case 27: result = checknames_gpos(rdata, owner, bad); break; \
1715         case 28: switch (rdata->rdclass) { \
1716                 case 1: result = checknames_in_aaaa(rdata, owner, bad); break; \
1717                 default: result = ISC_TRUE; break; \
1718                 } \
1719                 break; \
1720         case 29: result = checknames_loc(rdata, owner, bad); break; \
1721         case 30: result = checknames_nxt(rdata, owner, bad); break; \
1722         case 33: switch (rdata->rdclass) { \
1723                 case 1: result = checknames_in_srv(rdata, owner, bad); break; \
1724                 default: result = ISC_TRUE; break; \
1725                 } \
1726                 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; \
1731                 } \
1732                 break; \
1733         case 37: result = checknames_cert(rdata, owner, bad); break; \
1734         case 38: switch (rdata->rdclass) { \
1735                 case 1: result = checknames_in_a6(rdata, owner, bad); break; \
1736                 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; \
1744                 default: result = ISC_TRUE; break; \
1745                 } \
1746                 break; \
1747         case 43: result = checknames_ds(rdata, owner, bad); break; \
1748         case 44: result = checknames_sshfp(rdata, owner, bad); break; \
1749         case 45: result = checknames_ipseckey(rdata, owner, bad); break; \
1750         case 46: result = checknames_rrsig(rdata, owner, bad); break; \
1751         case 47: result = checknames_nsec(rdata, owner, bad); break; \
1752         case 48: result = checknames_dnskey(rdata, owner, bad); break; \
1753         case 49: switch (rdata->rdclass) { \
1754                 case 1: result = checknames_in_dhcid(rdata, owner, bad); break; \
1755                 default: result = ISC_TRUE; break; \
1756                 } \
1757                 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; \
1791         }
1792 #define RDATATYPE_COMPARE(_s, _d, _tn, _n, _tp) \
1793         do { \
1794                 if (sizeof(_s) - 1 == _n && \
1795                     strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \
1796                         if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \
1797                                 return (ISC_R_NOTIMPLEMENTED); \
1798                         *(_tp) = _d; \
1799                         return (ISC_R_SUCCESS); \
1800                 } \
1801         } while (0)
1802
1803 #define RDATATYPE_FROMTEXT_SW(_hash,_typename,_length,_typep) \
1804         switch (_hash) { \
1805                 case 16: \
1806                         RDATATYPE_COMPARE("reserved0", 0, _typename, _length, _typep); \
1807                         break; \
1808                 case 34: \
1809                         RDATATYPE_COMPARE("a", 1, _typename, _length, _typep); \
1810                         break; \
1811                 case 80: \
1812                         RDATATYPE_COMPARE("ns", 2, _typename, _length, _typep); \
1813                         break; \
1814                 case 92: \
1815                         RDATATYPE_COMPARE("md", 3, _typename, _length, _typep); \
1816                         break; \
1817                 case 58: \
1818                         RDATATYPE_COMPARE("mf", 4, _typename, _length, _typep); \
1819                         break; \
1820                 case 8: \
1821                         RDATATYPE_COMPARE("cname", 5, _typename, _length, _typep); \
1822                         RDATATYPE_COMPARE("mx", 15, _typename, _length, _typep); \
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); \
1830                         break; \
1831                 case 169: \
1832                         RDATATYPE_COMPARE("mg", 8, _typename, _length, _typep); \
1833                         break; \
1834                 case 110: \
1835                         RDATATYPE_COMPARE("mr", 9, _typename, _length, _typep); \
1836                         RDATATYPE_COMPARE("minfo", 14, _typename, _length, _typep); \
1837                         break; \
1838                 case 24: \
1839                         RDATATYPE_COMPARE("null", 10, _typename, _length, _typep); \
1840                         RDATATYPE_COMPARE("kx", 36, _typename, _length, _typep); \
1841                         RDATATYPE_COMPARE("nsec3param", 51, _typename, _length, _typep); \
1842                         break; \
1843                 case 206: \
1844                         RDATATYPE_COMPARE("wks", 11, _typename, _length, _typep); \
1845                         break; \
1846                 case 54: \
1847                         RDATATYPE_COMPARE("ptr", 12, _typename, _length, _typep); \
1848                         RDATATYPE_COMPARE("naptr", 35, _typename, _length, _typep); \
1849                         break; \
1850                 case 67: \
1851                         RDATATYPE_COMPARE("hinfo", 13, _typename, _length, _typep); \
1852                         break; \
1853                 case 236: \
1854                         RDATATYPE_COMPARE("txt", 16, _typename, _length, _typep); \
1855                         break; \
1856                 case 192: \
1857                         RDATATYPE_COMPARE("rp", 17, _typename, _length, _typep); \
1858                         break; \
1859                 case 12: \
1860                         RDATATYPE_COMPARE("afsdb", 18, _typename, _length, _typep); \
1861                         break; \
1862                 case 119: \
1863                         RDATATYPE_COMPARE("x25", 19, _typename, _length, _typep); \
1864                         break; \
1865                 case 214: \
1866                         RDATATYPE_COMPARE("isdn", 20, _typename, _length, _typep); \
1867                         break; \
1868                 case 144: \
1869                         RDATATYPE_COMPARE("rt", 21, _typename, _length, _typep); \
1870                         break; \
1871                 case 224: \
1872                         RDATATYPE_COMPARE("nsap", 22, _typename, _length, _typep); \
1873                         RDATATYPE_COMPARE("uid", 101, _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); \
1881                         RDATATYPE_COMPARE("dlv", 32769, _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); \
1889                         break; \
1890                 case 17: \
1891                         RDATATYPE_COMPARE("gpos", 27, _typename, _length, _typep); \
1892                         break; \
1893                 case 69: \
1894                         RDATATYPE_COMPARE("aaaa", 28, _typename, _length, _typep); \
1895                         RDATATYPE_COMPARE("atma", 34, _typename, _length, _typep); \
1896                         break; \
1897                 case 237: \
1898                         RDATATYPE_COMPARE("loc", 29, _typename, _length, _typep); \
1899                         break; \
1900                 case 52: \
1901                         RDATATYPE_COMPARE("nxt", 30, _typename, _length, _typep); \
1902                         break; \
1903                 case 160: \
1904                         RDATATYPE_COMPARE("eid", 31, _typename, _length, _typep); \
1905                         break; \
1906                 case 220: \
1907                         RDATATYPE_COMPARE("nimloc", 32, _typename, _length, _typep); \
1908                         break; \
1909                 case 100: \
1910                         RDATATYPE_COMPARE("srv", 33, _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); \
1918                         break; \
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); \
1938                         break; \
1939                 case 105: \
1940                         RDATATYPE_COMPARE("ipseckey", 45, _typename, _length, _typep); \
1941                         break; \
1942                 case 225: \
1943                         RDATATYPE_COMPARE("rrsig", 46, _typename, _length, _typep); \
1944                         break; \
1945                 case 22: \
1946                         RDATATYPE_COMPARE("nsec", 47, _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); \
1954                         RDATATYPE_COMPARE("spf", 99, _typename, _length, _typep); \
1955                         break; \
1956                 case 233: \
1957                         RDATATYPE_COMPARE("nsec3", 50, _typename, _length, _typep); \
1958                         break; \
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; \
1984                 case 104: \
1985                         RDATATYPE_COMPARE("gid", 102, _typename, _length, _typep); \
1986                         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; \
2005                 case 72: \
2006                         RDATATYPE_COMPARE("tsig", 250, _typename, _length, _typep); \
2007                         break; \
2008                 case 138: \
2009                         RDATATYPE_COMPARE("ixfr", 251, _typename, _length, _typep); \
2010                         break; \
2011                 case 250: \
2012                         RDATATYPE_COMPARE("axfr", 252, _typename, _length, _typep); \
2013                         break; \
2014                 case 164: \
2015                         RDATATYPE_COMPARE("mailb", 253, _typename, _length, _typep); \
2016                         break; \
2017                 case 50: \
2018                         RDATATYPE_COMPARE("maila", 254, _typename, _length, _typep); \
2019                         RDATATYPE_COMPARE("keydata", 65533, _typename, _length, _typep); \
2020                         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) { \
2030         case 0: return (DNS_RDATATYPEATTR_RESERVED); \
2031         case 1: return (RRTYPE_A_ATTRIBUTES); \
2032         case 2: return (RRTYPE_NS_ATTRIBUTES); \
2033         case 3: return (RRTYPE_MD_ATTRIBUTES); \
2034         case 4: return (RRTYPE_MF_ATTRIBUTES); \
2035         case 5: return (RRTYPE_CNAME_ATTRIBUTES); \
2036         case 6: return (RRTYPE_SOA_ATTRIBUTES); \
2037         case 7: return (RRTYPE_MB_ATTRIBUTES); \
2038         case 8: return (RRTYPE_MG_ATTRIBUTES); \
2039         case 9: return (RRTYPE_MR_ATTRIBUTES); \
2040         case 10: return (RRTYPE_NULL_ATTRIBUTES); \
2041         case 11: return (RRTYPE_WKS_ATTRIBUTES); \
2042         case 12: return (RRTYPE_PTR_ATTRIBUTES); \
2043         case 13: return (RRTYPE_HINFO_ATTRIBUTES); \
2044         case 14: return (RRTYPE_MINFO_ATTRIBUTES); \
2045         case 15: return (RRTYPE_MX_ATTRIBUTES); \
2046         case 16: return (RRTYPE_TXT_ATTRIBUTES); \
2047         case 17: return (RRTYPE_RP_ATTRIBUTES); \
2048         case 18: return (RRTYPE_AFSDB_ATTRIBUTES); \
2049         case 19: return (RRTYPE_X25_ATTRIBUTES); \
2050         case 20: return (RRTYPE_ISDN_ATTRIBUTES); \
2051         case 21: return (RRTYPE_RT_ATTRIBUTES); \
2052         case 22: return (RRTYPE_NSAP_ATTRIBUTES); \
2053         case 23: return (RRTYPE_NSAP_PTR_ATTRIBUTES); \
2054         case 24: return (RRTYPE_SIG_ATTRIBUTES); \
2055         case 25: return (RRTYPE_KEY_ATTRIBUTES); \
2056         case 26: return (RRTYPE_PX_ATTRIBUTES); \
2057         case 27: return (RRTYPE_GPOS_ATTRIBUTES); \
2058         case 28: return (RRTYPE_AAAA_ATTRIBUTES); \
2059         case 29: return (RRTYPE_LOC_ATTRIBUTES); \
2060         case 30: return (RRTYPE_NXT_ATTRIBUTES); \
2061         case 31: return (DNS_RDATATYPEATTR_RESERVED); \
2062         case 32: return (DNS_RDATATYPEATTR_RESERVED); \
2063         case 33: return (RRTYPE_SRV_ATTRIBUTES); \
2064         case 34: return (DNS_RDATATYPEATTR_RESERVED); \
2065         case 35: return (RRTYPE_NAPTR_ATTRIBUTES); \
2066         case 36: return (RRTYPE_KX_ATTRIBUTES); \
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); \
2074         case 44: return (RRTYPE_SSHFP_ATTRIBUTES); \
2075         case 45: return (RRTYPE_IPSECKEY_ATTRIBUTES); \
2076         case 46: return (RRTYPE_RRSIG_ATTRIBUTES); \
2077         case 47: return (RRTYPE_NSEC_ATTRIBUTES); \
2078         case 48: return (RRTYPE_DNSKEY_ATTRIBUTES); \
2079         case 49: return (RRTYPE_DHCID_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); \
2106         case 252: 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         }
2117 #define RDATATYPE_TOTEXT_SW \
2118         switch (type) { \
2119         case 0: return (str_totext("RESERVED0", target)); \
2120         case 1: return (str_totext("A", target)); \
2121         case 2: return (str_totext("NS", target)); \
2122         case 3: return (str_totext("MD", target)); \
2123         case 4: return (str_totext("MF", target)); \
2124         case 5: return (str_totext("CNAME", target)); \
2125         case 6: return (str_totext("SOA", target)); \
2126         case 7: return (str_totext("MB", target)); \
2127         case 8: return (str_totext("MG", target)); \
2128         case 9: return (str_totext("MR", target)); \
2129         case 10: return (str_totext("NULL", target)); \
2130         case 11: return (str_totext("WKS", target)); \
2131         case 12: return (str_totext("PTR", target)); \
2132         case 13: return (str_totext("HINFO", target)); \
2133         case 14: return (str_totext("MINFO", target)); \
2134         case 15: return (str_totext("MX", target)); \
2135         case 16: return (str_totext("TXT", target)); \
2136         case 17: return (str_totext("RP", target)); \
2137         case 18: return (str_totext("AFSDB", target)); \
2138         case 19: return (str_totext("X25", target)); \
2139         case 20: return (str_totext("ISDN", target)); \
2140         case 21: return (str_totext("RT", target)); \
2141         case 22: return (str_totext("NSAP", target)); \
2142         case 23: return (str_totext("NSAP-PTR", target)); \
2143         case 24: return (str_totext("SIG", target)); \
2144         case 25: return (str_totext("KEY", target)); \
2145         case 26: return (str_totext("PX", target)); \
2146         case 27: return (str_totext("GPOS", target)); \
2147         case 28: return (str_totext("AAAA", target)); \
2148         case 29: return (str_totext("LOC", target)); \
2149         case 30: return (str_totext("NXT", target)); \
2150         case 31: return (str_totext("EID", target)); \
2151         case 32: return (str_totext("NIMLOC", target)); \
2152         case 33: return (str_totext("SRV", target)); \
2153         case 34: return (str_totext("ATMA", target)); \
2154         case 35: return (str_totext("NAPTR", target)); \
2155         case 36: return (str_totext("KX", target)); \
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)); \
2163         case 44: return (str_totext("SSHFP", target)); \
2164         case 45: return (str_totext("IPSECKEY", target)); \
2165         case 46: return (str_totext("RRSIG", target)); \
2166         case 47: return (str_totext("NSEC", target)); \
2167         case 48: return (str_totext("DNSKEY", target)); \
2168         case 49: return (str_totext("DHCID", 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)); \
2195         case 252: return (str_totext("AXFR", 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)); \
2204         }
2205 #endif /* DNS_CODE_H */