usr.sbin/named/code.h

   1 /*
   2  * Copyright (C) 1998-2004 Internet Software Consortium.
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
   9  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
  10  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
  11  * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  13  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  14  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  15  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17 /* $DragonFly: src/usr.sbin/named/code.h,v 1.1 2004/05/27 18:15:42 dillon Exp $ */
  18
  19 /***************
  20  ***************
  21  ***************   THIS FILE IS AUTOMATICALLY GENERATED BY gen.c.
  22  ***************   DO NOT EDIT!
  23  ***************
  24  ***************/
  25
  26 #ifndef DNS_CODE_H
  27 #define DNS_CODE_H 1
  28
  29 #include <isc/boolean.h>
  30 #include <isc/result.h>
  31
  32 #include <dns/name.h>
  33
  34 #include "./rdata/in_1/a_1.c"
  35 #include "./rdata/hs_4/a_1.c"
  36 #include "./rdata/generic/ns_2.c"
  37 #include "./rdata/generic/md_3.c"
  38 #include "./rdata/generic/mf_4.c"
  39 #include "./rdata/generic/cname_5.c"
  40 #include "./rdata/generic/soa_6.c"
  41 #include "./rdata/generic/mb_7.c"
  42 #include "./rdata/generic/mg_8.c"
  43 #include "./rdata/generic/mr_9.c"
  44 #include "./rdata/generic/null_10.c"
  45 #include "./rdata/in_1/wks_11.c"
  46 #include "./rdata/generic/ptr_12.c"
  47 #include "./rdata/generic/hinfo_13.c"
  48 #include "./rdata/generic/minfo_14.c"
  49 #include "./rdata/generic/mx_15.c"
  50 #include "./rdata/generic/txt_16.c"
  51 #include "./rdata/generic/rp_17.c"
  52 #include "./rdata/generic/afsdb_18.c"
  53 #include "./rdata/generic/x25_19.c"
  54 #include "./rdata/generic/isdn_20.c"
  55 #include "./rdata/generic/rt_21.c"
  56 #include "./rdata/in_1/nsap_22.c"
  57 #include "./rdata/in_1/nsap-ptr_23.c"
  58 #include "./rdata/generic/sig_24.c"
  59 #include "./rdata/generic/key_25.c"
  60 #include "./rdata/in_1/px_26.c"
  61 #include "./rdata/generic/gpos_27.c"
  62 #include "./rdata/in_1/aaaa_28.c"
  63 #include "./rdata/generic/loc_29.c"
  64 #include "./rdata/generic/nxt_30.c"
  65 #include "./rdata/in_1/srv_33.c"
  66 #include "./rdata/in_1/naptr_35.c"
  67 #include "./rdata/in_1/kx_36.c"
  68 #include "./rdata/generic/cert_37.c"
  69 #include "./rdata/in_1/a6_38.c"
  70 #include "./rdata/generic/dname_39.c"
  71 #include "./rdata/generic/opt_41.c"
  72 #include "./rdata/generic/unspec_103.c"
  73 #include "./rdata/generic/tkey_249.c"
  74 #include "./rdata/any_255/tsig_250.c"
  75
  76
  77
  78 #define FROMTEXTSWITCH \
  79         switch (type) { \
  80         case 1: switch (rdclass) { \
  81                 case 1: result = fromtext_in_a(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  82                 case 4: result = fromtext_hs_a(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  83                 default: result = DNS_R_UNKNOWN; break; \
  84                 } \
  85                 break; \
  86         case 2: result = fromtext_ns(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  87         case 3: result = fromtext_md(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  88         case 4: result = fromtext_mf(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  89         case 5: result = fromtext_cname(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  90         case 6: result = fromtext_soa(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  91         case 7: result = fromtext_mb(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  92         case 8: result = fromtext_mg(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  93         case 9: result = fromtext_mr(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  94         case 10: result = fromtext_null(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  95         case 11: switch (rdclass) { \
  96                 case 1: result = fromtext_in_wks(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
  97                 default: result = DNS_R_UNKNOWN; break; \
  98                 } \
  99                 break; \
 100         case 12: result = fromtext_ptr(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 101         case 13: result = fromtext_hinfo(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 102         case 14: result = fromtext_minfo(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 103         case 15: result = fromtext_mx(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 104         case 16: result = fromtext_txt(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 105         case 17: result = fromtext_rp(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 106         case 18: result = fromtext_afsdb(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 107         case 19: result = fromtext_x25(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 108         case 20: result = fromtext_isdn(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 109         case 21: result = fromtext_rt(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 110         case 22: switch (rdclass) { \
 111                 case 1: result = fromtext_in_nsap(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 112                 default: result = DNS_R_UNKNOWN; break; \
 113                 } \
 114                 break; \
 115         case 23: switch (rdclass) { \
 116                 case 1: result = fromtext_in_nsap_ptr(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 117                 default: result = DNS_R_UNKNOWN; break; \
 118                 } \
 119                 break; \
 120         case 24: result = fromtext_sig(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 121         case 25: result = fromtext_key(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 122         case 26: switch (rdclass) { \
 123                 case 1: result = fromtext_in_px(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 124                 default: result = DNS_R_UNKNOWN; break; \
 125                 } \
 126                 break; \
 127         case 27: result = fromtext_gpos(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 128         case 28: switch (rdclass) { \
 129                 case 1: result = fromtext_in_aaaa(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 130                 default: result = DNS_R_UNKNOWN; break; \
 131                 } \
 132                 break; \
 133         case 29: result = fromtext_loc(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 134         case 30: result = fromtext_nxt(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 135         case 33: switch (rdclass) { \
 136                 case 1: result = fromtext_in_srv(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 137                 default: result = DNS_R_UNKNOWN; break; \
 138                 } \
 139                 break; \
 140         case 35: switch (rdclass) { \
 141                 case 1: result = fromtext_in_naptr(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 142                 default: result = DNS_R_UNKNOWN; break; \
 143                 } \
 144                 break; \
 145         case 36: switch (rdclass) { \
 146                 case 1: result = fromtext_in_kx(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 147                 default: result = DNS_R_UNKNOWN; break; \
 148                 } \
 149                 break; \
 150         case 37: result = fromtext_cert(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 151         case 38: switch (rdclass) { \
 152                 case 1: result = fromtext_in_a6(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 153                 default: result = DNS_R_UNKNOWN; break; \
 154                 } \
 155                 break; \
 156         case 39: result = fromtext_dname(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 157         case 41: result = fromtext_opt(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 158         case 103: result = fromtext_unspec(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 159         case 249: result = fromtext_tkey(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 160         case 250: switch (rdclass) { \
 161                 case 255: result = fromtext_any_tsig(rdclass, type, lexer, origin, downcase, target, callbacks); break; \
 162                 default: result = DNS_R_UNKNOWN; break; \
 163                 } \
 164                 break; \
 165         default: result = DNS_R_UNKNOWN; break; \
 166         }
 167
 168 #define TOTEXTSWITCH \
 169         switch (rdata->type) { \
 170         case 1: switch (rdata->rdclass) { \
 171                 case 1: result = totext_in_a(rdata, tctx, target); break; \
 172                 case 4: result = totext_hs_a(rdata, tctx, target); break; \
 173                 default: use_default = ISC_TRUE; break; \
 174                 } \
 175                 break; \
 176         case 2: result = totext_ns(rdata, tctx, target); break; \
 177         case 3: result = totext_md(rdata, tctx, target); break; \
 178         case 4: result = totext_mf(rdata, tctx, target); break; \
 179         case 5: result = totext_cname(rdata, tctx, target); break; \
 180         case 6: result = totext_soa(rdata, tctx, target); break; \
 181         case 7: result = totext_mb(rdata, tctx, target); break; \
 182         case 8: result = totext_mg(rdata, tctx, target); break; \
 183         case 9: result = totext_mr(rdata, tctx, target); break; \
 184         case 10: result = totext_null(rdata, tctx, target); break; \
 185         case 11: switch (rdata->rdclass) { \
 186                 case 1: result = totext_in_wks(rdata, tctx, target); break; \
 187                 default: use_default = ISC_TRUE; break; \
 188                 } \
 189                 break; \
 190         case 12: result = totext_ptr(rdata, tctx, target); break; \
 191         case 13: result = totext_hinfo(rdata, tctx, target); break; \
 192         case 14: result = totext_minfo(rdata, tctx, target); break; \
 193         case 15: result = totext_mx(rdata, tctx, target); break; \
 194         case 16: result = totext_txt(rdata, tctx, target); break; \
 195         case 17: result = totext_rp(rdata, tctx, target); break; \
 196         case 18: result = totext_afsdb(rdata, tctx, target); break; \
 197         case 19: result = totext_x25(rdata, tctx, target); break; \
 198         case 20: result = totext_isdn(rdata, tctx, target); break; \
 199         case 21: result = totext_rt(rdata, tctx, target); break; \
 200         case 22: switch (rdata->rdclass) { \
 201                 case 1: result = totext_in_nsap(rdata, tctx, target); break; \
 202                 default: use_default = ISC_TRUE; break; \
 203                 } \
 204                 break; \
 205         case 23: switch (rdata->rdclass) { \
 206                 case 1: result = totext_in_nsap_ptr(rdata, tctx, target); break; \
 207                 default: use_default = ISC_TRUE; break; \
 208                 } \
 209                 break; \
 210         case 24: result = totext_sig(rdata, tctx, target); break; \
 211         case 25: result = totext_key(rdata, tctx, target); break; \
 212         case 26: switch (rdata->rdclass) { \
 213                 case 1: result = totext_in_px(rdata, tctx, target); break; \
 214                 default: use_default = ISC_TRUE; break; \
 215                 } \
 216                 break; \
 217         case 27: result = totext_gpos(rdata, tctx, target); break; \
 218         case 28: switch (rdata->rdclass) { \
 219                 case 1: result = totext_in_aaaa(rdata, tctx, target); break; \
 220                 default: use_default = ISC_TRUE; break; \
 221                 } \
 222                 break; \
 223         case 29: result = totext_loc(rdata, tctx, target); break; \
 224         case 30: result = totext_nxt(rdata, tctx, target); break; \
 225         case 33: switch (rdata->rdclass) { \
 226                 case 1: result = totext_in_srv(rdata, tctx, target); break; \
 227                 default: use_default = ISC_TRUE; break; \
 228                 } \
 229                 break; \
 230         case 35: switch (rdata->rdclass) { \
 231                 case 1: result = totext_in_naptr(rdata, tctx, target); break; \
 232                 default: use_default = ISC_TRUE; break; \
 233                 } \
 234                 break; \
 235         case 36: switch (rdata->rdclass) { \
 236                 case 1: result = totext_in_kx(rdata, tctx, target); break; \
 237                 default: use_default = ISC_TRUE; break; \
 238                 } \
 239                 break; \
 240         case 37: result = totext_cert(rdata, tctx, target); break; \
 241         case 38: switch (rdata->rdclass) { \
 242                 case 1: result = totext_in_a6(rdata, tctx, target); break; \
 243                 default: use_default = ISC_TRUE; break; \
 244                 } \
 245                 break; \
 246         case 39: result = totext_dname(rdata, tctx, target); break; \
 247         case 41: result = totext_opt(rdata, tctx, target); break; \
 248         case 103: result = totext_unspec(rdata, tctx, target); break; \
 249         case 249: result = totext_tkey(rdata, tctx, target); break; \
 250         case 250: switch (rdata->rdclass) { \
 251                 case 255: result = totext_any_tsig(rdata, tctx, target); break; \
 252                 default: use_default = ISC_TRUE; break; \
 253                 } \
 254                 break; \
 255         default: use_default = ISC_TRUE; break; \
 256         }
 257
 258 #define FROMWIRESWITCH \
 259         switch (type) { \
 260         case 1: switch (rdclass) { \
 261                 case 1: result = fromwire_in_a(rdclass, type, source, dctx, downcase, target); break; \
 262                 case 4: result = fromwire_hs_a(rdclass, type, source, dctx, downcase, target); break; \
 263                 default: use_default = ISC_TRUE; break; \
 264                 } \
 265                 break; \
 266         case 2: result = fromwire_ns(rdclass, type, source, dctx, downcase, target); break; \
 267         case 3: result = fromwire_md(rdclass, type, source, dctx, downcase, target); break; \
 268         case 4: result = fromwire_mf(rdclass, type, source, dctx, downcase, target); break; \
 269         case 5: result = fromwire_cname(rdclass, type, source, dctx, downcase, target); break; \
 270         case 6: result = fromwire_soa(rdclass, type, source, dctx, downcase, target); break; \
 271         case 7: result = fromwire_mb(rdclass, type, source, dctx, downcase, target); break; \
 272         case 8: result = fromwire_mg(rdclass, type, source, dctx, downcase, target); break; \
 273         case 9: result = fromwire_mr(rdclass, type, source, dctx, downcase, target); break; \
 274         case 10: result = fromwire_null(rdclass, type, source, dctx, downcase, target); break; \
 275         case 11: switch (rdclass) { \
 276                 case 1: result = fromwire_in_wks(rdclass, type, source, dctx, downcase, target); break; \
 277                 default: use_default = ISC_TRUE; break; \
 278                 } \
 279                 break; \
 280         case 12: result = fromwire_ptr(rdclass, type, source, dctx, downcase, target); break; \
 281         case 13: result = fromwire_hinfo(rdclass, type, source, dctx, downcase, target); break; \
 282         case 14: result = fromwire_minfo(rdclass, type, source, dctx, downcase, target); break; \
 283         case 15: result = fromwire_mx(rdclass, type, source, dctx, downcase, target); break; \
 284         case 16: result = fromwire_txt(rdclass, type, source, dctx, downcase, target); break; \
 285         case 17: result = fromwire_rp(rdclass, type, source, dctx, downcase, target); break; \
 286         case 18: result = fromwire_afsdb(rdclass, type, source, dctx, downcase, target); break; \
 287         case 19: result = fromwire_x25(rdclass, type, source, dctx, downcase, target); break; \
 288         case 20: result = fromwire_isdn(rdclass, type, source, dctx, downcase, target); break; \
 289         case 21: result = fromwire_rt(rdclass, type, source, dctx, downcase, target); break; \
 290         case 22: switch (rdclass) { \
 291                 case 1: result = fromwire_in_nsap(rdclass, type, source, dctx, downcase, target); break; \
 292                 default: use_default = ISC_TRUE; break; \
 293                 } \
 294                 break; \
 295         case 23: switch (rdclass) { \
 296                 case 1: result = fromwire_in_nsap_ptr(rdclass, type, source, dctx, downcase, target); break; \
 297                 default: use_default = ISC_TRUE; break; \
 298                 } \
 299                 break; \
 300         case 24: result = fromwire_sig(rdclass, type, source, dctx, downcase, target); break; \
 301         case 25: result = fromwire_key(rdclass, type, source, dctx, downcase, target); break; \
 302         case 26: switch (rdclass) { \
 303                 case 1: result = fromwire_in_px(rdclass, type, source, dctx, downcase, target); break; \
 304                 default: use_default = ISC_TRUE; break; \
 305                 } \
 306                 break; \
 307         case 27: result = fromwire_gpos(rdclass, type, source, dctx, downcase, target); break; \
 308         case 28: switch (rdclass) { \
 309                 case 1: result = fromwire_in_aaaa(rdclass, type, source, dctx, downcase, target); break; \
 310                 default: use_default = ISC_TRUE; break; \
 311                 } \
 312                 break; \
 313         case 29: result = fromwire_loc(rdclass, type, source, dctx, downcase, target); break; \
 314         case 30: result = fromwire_nxt(rdclass, type, source, dctx, downcase, target); break; \
 315         case 33: switch (rdclass) { \
 316                 case 1: result = fromwire_in_srv(rdclass, type, source, dctx, downcase, target); break; \
 317                 default: use_default = ISC_TRUE; break; \
 318                 } \
 319                 break; \
 320         case 35: switch (rdclass) { \
 321                 case 1: result = fromwire_in_naptr(rdclass, type, source, dctx, downcase, target); break; \
 322                 default: use_default = ISC_TRUE; break; \
 323                 } \
 324                 break; \
 325         case 36: switch (rdclass) { \
 326                 case 1: result = fromwire_in_kx(rdclass, type, source, dctx, downcase, target); break; \
 327                 default: use_default = ISC_TRUE; break; \
 328                 } \
 329                 break; \
 330         case 37: result = fromwire_cert(rdclass, type, source, dctx, downcase, target); break; \
 331         case 38: switch (rdclass) { \
 332                 case 1: result = fromwire_in_a6(rdclass, type, source, dctx, downcase, target); break; \
 333                 default: use_default = ISC_TRUE; break; \
 334                 } \
 335                 break; \
 336         case 39: result = fromwire_dname(rdclass, type, source, dctx, downcase, target); break; \
 337         case 41: result = fromwire_opt(rdclass, type, source, dctx, downcase, target); break; \
 338         case 103: result = fromwire_unspec(rdclass, type, source, dctx, downcase, target); break; \
 339         case 249: result = fromwire_tkey(rdclass, type, source, dctx, downcase, target); break; \
 340         case 250: switch (rdclass) { \
 341                 case 255: result = fromwire_any_tsig(rdclass, type, source, dctx, downcase, target); break; \
 342                 default: use_default = ISC_TRUE; break; \
 343                 } \
 344                 break; \
 345         default: use_default = ISC_TRUE; break; \
 346         }
 347
 348 #define TOWIRESWITCH \
 349         switch (rdata->type) { \
 350         case 1: switch (rdata->rdclass) { \
 351                 case 1: result = towire_in_a(rdata, cctx, target); break; \
 352                 case 4: result = towire_hs_a(rdata, cctx, target); break; \
 353                 default: use_default = ISC_TRUE; break; \
 354                 } \
 355                 break; \
 356         case 2: result = towire_ns(rdata, cctx, target); break; \
 357         case 3: result = towire_md(rdata, cctx, target); break; \
 358         case 4: result = towire_mf(rdata, cctx, target); break; \
 359         case 5: result = towire_cname(rdata, cctx, target); break; \
 360         case 6: result = towire_soa(rdata, cctx, target); break; \
 361         case 7: result = towire_mb(rdata, cctx, target); break; \
 362         case 8: result = towire_mg(rdata, cctx, target); break; \
 363         case 9: result = towire_mr(rdata, cctx, target); break; \
 364         case 10: result = towire_null(rdata, cctx, target); break; \
 365         case 11: switch (rdata->rdclass) { \
 366                 case 1: result = towire_in_wks(rdata, cctx, target); break; \
 367                 default: use_default = ISC_TRUE; break; \
 368                 } \
 369                 break; \
 370         case 12: result = towire_ptr(rdata, cctx, target); break; \
 371         case 13: result = towire_hinfo(rdata, cctx, target); break; \
 372         case 14: result = towire_minfo(rdata, cctx, target); break; \
 373         case 15: result = towire_mx(rdata, cctx, target); break; \
 374         case 16: result = towire_txt(rdata, cctx, target); break; \
 375         case 17: result = towire_rp(rdata, cctx, target); break; \
 376         case 18: result = towire_afsdb(rdata, cctx, target); break; \
 377         case 19: result = towire_x25(rdata, cctx, target); break; \
 378         case 20: result = towire_isdn(rdata, cctx, target); break; \
 379         case 21: result = towire_rt(rdata, cctx, target); break; \
 380         case 22: switch (rdata->rdclass) { \
 381                 case 1: result = towire_in_nsap(rdata, cctx, target); break; \
 382                 default: use_default = ISC_TRUE; break; \
 383                 } \
 384                 break; \
 385         case 23: switch (rdata->rdclass) { \
 386                 case 1: result = towire_in_nsap_ptr(rdata, cctx, target); break; \
 387                 default: use_default = ISC_TRUE; break; \
 388                 } \
 389                 break; \
 390         case 24: result = towire_sig(rdata, cctx, target); break; \
 391         case 25: result = towire_key(rdata, cctx, target); break; \
 392         case 26: switch (rdata->rdclass) { \
 393                 case 1: result = towire_in_px(rdata, cctx, target); break; \
 394                 default: use_default = ISC_TRUE; break; \
 395                 } \
 396                 break; \
 397         case 27: result = towire_gpos(rdata, cctx, target); break; \
 398         case 28: switch (rdata->rdclass) { \
 399                 case 1: result = towire_in_aaaa(rdata, cctx, target); break; \
 400                 default: use_default = ISC_TRUE; break; \
 401                 } \
 402                 break; \
 403         case 29: result = towire_loc(rdata, cctx, target); break; \
 404         case 30: result = towire_nxt(rdata, cctx, target); break; \
 405         case 33: switch (rdata->rdclass) { \
 406                 case 1: result = towire_in_srv(rdata, cctx, target); break; \
 407                 default: use_default = ISC_TRUE; break; \
 408                 } \
 409                 break; \
 410         case 35: switch (rdata->rdclass) { \
 411                 case 1: result = towire_in_naptr(rdata, cctx, target); break; \
 412                 default: use_default = ISC_TRUE; break; \
 413                 } \
 414                 break; \
 415         case 36: switch (rdata->rdclass) { \
 416                 case 1: result = towire_in_kx(rdata, cctx, target); break; \
 417                 default: use_default = ISC_TRUE; break; \
 418                 } \
 419                 break; \
 420         case 37: result = towire_cert(rdata, cctx, target); break; \
 421         case 38: switch (rdata->rdclass) { \
 422                 case 1: result = towire_in_a6(rdata, cctx, target); break; \
 423                 default: use_default = ISC_TRUE; break; \
 424                 } \
 425                 break; \
 426         case 39: result = towire_dname(rdata, cctx, target); break; \
 427         case 41: result = towire_opt(rdata, cctx, target); break; \
 428         case 103: result = towire_unspec(rdata, cctx, target); break; \
 429         case 249: result = towire_tkey(rdata, cctx, target); break; \
 430         case 250: switch (rdata->rdclass) { \
 431                 case 255: result = towire_any_tsig(rdata, cctx, target); break; \
 432                 default: use_default = ISC_TRUE; break; \
 433                 } \
 434                 break; \
 435         default: use_default = ISC_TRUE; break; \
 436         }
 437
 438 #define COMPARESWITCH \
 439         switch (rdata1->type) { \
 440         case 1: switch (rdata1->rdclass) { \
 441                 case 1: result = compare_in_a(rdata1, rdata2); break; \
 442                 case 4: result = compare_hs_a(rdata1, rdata2); break; \
 443                 default: use_default = ISC_TRUE; break; \
 444                 } \
 445                 break; \
 446         case 2: result = compare_ns(rdata1, rdata2); break; \
 447         case 3: result = compare_md(rdata1, rdata2); break; \
 448         case 4: result = compare_mf(rdata1, rdata2); break; \
 449         case 5: result = compare_cname(rdata1, rdata2); break; \
 450         case 6: result = compare_soa(rdata1, rdata2); break; \
 451         case 7: result = compare_mb(rdata1, rdata2); break; \
 452         case 8: result = compare_mg(rdata1, rdata2); break; \
 453         case 9: result = compare_mr(rdata1, rdata2); break; \
 454         case 10: result = compare_null(rdata1, rdata2); break; \
 455         case 11: switch (rdata1->rdclass) { \
 456                 case 1: result = compare_in_wks(rdata1, rdata2); break; \
 457                 default: use_default = ISC_TRUE; break; \
 458                 } \
 459                 break; \
 460         case 12: result = compare_ptr(rdata1, rdata2); break; \
 461         case 13: result = compare_hinfo(rdata1, rdata2); break; \
 462         case 14: result = compare_minfo(rdata1, rdata2); break; \
 463         case 15: result = compare_mx(rdata1, rdata2); break; \
 464         case 16: result = compare_txt(rdata1, rdata2); break; \
 465         case 17: result = compare_rp(rdata1, rdata2); break; \
 466         case 18: result = compare_afsdb(rdata1, rdata2); break; \
 467         case 19: result = compare_x25(rdata1, rdata2); break; \
 468         case 20: result = compare_isdn(rdata1, rdata2); break; \
 469         case 21: result = compare_rt(rdata1, rdata2); break; \
 470         case 22: switch (rdata1->rdclass) { \
 471                 case 1: result = compare_in_nsap(rdata1, rdata2); break; \
 472                 default: use_default = ISC_TRUE; break; \
 473                 } \
 474                 break; \
 475         case 23: switch (rdata1->rdclass) { \
 476                 case 1: result = compare_in_nsap_ptr(rdata1, rdata2); break; \
 477                 default: use_default = ISC_TRUE; break; \
 478                 } \
 479                 break; \
 480         case 24: result = compare_sig(rdata1, rdata2); break; \
 481         case 25: result = compare_key(rdata1, rdata2); break; \
 482         case 26: switch (rdata1->rdclass) { \
 483                 case 1: result = compare_in_px(rdata1, rdata2); break; \
 484                 default: use_default = ISC_TRUE; break; \
 485                 } \
 486                 break; \
 487         case 27: result = compare_gpos(rdata1, rdata2); break; \
 488         case 28: switch (rdata1->rdclass) { \
 489                 case 1: result = compare_in_aaaa(rdata1, rdata2); break; \
 490                 default: use_default = ISC_TRUE; break; \
 491                 } \
 492                 break; \
 493         case 29: result = compare_loc(rdata1, rdata2); break; \
 494         case 30: result = compare_nxt(rdata1, rdata2); break; \
 495         case 33: switch (rdata1->rdclass) { \
 496                 case 1: result = compare_in_srv(rdata1, rdata2); break; \
 497                 default: use_default = ISC_TRUE; break; \
 498                 } \
 499                 break; \
 500         case 35: switch (rdata1->rdclass) { \
 501                 case 1: result = compare_in_naptr(rdata1, rdata2); break; \
 502                 default: use_default = ISC_TRUE; break; \
 503                 } \
 504                 break; \
 505         case 36: switch (rdata1->rdclass) { \
 506                 case 1: result = compare_in_kx(rdata1, rdata2); break; \
 507                 default: use_default = ISC_TRUE; break; \
 508                 } \
 509                 break; \
 510         case 37: result = compare_cert(rdata1, rdata2); break; \
 511         case 38: switch (rdata1->rdclass) { \
 512                 case 1: result = compare_in_a6(rdata1, rdata2); break; \
 513                 default: use_default = ISC_TRUE; break; \
 514                 } \
 515                 break; \
 516         case 39: result = compare_dname(rdata1, rdata2); break; \
 517         case 41: result = compare_opt(rdata1, rdata2); break; \
 518         case 103: result = compare_unspec(rdata1, rdata2); break; \
 519         case 249: result = compare_tkey(rdata1, rdata2); break; \
 520         case 250: switch (rdata1->rdclass) { \
 521                 case 255: result = compare_any_tsig(rdata1, rdata2); break; \
 522                 default: use_default = ISC_TRUE; break; \
 523                 } \
 524                 break; \
 525         default: use_default = ISC_TRUE; break; \
 526         }
 527
 528 #define FROMSTRUCTSWITCH \
 529         switch (type) { \
 530         case 1: switch (rdclass) { \
 531                 case 1: result = fromstruct_in_a(rdclass, type, source, target); break; \
 532                 case 4: result = fromstruct_hs_a(rdclass, type, source, target); break; \
 533                 default: use_default = ISC_TRUE; break; \
 534                 } \
 535                 break; \
 536         case 2: result = fromstruct_ns(rdclass, type, source, target); break; \
 537         case 3: result = fromstruct_md(rdclass, type, source, target); break; \
 538         case 4: result = fromstruct_mf(rdclass, type, source, target); break; \
 539         case 5: result = fromstruct_cname(rdclass, type, source, target); break; \
 540         case 6: result = fromstruct_soa(rdclass, type, source, target); break; \
 541         case 7: result = fromstruct_mb(rdclass, type, source, target); break; \
 542         case 8: result = fromstruct_mg(rdclass, type, source, target); break; \
 543         case 9: result = fromstruct_mr(rdclass, type, source, target); break; \
 544         case 10: result = fromstruct_null(rdclass, type, source, target); break; \
 545         case 11: switch (rdclass) { \
 546                 case 1: result = fromstruct_in_wks(rdclass, type, source, target); break; \
 547                 default: use_default = ISC_TRUE; break; \
 548                 } \
 549                 break; \
 550         case 12: result = fromstruct_ptr(rdclass, type, source, target); break; \
 551         case 13: result = fromstruct_hinfo(rdclass, type, source, target); break; \
 552         case 14: result = fromstruct_minfo(rdclass, type, source, target); break; \
 553         case 15: result = fromstruct_mx(rdclass, type, source, target); break; \
 554         case 16: result = fromstruct_txt(rdclass, type, source, target); break; \
 555         case 17: result = fromstruct_rp(rdclass, type, source, target); break; \
 556         case 18: result = fromstruct_afsdb(rdclass, type, source, target); break; \
 557         case 19: result = fromstruct_x25(rdclass, type, source, target); break; \
 558         case 20: result = fromstruct_isdn(rdclass, type, source, target); break; \
 559         case 21: result = fromstruct_rt(rdclass, type, source, target); break; \
 560         case 22: switch (rdclass) { \
 561                 case 1: result = fromstruct_in_nsap(rdclass, type, source, target); break; \
 562                 default: use_default = ISC_TRUE; break; \
 563                 } \
 564                 break; \
 565         case 23: switch (rdclass) { \
 566                 case 1: result = fromstruct_in_nsap_ptr(rdclass, type, source, target); break; \
 567                 default: use_default = ISC_TRUE; break; \
 568                 } \
 569                 break; \
 570         case 24: result = fromstruct_sig(rdclass, type, source, target); break; \
 571         case 25: result = fromstruct_key(rdclass, type, source, target); break; \
 572         case 26: switch (rdclass) { \
 573                 case 1: result = fromstruct_in_px(rdclass, type, source, target); break; \
 574                 default: use_default = ISC_TRUE; break; \
 575                 } \
 576                 break; \
 577         case 27: result = fromstruct_gpos(rdclass, type, source, target); break; \
 578         case 28: switch (rdclass) { \
 579                 case 1: result = fromstruct_in_aaaa(rdclass, type, source, target); break; \
 580                 default: use_default = ISC_TRUE; break; \
 581                 } \
 582                 break; \
 583         case 29: result = fromstruct_loc(rdclass, type, source, target); break; \
 584         case 30: result = fromstruct_nxt(rdclass, type, source, target); break; \
 585         case 33: switch (rdclass) { \
 586                 case 1: result = fromstruct_in_srv(rdclass, type, source, target); break; \
 587                 default: use_default = ISC_TRUE; break; \
 588                 } \
 589                 break; \
 590         case 35: switch (rdclass) { \
 591                 case 1: result = fromstruct_in_naptr(rdclass, type, source, target); break; \
 592                 default: use_default = ISC_TRUE; break; \
 593                 } \
 594                 break; \
 595         case 36: switch (rdclass) { \
 596                 case 1: result = fromstruct_in_kx(rdclass, type, source, target); break; \
 597                 default: use_default = ISC_TRUE; break; \
 598                 } \
 599                 break; \
 600         case 37: result = fromstruct_cert(rdclass, type, source, target); break; \
 601         case 38: switch (rdclass) { \
 602                 case 1: result = fromstruct_in_a6(rdclass, type, source, target); break; \
 603                 default: use_default = ISC_TRUE; break; \
 604                 } \
 605                 break; \
 606         case 39: result = fromstruct_dname(rdclass, type, source, target); break; \
 607         case 41: result = fromstruct_opt(rdclass, type, source, target); break; \
 608         case 103: result = fromstruct_unspec(rdclass, type, source, target); break; \
 609         case 249: result = fromstruct_tkey(rdclass, type, source, target); break; \
 610         case 250: switch (rdclass) { \
 611                 case 255: result = fromstruct_any_tsig(rdclass, type, source, target); break; \
 612                 default: use_default = ISC_TRUE; break; \
 613                 } \
 614                 break; \
 615         default: use_default = ISC_TRUE; break; \
 616         }
 617
 618 #define TOSTRUCTSWITCH \
 619         switch (rdata->type) { \
 620         case 1: switch (rdata->rdclass) { \
 621                 case 1: result = tostruct_in_a(rdata, target, mctx); break; \
 622                 case 4: result = tostruct_hs_a(rdata, target, mctx); break; \
 623                 default: use_default = ISC_TRUE; break; \
 624                 } \
 625                 break; \
 626         case 2: result = tostruct_ns(rdata, target, mctx); break; \
 627         case 3: result = tostruct_md(rdata, target, mctx); break; \
 628         case 4: result = tostruct_mf(rdata, target, mctx); break; \
 629         case 5: result = tostruct_cname(rdata, target, mctx); break; \
 630         case 6: result = tostruct_soa(rdata, target, mctx); break; \
 631         case 7: result = tostruct_mb(rdata, target, mctx); break; \
 632         case 8: result = tostruct_mg(rdata, target, mctx); break; \
 633         case 9: result = tostruct_mr(rdata, target, mctx); break; \
 634         case 10: result = tostruct_null(rdata, target, mctx); break; \
 635         case 11: switch (rdata->rdclass) { \
 636                 case 1: result = tostruct_in_wks(rdata, target, mctx); break; \
 637                 default: use_default = ISC_TRUE; break; \
 638                 } \
 639                 break; \
 640         case 12: result = tostruct_ptr(rdata, target, mctx); break; \
 641         case 13: result = tostruct_hinfo(rdata, target, mctx); break; \
 642         case 14: result = tostruct_minfo(rdata, target, mctx); break; \
 643         case 15: result = tostruct_mx(rdata, target, mctx); break; \
 644         case 16: result = tostruct_txt(rdata, target, mctx); break; \
 645         case 17: result = tostruct_rp(rdata, target, mctx); break; \
 646         case 18: result = tostruct_afsdb(rdata, target, mctx); break; \
 647         case 19: result = tostruct_x25(rdata, target, mctx); break; \
 648         case 20: result = tostruct_isdn(rdata, target, mctx); break; \
 649         case 21: result = tostruct_rt(rdata, target, mctx); break; \
 650         case 22: switch (rdata->rdclass) { \
 651                 case 1: result = tostruct_in_nsap(rdata, target, mctx); break; \
 652                 default: use_default = ISC_TRUE; break; \
 653                 } \
 654                 break; \
 655         case 23: switch (rdata->rdclass) { \
 656                 case 1: result = tostruct_in_nsap_ptr(rdata, target, mctx); break; \
 657                 default: use_default = ISC_TRUE; break; \
 658                 } \
 659                 break; \
 660         case 24: result = tostruct_sig(rdata, target, mctx); break; \
 661         case 25: result = tostruct_key(rdata, target, mctx); break; \
 662         case 26: switch (rdata->rdclass) { \
 663                 case 1: result = tostruct_in_px(rdata, target, mctx); break; \
 664                 default: use_default = ISC_TRUE; break; \
 665                 } \
 666                 break; \
 667         case 27: result = tostruct_gpos(rdata, target, mctx); break; \
 668         case 28: switch (rdata->rdclass) { \
 669                 case 1: result = tostruct_in_aaaa(rdata, target, mctx); break; \
 670                 default: use_default = ISC_TRUE; break; \
 671                 } \
 672                 break; \
 673         case 29: result = tostruct_loc(rdata, target, mctx); break; \
 674         case 30: result = tostruct_nxt(rdata, target, mctx); break; \
 675         case 33: switch (rdata->rdclass) { \
 676                 case 1: result = tostruct_in_srv(rdata, target, mctx); break; \
 677                 default: use_default = ISC_TRUE; break; \
 678                 } \
 679                 break; \
 680         case 35: switch (rdata->rdclass) { \
 681                 case 1: result = tostruct_in_naptr(rdata, target, mctx); break; \
 682                 default: use_default = ISC_TRUE; break; \
 683                 } \
 684                 break; \
 685         case 36: switch (rdata->rdclass) { \
 686                 case 1: result = tostruct_in_kx(rdata, target, mctx); break; \
 687                 default: use_default = ISC_TRUE; break; \
 688                 } \
 689                 break; \
 690         case 37: result = tostruct_cert(rdata, target, mctx); break; \
 691         case 38: switch (rdata->rdclass) { \
 692                 case 1: result = tostruct_in_a6(rdata, target, mctx); break; \
 693                 default: use_default = ISC_TRUE; break; \
 694                 } \
 695                 break; \
 696         case 39: result = tostruct_dname(rdata, target, mctx); break; \
 697         case 41: result = tostruct_opt(rdata, target, mctx); break; \
 698         case 103: result = tostruct_unspec(rdata, target, mctx); break; \
 699         case 249: result = tostruct_tkey(rdata, target, mctx); break; \
 700         case 250: switch (rdata->rdclass) { \
 701                 case 255: result = tostruct_any_tsig(rdata, target, mctx); break; \
 702                 default: use_default = ISC_TRUE; break; \
 703                 } \
 704                 break; \
 705         default: use_default = ISC_TRUE; break; \
 706         }
 707
 708 #define FREESTRUCTSWITCH \
 709         switch (common->rdtype) { \
 710         case 1: switch (common->rdclass) { \
 711                 case 1: freestruct_in_a(source); break; \
 712                 case 4: freestruct_hs_a(source); break; \
 713                 default: break; \
 714                 } \
 715                 break; \
 716         case 2: freestruct_ns(source); break; \
 717         case 3: freestruct_md(source); break; \
 718         case 4: freestruct_mf(source); break; \
 719         case 5: freestruct_cname(source); break; \
 720         case 6: freestruct_soa(source); break; \
 721         case 7: freestruct_mb(source); break; \
 722         case 8: freestruct_mg(source); break; \
 723         case 9: freestruct_mr(source); break; \
 724         case 10: freestruct_null(source); break; \
 725         case 11: switch (common->rdclass) { \
 726                 case 1: freestruct_in_wks(source); break; \
 727                 default: break; \
 728                 } \
 729                 break; \
 730         case 12: freestruct_ptr(source); break; \
 731         case 13: freestruct_hinfo(source); break; \
 732         case 14: freestruct_minfo(source); break; \
 733         case 15: freestruct_mx(source); break; \
 734         case 16: freestruct_txt(source); break; \
 735         case 17: freestruct_rp(source); break; \
 736         case 18: freestruct_afsdb(source); break; \
 737         case 19: freestruct_x25(source); break; \
 738         case 20: freestruct_isdn(source); break; \
 739         case 21: freestruct_rt(source); break; \
 740         case 22: switch (common->rdclass) { \
 741                 case 1: freestruct_in_nsap(source); break; \
 742                 default: break; \
 743                 } \
 744                 break; \
 745         case 23: switch (common->rdclass) { \
 746                 case 1: freestruct_in_nsap_ptr(source); break; \
 747                 default: break; \
 748                 } \
 749                 break; \
 750         case 24: freestruct_sig(source); break; \
 751         case 25: freestruct_key(source); break; \
 752         case 26: switch (common->rdclass) { \
 753                 case 1: freestruct_in_px(source); break; \
 754                 default: break; \
 755                 } \
 756                 break; \
 757         case 27: freestruct_gpos(source); break; \
 758         case 28: switch (common->rdclass) { \
 759                 case 1: freestruct_in_aaaa(source); break; \
 760                 default: break; \
 761                 } \
 762                 break; \
 763         case 29: freestruct_loc(source); break; \
 764         case 30: freestruct_nxt(source); break; \
 765         case 33: switch (common->rdclass) { \
 766                 case 1: freestruct_in_srv(source); break; \
 767                 default: break; \
 768                 } \
 769                 break; \
 770         case 35: switch (common->rdclass) { \
 771                 case 1: freestruct_in_naptr(source); break; \
 772                 default: break; \
 773                 } \
 774                 break; \
 775         case 36: switch (common->rdclass) { \
 776                 case 1: freestruct_in_kx(source); break; \
 777                 default: break; \
 778                 } \
 779                 break; \
 780         case 37: freestruct_cert(source); break; \
 781         case 38: switch (common->rdclass) { \
 782                 case 1: freestruct_in_a6(source); break; \
 783                 default: break; \
 784                 } \
 785                 break; \
 786         case 39: freestruct_dname(source); break; \
 787         case 41: freestruct_opt(source); break; \
 788         case 103: freestruct_unspec(source); break; \
 789         case 249: freestruct_tkey(source); break; \
 790         case 250: switch (common->rdclass) { \
 791                 case 255: freestruct_any_tsig(source); break; \
 792                 default: break; \
 793                 } \
 794                 break; \
 795         default: break; \
 796         }
 797
 798 #define ADDITIONALDATASWITCH \
 799         switch (rdata->type) { \
 800         case 1: switch (rdata->rdclass) { \
 801                 case 1: result = additionaldata_in_a(rdata, add, arg); break; \
 802                 case 4: result = additionaldata_hs_a(rdata, add, arg); break; \
 803                 default: use_default = ISC_TRUE; break; \
 804                 } \
 805                 break; \
 806         case 2: result = additionaldata_ns(rdata, add, arg); break; \
 807         case 3: result = additionaldata_md(rdata, add, arg); break; \
 808         case 4: result = additionaldata_mf(rdata, add, arg); break; \
 809         case 5: result = additionaldata_cname(rdata, add, arg); break; \
 810         case 6: result = additionaldata_soa(rdata, add, arg); break; \
 811         case 7: result = additionaldata_mb(rdata, add, arg); break; \
 812         case 8: result = additionaldata_mg(rdata, add, arg); break; \
 813         case 9: result = additionaldata_mr(rdata, add, arg); break; \
 814         case 10: result = additionaldata_null(rdata, add, arg); break; \
 815         case 11: switch (rdata->rdclass) { \
 816                 case 1: result = additionaldata_in_wks(rdata, add, arg); break; \
 817                 default: use_default = ISC_TRUE; break; \
 818                 } \
 819                 break; \
 820         case 12: result = additionaldata_ptr(rdata, add, arg); break; \
 821         case 13: result = additionaldata_hinfo(rdata, add, arg); break; \
 822         case 14: result = additionaldata_minfo(rdata, add, arg); break; \
 823         case 15: result = additionaldata_mx(rdata, add, arg); break; \
 824         case 16: result = additionaldata_txt(rdata, add, arg); break; \
 825         case 17: result = additionaldata_rp(rdata, add, arg); break; \
 826         case 18: result = additionaldata_afsdb(rdata, add, arg); break; \
 827         case 19: result = additionaldata_x25(rdata, add, arg); break; \
 828         case 20: result = additionaldata_isdn(rdata, add, arg); break; \
 829         case 21: result = additionaldata_rt(rdata, add, arg); break; \
 830         case 22: switch (rdata->rdclass) { \
 831                 case 1: result = additionaldata_in_nsap(rdata, add, arg); break; \
 832                 default: use_default = ISC_TRUE; break; \
 833                 } \
 834                 break; \
 835         case 23: switch (rdata->rdclass) { \
 836                 case 1: result = additionaldata_in_nsap_ptr(rdata, add, arg); break; \
 837                 default: use_default = ISC_TRUE; break; \
 838                 } \
 839                 break; \
 840         case 24: result = additionaldata_sig(rdata, add, arg); break; \
 841         case 25: result = additionaldata_key(rdata, add, arg); break; \
 842         case 26: switch (rdata->rdclass) { \
 843                 case 1: result = additionaldata_in_px(rdata, add, arg); break; \
 844                 default: use_default = ISC_TRUE; break; \
 845                 } \
 846                 break; \
 847         case 27: result = additionaldata_gpos(rdata, add, arg); break; \
 848         case 28: switch (rdata->rdclass) { \
 849                 case 1: result = additionaldata_in_aaaa(rdata, add, arg); break; \
 850                 default: use_default = ISC_TRUE; break; \
 851                 } \
 852                 break; \
 853         case 29: result = additionaldata_loc(rdata, add, arg); break; \
 854         case 30: result = additionaldata_nxt(rdata, add, arg); break; \
 855         case 33: switch (rdata->rdclass) { \
 856                 case 1: result = additionaldata_in_srv(rdata, add, arg); break; \
 857                 default: use_default = ISC_TRUE; break; \
 858                 } \
 859                 break; \
 860         case 35: switch (rdata->rdclass) { \
 861                 case 1: result = additionaldata_in_naptr(rdata, add, arg); break; \
 862                 default: use_default = ISC_TRUE; break; \
 863                 } \
 864                 break; \
 865         case 36: switch (rdata->rdclass) { \
 866                 case 1: result = additionaldata_in_kx(rdata, add, arg); break; \
 867                 default: use_default = ISC_TRUE; break; \
 868                 } \
 869                 break; \
 870         case 37: result = additionaldata_cert(rdata, add, arg); break; \
 871         case 38: switch (rdata->rdclass) { \
 872                 case 1: result = additionaldata_in_a6(rdata, add, arg); break; \
 873                 default: use_default = ISC_TRUE; break; \
 874                 } \
 875                 break; \
 876         case 39: result = additionaldata_dname(rdata, add, arg); break; \
 877         case 41: result = additionaldata_opt(rdata, add, arg); break; \
 878         case 103: result = additionaldata_unspec(rdata, add, arg); break; \
 879         case 249: result = additionaldata_tkey(rdata, add, arg); break; \
 880         case 250: switch (rdata->rdclass) { \
 881                 case 255: result = additionaldata_any_tsig(rdata, add, arg); break; \
 882                 default: use_default = ISC_TRUE; break; \
 883                 } \
 884                 break; \
 885         default: use_default = ISC_TRUE; break; \
 886         }
 887
 888 #define DIGESTSWITCH \
 889         switch (rdata->type) { \
 890         case 1: switch (rdata->rdclass) { \
 891                 case 1: result = digest_in_a(rdata, digest, arg); break; \
 892                 case 4: result = digest_hs_a(rdata, digest, arg); break; \
 893                 default: use_default = ISC_TRUE; break; \
 894                 } \
 895                 break; \
 896         case 2: result = digest_ns(rdata, digest, arg); break; \
 897         case 3: result = digest_md(rdata, digest, arg); break; \
 898         case 4: result = digest_mf(rdata, digest, arg); break; \
 899         case 5: result = digest_cname(rdata, digest, arg); break; \
 900         case 6: result = digest_soa(rdata, digest, arg); break; \
 901         case 7: result = digest_mb(rdata, digest, arg); break; \
 902         case 8: result = digest_mg(rdata, digest, arg); break; \
 903         case 9: result = digest_mr(rdata, digest, arg); break; \
 904         case 10: result = digest_null(rdata, digest, arg); break; \
 905         case 11: switch (rdata->rdclass) { \
 906                 case 1: result = digest_in_wks(rdata, digest, arg); break; \
 907                 default: use_default = ISC_TRUE; break; \
 908                 } \
 909                 break; \
 910         case 12: result = digest_ptr(rdata, digest, arg); break; \
 911         case 13: result = digest_hinfo(rdata, digest, arg); break; \
 912         case 14: result = digest_minfo(rdata, digest, arg); break; \
 913         case 15: result = digest_mx(rdata, digest, arg); break; \
 914         case 16: result = digest_txt(rdata, digest, arg); break; \
 915         case 17: result = digest_rp(rdata, digest, arg); break; \
 916         case 18: result = digest_afsdb(rdata, digest, arg); break; \
 917         case 19: result = digest_x25(rdata, digest, arg); break; \
 918         case 20: result = digest_isdn(rdata, digest, arg); break; \
 919         case 21: result = digest_rt(rdata, digest, arg); break; \
 920         case 22: switch (rdata->rdclass) { \
 921                 case 1: result = digest_in_nsap(rdata, digest, arg); break; \
 922                 default: use_default = ISC_TRUE; break; \
 923                 } \
 924                 break; \
 925         case 23: switch (rdata->rdclass) { \
 926                 case 1: result = digest_in_nsap_ptr(rdata, digest, arg); break; \
 927                 default: use_default = ISC_TRUE; break; \
 928                 } \
 929                 break; \
 930         case 24: result = digest_sig(rdata, digest, arg); break; \
 931         case 25: result = digest_key(rdata, digest, arg); break; \
 932         case 26: switch (rdata->rdclass) { \
 933                 case 1: result = digest_in_px(rdata, digest, arg); break; \
 934                 default: use_default = ISC_TRUE; break; \
 935                 } \
 936                 break; \
 937         case 27: result = digest_gpos(rdata, digest, arg); break; \
 938         case 28: switch (rdata->rdclass) { \
 939                 case 1: result = digest_in_aaaa(rdata, digest, arg); break; \
 940                 default: use_default = ISC_TRUE; break; \
 941                 } \
 942                 break; \
 943         case 29: result = digest_loc(rdata, digest, arg); break; \
 944         case 30: result = digest_nxt(rdata, digest, arg); break; \
 945         case 33: switch (rdata->rdclass) { \
 946                 case 1: result = digest_in_srv(rdata, digest, arg); break; \
 947                 default: use_default = ISC_TRUE; break; \
 948                 } \
 949                 break; \
 950         case 35: switch (rdata->rdclass) { \
 951                 case 1: result = digest_in_naptr(rdata, digest, arg); break; \
 952                 default: use_default = ISC_TRUE; break; \
 953                 } \
 954                 break; \
 955         case 36: switch (rdata->rdclass) { \
 956                 case 1: result = digest_in_kx(rdata, digest, arg); break; \
 957                 default: use_default = ISC_TRUE; break; \
 958                 } \
 959                 break; \
 960         case 37: result = digest_cert(rdata, digest, arg); break; \
 961         case 38: switch (rdata->rdclass) { \
 962                 case 1: result = digest_in_a6(rdata, digest, arg); break; \
 963                 default: use_default = ISC_TRUE; break; \
 964                 } \
 965                 break; \
 966         case 39: result = digest_dname(rdata, digest, arg); break; \
 967         case 41: result = digest_opt(rdata, digest, arg); break; \
 968         case 103: result = digest_unspec(rdata, digest, arg); break; \
 969         case 249: result = digest_tkey(rdata, digest, arg); break; \
 970         case 250: switch (rdata->rdclass) { \
 971                 case 255: result = digest_any_tsig(rdata, digest, arg); break; \
 972                 default: use_default = ISC_TRUE; break; \
 973                 } \
 974                 break; \
 975         default: use_default = ISC_TRUE; break; \
 976         }
 977
 978 typedef struct {
 979         const char *name;
 980         unsigned int flags;
 981 } typeattr_t;
 982 static typeattr_t typeattr[] = {
 983         { "RESERVED0", DNS_RDATATYPEATTR_RESERVED },
 984         { "A", RRTYPE_A_ATTRIBUTES },
 985         { "NS", RRTYPE_NS_ATTRIBUTES },
 986         { "MD", RRTYPE_MD_ATTRIBUTES },
 987         { "MF", RRTYPE_MF_ATTRIBUTES },
 988         { "CNAME", RRTYPE_CNAME_ATTRIBUTES },
 989         { "SOA", RRTYPE_SOA_ATTRIBUTES },
 990         { "MB", RRTYPE_MB_ATTRIBUTES },
 991         { "MG", RRTYPE_MG_ATTRIBUTES },
 992         { "MR", RRTYPE_MR_ATTRIBUTES },
 993         { "NULL", RRTYPE_NULL_ATTRIBUTES },
 994         { "WKS", RRTYPE_WKS_ATTRIBUTES },
 995         { "PTR", RRTYPE_PTR_ATTRIBUTES },
 996         { "HINFO", RRTYPE_HINFO_ATTRIBUTES },
 997         { "MINFO", RRTYPE_MINFO_ATTRIBUTES },
 998         { "MX", RRTYPE_MX_ATTRIBUTES },
 999         { "TXT", RRTYPE_TXT_ATTRIBUTES },
1000         { "RP", RRTYPE_RP_ATTRIBUTES },
1001         { "AFSDB", RRTYPE_AFSDB_ATTRIBUTES },
1002         { "X25", RRTYPE_X25_ATTRIBUTES },
1003         { "ISDN", RRTYPE_ISDN_ATTRIBUTES },
1004         { "RT", RRTYPE_RT_ATTRIBUTES },
1005         { "NSAP", RRTYPE_NSAP_ATTRIBUTES },
1006         { "NSAP-PTR", RRTYPE_NSAP_PTR_ATTRIBUTES },
1007         { "SIG", RRTYPE_SIG_ATTRIBUTES },
1008         { "KEY", RRTYPE_KEY_ATTRIBUTES },
1009         { "PX", RRTYPE_PX_ATTRIBUTES },
1010         { "GPOS", RRTYPE_GPOS_ATTRIBUTES },
1011         { "AAAA", RRTYPE_AAAA_ATTRIBUTES },
1012         { "LOC", RRTYPE_LOC_ATTRIBUTES },
1013         { "NXT", RRTYPE_NXT_ATTRIBUTES },
1014         { "EID", DNS_RDATATYPEATTR_RESERVED },
1015         { "NIMLOC", DNS_RDATATYPEATTR_RESERVED },
1016         { "SRV", RRTYPE_SRV_ATTRIBUTES },
1017         { "ATMA", DNS_RDATATYPEATTR_RESERVED },
1018         { "NAPTR", RRTYPE_NAPTR_ATTRIBUTES },
1019         { "KX", RRTYPE_KX_ATTRIBUTES },
1020         { "CERT", RRTYPE_CERT_ATTRIBUTES },
1021         { "A6", RRTYPE_A6_ATTRIBUTES },
1022         { "DNAME", RRTYPE_DNAME_ATTRIBUTES },
1023         { "TYPE40", DNS_RDATATYPEATTR_UNKNOWN},
1024         { "OPT", RRTYPE_OPT_ATTRIBUTES },
1025         { "TYPE42", DNS_RDATATYPEATTR_UNKNOWN},
1026         { "TYPE43", DNS_RDATATYPEATTR_UNKNOWN},
1027         { "TYPE44", DNS_RDATATYPEATTR_UNKNOWN},
1028         { "TYPE45", DNS_RDATATYPEATTR_UNKNOWN},
1029         { "TYPE46", DNS_RDATATYPEATTR_UNKNOWN},
1030         { "TYPE47", DNS_RDATATYPEATTR_UNKNOWN},
1031         { "TYPE48", DNS_RDATATYPEATTR_UNKNOWN},
1032         { "TYPE49", DNS_RDATATYPEATTR_UNKNOWN},
1033         { "TYPE50", DNS_RDATATYPEATTR_UNKNOWN},
1034         { "TYPE51", DNS_RDATATYPEATTR_UNKNOWN},
1035         { "TYPE52", DNS_RDATATYPEATTR_UNKNOWN},
1036         { "TYPE53", DNS_RDATATYPEATTR_UNKNOWN},
1037         { "TYPE54", DNS_RDATATYPEATTR_UNKNOWN},
1038         { "TYPE55", DNS_RDATATYPEATTR_UNKNOWN},
1039         { "TYPE56", DNS_RDATATYPEATTR_UNKNOWN},
1040         { "TYPE57", DNS_RDATATYPEATTR_UNKNOWN},
1041         { "TYPE58", DNS_RDATATYPEATTR_UNKNOWN},
1042         { "TYPE59", DNS_RDATATYPEATTR_UNKNOWN},
1043         { "TYPE60", DNS_RDATATYPEATTR_UNKNOWN},
1044         { "TYPE61", DNS_RDATATYPEATTR_UNKNOWN},
1045         { "TYPE62", DNS_RDATATYPEATTR_UNKNOWN},
1046         { "TYPE63", DNS_RDATATYPEATTR_UNKNOWN},
1047         { "TYPE64", DNS_RDATATYPEATTR_UNKNOWN},
1048         { "TYPE65", DNS_RDATATYPEATTR_UNKNOWN},
1049         { "TYPE66", DNS_RDATATYPEATTR_UNKNOWN},
1050         { "TYPE67", DNS_RDATATYPEATTR_UNKNOWN},
1051         { "TYPE68", DNS_RDATATYPEATTR_UNKNOWN},
1052         { "TYPE69", DNS_RDATATYPEATTR_UNKNOWN},
1053         { "TYPE70", DNS_RDATATYPEATTR_UNKNOWN},
1054         { "TYPE71", DNS_RDATATYPEATTR_UNKNOWN},
1055         { "TYPE72", DNS_RDATATYPEATTR_UNKNOWN},
1056         { "TYPE73", DNS_RDATATYPEATTR_UNKNOWN},
1057         { "TYPE74", DNS_RDATATYPEATTR_UNKNOWN},
1058         { "TYPE75", DNS_RDATATYPEATTR_UNKNOWN},
1059         { "TYPE76", DNS_RDATATYPEATTR_UNKNOWN},
1060         { "TYPE77", DNS_RDATATYPEATTR_UNKNOWN},
1061         { "TYPE78", DNS_RDATATYPEATTR_UNKNOWN},
1062         { "TYPE79", DNS_RDATATYPEATTR_UNKNOWN},
1063         { "TYPE80", DNS_RDATATYPEATTR_UNKNOWN},
1064         { "TYPE81", DNS_RDATATYPEATTR_UNKNOWN},
1065         { "TYPE82", DNS_RDATATYPEATTR_UNKNOWN},
1066         { "TYPE83", DNS_RDATATYPEATTR_UNKNOWN},
1067         { "TYPE84", DNS_RDATATYPEATTR_UNKNOWN},
1068         { "TYPE85", DNS_RDATATYPEATTR_UNKNOWN},
1069         { "TYPE86", DNS_RDATATYPEATTR_UNKNOWN},
1070         { "TYPE87", DNS_RDATATYPEATTR_UNKNOWN},
1071         { "TYPE88", DNS_RDATATYPEATTR_UNKNOWN},
1072         { "TYPE89", DNS_RDATATYPEATTR_UNKNOWN},
1073         { "TYPE90", DNS_RDATATYPEATTR_UNKNOWN},
1074         { "TYPE91", DNS_RDATATYPEATTR_UNKNOWN},
1075         { "TYPE92", DNS_RDATATYPEATTR_UNKNOWN},
1076         { "TYPE93", DNS_RDATATYPEATTR_UNKNOWN},
1077         { "TYPE94", DNS_RDATATYPEATTR_UNKNOWN},
1078         { "TYPE95", DNS_RDATATYPEATTR_UNKNOWN},
1079         { "TYPE96", DNS_RDATATYPEATTR_UNKNOWN},
1080         { "TYPE97", DNS_RDATATYPEATTR_UNKNOWN},
1081         { "TYPE98", DNS_RDATATYPEATTR_UNKNOWN},
1082         { "TYPE99", DNS_RDATATYPEATTR_UNKNOWN},
1083         { "UINFO", DNS_RDATATYPEATTR_RESERVED },
1084         { "UID", DNS_RDATATYPEATTR_RESERVED },
1085         { "GID", DNS_RDATATYPEATTR_RESERVED },
1086         { "UNSPEC", RRTYPE_UNSPEC_ATTRIBUTES },
1087         { "TYPE104", DNS_RDATATYPEATTR_UNKNOWN},
1088         { "TYPE105", DNS_RDATATYPEATTR_UNKNOWN},
1089         { "TYPE106", DNS_RDATATYPEATTR_UNKNOWN},
1090         { "TYPE107", DNS_RDATATYPEATTR_UNKNOWN},
1091         { "TYPE108", DNS_RDATATYPEATTR_UNKNOWN},
1092         { "TYPE109", DNS_RDATATYPEATTR_UNKNOWN},
1093         { "TYPE110", DNS_RDATATYPEATTR_UNKNOWN},
1094         { "TYPE111", DNS_RDATATYPEATTR_UNKNOWN},
1095         { "TYPE112", DNS_RDATATYPEATTR_UNKNOWN},
1096         { "TYPE113", DNS_RDATATYPEATTR_UNKNOWN},
1097         { "TYPE114", DNS_RDATATYPEATTR_UNKNOWN},
1098         { "TYPE115", DNS_RDATATYPEATTR_UNKNOWN},
1099         { "TYPE116", DNS_RDATATYPEATTR_UNKNOWN},
1100         { "TYPE117", DNS_RDATATYPEATTR_UNKNOWN},
1101         { "TYPE118", DNS_RDATATYPEATTR_UNKNOWN},
1102         { "TYPE119", DNS_RDATATYPEATTR_UNKNOWN},
1103         { "TYPE120", DNS_RDATATYPEATTR_UNKNOWN},
1104         { "TYPE121", DNS_RDATATYPEATTR_UNKNOWN},
1105         { "TYPE122", DNS_RDATATYPEATTR_UNKNOWN},
1106         { "TYPE123", DNS_RDATATYPEATTR_UNKNOWN},
1107         { "TYPE124", DNS_RDATATYPEATTR_UNKNOWN},
1108         { "TYPE125", DNS_RDATATYPEATTR_UNKNOWN},
1109         { "TYPE126", DNS_RDATATYPEATTR_UNKNOWN},
1110         { "TYPE127", DNS_RDATATYPEATTR_UNKNOWN},
1111         { "TYPE128", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1112         { "TYPE129", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1113         { "TYPE130", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1114         { "TYPE131", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1115         { "TYPE132", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1116         { "TYPE133", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1117         { "TYPE134", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1118         { "TYPE135", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1119         { "TYPE136", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1120         { "TYPE137", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1121         { "TYPE138", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1122         { "TYPE139", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1123         { "TYPE140", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1124         { "TYPE141", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1125         { "TYPE142", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1126         { "TYPE143", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1127         { "TYPE144", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1128         { "TYPE145", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1129         { "TYPE146", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1130         { "TYPE147", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1131         { "TYPE148", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1132         { "TYPE149", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1133         { "TYPE150", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1134         { "TYPE151", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1135         { "TYPE152", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1136         { "TYPE153", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1137         { "TYPE154", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1138         { "TYPE155", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1139         { "TYPE156", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1140         { "TYPE157", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1141         { "TYPE158", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1142         { "TYPE159", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1143         { "TYPE160", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1144         { "TYPE161", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1145         { "TYPE162", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1146         { "TYPE163", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1147         { "TYPE164", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1148         { "TYPE165", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1149         { "TYPE166", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1150         { "TYPE167", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1151         { "TYPE168", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1152         { "TYPE169", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1153         { "TYPE170", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1154         { "TYPE171", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1155         { "TYPE172", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1156         { "TYPE173", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1157         { "TYPE174", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1158         { "TYPE175", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1159         { "TYPE176", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1160         { "TYPE177", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1161         { "TYPE178", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1162         { "TYPE179", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1163         { "TYPE180", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1164         { "TYPE181", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1165         { "TYPE182", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1166         { "TYPE183", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1167         { "TYPE184", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1168         { "TYPE185", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1169         { "TYPE186", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1170         { "TYPE187", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1171         { "TYPE188", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1172         { "TYPE189", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1173         { "TYPE190", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1174         { "TYPE191", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1175         { "TYPE192", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1176         { "TYPE193", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1177         { "TYPE194", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1178         { "TYPE195", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1179         { "TYPE196", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1180         { "TYPE197", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1181         { "TYPE198", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1182         { "TYPE199", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1183         { "TYPE200", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1184         { "TYPE201", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1185         { "TYPE202", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1186         { "TYPE203", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1187         { "TYPE204", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1188         { "TYPE205", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1189         { "TYPE206", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1190         { "TYPE207", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1191         { "TYPE208", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1192         { "TYPE209", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1193         { "TYPE210", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1194         { "TYPE211", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1195         { "TYPE212", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1196         { "TYPE213", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1197         { "TYPE214", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1198         { "TYPE215", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1199         { "TYPE216", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1200         { "TYPE217", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1201         { "TYPE218", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1202         { "TYPE219", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1203         { "TYPE220", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1204         { "TYPE221", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1205         { "TYPE222", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1206         { "TYPE223", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1207         { "TYPE224", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1208         { "TYPE225", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1209         { "TYPE226", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1210         { "TYPE227", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1211         { "TYPE228", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1212         { "TYPE229", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1213         { "TYPE230", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1214         { "TYPE231", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1215         { "TYPE232", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1216         { "TYPE233", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1217         { "TYPE234", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1218         { "TYPE235", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1219         { "TYPE236", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1220         { "TYPE237", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1221         { "TYPE238", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1222         { "TYPE239", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1223         { "TYPE240", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1224         { "TYPE241", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1225         { "TYPE242", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1226         { "TYPE243", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1227         { "TYPE244", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1228         { "TYPE245", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1229         { "TYPE246", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1230         { "TYPE247", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1231         { "TYPE248", DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META},
1232         { "TKEY", RRTYPE_TKEY_ATTRIBUTES },
1233         { "TSIG", RRTYPE_TSIG_ATTRIBUTES },
1234         { "IXFR", DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY },
1235         { "AXFR", DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY },
1236         { "MAILB", DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY },
1237         { "MAILA", DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY },
1238         { "ANY", DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY }
1239 };
1240 #define RDATATYPE_COMPARE(_s, _d, _tn, _n, _tp) \
1241         do { \
1242                 if (sizeof(_s) - 1 == _n && \
1243                     strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \
1244                         if ((typeattr[_d].flags & DNS_RDATATYPEATTR_RESERVED) != 0) \
1245                                 return (ISC_R_NOTIMPLEMENTED); \
1246                         *(_tp) = _d; \
1247                         return (ISC_R_SUCCESS); \
1248                 } \
1249         } while (0)
1250
1251 #define RDATATYPE_FROMTEXT_SW(_hash,_typename,_length,_typep) \
1252         switch (_hash) { \
1253                 case 16: \
1254                         RDATATYPE_COMPARE("reserved0", 0, _typename, _length, _typep); \
1255                         break; \
1256                 case 34: \
1257                         RDATATYPE_COMPARE("a", 1, _typename, _length, _typep); \
1258                         break; \
1259                 case 80: \
1260                         RDATATYPE_COMPARE("ns", 2, _typename, _length, _typep); \
1261                         break; \
1262                 case 92: \
1263                         RDATATYPE_COMPARE("md", 3, _typename, _length, _typep); \
1264                         break; \
1265                 case 58: \
1266                         RDATATYPE_COMPARE("mf", 4, _typename, _length, _typep); \
1267                         break; \
1268                 case 8: \
1269                         RDATATYPE_COMPARE("cname", 5, _typename, _length, _typep); \
1270                         RDATATYPE_COMPARE("mx", 15, _typename, _length, _typep); \
1271                         break; \
1272                 case 182: \
1273                         RDATATYPE_COMPARE("soa", 6, _typename, _length, _typep); \
1274                         break; \
1275                 case 126: \
1276                         RDATATYPE_COMPARE("mb", 7, _typename, _length, _typep); \
1277                         break; \
1278                 case 169: \
1279                         RDATATYPE_COMPARE("mg", 8, _typename, _length, _typep); \
1280                         break; \
1281                 case 110: \
1282                         RDATATYPE_COMPARE("mr", 9, _typename, _length, _typep); \
1283                         RDATATYPE_COMPARE("minfo", 14, _typename, _length, _typep); \
1284                         break; \
1285                 case 24: \
1286                         RDATATYPE_COMPARE("null", 10, _typename, _length, _typep); \
1287                         RDATATYPE_COMPARE("kx", 36, _typename, _length, _typep); \
1288                         break; \
1289                 case 206: \
1290                         RDATATYPE_COMPARE("wks", 11, _typename, _length, _typep); \
1291                         break; \
1292                 case 54: \
1293                         RDATATYPE_COMPARE("ptr", 12, _typename, _length, _typep); \
1294                         RDATATYPE_COMPARE("naptr", 35, _typename, _length, _typep); \
1295                         break; \
1296                 case 67: \
1297                         RDATATYPE_COMPARE("hinfo", 13, _typename, _length, _typep); \
1298                         break; \
1299                 case 236: \
1300                         RDATATYPE_COMPARE("txt", 16, _typename, _length, _typep); \
1301                         break; \
1302                 case 192: \
1303                         RDATATYPE_COMPARE("rp", 17, _typename, _length, _typep); \
1304                         break; \
1305                 case 12: \
1306                         RDATATYPE_COMPARE("afsdb", 18, _typename, _length, _typep); \
1307                         break; \
1308                 case 119: \
1309                         RDATATYPE_COMPARE("x25", 19, _typename, _length, _typep); \
1310                         break; \
1311                 case 214: \
1312                         RDATATYPE_COMPARE("isdn", 20, _typename, _length, _typep); \
1313                         break; \
1314                 case 144: \
1315                         RDATATYPE_COMPARE("rt", 21, _typename, _length, _typep); \
1316                         break; \
1317                 case 224: \
1318                         RDATATYPE_COMPARE("nsap", 22, _typename, _length, _typep); \
1319                         RDATATYPE_COMPARE("uid", 101, _typename, _length, _typep); \
1320                         break; \
1321                 case 140: \
1322                         RDATATYPE_COMPARE("nsap-ptr", 23, _typename, _length, _typep); \
1323                         break; \
1324                 case 122: \
1325                         RDATATYPE_COMPARE("sig", 24, _typename, _length, _typep); \
1326                         break; \
1327                 case 254: \
1328                         RDATATYPE_COMPARE("key", 25, _typename, _length, _typep); \
1329                         break; \
1330                 case 112: \
1331                         RDATATYPE_COMPARE("px", 26, _typename, _length, _typep); \
1332                         break; \
1333                 case 17: \
1334                         RDATATYPE_COMPARE("gpos", 27, _typename, _length, _typep); \
1335                         break; \
1336                 case 69: \
1337                         RDATATYPE_COMPARE("aaaa", 28, _typename, _length, _typep); \
1338                         RDATATYPE_COMPARE("atma", 34, _typename, _length, _typep); \
1339                         break; \
1340                 case 237: \
1341                         RDATATYPE_COMPARE("loc", 29, _typename, _length, _typep); \
1342                         break; \
1343                 case 52: \
1344                         RDATATYPE_COMPARE("nxt", 30, _typename, _length, _typep); \
1345                         break; \
1346                 case 160: \
1347                         RDATATYPE_COMPARE("eid", 31, _typename, _length, _typep); \
1348                         break; \
1349                 case 220: \
1350                         RDATATYPE_COMPARE("nimloc", 32, _typename, _length, _typep); \
1351                         break; \
1352                 case 100: \
1353                         RDATATYPE_COMPARE("srv", 33, _typename, _length, _typep); \
1354                         break; \
1355                 case 172: \
1356                         RDATATYPE_COMPARE("cert", 37, _typename, _length, _typep); \
1357                         break; \
1358                 case 226: \
1359                         RDATATYPE_COMPARE("a6", 38, _typename, _length, _typep); \
1360                         break; \
1361                 case 109: \
1362                         RDATATYPE_COMPARE("dname", 39, _typename, _length, _typep); \
1363                         break; \
1364                 case 168: \
1365                         RDATATYPE_COMPARE("opt", 41, _typename, _length, _typep); \
1366                         break; \
1367                 case 230: \
1368                         RDATATYPE_COMPARE("uinfo", 100, _typename, _length, _typep); \
1369                         break; \
1370                 case 104: \
1371                         RDATATYPE_COMPARE("gid", 102, _typename, _length, _typep); \
1372                         break; \
1373                 case 145: \
1374                         RDATATYPE_COMPARE("unspec", 103, _typename, _length, _typep); \
1375                         break; \
1376                 case 184: \
1377                         RDATATYPE_COMPARE("tkey", 249, _typename, _length, _typep); \
1378                         break; \
1379                 case 72: \
1380                         RDATATYPE_COMPARE("tsig", 250, _typename, _length, _typep); \
1381                         break; \
1382                 case 138: \
1383                         RDATATYPE_COMPARE("ixfr", 251, _typename, _length, _typep); \
1384                         break; \
1385                 case 250: \
1386                         RDATATYPE_COMPARE("axfr", 252, _typename, _length, _typep); \
1387                         break; \
1388                 case 164: \
1389                         RDATATYPE_COMPARE("mailb", 253, _typename, _length, _typep); \
1390                         break; \
1391                 case 50: \
1392                         RDATATYPE_COMPARE("maila", 254, _typename, _length, _typep); \
1393                         break; \
1394                 case 68: \
1395                         RDATATYPE_COMPARE("any", 255, _typename, _length, _typep); \
1396                         break; \
1397         }
1398 #endif /* DNS_CODE_H */