lib/bind/dns/code.h

   1 /* $FreeBSD$ */
   2
   3 /*
   4  * Copyright (C) 2004-2013 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/in_1/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/opt_41.c"
  76 #include "rdata/in_1/apl_42.c"
  77 #include "rdata/generic/ds_43.c"
  78 #include "rdata/generic/sshfp_44.c"
  79 #include "rdata/generic/ipseckey_45.c"
  80 #include "rdata/generic/rrsig_46.c"
  81 #include "rdata/generic/nsec_47.c"
  82 #include "rdata/generic/dnskey_48.c"
  83 #include "rdata/in_1/dhcid_49.c"
  84 #include "rdata/generic/nsec3_50.c"
  85 #include "rdata/generic/nsec3param_51.c"
  86 #include "rdata/generic/tlsa_52.c"
  87 #include "rdata/generic/hip_55.c"
  88 #include "rdata/generic/spf_99.c"
  89 #include "rdata/generic/unspec_103.c"
  90 #include "rdata/generic/tkey_249.c"
  91 #include "rdata/any_255/tsig_250.c"
  92 #include "rdata/generic/dlv_32769.c"
  93 #include "rdata/generic/keydata_65533.c"
  94
  95
  96
  97 #define FROMTEXTSWITCH \
  98         switch (type) { \
  99         case 1: switch (rdclass) { \
 100                 case 1: result = fromtext_in_a(rdclass, type, lexer, origin, options, target, callbacks); break; \
 101                 case 3: result = fromtext_ch_a(rdclass, type, lexer, origin, options, target, callbacks); break; \
 102                 case 4: result = fromtext_hs_a(rdclass, type, lexer, origin, options, target, callbacks); break; \
 103                 default: result = DNS_R_UNKNOWN; break; \
 104                 } \
 105                 break; \
 106         case 2: result = fromtext_ns(rdclass, type, lexer, origin, options, target, callbacks); break; \
 107         case 3: result = fromtext_md(rdclass, type, lexer, origin, options, target, callbacks); break; \
 108         case 4: result = fromtext_mf(rdclass, type, lexer, origin, options, target, callbacks); break; \
 109         case 5: result = fromtext_cname(rdclass, type, lexer, origin, options, target, callbacks); break; \
 110         case 6: result = fromtext_soa(rdclass, type, lexer, origin, options, target, callbacks); break; \
 111         case 7: result = fromtext_mb(rdclass, type, lexer, origin, options, target, callbacks); break; \
 112         case 8: result = fromtext_mg(rdclass, type, lexer, origin, options, target, callbacks); break; \
 113         case 9: result = fromtext_mr(rdclass, type, lexer, origin, options, target, callbacks); break; \
 114         case 10: result = fromtext_null(rdclass, type, lexer, origin, options, target, callbacks); break; \
 115         case 11: switch (rdclass) { \
 116                 case 1: result = fromtext_in_wks(rdclass, type, lexer, origin, options, target, callbacks); break; \
 117                 default: result = DNS_R_UNKNOWN; break; \
 118                 } \
 119                 break; \
 120         case 12: result = fromtext_ptr(rdclass, type, lexer, origin, options, target, callbacks); break; \
 121         case 13: result = fromtext_hinfo(rdclass, type, lexer, origin, options, target, callbacks); break; \
 122         case 14: result = fromtext_minfo(rdclass, type, lexer, origin, options, target, callbacks); break; \
 123         case 15: result = fromtext_mx(rdclass, type, lexer, origin, options, target, callbacks); break; \
 124         case 16: result = fromtext_txt(rdclass, type, lexer, origin, options, target, callbacks); break; \
 125         case 17: result = fromtext_rp(rdclass, type, lexer, origin, options, target, callbacks); break; \
 126         case 18: result = fromtext_afsdb(rdclass, type, lexer, origin, options, target, callbacks); break; \
 127         case 19: result = fromtext_x25(rdclass, type, lexer, origin, options, target, callbacks); break; \
 128         case 20: result = fromtext_isdn(rdclass, type, lexer, origin, options, target, callbacks); break; \
 129         case 21: result = fromtext_rt(rdclass, type, lexer, origin, options, target, callbacks); break; \
 130         case 22: switch (rdclass) { \
 131                 case 1: result = fromtext_in_nsap(rdclass, type, lexer, origin, options, target, callbacks); break; \
 132                 default: result = DNS_R_UNKNOWN; break; \
 133                 } \
 134                 break; \
 135         case 23: switch (rdclass) { \
 136                 case 1: result = fromtext_in_nsap_ptr(rdclass, type, lexer, origin, options, target, callbacks); break; \
 137                 default: result = DNS_R_UNKNOWN; break; \
 138                 } \
 139                 break; \
 140         case 24: result = fromtext_sig(rdclass, type, lexer, origin, options, target, callbacks); break; \
 141         case 25: result = fromtext_key(rdclass, type, lexer, origin, options, target, callbacks); break; \
 142         case 26: switch (rdclass) { \
 143                 case 1: result = fromtext_in_px(rdclass, type, lexer, origin, options, target, callbacks); break; \
 144                 default: result = DNS_R_UNKNOWN; break; \
 145                 } \
 146                 break; \
 147         case 27: result = fromtext_gpos(rdclass, type, lexer, origin, options, target, callbacks); break; \
 148         case 28: switch (rdclass) { \
 149                 case 1: result = fromtext_in_aaaa(rdclass, type, lexer, origin, options, target, callbacks); break; \
 150                 default: result = DNS_R_UNKNOWN; break; \
 151                 } \
 152                 break; \
 153         case 29: result = fromtext_loc(rdclass, type, lexer, origin, options, target, callbacks); break; \
 154         case 30: result = fromtext_nxt(rdclass, type, lexer, origin, options, target, callbacks); break; \
 155         case 33: switch (rdclass) { \
 156                 case 1: result = fromtext_in_srv(rdclass, type, lexer, origin, options, target, callbacks); break; \
 157                 default: result = DNS_R_UNKNOWN; break; \
 158                 } \
 159                 break; \
 160         case 35: switch (rdclass) { \
 161                 case 1: result = fromtext_in_naptr(rdclass, type, lexer, origin, options, target, callbacks); break; \
 162                 default: result = DNS_R_UNKNOWN; break; \
 163                 } \
 164                 break; \
 165         case 36: switch (rdclass) { \
 166                 case 1: result = fromtext_in_kx(rdclass, type, lexer, origin, options, target, callbacks); break; \
 167                 default: result = DNS_R_UNKNOWN; break; \
 168                 } \
 169                 break; \
 170         case 37: result = fromtext_cert(rdclass, type, lexer, origin, options, target, callbacks); break; \
 171         case 38: switch (rdclass) { \
 172                 case 1: result = fromtext_in_a6(rdclass, type, lexer, origin, options, target, callbacks); break; \
 173                 default: result = DNS_R_UNKNOWN; break; \
 174                 } \
 175                 break; \
 176         case 39: result = fromtext_dname(rdclass, type, lexer, origin, options, target, callbacks); break; \
 177         case 41: result = fromtext_opt(rdclass, type, lexer, origin, options, target, callbacks); break; \
 178         case 42: switch (rdclass) { \
 179                 case 1: result = fromtext_in_apl(rdclass, type, lexer, origin, options, target, callbacks); break; \
 180                 default: result = DNS_R_UNKNOWN; break; \
 181                 } \
 182                 break; \
 183         case 43: result = fromtext_ds(rdclass, type, lexer, origin, options, target, callbacks); break; \
 184         case 44: result = fromtext_sshfp(rdclass, type, lexer, origin, options, target, callbacks); break; \
 185         case 45: result = fromtext_ipseckey(rdclass, type, lexer, origin, options, target, callbacks); break; \
 186         case 46: result = fromtext_rrsig(rdclass, type, lexer, origin, options, target, callbacks); break; \
 187         case 47: result = fromtext_nsec(rdclass, type, lexer, origin, options, target, callbacks); break; \
 188         case 48: result = fromtext_dnskey(rdclass, type, lexer, origin, options, target, callbacks); break; \
 189         case 49: switch (rdclass) { \
 190                 case 1: result = fromtext_in_dhcid(rdclass, type, lexer, origin, options, target, callbacks); break; \
 191                 default: result = DNS_R_UNKNOWN; break; \
 192                 } \
 193                 break; \
 194         case 50: result = fromtext_nsec3(rdclass, type, lexer, origin, options, target, callbacks); break; \
 195         case 51: result = fromtext_nsec3param(rdclass, type, lexer, origin, options, target, callbacks); break; \
 196         case 52: result = fromtext_tlsa(rdclass, type, lexer, origin, options, target, callbacks); break; \
 197         case 55: result = fromtext_hip(rdclass, type, lexer, origin, options, target, callbacks); break; \
 198         case 99: result = fromtext_spf(rdclass, type, lexer, origin, options, target, callbacks); break; \
 199         case 103: result = fromtext_unspec(rdclass, type, lexer, origin, options, target, callbacks); break; \
 200         case 249: result = fromtext_tkey(rdclass, type, lexer, origin, options, target, callbacks); break; \
 201         case 250: switch (rdclass) { \
 202                 case 255: result = fromtext_any_tsig(rdclass, type, lexer, origin, options, target, callbacks); break; \
 203                 default: result = DNS_R_UNKNOWN; break; \
 204                 } \
 205                 break; \
 206         case 32769: result = fromtext_dlv(rdclass, type, lexer, origin, options, target, callbacks); break; \
 207         case 65533: result = fromtext_keydata(rdclass, type, lexer, origin, options, target, callbacks); break; \
 208         default: result = DNS_R_UNKNOWN; break; \
 209         }
 210
 211 #define TOTEXTSWITCH \
 212         switch (rdata->type) { \
 213         case 1: switch (rdata->rdclass) { \
 214                 case 1: result = totext_in_a(rdata, tctx, target); break; \
 215                 case 3: result = totext_ch_a(rdata, tctx, target); break; \
 216                 case 4: result = totext_hs_a(rdata, tctx, target); break; \
 217                 default: use_default = ISC_TRUE; break; \
 218                 } \
 219                 break; \
 220         case 2: result = totext_ns(rdata, tctx, target); break; \
 221         case 3: result = totext_md(rdata, tctx, target); break; \
 222         case 4: result = totext_mf(rdata, tctx, target); break; \
 223         case 5: result = totext_cname(rdata, tctx, target); break; \
 224         case 6: result = totext_soa(rdata, tctx, target); break; \
 225         case 7: result = totext_mb(rdata, tctx, target); break; \
 226         case 8: result = totext_mg(rdata, tctx, target); break; \
 227         case 9: result = totext_mr(rdata, tctx, target); break; \
 228         case 10: result = totext_null(rdata, tctx, target); break; \
 229         case 11: switch (rdata->rdclass) { \
 230                 case 1: result = totext_in_wks(rdata, tctx, target); break; \
 231                 default: use_default = ISC_TRUE; break; \
 232                 } \
 233                 break; \
 234         case 12: result = totext_ptr(rdata, tctx, target); break; \
 235         case 13: result = totext_hinfo(rdata, tctx, target); break; \
 236         case 14: result = totext_minfo(rdata, tctx, target); break; \
 237         case 15: result = totext_mx(rdata, tctx, target); break; \
 238         case 16: result = totext_txt(rdata, tctx, target); break; \
 239         case 17: result = totext_rp(rdata, tctx, target); break; \
 240         case 18: result = totext_afsdb(rdata, tctx, target); break; \
 241         case 19: result = totext_x25(rdata, tctx, target); break; \
 242         case 20: result = totext_isdn(rdata, tctx, target); break; \
 243         case 21: result = totext_rt(rdata, tctx, target); break; \
 244         case 22: switch (rdata->rdclass) { \
 245                 case 1: result = totext_in_nsap(rdata, tctx, target); break; \
 246                 default: use_default = ISC_TRUE; break; \
 247                 } \
 248                 break; \
 249         case 23: switch (rdata->rdclass) { \
 250                 case 1: result = totext_in_nsap_ptr(rdata, tctx, target); break; \
 251                 default: use_default = ISC_TRUE; break; \
 252                 } \
 253                 break; \
 254         case 24: result = totext_sig(rdata, tctx, target); break; \
 255         case 25: result = totext_key(rdata, tctx, target); break; \
 256         case 26: switch (rdata->rdclass) { \
 257                 case 1: result = totext_in_px(rdata, tctx, target); break; \
 258                 default: use_default = ISC_TRUE; break; \
 259                 } \
 260                 break; \
 261         case 27: result = totext_gpos(rdata, tctx, target); break; \
 262         case 28: switch (rdata->rdclass) { \
 263                 case 1: result = totext_in_aaaa(rdata, tctx, target); break; \
 264                 default: use_default = ISC_TRUE; break; \
 265                 } \
 266                 break; \
 267         case 29: result = totext_loc(rdata, tctx, target); break; \
 268         case 30: result = totext_nxt(rdata, tctx, target); break; \
 269         case 33: switch (rdata->rdclass) { \
 270                 case 1: result = totext_in_srv(rdata, tctx, target); break; \
 271                 default: use_default = ISC_TRUE; break; \
 272                 } \
 273                 break; \
 274         case 35: switch (rdata->rdclass) { \
 275                 case 1: result = totext_in_naptr(rdata, tctx, target); break; \
 276                 default: use_default = ISC_TRUE; break; \
 277                 } \
 278                 break; \
 279         case 36: switch (rdata->rdclass) { \
 280                 case 1: result = totext_in_kx(rdata, tctx, target); break; \
 281                 default: use_default = ISC_TRUE; break; \
 282                 } \
 283                 break; \
 284         case 37: result = totext_cert(rdata, tctx, target); break; \
 285         case 38: switch (rdata->rdclass) { \
 286                 case 1: result = totext_in_a6(rdata, tctx, target); break; \
 287                 default: use_default = ISC_TRUE; break; \
 288                 } \
 289                 break; \
 290         case 39: result = totext_dname(rdata, tctx, target); break; \
 291         case 41: result = totext_opt(rdata, tctx, target); break; \
 292         case 42: switch (rdata->rdclass) { \
 293                 case 1: result = totext_in_apl(rdata, tctx, target); break; \
 294                 default: use_default = ISC_TRUE; break; \
 295                 } \
 296                 break; \
 297         case 43: result = totext_ds(rdata, tctx, target); break; \
 298         case 44: result = totext_sshfp(rdata, tctx, target); break; \
 299         case 45: result = totext_ipseckey(rdata, tctx, target); break; \
 300         case 46: result = totext_rrsig(rdata, tctx, target); break; \
 301         case 47: result = totext_nsec(rdata, tctx, target); break; \
 302         case 48: result = totext_dnskey(rdata, tctx, target); break; \
 303         case 49: switch (rdata->rdclass) { \
 304                 case 1: result = totext_in_dhcid(rdata, tctx, target); break; \
 305                 default: use_default = ISC_TRUE; break; \
 306                 } \
 307                 break; \
 308         case 50: result = totext_nsec3(rdata, tctx, target); break; \
 309         case 51: result = totext_nsec3param(rdata, tctx, target); break; \
 310         case 52: result = totext_tlsa(rdata, tctx, target); break; \
 311         case 55: result = totext_hip(rdata, tctx, target); break; \
 312         case 99: result = totext_spf(rdata, tctx, target); break; \
 313         case 103: result = totext_unspec(rdata, tctx, target); break; \
 314         case 249: result = totext_tkey(rdata, tctx, target); break; \
 315         case 250: switch (rdata->rdclass) { \
 316                 case 255: result = totext_any_tsig(rdata, tctx, target); break; \
 317                 default: use_default = ISC_TRUE; break; \
 318                 } \
 319                 break; \
 320         case 32769: result = totext_dlv(rdata, tctx, target); break; \
 321         case 65533: result = totext_keydata(rdata, tctx, target); break; \
 322         default: use_default = ISC_TRUE; break; \
 323         }
 324
 325 #define FROMWIRESWITCH \
 326         switch (type) { \
 327         case 1: switch (rdclass) { \
 328                 case 1: result = fromwire_in_a(rdclass, type, source, dctx, options, target); break; \
 329                 case 3: result = fromwire_ch_a(rdclass, type, source, dctx, options, target); break; \
 330                 case 4: result = fromwire_hs_a(rdclass, type, source, dctx, options, target); break; \
 331                 default: use_default = ISC_TRUE; break; \
 332                 } \
 333                 break; \
 334         case 2: result = fromwire_ns(rdclass, type, source, dctx, options, target); break; \
 335         case 3: result = fromwire_md(rdclass, type, source, dctx, options, target); break; \
 336         case 4: result = fromwire_mf(rdclass, type, source, dctx, options, target); break; \
 337         case 5: result = fromwire_cname(rdclass, type, source, dctx, options, target); break; \
 338         case 6: result = fromwire_soa(rdclass, type, source, dctx, options, target); break; \
 339         case 7: result = fromwire_mb(rdclass, type, source, dctx, options, target); break; \
 340         case 8: result = fromwire_mg(rdclass, type, source, dctx, options, target); break; \
 341         case 9: result = fromwire_mr(rdclass, type, source, dctx, options, target); break; \
 342         case 10: result = fromwire_null(rdclass, type, source, dctx, options, target); break; \
 343         case 11: switch (rdclass) { \
 344                 case 1: result = fromwire_in_wks(rdclass, type, source, dctx, options, target); break; \
 345                 default: use_default = ISC_TRUE; break; \
 346                 } \
 347                 break; \
 348         case 12: result = fromwire_ptr(rdclass, type, source, dctx, options, target); break; \
 349         case 13: result = fromwire_hinfo(rdclass, type, source, dctx, options, target); break; \
 350         case 14: result = fromwire_minfo(rdclass, type, source, dctx, options, target); break; \
 351         case 15: result = fromwire_mx(rdclass, type, source, dctx, options, target); break; \
 352         case 16: result = fromwire_txt(rdclass, type, source, dctx, options, target); break; \
 353         case 17: result = fromwire_rp(rdclass, type, source, dctx, options, target); break; \
 354         case 18: result = fromwire_afsdb(rdclass, type, source, dctx, options, target); break; \
 355         case 19: result = fromwire_x25(rdclass, type, source, dctx, options, target); break; \
 356         case 20: result = fromwire_isdn(rdclass, type, source, dctx, options, target); break; \
 357         case 21: result = fromwire_rt(rdclass, type, source, dctx, options, target); break; \
 358         case 22: switch (rdclass) { \
 359                 case 1: result = fromwire_in_nsap(rdclass, type, source, dctx, options, target); break; \
 360                 default: use_default = ISC_TRUE; break; \
 361                 } \
 362                 break; \
 363         case 23: switch (rdclass) { \
 364                 case 1: result = fromwire_in_nsap_ptr(rdclass, type, source, dctx, options, target); break; \
 365                 default: use_default = ISC_TRUE; break; \
 366                 } \
 367                 break; \
 368         case 24: result = fromwire_sig(rdclass, type, source, dctx, options, target); break; \
 369         case 25: result = fromwire_key(rdclass, type, source, dctx, options, target); break; \
 370         case 26: switch (rdclass) { \
 371                 case 1: result = fromwire_in_px(rdclass, type, source, dctx, options, target); break; \
 372                 default: use_default = ISC_TRUE; break; \
 373                 } \
 374                 break; \
 375         case 27: result = fromwire_gpos(rdclass, type, source, dctx, options, target); break; \
 376         case 28: switch (rdclass) { \
 377                 case 1: result = fromwire_in_aaaa(rdclass, type, source, dctx, options, target); break; \
 378                 default: use_default = ISC_TRUE; break; \
 379                 } \
 380                 break; \
 381         case 29: result = fromwire_loc(rdclass, type, source, dctx, options, target); break; \
 382         case 30: result = fromwire_nxt(rdclass, type, source, dctx, options, target); break; \
 383         case 33: switch (rdclass) { \
 384                 case 1: result = fromwire_in_srv(rdclass, type, source, dctx, options, target); break; \
 385                 default: use_default = ISC_TRUE; break; \
 386                 } \
 387                 break; \
 388         case 35: switch (rdclass) { \
 389                 case 1: result = fromwire_in_naptr(rdclass, type, source, dctx, options, target); break; \
 390                 default: use_default = ISC_TRUE; break; \
 391                 } \
 392                 break; \
 393         case 36: switch (rdclass) { \
 394                 case 1: result = fromwire_in_kx(rdclass, type, source, dctx, options, target); break; \
 395                 default: use_default = ISC_TRUE; break; \
 396                 } \
 397                 break; \
 398         case 37: result = fromwire_cert(rdclass, type, source, dctx, options, target); break; \
 399         case 38: switch (rdclass) { \
 400                 case 1: result = fromwire_in_a6(rdclass, type, source, dctx, options, target); break; \
 401                 default: use_default = ISC_TRUE; break; \
 402                 } \
 403                 break; \
 404         case 39: result = fromwire_dname(rdclass, type, source, dctx, options, target); break; \
 405         case 41: result = fromwire_opt(rdclass, type, source, dctx, options, target); break; \
 406         case 42: switch (rdclass) { \
 407                 case 1: result = fromwire_in_apl(rdclass, type, source, dctx, options, target); break; \
 408                 default: use_default = ISC_TRUE; break; \
 409                 } \
 410                 break; \
 411         case 43: result = fromwire_ds(rdclass, type, source, dctx, options, target); break; \
 412         case 44: result = fromwire_sshfp(rdclass, type, source, dctx, options, target); break; \
 413         case 45: result = fromwire_ipseckey(rdclass, type, source, dctx, options, target); break; \
 414         case 46: result = fromwire_rrsig(rdclass, type, source, dctx, options, target); break; \
 415         case 47: result = fromwire_nsec(rdclass, type, source, dctx, options, target); break; \
 416         case 48: result = fromwire_dnskey(rdclass, type, source, dctx, options, target); break; \
 417         case 49: switch (rdclass) { \
 418                 case 1: result = fromwire_in_dhcid(rdclass, type, source, dctx, options, target); break; \
 419                 default: use_default = ISC_TRUE; break; \
 420                 } \
 421                 break; \
 422         case 50: result = fromwire_nsec3(rdclass, type, source, dctx, options, target); break; \
 423         case 51: result = fromwire_nsec3param(rdclass, type, source, dctx, options, target); break; \
 424         case 52: result = fromwire_tlsa(rdclass, type, source, dctx, options, target); break; \
 425         case 55: result = fromwire_hip(rdclass, type, source, dctx, options, target); break; \
 426         case 99: result = fromwire_spf(rdclass, type, source, dctx, options, target); break; \
 427         case 103: result = fromwire_unspec(rdclass, type, source, dctx, options, target); break; \
 428         case 249: result = fromwire_tkey(rdclass, type, source, dctx, options, target); break; \
 429         case 250: switch (rdclass) { \
 430                 case 255: result = fromwire_any_tsig(rdclass, type, source, dctx, options, target); break; \
 431                 default: use_default = ISC_TRUE; break; \
 432                 } \
 433                 break; \
 434         case 32769: result = fromwire_dlv(rdclass, type, source, dctx, options, target); break; \
 435         case 65533: result = fromwire_keydata(rdclass, type, source, dctx, options, target); break; \
 436         default: use_default = ISC_TRUE; break; \
 437         }
 438
 439 #define TOWIRESWITCH \
 440         switch (rdata->type) { \
 441         case 1: switch (rdata->rdclass) { \
 442                 case 1: result = towire_in_a(rdata, cctx, target); break; \
 443                 case 3: result = towire_ch_a(rdata, cctx, target); break; \
 444                 case 4: result = towire_hs_a(rdata, cctx, target); break; \
 445                 default: use_default = ISC_TRUE; break; \
 446                 } \
 447                 break; \
 448         case 2: result = towire_ns(rdata, cctx, target); break; \
 449         case 3: result = towire_md(rdata, cctx, target); break; \
 450         case 4: result = towire_mf(rdata, cctx, target); break; \
 451         case 5: result = towire_cname(rdata, cctx, target); break; \
 452         case 6: result = towire_soa(rdata, cctx, target); break; \
 453         case 7: result = towire_mb(rdata, cctx, target); break; \
 454         case 8: result = towire_mg(rdata, cctx, target); break; \
 455         case 9: result = towire_mr(rdata, cctx, target); break; \
 456         case 10: result = towire_null(rdata, cctx, target); break; \
 457         case 11: switch (rdata->rdclass) { \
 458                 case 1: result = towire_in_wks(rdata, cctx, target); break; \
 459                 default: use_default = ISC_TRUE; break; \
 460                 } \
 461                 break; \
 462         case 12: result = towire_ptr(rdata, cctx, target); break; \
 463         case 13: result = towire_hinfo(rdata, cctx, target); break; \
 464         case 14: result = towire_minfo(rdata, cctx, target); break; \
 465         case 15: result = towire_mx(rdata, cctx, target); break; \
 466         case 16: result = towire_txt(rdata, cctx, target); break; \
 467         case 17: result = towire_rp(rdata, cctx, target); break; \
 468         case 18: result = towire_afsdb(rdata, cctx, target); break; \
 469         case 19: result = towire_x25(rdata, cctx, target); break; \
 470         case 20: result = towire_isdn(rdata, cctx, target); break; \
 471         case 21: result = towire_rt(rdata, cctx, target); break; \
 472         case 22: switch (rdata->rdclass) { \
 473                 case 1: result = towire_in_nsap(rdata, cctx, target); break; \
 474                 default: use_default = ISC_TRUE; break; \
 475                 } \
 476                 break; \
 477         case 23: switch (rdata->rdclass) { \
 478                 case 1: result = towire_in_nsap_ptr(rdata, cctx, target); break; \
 479                 default: use_default = ISC_TRUE; break; \
 480                 } \
 481                 break; \
 482         case 24: result = towire_sig(rdata, cctx, target); break; \
 483         case 25: result = towire_key(rdata, cctx, target); break; \
 484         case 26: switch (rdata->rdclass) { \
 485                 case 1: result = towire_in_px(rdata, cctx, target); break; \
 486                 default: use_default = ISC_TRUE; break; \
 487                 } \
 488                 break; \
 489         case 27: result = towire_gpos(rdata, cctx, target); break; \
 490         case 28: switch (rdata->rdclass) { \
 491                 case 1: result = towire_in_aaaa(rdata, cctx, target); break; \
 492                 default: use_default = ISC_TRUE; break; \
 493                 } \
 494                 break; \
 495         case 29: result = towire_loc(rdata, cctx, target); break; \
 496         case 30: result = towire_nxt(rdata, cctx, target); break; \
 497         case 33: switch (rdata->rdclass) { \
 498                 case 1: result = towire_in_srv(rdata, cctx, target); break; \
 499                 default: use_default = ISC_TRUE; break; \
 500                 } \
 501                 break; \
 502         case 35: switch (rdata->rdclass) { \
 503                 case 1: result = towire_in_naptr(rdata, cctx, target); break; \
 504                 default: use_default = ISC_TRUE; break; \
 505                 } \
 506                 break; \
 507         case 36: switch (rdata->rdclass) { \
 508                 case 1: result = towire_in_kx(rdata, cctx, target); break; \
 509                 default: use_default = ISC_TRUE; break; \
 510                 } \
 511                 break; \
 512         case 37: result = towire_cert(rdata, cctx, target); break; \
 513         case 38: switch (rdata->rdclass) { \
 514                 case 1: result = towire_in_a6(rdata, cctx, target); break; \
 515                 default: use_default = ISC_TRUE; break; \
 516                 } \
 517                 break; \
 518         case 39: result = towire_dname(rdata, cctx, target); break; \
 519         case 41: result = towire_opt(rdata, cctx, target); break; \
 520         case 42: switch (rdata->rdclass) { \
 521                 case 1: result = towire_in_apl(rdata, cctx, target); break; \
 522                 default: use_default = ISC_TRUE; break; \
 523                 } \
 524                 break; \
 525         case 43: result = towire_ds(rdata, cctx, target); break; \
 526         case 44: result = towire_sshfp(rdata, cctx, target); break; \
 527         case 45: result = towire_ipseckey(rdata, cctx, target); break; \
 528         case 46: result = towire_rrsig(rdata, cctx, target); break; \
 529         case 47: result = towire_nsec(rdata, cctx, target); break; \
 530         case 48: result = towire_dnskey(rdata, cctx, target); break; \
 531         case 49: switch (rdata->rdclass) { \
 532                 case 1: result = towire_in_dhcid(rdata, cctx, target); break; \
 533                 default: use_default = ISC_TRUE; break; \
 534                 } \
 535                 break; \
 536         case 50: result = towire_nsec3(rdata, cctx, target); break; \
 537         case 51: result = towire_nsec3param(rdata, cctx, target); break; \
 538         case 52: result = towire_tlsa(rdata, cctx, target); break; \
 539         case 55: result = towire_hip(rdata, cctx, target); break; \
 540         case 99: result = towire_spf(rdata, cctx, target); break; \
 541         case 103: result = towire_unspec(rdata, cctx, target); break; \
 542         case 249: result = towire_tkey(rdata, cctx, target); break; \
 543         case 250: switch (rdata->rdclass) { \
 544                 case 255: result = towire_any_tsig(rdata, cctx, target); break; \
 545                 default: use_default = ISC_TRUE; break; \
 546                 } \
 547                 break; \
 548         case 32769: result = towire_dlv(rdata, cctx, target); break; \
 549         case 65533: result = towire_keydata(rdata, cctx, target); break; \
 550         default: use_default = ISC_TRUE; break; \
 551         }
 552
 553 #define COMPARESWITCH \
 554         switch (rdata1->type) { \
 555         case 1: switch (rdata1->rdclass) { \
 556                 case 1: result = compare_in_a(rdata1, rdata2); break; \
 557                 case 3: result = compare_ch_a(rdata1, rdata2); break; \
 558                 case 4: result = compare_hs_a(rdata1, rdata2); break; \
 559                 default: use_default = ISC_TRUE; break; \
 560                 } \
 561                 break; \
 562         case 2: result = compare_ns(rdata1, rdata2); break; \
 563         case 3: result = compare_md(rdata1, rdata2); break; \
 564         case 4: result = compare_mf(rdata1, rdata2); break; \
 565         case 5: result = compare_cname(rdata1, rdata2); break; \
 566         case 6: result = compare_soa(rdata1, rdata2); break; \
 567         case 7: result = compare_mb(rdata1, rdata2); break; \
 568         case 8: result = compare_mg(rdata1, rdata2); break; \
 569         case 9: result = compare_mr(rdata1, rdata2); break; \
 570         case 10: result = compare_null(rdata1, rdata2); break; \
 571         case 11: switch (rdata1->rdclass) { \
 572                 case 1: result = compare_in_wks(rdata1, rdata2); break; \
 573                 default: use_default = ISC_TRUE; break; \
 574                 } \
 575                 break; \
 576         case 12: result = compare_ptr(rdata1, rdata2); break; \
 577         case 13: result = compare_hinfo(rdata1, rdata2); break; \
 578         case 14: result = compare_minfo(rdata1, rdata2); break; \
 579         case 15: result = compare_mx(rdata1, rdata2); break; \
 580         case 16: result = compare_txt(rdata1, rdata2); break; \
 581         case 17: result = compare_rp(rdata1, rdata2); break; \
 582         case 18: result = compare_afsdb(rdata1, rdata2); break; \
 583         case 19: result = compare_x25(rdata1, rdata2); break; \
 584         case 20: result = compare_isdn(rdata1, rdata2); break; \
 585         case 21: result = compare_rt(rdata1, rdata2); break; \
 586         case 22: switch (rdata1->rdclass) { \
 587                 case 1: result = compare_in_nsap(rdata1, rdata2); break; \
 588                 default: use_default = ISC_TRUE; break; \
 589                 } \
 590                 break; \
 591         case 23: switch (rdata1->rdclass) { \
 592                 case 1: result = compare_in_nsap_ptr(rdata1, rdata2); break; \
 593                 default: use_default = ISC_TRUE; break; \
 594                 } \
 595                 break; \
 596         case 24: result = compare_sig(rdata1, rdata2); break; \
 597         case 25: result = compare_key(rdata1, rdata2); break; \
 598         case 26: switch (rdata1->rdclass) { \
 599                 case 1: result = compare_in_px(rdata1, rdata2); break; \
 600                 default: use_default = ISC_TRUE; break; \
 601                 } \
 602                 break; \
 603         case 27: result = compare_gpos(rdata1, rdata2); break; \
 604         case 28: switch (rdata1->rdclass) { \
 605                 case 1: result = compare_in_aaaa(rdata1, rdata2); break; \
 606                 default: use_default = ISC_TRUE; break; \
 607                 } \
 608                 break; \
 609         case 29: result = compare_loc(rdata1, rdata2); break; \
 610         case 30: result = compare_nxt(rdata1, rdata2); break; \
 611         case 33: switch (rdata1->rdclass) { \
 612                 case 1: result = compare_in_srv(rdata1, rdata2); break; \
 613                 default: use_default = ISC_TRUE; break; \
 614                 } \
 615                 break; \
 616         case 35: switch (rdata1->rdclass) { \
 617                 case 1: result = compare_in_naptr(rdata1, rdata2); break; \
 618                 default: use_default = ISC_TRUE; break; \
 619                 } \
 620                 break; \
 621         case 36: switch (rdata1->rdclass) { \
 622                 case 1: result = compare_in_kx(rdata1, rdata2); break; \
 623                 default: use_default = ISC_TRUE; break; \
 624                 } \
 625                 break; \
 626         case 37: result = compare_cert(rdata1, rdata2); break; \
 627         case 38: switch (rdata1->rdclass) { \
 628                 case 1: result = compare_in_a6(rdata1, rdata2); break; \
 629                 default: use_default = ISC_TRUE; break; \
 630                 } \
 631                 break; \
 632         case 39: result = compare_dname(rdata1, rdata2); break; \
 633         case 41: result = compare_opt(rdata1, rdata2); break; \
 634         case 42: switch (rdata1->rdclass) { \
 635                 case 1: result = compare_in_apl(rdata1, rdata2); break; \
 636                 default: use_default = ISC_TRUE; break; \
 637                 } \
 638                 break; \
 639         case 43: result = compare_ds(rdata1, rdata2); break; \
 640         case 44: result = compare_sshfp(rdata1, rdata2); break; \
 641         case 45: result = compare_ipseckey(rdata1, rdata2); break; \
 642         case 46: result = compare_rrsig(rdata1, rdata2); break; \
 643         case 47: result = compare_nsec(rdata1, rdata2); break; \
 644         case 48: result = compare_dnskey(rdata1, rdata2); break; \
 645         case 49: switch (rdata1->rdclass) { \
 646                 case 1: result = compare_in_dhcid(rdata1, rdata2); break; \
 647                 default: use_default = ISC_TRUE; break; \
 648                 } \
 649                 break; \
 650         case 50: result = compare_nsec3(rdata1, rdata2); break; \
 651         case 51: result = compare_nsec3param(rdata1, rdata2); break; \
 652         case 52: result = compare_tlsa(rdata1, rdata2); break; \
 653         case 55: result = compare_hip(rdata1, rdata2); break; \
 654         case 99: result = compare_spf(rdata1, rdata2); break; \
 655         case 103: result = compare_unspec(rdata1, rdata2); break; \
 656         case 249: result = compare_tkey(rdata1, rdata2); break; \
 657         case 250: switch (rdata1->rdclass) { \
 658                 case 255: result = compare_any_tsig(rdata1, rdata2); break; \
 659                 default: use_default = ISC_TRUE; break; \
 660                 } \
 661                 break; \
 662         case 32769: result = compare_dlv(rdata1, rdata2); break; \
 663         case 65533: result = compare_keydata(rdata1, rdata2); break; \
 664         default: use_default = ISC_TRUE; break; \
 665         }
 666
 667 #define CASECOMPARESWITCH \
 668         switch (rdata1->type) { \
 669         case 1: switch (rdata1->rdclass) { \
 670                 case 1: result = casecompare_in_a(rdata1, rdata2); break; \
 671                 case 3: result = casecompare_ch_a(rdata1, rdata2); break; \
 672                 case 4: result = casecompare_hs_a(rdata1, rdata2); break; \
 673                 default: use_default = ISC_TRUE; break; \
 674                 } \
 675                 break; \
 676         case 2: result = casecompare_ns(rdata1, rdata2); break; \
 677         case 3: result = casecompare_md(rdata1, rdata2); break; \
 678         case 4: result = casecompare_mf(rdata1, rdata2); break; \
 679         case 5: result = casecompare_cname(rdata1, rdata2); break; \
 680         case 6: result = casecompare_soa(rdata1, rdata2); break; \
 681         case 7: result = casecompare_mb(rdata1, rdata2); break; \
 682         case 8: result = casecompare_mg(rdata1, rdata2); break; \
 683         case 9: result = casecompare_mr(rdata1, rdata2); break; \
 684         case 10: result = casecompare_null(rdata1, rdata2); break; \
 685         case 11: switch (rdata1->rdclass) { \
 686                 case 1: result = casecompare_in_wks(rdata1, rdata2); break; \
 687                 default: use_default = ISC_TRUE; break; \
 688                 } \
 689                 break; \
 690         case 12: result = casecompare_ptr(rdata1, rdata2); break; \
 691         case 13: result = casecompare_hinfo(rdata1, rdata2); break; \
 692         case 14: result = casecompare_minfo(rdata1, rdata2); break; \
 693         case 15: result = casecompare_mx(rdata1, rdata2); break; \
 694         case 16: result = casecompare_txt(rdata1, rdata2); break; \
 695         case 17: result = casecompare_rp(rdata1, rdata2); break; \
 696         case 18: result = casecompare_afsdb(rdata1, rdata2); break; \
 697         case 19: result = casecompare_x25(rdata1, rdata2); break; \
 698         case 20: result = casecompare_isdn(rdata1, rdata2); break; \
 699         case 21: result = casecompare_rt(rdata1, rdata2); break; \
 700         case 22: switch (rdata1->rdclass) { \
 701                 case 1: result = casecompare_in_nsap(rdata1, rdata2); break; \
 702                 default: use_default = ISC_TRUE; break; \
 703                 } \
 704                 break; \
 705         case 23: switch (rdata1->rdclass) { \
 706                 case 1: result = casecompare_in_nsap_ptr(rdata1, rdata2); break; \
 707                 default: use_default = ISC_TRUE; break; \
 708                 } \
 709                 break; \
 710         case 24: result = casecompare_sig(rdata1, rdata2); break; \
 711         case 25: result = casecompare_key(rdata1, rdata2); break; \
 712         case 26: switch (rdata1->rdclass) { \
 713                 case 1: result = casecompare_in_px(rdata1, rdata2); break; \
 714                 default: use_default = ISC_TRUE; break; \
 715                 } \
 716                 break; \
 717         case 27: result = casecompare_gpos(rdata1, rdata2); break; \
 718         case 28: switch (rdata1->rdclass) { \
 719                 case 1: result = casecompare_in_aaaa(rdata1, rdata2); break; \
 720                 default: use_default = ISC_TRUE; break; \
 721                 } \
 722                 break; \
 723         case 29: result = casecompare_loc(rdata1, rdata2); break; \
 724         case 30: result = casecompare_nxt(rdata1, rdata2); break; \
 725         case 33: switch (rdata1->rdclass) { \
 726                 case 1: result = casecompare_in_srv(rdata1, rdata2); break; \
 727                 default: use_default = ISC_TRUE; break; \
 728                 } \
 729                 break; \
 730         case 35: switch (rdata1->rdclass) { \
 731                 case 1: result = casecompare_in_naptr(rdata1, rdata2); break; \
 732                 default: use_default = ISC_TRUE; break; \
 733                 } \
 734                 break; \
 735         case 36: switch (rdata1->rdclass) { \
 736                 case 1: result = casecompare_in_kx(rdata1, rdata2); break; \
 737                 default: use_default = ISC_TRUE; break; \
 738                 } \
 739                 break; \
 740         case 37: result = casecompare_cert(rdata1, rdata2); break; \
 741         case 38: switch (rdata1->rdclass) { \
 742                 case 1: result = casecompare_in_a6(rdata1, rdata2); break; \
 743                 default: use_default = ISC_TRUE; break; \
 744                 } \
 745                 break; \
 746         case 39: result = casecompare_dname(rdata1, rdata2); break; \
 747         case 41: result = casecompare_opt(rdata1, rdata2); break; \
 748         case 42: switch (rdata1->rdclass) { \
 749                 case 1: result = casecompare_in_apl(rdata1, rdata2); break; \
 750                 default: use_default = ISC_TRUE; break; \
 751                 } \
 752                 break; \
 753         case 43: result = casecompare_ds(rdata1, rdata2); break; \
 754         case 44: result = casecompare_sshfp(rdata1, rdata2); break; \
 755         case 45: result = casecompare_ipseckey(rdata1, rdata2); break; \
 756         case 46: result = casecompare_rrsig(rdata1, rdata2); break; \
 757         case 47: result = casecompare_nsec(rdata1, rdata2); break; \
 758         case 48: result = casecompare_dnskey(rdata1, rdata2); break; \
 759         case 49: switch (rdata1->rdclass) { \
 760                 case 1: result = casecompare_in_dhcid(rdata1, rdata2); break; \
 761                 default: use_default = ISC_TRUE; break; \
 762                 } \
 763                 break; \
 764         case 50: result = casecompare_nsec3(rdata1, rdata2); break; \
 765         case 51: result = casecompare_nsec3param(rdata1, rdata2); break; \
 766         case 52: result = casecompare_tlsa(rdata1, rdata2); break; \
 767         case 55: result = casecompare_hip(rdata1, rdata2); break; \
 768         case 99: result = casecompare_spf(rdata1, rdata2); break; \
 769         case 103: result = casecompare_unspec(rdata1, rdata2); break; \
 770         case 249: result = casecompare_tkey(rdata1, rdata2); break; \
 771         case 250: switch (rdata1->rdclass) { \
 772                 case 255: result = casecompare_any_tsig(rdata1, rdata2); break; \
 773                 default: use_default = ISC_TRUE; break; \
 774                 } \
 775                 break; \
 776         case 32769: result = casecompare_dlv(rdata1, rdata2); break; \
 777         case 65533: result = casecompare_keydata(rdata1, rdata2); break; \
 778         default: use_default = ISC_TRUE; break; \
 779         }
 780
 781 #define FROMSTRUCTSWITCH \
 782         switch (type) { \
 783         case 1: switch (rdclass) { \
 784                 case 1: result = fromstruct_in_a(rdclass, type, source, target); break; \
 785                 case 3: result = fromstruct_ch_a(rdclass, type, source, target); break; \
 786                 case 4: result = fromstruct_hs_a(rdclass, type, source, target); break; \
 787                 default: use_default = ISC_TRUE; break; \
 788                 } \
 789                 break; \
 790         case 2: result = fromstruct_ns(rdclass, type, source, target); break; \
 791         case 3: result = fromstruct_md(rdclass, type, source, target); break; \
 792         case 4: result = fromstruct_mf(rdclass, type, source, target); break; \
 793         case 5: result = fromstruct_cname(rdclass, type, source, target); break; \
 794         case 6: result = fromstruct_soa(rdclass, type, source, target); break; \
 795         case 7: result = fromstruct_mb(rdclass, type, source, target); break; \
 796         case 8: result = fromstruct_mg(rdclass, type, source, target); break; \
 797         case 9: result = fromstruct_mr(rdclass, type, source, target); break; \
 798         case 10: result = fromstruct_null(rdclass, type, source, target); break; \
 799         case 11: switch (rdclass) { \
 800                 case 1: result = fromstruct_in_wks(rdclass, type, source, target); break; \
 801                 default: use_default = ISC_TRUE; break; \
 802                 } \
 803                 break; \
 804         case 12: result = fromstruct_ptr(rdclass, type, source, target); break; \
 805         case 13: result = fromstruct_hinfo(rdclass, type, source, target); break; \
 806         case 14: result = fromstruct_minfo(rdclass, type, source, target); break; \
 807         case 15: result = fromstruct_mx(rdclass, type, source, target); break; \
 808         case 16: result = fromstruct_txt(rdclass, type, source, target); break; \
 809         case 17: result = fromstruct_rp(rdclass, type, source, target); break; \
 810         case 18: result = fromstruct_afsdb(rdclass, type, source, target); break; \
 811         case 19: result = fromstruct_x25(rdclass, type, source, target); break; \
 812         case 20: result = fromstruct_isdn(rdclass, type, source, target); break; \
 813         case 21: result = fromstruct_rt(rdclass, type, source, target); break; \
 814         case 22: switch (rdclass) { \
 815                 case 1: result = fromstruct_in_nsap(rdclass, type, source, target); break; \
 816                 default: use_default = ISC_TRUE; break; \
 817                 } \
 818                 break; \
 819         case 23: switch (rdclass) { \
 820                 case 1: result = fromstruct_in_nsap_ptr(rdclass, type, source, target); break; \
 821                 default: use_default = ISC_TRUE; break; \
 822                 } \
 823                 break; \
 824         case 24: result = fromstruct_sig(rdclass, type, source, target); break; \
 825         case 25: result = fromstruct_key(rdclass, type, source, target); break; \
 826         case 26: switch (rdclass) { \
 827                 case 1: result = fromstruct_in_px(rdclass, type, source, target); break; \
 828                 default: use_default = ISC_TRUE; break; \
 829                 } \
 830                 break; \
 831         case 27: result = fromstruct_gpos(rdclass, type, source, target); break; \
 832         case 28: switch (rdclass) { \
 833                 case 1: result = fromstruct_in_aaaa(rdclass, type, source, target); break; \
 834                 default: use_default = ISC_TRUE; break; \
 835                 } \
 836                 break; \
 837         case 29: result = fromstruct_loc(rdclass, type, source, target); break; \
 838         case 30: result = fromstruct_nxt(rdclass, type, source, target); break; \
 839         case 33: switch (rdclass) { \
 840                 case 1: result = fromstruct_in_srv(rdclass, type, source, target); break; \
 841                 default: use_default = ISC_TRUE; break; \
 842                 } \
 843                 break; \
 844         case 35: switch (rdclass) { \
 845                 case 1: result = fromstruct_in_naptr(rdclass, type, source, target); break; \
 846                 default: use_default = ISC_TRUE; break; \
 847                 } \
 848                 break; \
 849         case 36: switch (rdclass) { \
 850                 case 1: result = fromstruct_in_kx(rdclass, type, source, target); break; \
 851                 default: use_default = ISC_TRUE; break; \
 852                 } \
 853                 break; \
 854         case 37: result = fromstruct_cert(rdclass, type, source, target); break; \
 855         case 38: switch (rdclass) { \
 856                 case 1: result = fromstruct_in_a6(rdclass, type, source, target); break; \
 857                 default: use_default = ISC_TRUE; break; \
 858                 } \
 859                 break; \
 860         case 39: result = fromstruct_dname(rdclass, type, source, target); break; \
 861         case 41: result = fromstruct_opt(rdclass, type, source, target); break; \
 862         case 42: switch (rdclass) { \
 863                 case 1: result = fromstruct_in_apl(rdclass, type, source, target); break; \
 864                 default: use_default = ISC_TRUE; break; \
 865                 } \
 866                 break; \
 867         case 43: result = fromstruct_ds(rdclass, type, source, target); break; \
 868         case 44: result = fromstruct_sshfp(rdclass, type, source, target); break; \
 869         case 45: result = fromstruct_ipseckey(rdclass, type, source, target); break; \
 870         case 46: result = fromstruct_rrsig(rdclass, type, source, target); break; \
 871         case 47: result = fromstruct_nsec(rdclass, type, source, target); break; \
 872         case 48: result = fromstruct_dnskey(rdclass, type, source, target); break; \
 873         case 49: switch (rdclass) { \
 874                 case 1: result = fromstruct_in_dhcid(rdclass, type, source, target); break; \
 875                 default: use_default = ISC_TRUE; break; \
 876                 } \
 877                 break; \
 878         case 50: result = fromstruct_nsec3(rdclass, type, source, target); break; \
 879         case 51: result = fromstruct_nsec3param(rdclass, type, source, target); break; \
 880         case 52: result = fromstruct_tlsa(rdclass, type, source, target); break; \
 881         case 55: result = fromstruct_hip(rdclass, type, source, target); break; \
 882         case 99: result = fromstruct_spf(rdclass, type, source, target); break; \
 883         case 103: result = fromstruct_unspec(rdclass, type, source, target); break; \
 884         case 249: result = fromstruct_tkey(rdclass, type, source, target); break; \
 885         case 250: switch (rdclass) { \
 886                 case 255: result = fromstruct_any_tsig(rdclass, type, source, target); break; \
 887                 default: use_default = ISC_TRUE; break; \
 888                 } \
 889                 break; \
 890         case 32769: result = fromstruct_dlv(rdclass, type, source, target); break; \
 891         case 65533: result = fromstruct_keydata(rdclass, type, source, target); break; \
 892         default: use_default = ISC_TRUE; break; \
 893         }
 894
 895 #define TOSTRUCTSWITCH \
 896         switch (rdata->type) { \
 897         case 1: switch (rdata->rdclass) { \
 898                 case 1: result = tostruct_in_a(rdata, target, mctx); break; \
 899                 case 3: result = tostruct_ch_a(rdata, target, mctx); break; \
 900                 case 4: result = tostruct_hs_a(rdata, target, mctx); break; \
 901                 default: use_default = ISC_TRUE; break; \
 902                 } \
 903                 break; \
 904         case 2: result = tostruct_ns(rdata, target, mctx); break; \
 905         case 3: result = tostruct_md(rdata, target, mctx); break; \
 906         case 4: result = tostruct_mf(rdata, target, mctx); break; \
 907         case 5: result = tostruct_cname(rdata, target, mctx); break; \
 908         case 6: result = tostruct_soa(rdata, target, mctx); break; \
 909         case 7: result = tostruct_mb(rdata, target, mctx); break; \
 910         case 8: result = tostruct_mg(rdata, target, mctx); break; \
 911         case 9: result = tostruct_mr(rdata, target, mctx); break; \
 912         case 10: result = tostruct_null(rdata, target, mctx); break; \
 913         case 11: switch (rdata->rdclass) { \
 914                 case 1: result = tostruct_in_wks(rdata, target, mctx); break; \
 915                 default: use_default = ISC_TRUE; break; \
 916                 } \
 917                 break; \
 918         case 12: result = tostruct_ptr(rdata, target, mctx); break; \
 919         case 13: result = tostruct_hinfo(rdata, target, mctx); break; \
 920         case 14: result = tostruct_minfo(rdata, target, mctx); break; \
 921         case 15: result = tostruct_mx(rdata, target, mctx); break; \
 922         case 16: result = tostruct_txt(rdata, target, mctx); break; \
 923         case 17: result = tostruct_rp(rdata, target, mctx); break; \
 924         case 18: result = tostruct_afsdb(rdata, target, mctx); break; \
 925         case 19: result = tostruct_x25(rdata, target, mctx); break; \
 926         case 20: result = tostruct_isdn(rdata, target, mctx); break; \
 927         case 21: result = tostruct_rt(rdata, target, mctx); break; \
 928         case 22: switch (rdata->rdclass) { \
 929                 case 1: result = tostruct_in_nsap(rdata, target, mctx); break; \
 930                 default: use_default = ISC_TRUE; break; \
 931                 } \
 932                 break; \
 933         case 23: switch (rdata->rdclass) { \
 934                 case 1: result = tostruct_in_nsap_ptr(rdata, target, mctx); break; \
 935                 default: use_default = ISC_TRUE; break; \
 936                 } \
 937                 break; \
 938         case 24: result = tostruct_sig(rdata, target, mctx); break; \
 939         case 25: result = tostruct_key(rdata, target, mctx); break; \
 940         case 26: switch (rdata->rdclass) { \
 941                 case 1: result = tostruct_in_px(rdata, target, mctx); break; \
 942                 default: use_default = ISC_TRUE; break; \
 943                 } \
 944                 break; \
 945         case 27: result = tostruct_gpos(rdata, target, mctx); break; \
 946         case 28: switch (rdata->rdclass) { \
 947                 case 1: result = tostruct_in_aaaa(rdata, target, mctx); break; \
 948                 default: use_default = ISC_TRUE; break; \
 949                 } \
 950                 break; \
 951         case 29: result = tostruct_loc(rdata, target, mctx); break; \
 952         case 30: result = tostruct_nxt(rdata, target, mctx); break; \
 953         case 33: switch (rdata->rdclass) { \
 954                 case 1: result = tostruct_in_srv(rdata, target, mctx); break; \
 955                 default: use_default = ISC_TRUE; break; \
 956                 } \
 957                 break; \
 958         case 35: switch (rdata->rdclass) { \
 959                 case 1: result = tostruct_in_naptr(rdata, target, mctx); break; \
 960                 default: use_default = ISC_TRUE; break; \
 961                 } \
 962                 break; \
 963         case 36: switch (rdata->rdclass) { \
 964                 case 1: result = tostruct_in_kx(rdata, target, mctx); break; \
 965                 default: use_default = ISC_TRUE; break; \
 966                 } \
 967                 break; \
 968         case 37: result = tostruct_cert(rdata, target, mctx); break; \
 969         case 38: switch (rdata->rdclass) { \
 970                 case 1: result = tostruct_in_a6(rdata, target, mctx); break; \
 971                 default: use_default = ISC_TRUE; break; \
 972                 } \
 973                 break; \
 974         case 39: result = tostruct_dname(rdata, target, mctx); break; \
 975         case 41: result = tostruct_opt(rdata, target, mctx); break; \
 976         case 42: switch (rdata->rdclass) { \
 977                 case 1: result = tostruct_in_apl(rdata, target, mctx); break; \
 978                 default: use_default = ISC_TRUE; break; \
 979                 } \
 980                 break; \
 981         case 43: result = tostruct_ds(rdata, target, mctx); break; \
 982         case 44: result = tostruct_sshfp(rdata, target, mctx); break; \
 983         case 45: result = tostruct_ipseckey(rdata, target, mctx); break; \
 984         case 46: result = tostruct_rrsig(rdata, target, mctx); break; \
 985         case 47: result = tostruct_nsec(rdata, target, mctx); break; \
 986         case 48: result = tostruct_dnskey(rdata, target, mctx); break; \
 987         case 49: switch (rdata->rdclass) { \
 988                 case 1: result = tostruct_in_dhcid(rdata, target, mctx); break; \
 989                 default: use_default = ISC_TRUE; break; \
 990                 } \
 991                 break; \
 992         case 50: result = tostruct_nsec3(rdata, target, mctx); break; \
 993         case 51: result = tostruct_nsec3param(rdata, target, mctx); break; \
 994         case 52: result = tostruct_tlsa(rdata, target, mctx); break; \
 995         case 55: result = tostruct_hip(rdata, target, mctx); break; \
 996         case 99: result = tostruct_spf(rdata, target, mctx); break; \
 997         case 103: result = tostruct_unspec(rdata, target, mctx); break; \
 998         case 249: result = tostruct_tkey(rdata, target, mctx); break; \
 999         case 250: switch (rdata->rdclass) { \
1000                 case 255: result = tostruct_any_tsig(rdata, target, mctx); break; \
1001                 default: use_default = ISC_TRUE; break; \
1002                 } \
1003                 break; \
1004         case 32769: result = tostruct_dlv(rdata, target, mctx); break; \
1005         case 65533: result = tostruct_keydata(rdata, target, mctx); break; \
1006         default: use_default = ISC_TRUE; break; \
1007         }
1008
1009 #define FREESTRUCTSWITCH \
1010         switch (common->rdtype) { \
1011         case 1: switch (common->rdclass) { \
1012                 case 1: freestruct_in_a(source); break; \
1013                 case 3: freestruct_ch_a(source); break; \
1014                 case 4: freestruct_hs_a(source); break; \
1015                 default: break; \
1016                 } \
1017                 break; \
1018         case 2: freestruct_ns(source); break; \
1019         case 3: freestruct_md(source); break; \
1020         case 4: freestruct_mf(source); break; \
1021         case 5: freestruct_cname(source); break; \
1022         case 6: freestruct_soa(source); break; \
1023         case 7: freestruct_mb(source); break; \
1024         case 8: freestruct_mg(source); break; \
1025         case 9: freestruct_mr(source); break; \
1026         case 10: freestruct_null(source); break; \
1027         case 11: switch (common->rdclass) { \
1028                 case 1: freestruct_in_wks(source); break; \
1029                 default: break; \
1030                 } \
1031                 break; \
1032         case 12: freestruct_ptr(source); break; \
1033         case 13: freestruct_hinfo(source); break; \
1034         case 14: freestruct_minfo(source); break; \
1035         case 15: freestruct_mx(source); break; \
1036         case 16: freestruct_txt(source); break; \
1037         case 17: freestruct_rp(source); break; \
1038         case 18: freestruct_afsdb(source); break; \
1039         case 19: freestruct_x25(source); break; \
1040         case 20: freestruct_isdn(source); break; \
1041         case 21: freestruct_rt(source); break; \
1042         case 22: switch (common->rdclass) { \
1043                 case 1: freestruct_in_nsap(source); break; \
1044                 default: break; \
1045                 } \
1046                 break; \
1047         case 23: switch (common->rdclass) { \
1048                 case 1: freestruct_in_nsap_ptr(source); break; \
1049                 default: break; \
1050                 } \
1051                 break; \
1052         case 24: freestruct_sig(source); break; \
1053         case 25: freestruct_key(source); break; \
1054         case 26: switch (common->rdclass) { \
1055                 case 1: freestruct_in_px(source); break; \
1056                 default: break; \
1057                 } \
1058                 break; \
1059         case 27: freestruct_gpos(source); break; \
1060         case 28: switch (common->rdclass) { \
1061                 case 1: freestruct_in_aaaa(source); break; \
1062                 default: break; \
1063                 } \
1064                 break; \
1065         case 29: freestruct_loc(source); break; \
1066         case 30: freestruct_nxt(source); break; \
1067         case 33: switch (common->rdclass) { \
1068                 case 1: freestruct_in_srv(source); break; \
1069                 default: break; \
1070                 } \
1071                 break; \
1072         case 35: switch (common->rdclass) { \
1073                 case 1: freestruct_in_naptr(source); break; \
1074                 default: break; \
1075                 } \
1076                 break; \
1077         case 36: switch (common->rdclass) { \
1078                 case 1: freestruct_in_kx(source); break; \
1079                 default: break; \
1080                 } \
1081                 break; \
1082         case 37: freestruct_cert(source); break; \
1083         case 38: switch (common->rdclass) { \
1084                 case 1: freestruct_in_a6(source); break; \
1085                 default: break; \
1086                 } \
1087                 break; \
1088         case 39: freestruct_dname(source); break; \
1089         case 41: freestruct_opt(source); break; \
1090         case 42: switch (common->rdclass) { \
1091                 case 1: freestruct_in_apl(source); break; \
1092                 default: break; \
1093                 } \
1094                 break; \
1095         case 43: freestruct_ds(source); break; \
1096         case 44: freestruct_sshfp(source); break; \
1097         case 45: freestruct_ipseckey(source); break; \
1098         case 46: freestruct_rrsig(source); break; \
1099         case 47: freestruct_nsec(source); break; \
1100         case 48: freestruct_dnskey(source); break; \
1101         case 49: switch (common->rdclass) { \
1102                 case 1: freestruct_in_dhcid(source); break; \
1103                 default: break; \
1104                 } \
1105                 break; \
1106         case 50: freestruct_nsec3(source); break; \
1107         case 51: freestruct_nsec3param(source); break; \
1108         case 52: freestruct_tlsa(source); break; \
1109         case 55: freestruct_hip(source); break; \
1110         case 99: freestruct_spf(source); break; \
1111         case 103: freestruct_unspec(source); break; \
1112         case 249: freestruct_tkey(source); break; \
1113         case 250: switch (common->rdclass) { \
1114                 case 255: freestruct_any_tsig(source); break; \
1115                 default: break; \
1116                 } \
1117                 break; \
1118         case 32769: freestruct_dlv(source); break; \
1119         case 65533: freestruct_keydata(source); break; \
1120         default: break; \
1121         }
1122
1123 #define ADDITIONALDATASWITCH \
1124         switch (rdata->type) { \
1125         case 1: switch (rdata->rdclass) { \
1126                 case 1: result = additionaldata_in_a(rdata, add, arg); break; \
1127                 case 3: result = additionaldata_ch_a(rdata, add, arg); break; \
1128                 case 4: result = additionaldata_hs_a(rdata, add, arg); break; \
1129                 default: use_default = ISC_TRUE; break; \
1130                 } \
1131                 break; \
1132         case 2: result = additionaldata_ns(rdata, add, arg); break; \
1133         case 3: result = additionaldata_md(rdata, add, arg); break; \
1134         case 4: result = additionaldata_mf(rdata, add, arg); break; \
1135         case 5: result = additionaldata_cname(rdata, add, arg); break; \
1136         case 6: result = additionaldata_soa(rdata, add, arg); break; \
1137         case 7: result = additionaldata_mb(rdata, add, arg); break; \
1138         case 8: result = additionaldata_mg(rdata, add, arg); break; \
1139         case 9: result = additionaldata_mr(rdata, add, arg); break; \
1140         case 10: result = additionaldata_null(rdata, add, arg); break; \
1141         case 11: switch (rdata->rdclass) { \
1142                 case 1: result = additionaldata_in_wks(rdata, add, arg); break; \
1143                 default: use_default = ISC_TRUE; break; \
1144                 } \
1145                 break; \
1146         case 12: result = additionaldata_ptr(rdata, add, arg); break; \
1147         case 13: result = additionaldata_hinfo(rdata, add, arg); break; \
1148         case 14: result = additionaldata_minfo(rdata, add, arg); break; \
1149         case 15: result = additionaldata_mx(rdata, add, arg); break; \
1150         case 16: result = additionaldata_txt(rdata, add, arg); break; \
1151         case 17: result = additionaldata_rp(rdata, add, arg); break; \
1152         case 18: result = additionaldata_afsdb(rdata, add, arg); break; \
1153         case 19: result = additionaldata_x25(rdata, add, arg); break; \
1154         case 20: result = additionaldata_isdn(rdata, add, arg); break; \
1155         case 21: result = additionaldata_rt(rdata, add, arg); break; \
1156         case 22: switch (rdata->rdclass) { \
1157                 case 1: result = additionaldata_in_nsap(rdata, add, arg); break; \
1158                 default: use_default = ISC_TRUE; break; \
1159                 } \
1160                 break; \
1161         case 23: switch (rdata->rdclass) { \
1162                 case 1: result = additionaldata_in_nsap_ptr(rdata, add, arg); break; \
1163                 default: use_default = ISC_TRUE; break; \
1164                 } \
1165                 break; \
1166         case 24: result = additionaldata_sig(rdata, add, arg); break; \
1167         case 25: result = additionaldata_key(rdata, add, arg); break; \
1168         case 26: switch (rdata->rdclass) { \
1169                 case 1: result = additionaldata_in_px(rdata, add, arg); break; \
1170                 default: use_default = ISC_TRUE; break; \
1171                 } \
1172                 break; \
1173         case 27: result = additionaldata_gpos(rdata, add, arg); break; \
1174         case 28: switch (rdata->rdclass) { \
1175                 case 1: result = additionaldata_in_aaaa(rdata, add, arg); break; \
1176                 default: use_default = ISC_TRUE; break; \
1177                 } \
1178                 break; \
1179         case 29: result = additionaldata_loc(rdata, add, arg); break; \
1180         case 30: result = additionaldata_nxt(rdata, add, arg); break; \
1181         case 33: switch (rdata->rdclass) { \
1182                 case 1: result = additionaldata_in_srv(rdata, add, arg); break; \
1183                 default: use_default = ISC_TRUE; break; \
1184                 } \
1185                 break; \
1186         case 35: switch (rdata->rdclass) { \
1187                 case 1: result = additionaldata_in_naptr(rdata, add, arg); break; \
1188                 default: use_default = ISC_TRUE; break; \
1189                 } \
1190                 break; \
1191         case 36: switch (rdata->rdclass) { \
1192                 case 1: result = additionaldata_in_kx(rdata, add, arg); break; \
1193                 default: use_default = ISC_TRUE; break; \
1194                 } \
1195                 break; \
1196         case 37: result = additionaldata_cert(rdata, add, arg); break; \
1197         case 38: switch (rdata->rdclass) { \
1198                 case 1: result = additionaldata_in_a6(rdata, add, arg); break; \
1199                 default: use_default = ISC_TRUE; break; \
1200                 } \
1201                 break; \
1202         case 39: result = additionaldata_dname(rdata, add, arg); break; \
1203         case 41: result = additionaldata_opt(rdata, add, arg); break; \
1204         case 42: switch (rdata->rdclass) { \
1205                 case 1: result = additionaldata_in_apl(rdata, add, arg); break; \
1206                 default: use_default = ISC_TRUE; break; \
1207                 } \
1208                 break; \
1209         case 43: result = additionaldata_ds(rdata, add, arg); break; \
1210         case 44: result = additionaldata_sshfp(rdata, add, arg); break; \
1211         case 45: result = additionaldata_ipseckey(rdata, add, arg); break; \
1212         case 46: result = additionaldata_rrsig(rdata, add, arg); break; \
1213         case 47: result = additionaldata_nsec(rdata, add, arg); break; \
1214         case 48: result = additionaldata_dnskey(rdata, add, arg); break; \
1215         case 49: switch (rdata->rdclass) { \
1216                 case 1: result = additionaldata_in_dhcid(rdata, add, arg); break; \
1217                 default: use_default = ISC_TRUE; break; \
1218                 } \
1219                 break; \
1220         case 50: result = additionaldata_nsec3(rdata, add, arg); break; \
1221         case 51: result = additionaldata_nsec3param(rdata, add, arg); break; \
1222         case 52: result = additionaldata_tlsa(rdata, add, arg); break; \
1223         case 55: result = additionaldata_hip(rdata, add, arg); break; \
1224         case 99: result = additionaldata_spf(rdata, add, arg); break; \
1225         case 103: result = additionaldata_unspec(rdata, add, arg); break; \
1226         case 249: result = additionaldata_tkey(rdata, add, arg); break; \
1227         case 250: switch (rdata->rdclass) { \
1228                 case 255: result = additionaldata_any_tsig(rdata, add, arg); break; \
1229                 default: use_default = ISC_TRUE; break; \
1230                 } \
1231                 break; \
1232         case 32769: result = additionaldata_dlv(rdata, add, arg); break; \
1233         case 65533: result = additionaldata_keydata(rdata, add, arg); break; \
1234         default: use_default = ISC_TRUE; break; \
1235         }
1236
1237 #define DIGESTSWITCH \
1238         switch (rdata->type) { \
1239         case 1: switch (rdata->rdclass) { \
1240                 case 1: result = digest_in_a(rdata, digest, arg); break; \
1241                 case 3: result = digest_ch_a(rdata, digest, arg); break; \
1242                 case 4: result = digest_hs_a(rdata, digest, arg); break; \
1243                 default: use_default = ISC_TRUE; break; \
1244                 } \
1245                 break; \
1246         case 2: result = digest_ns(rdata, digest, arg); break; \
1247         case 3: result = digest_md(rdata, digest, arg); break; \
1248         case 4: result = digest_mf(rdata, digest, arg); break; \
1249         case 5: result = digest_cname(rdata, digest, arg); break; \
1250         case 6: result = digest_soa(rdata, digest, arg); break; \
1251         case 7: result = digest_mb(rdata, digest, arg); break; \
1252         case 8: result = digest_mg(rdata, digest, arg); break; \
1253         case 9: result = digest_mr(rdata, digest, arg); break; \
1254         case 10: result = digest_null(rdata, digest, arg); break; \
1255         case 11: switch (rdata->rdclass) { \
1256                 case 1: result = digest_in_wks(rdata, digest, arg); break; \
1257                 default: use_default = ISC_TRUE; break; \
1258                 } \
1259                 break; \
1260         case 12: result = digest_ptr(rdata, digest, arg); break; \
1261         case 13: result = digest_hinfo(rdata, digest, arg); break; \
1262         case 14: result = digest_minfo(rdata, digest, arg); break; \
1263         case 15: result = digest_mx(rdata, digest, arg); break; \
1264         case 16: result = digest_txt(rdata, digest, arg); break; \
1265         case 17: result = digest_rp(rdata, digest, arg); break; \
1266         case 18: result = digest_afsdb(rdata, digest, arg); break; \
1267         case 19: result = digest_x25(rdata, digest, arg); break; \
1268         case 20: result = digest_isdn(rdata, digest, arg); break; \
1269         case 21: result = digest_rt(rdata, digest, arg); break; \
1270         case 22: switch (rdata->rdclass) { \
1271                 case 1: result = digest_in_nsap(rdata, digest, arg); break; \
1272                 default: use_default = ISC_TRUE; break; \
1273                 } \
1274                 break; \
1275         case 23: switch (rdata->rdclass) { \
1276                 case 1: result = digest_in_nsap_ptr(rdata, digest, arg); break; \
1277                 default: use_default = ISC_TRUE; break; \
1278                 } \
1279                 break; \
1280         case 24: result = digest_sig(rdata, digest, arg); break; \
1281         case 25: result = digest_key(rdata, digest, arg); break; \
1282         case 26: switch (rdata->rdclass) { \
1283                 case 1: result = digest_in_px(rdata, digest, arg); break; \
1284                 default: use_default = ISC_TRUE; break; \
1285                 } \
1286                 break; \
1287         case 27: result = digest_gpos(rdata, digest, arg); break; \
1288         case 28: switch (rdata->rdclass) { \
1289                 case 1: result = digest_in_aaaa(rdata, digest, arg); break; \
1290                 default: use_default = ISC_TRUE; break; \
1291                 } \
1292                 break; \
1293         case 29: result = digest_loc(rdata, digest, arg); break; \
1294         case 30: result = digest_nxt(rdata, digest, arg); break; \
1295         case 33: switch (rdata->rdclass) { \
1296                 case 1: result = digest_in_srv(rdata, digest, arg); break; \
1297                 default: use_default = ISC_TRUE; break; \
1298                 } \
1299                 break; \
1300         case 35: switch (rdata->rdclass) { \
1301                 case 1: result = digest_in_naptr(rdata, digest, arg); break; \
1302                 default: use_default = ISC_TRUE; break; \
1303                 } \
1304                 break; \
1305         case 36: switch (rdata->rdclass) { \
1306                 case 1: result = digest_in_kx(rdata, digest, arg); break; \
1307                 default: use_default = ISC_TRUE; break; \
1308                 } \
1309                 break; \
1310         case 37: result = digest_cert(rdata, digest, arg); break; \
1311         case 38: switch (rdata->rdclass) { \
1312                 case 1: result = digest_in_a6(rdata, digest, arg); break; \
1313                 default: use_default = ISC_TRUE; break; \
1314                 } \
1315                 break; \
1316         case 39: result = digest_dname(rdata, digest, arg); break; \
1317         case 41: result = digest_opt(rdata, digest, arg); break; \
1318         case 42: switch (rdata->rdclass) { \
1319                 case 1: result = digest_in_apl(rdata, digest, arg); break; \
1320                 default: use_default = ISC_TRUE; break; \
1321                 } \
1322                 break; \
1323         case 43: result = digest_ds(rdata, digest, arg); break; \
1324         case 44: result = digest_sshfp(rdata, digest, arg); break; \
1325         case 45: result = digest_ipseckey(rdata, digest, arg); break; \
1326         case 46: result = digest_rrsig(rdata, digest, arg); break; \
1327         case 47: result = digest_nsec(rdata, digest, arg); break; \
1328         case 48: result = digest_dnskey(rdata, digest, arg); break; \
1329         case 49: switch (rdata->rdclass) { \
1330                 case 1: result = digest_in_dhcid(rdata, digest, arg); break; \
1331                 default: use_default = ISC_TRUE; break; \
1332                 } \
1333                 break; \
1334         case 50: result = digest_nsec3(rdata, digest, arg); break; \
1335         case 51: result = digest_nsec3param(rdata, digest, arg); break; \
1336         case 52: result = digest_tlsa(rdata, digest, arg); break; \
1337         case 55: result = digest_hip(rdata, digest, arg); break; \
1338         case 99: result = digest_spf(rdata, digest, arg); break; \
1339         case 103: result = digest_unspec(rdata, digest, arg); break; \
1340         case 249: result = digest_tkey(rdata, digest, arg); break; \
1341         case 250: switch (rdata->rdclass) { \
1342                 case 255: result = digest_any_tsig(rdata, digest, arg); break; \
1343                 default: use_default = ISC_TRUE; break; \
1344                 } \
1345                 break; \
1346         case 32769: result = digest_dlv(rdata, digest, arg); break; \
1347         case 65533: result = digest_keydata(rdata, digest, arg); break; \
1348         default: use_default = ISC_TRUE; break; \
1349         }
1350
1351 #define CHECKOWNERSWITCH \
1352         switch (type) { \
1353         case 1: switch (rdclass) { \
1354                 case 1: result = checkowner_in_a(name, rdclass, type, wildcard); break; \
1355                 case 3: result = checkowner_ch_a(name, rdclass, type, wildcard); break; \
1356                 case 4: result = checkowner_hs_a(name, rdclass, type, wildcard); break; \
1357                 default: result = ISC_TRUE; break; \
1358                 } \
1359                 break; \
1360         case 2: result = checkowner_ns(name, rdclass, type, wildcard); break; \
1361         case 3: result = checkowner_md(name, rdclass, type, wildcard); break; \
1362         case 4: result = checkowner_mf(name, rdclass, type, wildcard); break; \
1363         case 5: result = checkowner_cname(name, rdclass, type, wildcard); break; \
1364         case 6: result = checkowner_soa(name, rdclass, type, wildcard); break; \
1365         case 7: result = checkowner_mb(name, rdclass, type, wildcard); break; \
1366         case 8: result = checkowner_mg(name, rdclass, type, wildcard); break; \
1367         case 9: result = checkowner_mr(name, rdclass, type, wildcard); break; \
1368         case 10: result = checkowner_null(name, rdclass, type, wildcard); break; \
1369         case 11: switch (rdclass) { \
1370                 case 1: result = checkowner_in_wks(name, rdclass, type, wildcard); break; \
1371                 default: result = ISC_TRUE; break; \
1372                 } \
1373                 break; \
1374         case 12: result = checkowner_ptr(name, rdclass, type, wildcard); break; \
1375         case 13: result = checkowner_hinfo(name, rdclass, type, wildcard); break; \
1376         case 14: result = checkowner_minfo(name, rdclass, type, wildcard); break; \
1377         case 15: result = checkowner_mx(name, rdclass, type, wildcard); break; \
1378         case 16: result = checkowner_txt(name, rdclass, type, wildcard); break; \
1379         case 17: result = checkowner_rp(name, rdclass, type, wildcard); break; \
1380         case 18: result = checkowner_afsdb(name, rdclass, type, wildcard); break; \
1381         case 19: result = checkowner_x25(name, rdclass, type, wildcard); break; \
1382         case 20: result = checkowner_isdn(name, rdclass, type, wildcard); break; \
1383         case 21: result = checkowner_rt(name, rdclass, type, wildcard); break; \
1384         case 22: switch (rdclass) { \
1385                 case 1: result = checkowner_in_nsap(name, rdclass, type, wildcard); break; \
1386                 default: result = ISC_TRUE; break; \
1387                 } \
1388                 break; \
1389         case 23: switch (rdclass) { \
1390                 case 1: result = checkowner_in_nsap_ptr(name, rdclass, type, wildcard); break; \
1391                 default: result = ISC_TRUE; break; \
1392                 } \
1393                 break; \
1394         case 24: result = checkowner_sig(name, rdclass, type, wildcard); break; \
1395         case 25: result = checkowner_key(name, rdclass, type, wildcard); break; \
1396         case 26: switch (rdclass) { \
1397                 case 1: result = checkowner_in_px(name, rdclass, type, wildcard); break; \
1398                 default: result = ISC_TRUE; break; \
1399                 } \
1400                 break; \
1401         case 27: result = checkowner_gpos(name, rdclass, type, wildcard); break; \
1402         case 28: switch (rdclass) { \
1403                 case 1: result = checkowner_in_aaaa(name, rdclass, type, wildcard); break; \
1404                 default: result = ISC_TRUE; break; \
1405                 } \
1406                 break; \
1407         case 29: result = checkowner_loc(name, rdclass, type, wildcard); break; \
1408         case 30: result = checkowner_nxt(name, rdclass, type, wildcard); break; \
1409         case 33: switch (rdclass) { \
1410                 case 1: result = checkowner_in_srv(name, rdclass, type, wildcard); break; \
1411                 default: result = ISC_TRUE; break; \
1412                 } \
1413                 break; \
1414         case 35: switch (rdclass) { \
1415                 case 1: result = checkowner_in_naptr(name, rdclass, type, wildcard); break; \
1416                 default: result = ISC_TRUE; break; \
1417                 } \
1418                 break; \
1419         case 36: switch (rdclass) { \
1420                 case 1: result = checkowner_in_kx(name, rdclass, type, wildcard); break; \
1421                 default: result = ISC_TRUE; break; \
1422                 } \
1423                 break; \
1424         case 37: result = checkowner_cert(name, rdclass, type, wildcard); break; \
1425         case 38: switch (rdclass) { \
1426                 case 1: result = checkowner_in_a6(name, rdclass, type, wildcard); break; \
1427                 default: result = ISC_TRUE; break; \
1428                 } \
1429                 break; \
1430         case 39: result = checkowner_dname(name, rdclass, type, wildcard); break; \
1431         case 41: result = checkowner_opt(name, rdclass, type, wildcard); break; \
1432         case 42: switch (rdclass) { \
1433                 case 1: result = checkowner_in_apl(name, rdclass, type, wildcard); break; \
1434                 default: result = ISC_TRUE; break; \
1435                 } \
1436                 break; \
1437         case 43: result = checkowner_ds(name, rdclass, type, wildcard); break; \
1438         case 44: result = checkowner_sshfp(name, rdclass, type, wildcard); break; \
1439         case 45: result = checkowner_ipseckey(name, rdclass, type, wildcard); break; \
1440         case 46: result = checkowner_rrsig(name, rdclass, type, wildcard); break; \
1441         case 47: result = checkowner_nsec(name, rdclass, type, wildcard); break; \
1442         case 48: result = checkowner_dnskey(name, rdclass, type, wildcard); break; \
1443         case 49: switch (rdclass) { \
1444                 case 1: result = checkowner_in_dhcid(name, rdclass, type, wildcard); break; \
1445                 default: result = ISC_TRUE; break; \
1446                 } \
1447                 break; \
1448         case 50: result = checkowner_nsec3(name, rdclass, type, wildcard); break; \
1449         case 51: result = checkowner_nsec3param(name, rdclass, type, wildcard); break; \
1450         case 52: result = checkowner_tlsa(name, rdclass, type, wildcard); break; \
1451         case 55: result = checkowner_hip(name, rdclass, type, wildcard); break; \
1452         case 99: result = checkowner_spf(name, rdclass, type, wildcard); break; \
1453         case 103: result = checkowner_unspec(name, rdclass, type, wildcard); break; \
1454         case 249: result = checkowner_tkey(name, rdclass, type, wildcard); break; \
1455         case 250: switch (rdclass) { \
1456                 case 255: result = checkowner_any_tsig(name, rdclass, type, wildcard); break; \
1457                 default: result = ISC_TRUE; break; \
1458                 } \
1459                 break; \
1460         case 32769: result = checkowner_dlv(name, rdclass, type, wildcard); break; \
1461         case 65533: result = checkowner_keydata(name, rdclass, type, wildcard); break; \
1462         default: result = ISC_TRUE; break; \
1463         }
1464
1465 #define CHECKNAMESSWITCH \
1466         switch (rdata->type) { \
1467         case 1: switch (rdata->rdclass) { \
1468                 case 1: result = checknames_in_a(rdata, owner, bad); break; \
1469                 case 3: result = checknames_ch_a(rdata, owner, bad); break; \
1470                 case 4: result = checknames_hs_a(rdata, owner, bad); break; \
1471                 default: result = ISC_TRUE; break; \
1472                 } \
1473                 break; \
1474         case 2: result = checknames_ns(rdata, owner, bad); break; \
1475         case 3: result = checknames_md(rdata, owner, bad); break; \
1476         case 4: result = checknames_mf(rdata, owner, bad); break; \
1477         case 5: result = checknames_cname(rdata, owner, bad); break; \
1478         case 6: result = checknames_soa(rdata, owner, bad); break; \
1479         case 7: result = checknames_mb(rdata, owner, bad); break; \
1480         case 8: result = checknames_mg(rdata, owner, bad); break; \
1481         case 9: result = checknames_mr(rdata, owner, bad); break; \
1482         case 10: result = checknames_null(rdata, owner, bad); break; \
1483         case 11: switch (rdata->rdclass) { \
1484                 case 1: result = checknames_in_wks(rdata, owner, bad); break; \
1485                 default: result = ISC_TRUE; break; \
1486                 } \
1487                 break; \
1488         case 12: result = checknames_ptr(rdata, owner, bad); break; \
1489         case 13: result = checknames_hinfo(rdata, owner, bad); break; \
1490         case 14: result = checknames_minfo(rdata, owner, bad); break; \
1491         case 15: result = checknames_mx(rdata, owner, bad); break; \
1492         case 16: result = checknames_txt(rdata, owner, bad); break; \
1493         case 17: result = checknames_rp(rdata, owner, bad); break; \
1494         case 18: result = checknames_afsdb(rdata, owner, bad); break; \
1495         case 19: result = checknames_x25(rdata, owner, bad); break; \
1496         case 20: result = checknames_isdn(rdata, owner, bad); break; \
1497         case 21: result = checknames_rt(rdata, owner, bad); break; \
1498         case 22: switch (rdata->rdclass) { \
1499                 case 1: result = checknames_in_nsap(rdata, owner, bad); break; \
1500                 default: result = ISC_TRUE; break; \
1501                 } \
1502                 break; \
1503         case 23: switch (rdata->rdclass) { \
1504                 case 1: result = checknames_in_nsap_ptr(rdata, owner, bad); break; \
1505                 default: result = ISC_TRUE; break; \
1506                 } \
1507                 break; \
1508         case 24: result = checknames_sig(rdata, owner, bad); break; \
1509         case 25: result = checknames_key(rdata, owner, bad); break; \
1510         case 26: switch (rdata->rdclass) { \
1511                 case 1: result = checknames_in_px(rdata, owner, bad); break; \
1512                 default: result = ISC_TRUE; break; \
1513                 } \
1514                 break; \
1515         case 27: result = checknames_gpos(rdata, owner, bad); break; \
1516         case 28: switch (rdata->rdclass) { \
1517                 case 1: result = checknames_in_aaaa(rdata, owner, bad); break; \
1518                 default: result = ISC_TRUE; break; \
1519                 } \
1520                 break; \
1521         case 29: result = checknames_loc(rdata, owner, bad); break; \
1522         case 30: result = checknames_nxt(rdata, owner, bad); break; \
1523         case 33: switch (rdata->rdclass) { \
1524                 case 1: result = checknames_in_srv(rdata, owner, bad); break; \
1525                 default: result = ISC_TRUE; break; \
1526                 } \
1527                 break; \
1528         case 35: switch (rdata->rdclass) { \
1529                 case 1: result = checknames_in_naptr(rdata, owner, bad); break; \
1530                 default: result = ISC_TRUE; break; \
1531                 } \
1532                 break; \
1533         case 36: switch (rdata->rdclass) { \
1534                 case 1: result = checknames_in_kx(rdata, owner, bad); break; \
1535                 default: result = ISC_TRUE; break; \
1536                 } \
1537                 break; \
1538         case 37: result = checknames_cert(rdata, owner, bad); break; \
1539         case 38: switch (rdata->rdclass) { \
1540                 case 1: result = checknames_in_a6(rdata, owner, bad); break; \
1541                 default: result = ISC_TRUE; break; \
1542                 } \
1543                 break; \
1544         case 39: result = checknames_dname(rdata, owner, bad); break; \
1545         case 41: result = checknames_opt(rdata, owner, bad); break; \
1546         case 42: switch (rdata->rdclass) { \
1547                 case 1: result = checknames_in_apl(rdata, owner, bad); break; \
1548                 default: result = ISC_TRUE; break; \
1549                 } \
1550                 break; \
1551         case 43: result = checknames_ds(rdata, owner, bad); break; \
1552         case 44: result = checknames_sshfp(rdata, owner, bad); break; \
1553         case 45: result = checknames_ipseckey(rdata, owner, bad); break; \
1554         case 46: result = checknames_rrsig(rdata, owner, bad); break; \
1555         case 47: result = checknames_nsec(rdata, owner, bad); break; \
1556         case 48: result = checknames_dnskey(rdata, owner, bad); break; \
1557         case 49: switch (rdata->rdclass) { \
1558                 case 1: result = checknames_in_dhcid(rdata, owner, bad); break; \
1559                 default: result = ISC_TRUE; break; \
1560                 } \
1561                 break; \
1562         case 50: result = checknames_nsec3(rdata, owner, bad); break; \
1563         case 51: result = checknames_nsec3param(rdata, owner, bad); break; \
1564         case 52: result = checknames_tlsa(rdata, owner, bad); break; \
1565         case 55: result = checknames_hip(rdata, owner, bad); break; \
1566         case 99: result = checknames_spf(rdata, owner, bad); break; \
1567         case 103: result = checknames_unspec(rdata, owner, bad); break; \
1568         case 249: result = checknames_tkey(rdata, owner, bad); break; \
1569         case 250: switch (rdata->rdclass) { \
1570                 case 255: result = checknames_any_tsig(rdata, owner, bad); break; \
1571                 default: result = ISC_TRUE; break; \
1572                 } \
1573                 break; \
1574         case 32769: result = checknames_dlv(rdata, owner, bad); break; \
1575         case 65533: result = checknames_keydata(rdata, owner, bad); break; \
1576         default: result = ISC_TRUE; break; \
1577         }
1578 #define RDATATYPE_COMPARE(_s, _d, _tn, _n, _tp) \
1579         do { \
1580                 if (sizeof(_s) - 1 == _n && \
1581                     strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \
1582                         if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \
1583                                 return (ISC_R_NOTIMPLEMENTED); \
1584                         *(_tp) = _d; \
1585                         return (ISC_R_SUCCESS); \
1586                 } \
1587         } while (0)
1588
1589 #define RDATATYPE_FROMTEXT_SW(_hash,_typename,_length,_typep) \
1590         switch (_hash) { \
1591                 case 16: \
1592                         RDATATYPE_COMPARE("reserved0", 0, _typename, _length, _typep); \
1593                         break; \
1594                 case 34: \
1595                         RDATATYPE_COMPARE("a", 1, _typename, _length, _typep); \
1596                         break; \
1597                 case 80: \
1598                         RDATATYPE_COMPARE("ns", 2, _typename, _length, _typep); \
1599                         break; \
1600                 case 92: \
1601                         RDATATYPE_COMPARE("md", 3, _typename, _length, _typep); \
1602                         break; \
1603                 case 58: \
1604                         RDATATYPE_COMPARE("mf", 4, _typename, _length, _typep); \
1605                         break; \
1606                 case 8: \
1607                         RDATATYPE_COMPARE("cname", 5, _typename, _length, _typep); \
1608                         RDATATYPE_COMPARE("mx", 15, _typename, _length, _typep); \
1609                         break; \
1610                 case 182: \
1611                         RDATATYPE_COMPARE("soa", 6, _typename, _length, _typep); \
1612                         break; \
1613                 case 126: \
1614                         RDATATYPE_COMPARE("mb", 7, _typename, _length, _typep); \
1615                         break; \
1616                 case 169: \
1617                         RDATATYPE_COMPARE("mg", 8, _typename, _length, _typep); \
1618                         break; \
1619                 case 110: \
1620                         RDATATYPE_COMPARE("mr", 9, _typename, _length, _typep); \
1621                         RDATATYPE_COMPARE("minfo", 14, _typename, _length, _typep); \
1622                         break; \
1623                 case 24: \
1624                         RDATATYPE_COMPARE("null", 10, _typename, _length, _typep); \
1625                         RDATATYPE_COMPARE("kx", 36, _typename, _length, _typep); \
1626                         RDATATYPE_COMPARE("nsec3param", 51, _typename, _length, _typep); \
1627                         break; \
1628                 case 206: \
1629                         RDATATYPE_COMPARE("wks", 11, _typename, _length, _typep); \
1630                         break; \
1631                 case 54: \
1632                         RDATATYPE_COMPARE("ptr", 12, _typename, _length, _typep); \
1633                         RDATATYPE_COMPARE("naptr", 35, _typename, _length, _typep); \
1634                         break; \
1635                 case 67: \
1636                         RDATATYPE_COMPARE("hinfo", 13, _typename, _length, _typep); \
1637                         break; \
1638                 case 236: \
1639                         RDATATYPE_COMPARE("txt", 16, _typename, _length, _typep); \
1640                         break; \
1641                 case 192: \
1642                         RDATATYPE_COMPARE("rp", 17, _typename, _length, _typep); \
1643                         break; \
1644                 case 12: \
1645                         RDATATYPE_COMPARE("afsdb", 18, _typename, _length, _typep); \
1646                         break; \
1647                 case 119: \
1648                         RDATATYPE_COMPARE("x25", 19, _typename, _length, _typep); \
1649                         break; \
1650                 case 214: \
1651                         RDATATYPE_COMPARE("isdn", 20, _typename, _length, _typep); \
1652                         break; \
1653                 case 144: \
1654                         RDATATYPE_COMPARE("rt", 21, _typename, _length, _typep); \
1655                         break; \
1656                 case 224: \
1657                         RDATATYPE_COMPARE("nsap", 22, _typename, _length, _typep); \
1658                         RDATATYPE_COMPARE("uid", 101, _typename, _length, _typep); \
1659                         break; \
1660                 case 140: \
1661                         RDATATYPE_COMPARE("nsap-ptr", 23, _typename, _length, _typep); \
1662                         break; \
1663                 case 122: \
1664                         RDATATYPE_COMPARE("sig", 24, _typename, _length, _typep); \
1665                         RDATATYPE_COMPARE("dlv", 32769, _typename, _length, _typep); \
1666                         break; \
1667                 case 254: \
1668                         RDATATYPE_COMPARE("key", 25, _typename, _length, _typep); \
1669                         break; \
1670                 case 112: \
1671                         RDATATYPE_COMPARE("px", 26, _typename, _length, _typep); \
1672                         break; \
1673                 case 17: \
1674                         RDATATYPE_COMPARE("gpos", 27, _typename, _length, _typep); \
1675                         break; \
1676                 case 69: \
1677                         RDATATYPE_COMPARE("aaaa", 28, _typename, _length, _typep); \
1678                         RDATATYPE_COMPARE("atma", 34, _typename, _length, _typep); \
1679                         break; \
1680                 case 237: \
1681                         RDATATYPE_COMPARE("loc", 29, _typename, _length, _typep); \
1682                         break; \
1683                 case 52: \
1684                         RDATATYPE_COMPARE("nxt", 30, _typename, _length, _typep); \
1685                         break; \
1686                 case 160: \
1687                         RDATATYPE_COMPARE("eid", 31, _typename, _length, _typep); \
1688                         break; \
1689                 case 220: \
1690                         RDATATYPE_COMPARE("nimloc", 32, _typename, _length, _typep); \
1691                         break; \
1692                 case 100: \
1693                         RDATATYPE_COMPARE("srv", 33, _typename, _length, _typep); \
1694                         break; \
1695                 case 172: \
1696                         RDATATYPE_COMPARE("cert", 37, _typename, _length, _typep); \
1697                         break; \
1698                 case 226: \
1699                         RDATATYPE_COMPARE("a6", 38, _typename, _length, _typep); \
1700                         break; \
1701                 case 109: \
1702                         RDATATYPE_COMPARE("dname", 39, _typename, _length, _typep); \
1703                         break; \
1704                 case 168: \
1705                         RDATATYPE_COMPARE("opt", 41, _typename, _length, _typep); \
1706                         break; \
1707                 case 48: \
1708                         RDATATYPE_COMPARE("apl", 42, _typename, _length, _typep); \
1709                         break; \
1710                 case 210: \
1711                         RDATATYPE_COMPARE("ds", 43, _typename, _length, _typep); \
1712                         break; \
1713                 case 128: \
1714                         RDATATYPE_COMPARE("sshfp", 44, _typename, _length, _typep); \
1715                         break; \
1716                 case 105: \
1717                         RDATATYPE_COMPARE("ipseckey", 45, _typename, _length, _typep); \
1718                         break; \
1719                 case 225: \
1720                         RDATATYPE_COMPARE("rrsig", 46, _typename, _length, _typep); \
1721                         break; \
1722                 case 22: \
1723                         RDATATYPE_COMPARE("nsec", 47, _typename, _length, _typep); \
1724                         break; \
1725                 case 26: \
1726                         RDATATYPE_COMPARE("dnskey", 48, _typename, _length, _typep); \
1727                         break; \
1728                 case 4: \
1729                         RDATATYPE_COMPARE("dhcid", 49, _typename, _length, _typep); \
1730                         RDATATYPE_COMPARE("spf", 99, _typename, _length, _typep); \
1731                         break; \
1732                 case 233: \
1733                         RDATATYPE_COMPARE("nsec3", 50, _typename, _length, _typep); \
1734                         break; \
1735                 case 120: \
1736                         RDATATYPE_COMPARE("tlsa", 52, _typename, _length, _typep); \
1737                         break; \
1738                 case 208: \
1739                         RDATATYPE_COMPARE("hip", 55, _typename, _length, _typep); \
1740                         break; \
1741                 case 230: \
1742                         RDATATYPE_COMPARE("uinfo", 100, _typename, _length, _typep); \
1743                         break; \
1744                 case 104: \
1745                         RDATATYPE_COMPARE("gid", 102, _typename, _length, _typep); \
1746                         break; \
1747                 case 145: \
1748                         RDATATYPE_COMPARE("unspec", 103, _typename, _length, _typep); \
1749                         break; \
1750                 case 184: \
1751                         RDATATYPE_COMPARE("tkey", 249, _typename, _length, _typep); \
1752                         break; \
1753                 case 72: \
1754                         RDATATYPE_COMPARE("tsig", 250, _typename, _length, _typep); \
1755                         break; \
1756                 case 138: \
1757                         RDATATYPE_COMPARE("ixfr", 251, _typename, _length, _typep); \
1758                         break; \
1759                 case 250: \
1760                         RDATATYPE_COMPARE("axfr", 252, _typename, _length, _typep); \
1761                         break; \
1762                 case 164: \
1763                         RDATATYPE_COMPARE("mailb", 253, _typename, _length, _typep); \
1764                         break; \
1765                 case 50: \
1766                         RDATATYPE_COMPARE("maila", 254, _typename, _length, _typep); \
1767                         RDATATYPE_COMPARE("keydata", 65533, _typename, _length, _typep); \
1768                         break; \
1769                 case 68: \
1770                         RDATATYPE_COMPARE("any", 255, _typename, _length, _typep); \
1771                         break; \
1772         }
1773 #define RDATATYPE_ATTRIBUTE_SW \
1774         switch (type) { \
1775         case 0: return (DNS_RDATATYPEATTR_RESERVED); \
1776         case 1: return (RRTYPE_A_ATTRIBUTES); \
1777         case 2: return (RRTYPE_NS_ATTRIBUTES); \
1778         case 3: return (RRTYPE_MD_ATTRIBUTES); \
1779         case 4: return (RRTYPE_MF_ATTRIBUTES); \
1780         case 5: return (RRTYPE_CNAME_ATTRIBUTES); \
1781         case 6: return (RRTYPE_SOA_ATTRIBUTES); \
1782         case 7: return (RRTYPE_MB_ATTRIBUTES); \
1783         case 8: return (RRTYPE_MG_ATTRIBUTES); \
1784         case 9: return (RRTYPE_MR_ATTRIBUTES); \
1785         case 10: return (RRTYPE_NULL_ATTRIBUTES); \
1786         case 11: return (RRTYPE_WKS_ATTRIBUTES); \
1787         case 12: return (RRTYPE_PTR_ATTRIBUTES); \
1788         case 13: return (RRTYPE_HINFO_ATTRIBUTES); \
1789         case 14: return (RRTYPE_MINFO_ATTRIBUTES); \
1790         case 15: return (RRTYPE_MX_ATTRIBUTES); \
1791         case 16: return (RRTYPE_TXT_ATTRIBUTES); \
1792         case 17: return (RRTYPE_RP_ATTRIBUTES); \
1793         case 18: return (RRTYPE_AFSDB_ATTRIBUTES); \
1794         case 19: return (RRTYPE_X25_ATTRIBUTES); \
1795         case 20: return (RRTYPE_ISDN_ATTRIBUTES); \
1796         case 21: return (RRTYPE_RT_ATTRIBUTES); \
1797         case 22: return (RRTYPE_NSAP_ATTRIBUTES); \
1798         case 23: return (RRTYPE_NSAP_PTR_ATTRIBUTES); \
1799         case 24: return (RRTYPE_SIG_ATTRIBUTES); \
1800         case 25: return (RRTYPE_KEY_ATTRIBUTES); \
1801         case 26: return (RRTYPE_PX_ATTRIBUTES); \
1802         case 27: return (RRTYPE_GPOS_ATTRIBUTES); \
1803         case 28: return (RRTYPE_AAAA_ATTRIBUTES); \
1804         case 29: return (RRTYPE_LOC_ATTRIBUTES); \
1805         case 30: return (RRTYPE_NXT_ATTRIBUTES); \
1806         case 31: return (DNS_RDATATYPEATTR_RESERVED); \
1807         case 32: return (DNS_RDATATYPEATTR_RESERVED); \
1808         case 33: return (RRTYPE_SRV_ATTRIBUTES); \
1809         case 34: return (DNS_RDATATYPEATTR_RESERVED); \
1810         case 35: return (RRTYPE_NAPTR_ATTRIBUTES); \
1811         case 36: return (RRTYPE_KX_ATTRIBUTES); \
1812         case 37: return (RRTYPE_CERT_ATTRIBUTES); \
1813         case 38: return (RRTYPE_A6_ATTRIBUTES); \
1814         case 39: return (RRTYPE_DNAME_ATTRIBUTES); \
1815         case 41: return (RRTYPE_OPT_ATTRIBUTES); \
1816         case 42: return (RRTYPE_APL_ATTRIBUTES); \
1817         case 43: return (RRTYPE_DS_ATTRIBUTES); \
1818         case 44: return (RRTYPE_SSHFP_ATTRIBUTES); \
1819         case 45: return (RRTYPE_IPSECKEY_ATTRIBUTES); \
1820         case 46: return (RRTYPE_RRSIG_ATTRIBUTES); \
1821         case 47: return (RRTYPE_NSEC_ATTRIBUTES); \
1822         case 48: return (RRTYPE_DNSKEY_ATTRIBUTES); \
1823         case 49: return (RRTYPE_DHCID_ATTRIBUTES); \
1824         case 50: return (RRTYPE_NSEC3_ATTRIBUTES); \
1825         case 51: return (RRTYPE_NSEC3PARAM_ATTRIBUTES); \
1826         case 52: return (RRTYPE_TLSA_ATTRIBUTES); \
1827         case 55: return (RRTYPE_HIP_ATTRIBUTES); \
1828         case 99: return (RRTYPE_SPF_ATTRIBUTES); \
1829         case 100: return (DNS_RDATATYPEATTR_RESERVED); \
1830         case 101: return (DNS_RDATATYPEATTR_RESERVED); \
1831         case 102: return (DNS_RDATATYPEATTR_RESERVED); \
1832         case 103: return (RRTYPE_UNSPEC_ATTRIBUTES); \
1833         case 249: return (RRTYPE_TKEY_ATTRIBUTES); \
1834         case 250: return (RRTYPE_TSIG_ATTRIBUTES); \
1835         case 251: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \
1836         case 252: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \
1837         case 253: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \
1838         case 254: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \
1839         case 255: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \
1840         case 32769: return (RRTYPE_DLV_ATTRIBUTES); \
1841         case 65533: return (RRTYPE_KEYDATA_ATTRIBUTES); \
1842         }
1843 #define RDATATYPE_TOTEXT_SW \
1844         switch (type) { \
1845         case 0: return (str_totext("RESERVED0", target)); \
1846         case 1: return (str_totext("A", target)); \
1847         case 2: return (str_totext("NS", target)); \
1848         case 3: return (str_totext("MD", target)); \
1849         case 4: return (str_totext("MF", target)); \
1850         case 5: return (str_totext("CNAME", target)); \
1851         case 6: return (str_totext("SOA", target)); \
1852         case 7: return (str_totext("MB", target)); \
1853         case 8: return (str_totext("MG", target)); \
1854         case 9: return (str_totext("MR", target)); \
1855         case 10: return (str_totext("NULL", target)); \
1856         case 11: return (str_totext("WKS", target)); \
1857         case 12: return (str_totext("PTR", target)); \
1858         case 13: return (str_totext("HINFO", target)); \
1859         case 14: return (str_totext("MINFO", target)); \
1860         case 15: return (str_totext("MX", target)); \
1861         case 16: return (str_totext("TXT", target)); \
1862         case 17: return (str_totext("RP", target)); \
1863         case 18: return (str_totext("AFSDB", target)); \
1864         case 19: return (str_totext("X25", target)); \
1865         case 20: return (str_totext("ISDN", target)); \
1866         case 21: return (str_totext("RT", target)); \
1867         case 22: return (str_totext("NSAP", target)); \
1868         case 23: return (str_totext("NSAP-PTR", target)); \
1869         case 24: return (str_totext("SIG", target)); \
1870         case 25: return (str_totext("KEY", target)); \
1871         case 26: return (str_totext("PX", target)); \
1872         case 27: return (str_totext("GPOS", target)); \
1873         case 28: return (str_totext("AAAA", target)); \
1874         case 29: return (str_totext("LOC", target)); \
1875         case 30: return (str_totext("NXT", target)); \
1876         case 31: return (str_totext("EID", target)); \
1877         case 32: return (str_totext("NIMLOC", target)); \
1878         case 33: return (str_totext("SRV", target)); \
1879         case 34: return (str_totext("ATMA", target)); \
1880         case 35: return (str_totext("NAPTR", target)); \
1881         case 36: return (str_totext("KX", target)); \
1882         case 37: return (str_totext("CERT", target)); \
1883         case 38: return (str_totext("A6", target)); \
1884         case 39: return (str_totext("DNAME", target)); \
1885         case 41: return (str_totext("OPT", target)); \
1886         case 42: return (str_totext("APL", target)); \
1887         case 43: return (str_totext("DS", target)); \
1888         case 44: return (str_totext("SSHFP", target)); \
1889         case 45: return (str_totext("IPSECKEY", target)); \
1890         case 46: return (str_totext("RRSIG", target)); \
1891         case 47: return (str_totext("NSEC", target)); \
1892         case 48: return (str_totext("DNSKEY", target)); \
1893         case 49: return (str_totext("DHCID", target)); \
1894         case 50: return (str_totext("NSEC3", target)); \
1895         case 51: return (str_totext("NSEC3PARAM", target)); \
1896         case 52: return (str_totext("TLSA", target)); \
1897         case 55: return (str_totext("HIP", target)); \
1898         case 99: return (str_totext("SPF", target)); \
1899         case 100: return (str_totext("UINFO", target)); \
1900         case 101: return (str_totext("UID", target)); \
1901         case 102: return (str_totext("GID", target)); \
1902         case 103: return (str_totext("UNSPEC", target)); \
1903         case 249: return (str_totext("TKEY", target)); \
1904         case 250: return (str_totext("TSIG", target)); \
1905         case 251: return (str_totext("IXFR", target)); \
1906         case 252: return (str_totext("AXFR", target)); \
1907         case 253: return (str_totext("MAILB", target)); \
1908         case 254: return (str_totext("MAILA", target)); \
1909         case 255: return (str_totext("ANY", target)); \
1910         case 32769: return (str_totext("DLV", target)); \
1911         case 65533: return (str_totext("KEYDATA", target)); \
1912         }
1913 #endif /* DNS_CODE_H */