xref: /openbsd/usr.sbin/nsd/dns.c (revision d415bd75) 
1 /*
2  * dns.c -- DNS definitions.
3  *
4  * Copyright (c) 2001-2006, NLnet Labs. All rights reserved.
5  *
6  * See LICENSE for the license.
7  *
8  */
9 
10 #include "config.h"
11 
12 #include <sys/types.h>
13 #include <sys/socket.h>
14 #include <netinet/in.h>
15 #include <arpa/inet.h>
16 #include <ctype.h>
17 #include <netdb.h>
18 #include <string.h>
19 #ifdef HAVE_STRINGS_H
20 #include <strings.h>
21 #endif
22 
23 #include "dns.h"
24 #include "zonec.h"
25 #include "zparser.h"
26 
27 /* Taken from RFC 1035, section 3.2.4.  */
28 static lookup_table_type dns_rrclasses[] = {
29 	{ CLASS_IN, "IN" },	/* the Internet */
30 	{ CLASS_CS, "CS" },	/* the CSNET class (Obsolete) */
31 	{ CLASS_CH, "CH" },	/* the CHAOS class */
32 	{ CLASS_HS, "HS" },	/* Hesiod */
33 	{ 0, NULL }
34 };
35 
36 static rrtype_descriptor_type rrtype_descriptors[(RRTYPE_DESCRIPTORS_LENGTH+1)] = {
37 	/* 0 */
38 	{ 0, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
39 	/* 1 */
40 	{ TYPE_A, "A", T_A, 1, 1,
41 	  { RDATA_WF_A }, { RDATA_ZF_A } },
42 	/* 2 */
43 	{ TYPE_NS, "NS", T_NS, 1, 1,
44 	  { RDATA_WF_COMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
45 	/* 3 */
46 	{ TYPE_MD, "MD", T_MD, 1, 1,
47 	  { RDATA_WF_UNCOMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
48 	/* 4 */
49 	{ TYPE_MF, "MF", T_MF, 1, 1,
50 	  { RDATA_WF_UNCOMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
51 	/* 5 */
52 	{ TYPE_CNAME, "CNAME", T_CNAME, 1, 1,
53 	  { RDATA_WF_COMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
54 	/* 6 */
55 	{ TYPE_SOA, "SOA", T_SOA, 7, 7,
56 	  { RDATA_WF_COMPRESSED_DNAME, RDATA_WF_COMPRESSED_DNAME, RDATA_WF_LONG,
57 	    RDATA_WF_LONG, RDATA_WF_LONG, RDATA_WF_LONG, RDATA_WF_LONG },
58 	  { RDATA_ZF_DNAME, RDATA_ZF_DNAME, RDATA_ZF_PERIOD, RDATA_ZF_PERIOD,
59 	    RDATA_ZF_PERIOD, RDATA_ZF_PERIOD, RDATA_ZF_PERIOD } },
60 	/* 7 */
61 	{ TYPE_MB, "MB", T_MB, 1, 1,
62 	  { RDATA_WF_COMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
63 	/* 8 */
64 	{ TYPE_MG, "MG", T_MG, 1, 1,
65 	  { RDATA_WF_COMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
66 	/* 9 */
67 	{ TYPE_MR, "MR", T_MR, 1, 1,
68 	  { RDATA_WF_COMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
69 	/* 10 */
70 	{ TYPE_NULL, "NULL", T_UTYPE, 1, 1,
71 	  { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
72 	/* 11 */
73 	{ TYPE_WKS, "WKS", T_WKS, 2, 2,
74 	  { RDATA_WF_A, RDATA_WF_BINARY },
75 	  { RDATA_ZF_A, RDATA_ZF_SERVICES } },
76 	/* 12 */
77 	{ TYPE_PTR, "PTR", T_PTR, 1, 1,
78 	  { RDATA_WF_COMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
79 	/* 13 */
80 	{ TYPE_HINFO, "HINFO", T_HINFO, 2, 2,
81 	  { RDATA_WF_TEXT, RDATA_WF_TEXT }, { RDATA_ZF_TEXT, RDATA_ZF_TEXT } },
82 	/* 14 */
83 	{ TYPE_MINFO, "MINFO", T_MINFO, 2, 2,
84 	  { RDATA_WF_COMPRESSED_DNAME, RDATA_WF_COMPRESSED_DNAME },
85 	  { RDATA_ZF_DNAME, RDATA_ZF_DNAME } },
86 	/* 15 */
87 	{ TYPE_MX, "MX", T_MX, 2, 2,
88 	  { RDATA_WF_SHORT, RDATA_WF_COMPRESSED_DNAME },
89 	  { RDATA_ZF_SHORT, RDATA_ZF_DNAME } },
90 	/* 16 */
91 	{ TYPE_TXT, "TXT", T_TXT, 1, 1,
92 	  { RDATA_WF_TEXTS },
93 	  { RDATA_ZF_TEXTS } },
94 	/* 17 */
95 	{ TYPE_RP, "RP", T_RP, 2, 2,
96 	  { RDATA_WF_UNCOMPRESSED_DNAME, RDATA_WF_UNCOMPRESSED_DNAME },
97 	  { RDATA_ZF_DNAME, RDATA_ZF_DNAME } },
98 	/* 18 */
99 	{ TYPE_AFSDB, "AFSDB", T_AFSDB, 2, 2,
100 	  { RDATA_WF_SHORT, RDATA_WF_UNCOMPRESSED_DNAME },
101 	  { RDATA_ZF_SHORT, RDATA_ZF_DNAME } },
102 	/* 19 */
103 	{ TYPE_X25, "X25", T_X25, 1, 1,
104 	  { RDATA_WF_TEXT },
105 	  { RDATA_ZF_TEXT } },
106 	/* 20 */
107 	{ TYPE_ISDN, "ISDN", T_ISDN, 1, 2,
108 	  { RDATA_WF_TEXT, RDATA_WF_TEXT },
109 	  { RDATA_ZF_TEXT, RDATA_ZF_TEXT } },
110 	/* 21 */
111 	{ TYPE_RT, "RT", T_RT, 2, 2,
112 	  { RDATA_WF_SHORT, RDATA_WF_UNCOMPRESSED_DNAME },
113 	  { RDATA_ZF_SHORT, RDATA_ZF_DNAME } },
114 	/* 22 */
115 	{ TYPE_NSAP, "NSAP", T_NSAP, 1, 1,
116 	  { RDATA_WF_BINARY },
117 	  { RDATA_ZF_NSAP } },
118 	/* 23 */
119 	{ 23, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
120 	/* 24 */
121 	{ TYPE_SIG, "SIG", T_SIG, 9, 9,
122 	  { RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_LONG,
123 	    RDATA_WF_LONG, RDATA_WF_LONG, RDATA_WF_SHORT,
124 	    RDATA_WF_LITERAL_DNAME, RDATA_WF_BINARY },
125 	  { RDATA_ZF_RRTYPE, RDATA_ZF_ALGORITHM, RDATA_ZF_BYTE, RDATA_ZF_PERIOD,
126 	    RDATA_ZF_TIME, RDATA_ZF_TIME, RDATA_ZF_SHORT,
127 	    RDATA_ZF_LITERAL_DNAME, RDATA_ZF_BASE64 } },
128 	/* 25 */
129 	{ TYPE_KEY, "KEY", T_KEY, 4, 4,
130 	  { RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_BINARY },
131 	  { RDATA_ZF_SHORT, RDATA_ZF_BYTE, RDATA_ZF_ALGORITHM,
132 	    RDATA_ZF_BASE64 } },
133 	/* 26 */
134 	{ TYPE_PX, "PX", T_PX, 3, 3,
135 	  { RDATA_WF_SHORT, RDATA_WF_UNCOMPRESSED_DNAME,
136 	    RDATA_WF_UNCOMPRESSED_DNAME },
137 	  { RDATA_ZF_SHORT, RDATA_ZF_DNAME, RDATA_ZF_DNAME } },
138 	/* 27 */
139 	{ 27, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
140 	/* 28 */
141 	{ TYPE_AAAA, "AAAA", T_AAAA, 1, 1,
142 	  { RDATA_WF_AAAA },
143 	  { RDATA_ZF_AAAA } },
144 	/* 29 */
145 	{ TYPE_LOC, "LOC", T_LOC, 1, 1,
146 	  { RDATA_WF_BINARY },
147 	  { RDATA_ZF_LOC } },
148 	/* 30 */
149 	{ TYPE_NXT, "NXT", T_NXT, 2, 2,
150 	  { RDATA_WF_UNCOMPRESSED_DNAME, RDATA_WF_BINARY },
151 	  { RDATA_ZF_DNAME, RDATA_ZF_NXT } },
152 	/* 31 */
153 	{ 31, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
154 	/* 32 */
155 	{ 32, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
156 	/* 33 */
157 	{ TYPE_SRV, "SRV", T_SRV, 4, 4,
158 	  { RDATA_WF_SHORT, RDATA_WF_SHORT, RDATA_WF_SHORT,
159 	    RDATA_WF_UNCOMPRESSED_DNAME },
160 	  { RDATA_ZF_SHORT, RDATA_ZF_SHORT, RDATA_ZF_SHORT, RDATA_ZF_DNAME } },
161 	/* 34 */
162 	{ 34, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
163 	/* 35 */
164 	{ TYPE_NAPTR, "NAPTR", T_NAPTR, 6, 6,
165 	  { RDATA_WF_SHORT, RDATA_WF_SHORT, RDATA_WF_TEXT, RDATA_WF_TEXT,
166 	    RDATA_WF_TEXT, RDATA_WF_UNCOMPRESSED_DNAME },
167 	  { RDATA_ZF_SHORT, RDATA_ZF_SHORT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
168 	    RDATA_ZF_TEXT, RDATA_ZF_DNAME } },
169 	/* 36 */
170 	{ TYPE_KX, "KX", T_KX, 2, 2,
171 	  { RDATA_WF_SHORT, RDATA_WF_UNCOMPRESSED_DNAME },
172 	  { RDATA_ZF_SHORT, RDATA_ZF_DNAME } },
173 	/* 37 */
174 	{ TYPE_CERT, "CERT", T_CERT, 4, 4,
175 	  { RDATA_WF_SHORT, RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BINARY },
176 	  { RDATA_ZF_CERTIFICATE_TYPE, RDATA_ZF_SHORT, RDATA_ZF_ALGORITHM,
177 	    RDATA_ZF_BASE64 } },
178 	/* 38 */
179 	{ TYPE_A6, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
180 	/* 39 */
181 	{ TYPE_DNAME, "DNAME", T_DNAME, 1, 1,
182 	  { RDATA_WF_UNCOMPRESSED_DNAME }, { RDATA_ZF_DNAME } },
183 	/* 40 */
184 	{ 40, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
185 	/* 41 */
186 	{ TYPE_OPT, "OPT", T_UTYPE, 1, 1,
187 	  { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
188 	/* 42 */
189 	{ TYPE_APL, "APL", T_APL, 0, MAXRDATALEN,
190 	  { RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
191 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
192 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
193 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
194 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
195 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
196 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
197 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
198 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
199 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
200 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
201 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
202 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
203 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
204 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL,
205 	    RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL, RDATA_WF_APL },
206 	  { RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
207 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
208 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
209 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
210 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
211 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
212 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
213 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
214 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
215 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
216 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
217 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
218 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
219 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
220 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL,
221 	    RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL, RDATA_ZF_APL } },
222 	/* 43 */
223 	{ TYPE_DS, "DS", T_DS, 4, 4,
224 	  { RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_BINARY },
225 	  { RDATA_ZF_SHORT, RDATA_ZF_ALGORITHM, RDATA_ZF_BYTE, RDATA_ZF_HEX } },
226 	/* 44 */
227 	{ TYPE_SSHFP, "SSHFP", T_SSHFP, 3, 3,
228 	  { RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_BINARY },
229 	  { RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_HEX } },
230 	/* 45 */
231 	{ TYPE_IPSECKEY, "IPSECKEY", T_IPSECKEY, 4, 5,
232 	  { RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_IPSECGATEWAY,
233 	    RDATA_WF_BINARY },
234 	  { RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_IPSECGATEWAY,
235 	    RDATA_ZF_BASE64 } },
236 	/* 46 */
237 	{ TYPE_RRSIG, "RRSIG", T_RRSIG, 9, 9,
238 	  { RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_LONG,
239 	    RDATA_WF_LONG, RDATA_WF_LONG, RDATA_WF_SHORT,
240 	    RDATA_WF_LITERAL_DNAME, RDATA_WF_BINARY },
241 	  { RDATA_ZF_RRTYPE, RDATA_ZF_ALGORITHM, RDATA_ZF_BYTE, RDATA_ZF_PERIOD,
242 	    RDATA_ZF_TIME, RDATA_ZF_TIME, RDATA_ZF_SHORT,
243 		RDATA_ZF_LITERAL_DNAME, RDATA_ZF_BASE64 } },
244 	/* 47 */
245 	{ TYPE_NSEC, "NSEC", T_NSEC, 2, 2,
246 	  { RDATA_WF_LITERAL_DNAME, RDATA_WF_BINARY },
247 	  { RDATA_ZF_LITERAL_DNAME, RDATA_ZF_NSEC } },
248 	/* 48 */
249 	{ TYPE_DNSKEY, "DNSKEY", T_DNSKEY, 4, 4,
250 	  { RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_BINARY },
251 	  { RDATA_ZF_SHORT, RDATA_ZF_BYTE, RDATA_ZF_ALGORITHM,
252 	    RDATA_ZF_BASE64 } },
253 	/* 49 */
254 	{ TYPE_DHCID, "DHCID", T_DHCID, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_BASE64 } },
255 	/* 50 */
256 	{ TYPE_NSEC3, "NSEC3", T_NSEC3, 6, 6,
257 	  { RDATA_WF_BYTE, /* hash type */
258 	    RDATA_WF_BYTE, /* flags */
259 	    RDATA_WF_SHORT, /* iterations */
260 	    RDATA_WF_BINARYWITHLENGTH, /* salt */
261 	    RDATA_WF_BINARYWITHLENGTH, /* next hashed name */
262 	    RDATA_WF_BINARY /* type bitmap */ },
263 	  { RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_SHORT, RDATA_ZF_HEX_LEN,
264 	    RDATA_ZF_BASE32, RDATA_ZF_NSEC } },
265 	/* 51 */
266 	{ TYPE_NSEC3PARAM, "NSEC3PARAM", T_NSEC3PARAM, 4, 4,
267 	  { RDATA_WF_BYTE, /* hash type */
268 	    RDATA_WF_BYTE, /* flags */
269 	    RDATA_WF_SHORT, /* iterations */
270 	    RDATA_WF_BINARYWITHLENGTH /* salt */ },
271 	  { RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_SHORT, RDATA_ZF_HEX_LEN } },
272 	/* 52 */
273 	{ TYPE_TLSA, "TLSA", T_TLSA, 4, 4,
274 	  { RDATA_WF_BYTE, /* usage */
275 	    RDATA_WF_BYTE, /* selector */
276 	    RDATA_WF_BYTE, /* matching type */
277 	    RDATA_WF_BINARY }, /* certificate association data */
278 	  { RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_HEX } },
279 	/* 53 */
280 	{ TYPE_SMIMEA, "SMIMEA", T_SMIMEA, 4, 4,
281 	  { RDATA_WF_BYTE, /* usage */
282 	    RDATA_WF_BYTE, /* selector */
283 	    RDATA_WF_BYTE, /* matching type */
284 	    RDATA_WF_BINARY }, /* certificate association data */
285 	  { RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_HEX } },
286 	/* 54 */
287 	{ 54, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
288 	/* 55 - HIP [RFC 5205] */
289 	{ 55, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
290 	/* 56 - NINFO */
291 	{ 56, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
292 	/* 57 - RKEY */
293 	{ 57, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
294 	/* 58 - TALINK */
295 	{ 58, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
296 	/* 59 - CDS */
297 	{ TYPE_CDS, "CDS", T_CDS, 4, 4,
298 	  { RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_BINARY },
299 	  { RDATA_ZF_SHORT, RDATA_ZF_ALGORITHM, RDATA_ZF_BYTE, RDATA_ZF_HEX } },
300 	/* 60 - CDNSKEY */
301 	{ TYPE_CDNSKEY, "CDNSKEY", T_CDNSKEY, 4, 4,
302 	  { RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_BINARY },
303 	  { RDATA_ZF_SHORT, RDATA_ZF_BYTE, RDATA_ZF_ALGORITHM,
304 	    RDATA_ZF_BASE64 } },
305 	/* 61 - OPENPGPKEY */
306 	{ TYPE_OPENPGPKEY, "OPENPGPKEY", T_OPENPGPKEY, 1, 1,
307 	  { RDATA_WF_BINARY }, { RDATA_ZF_BASE64 } },
308 	/* 62 - CSYNC */
309 	{ TYPE_CSYNC, "CSYNC", T_CSYNC, 3, 3, { RDATA_WF_LONG, RDATA_WF_SHORT,
310 	 RDATA_WF_BINARY }, { RDATA_ZF_LONG, RDATA_ZF_SHORT, RDATA_ZF_NSEC } },
311 	/* 63 - ZONEMD */
312 	{ TYPE_ZONEMD, "ZONEMD", T_ZONEMD, 4, 4,
313 	  { RDATA_WF_LONG, /* serial */
314 	    RDATA_WF_BYTE, /* scheme */
315 	    RDATA_WF_BYTE, /* hash Algorithm */
316 	    RDATA_WF_BINARY }, /* digest */
317 	  { RDATA_ZF_PERIOD, RDATA_ZF_BYTE, RDATA_ZF_BYTE, RDATA_ZF_HEX } },
318 	/* 64 - SVCB */
319 	{ TYPE_SVCB, "SVCB", T_SVCB, 2, MAXRDATALEN,
320 	  { RDATA_WF_SHORT                        /* SvcFieldPriority */
321 	  , RDATA_WF_UNCOMPRESSED_DNAME           /* SvcDomainName */
322 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM  /* SvcFieldValue */
323 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
324 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
325 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
326 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
327 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
328 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
329 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
330 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
331 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
332 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
333 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
334 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
335 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
336 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
337 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
338 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
339 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
340 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
341 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
342 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
343 	  },
344 	  { RDATA_ZF_SHORT   , RDATA_ZF_DNAME
345 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
346 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
347 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
348 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
349 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
350 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
351 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
352 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
353 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
354 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
355 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
356 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
357 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
358 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
359 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
360 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
361 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
362 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
363 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
364 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
365 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
366 	  } },
367 	/* 65 - HTTPS */
368 	{ TYPE_HTTPS, "HTTPS", T_HTTPS, 2, MAXRDATALEN,
369 	  { RDATA_WF_SHORT                        /* SvcFieldPriority */
370 	  , RDATA_WF_UNCOMPRESSED_DNAME           /* SvcDomainName */
371 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM  /* SvcFieldValue */
372 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
373 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
374 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
375 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
376 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
377 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
378 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
379 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
380 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
381 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
382 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
383 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
384 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
385 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
386 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
387 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
388 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
389 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
390 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
391 	  , RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM, RDATA_WF_SVCPARAM
392 	  },
393 	  { RDATA_ZF_SHORT   , RDATA_ZF_DNAME
394 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
395 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
396 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
397 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
398 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
399 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
400 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
401 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
402 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
403 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
404 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
405 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
406 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
407 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
408 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
409 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
410 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
411 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
412 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
413 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
414 	  , RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM, RDATA_ZF_SVCPARAM
415 	  } },
416 	/* 66 */
417 	{ 66, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
418 	/* 67 */
419 	{ 67, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
420 	/* 68 */
421 	{ 68, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
422 	/* 69 */
423 	{ 69, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
424 	/* 70 */
425 	{ 70, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
426 	/* 71 */
427 	{ 71, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
428 	/* 72 */
429 	{ 72, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
430 	/* 73 */
431 	{ 73, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
432 	/* 74 */
433 	{ 74, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
434 	/* 75 */
435 	{ 75, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
436 	/* 76 */
437 	{ 76, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
438 	/* 77 */
439 	{ 77, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
440 	/* 78 */
441 	{ 78, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
442 	/* 79 */
443 	{ 79, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
444 	/* 80 */
445 	{ 80, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
446 	/* 81 */
447 	{ 81, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
448 	/* 82 */
449 	{ 82, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
450 	/* 83 */
451 	{ 83, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
452 	/* 84 */
453 	{ 84, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
454 	/* 85 */
455 	{ 85, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
456 	/* 86 */
457 	{ 86, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
458 	/* 87 */
459 	{ 87, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
460 	/* 88 */
461 	{ 88, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
462 	/* 89 */
463 	{ 89, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
464 	/* 90 */
465 	{ 90, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
466 	/* 91 */
467 	{ 91, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
468 	/* 92 */
469 	{ 92, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
470 	/* 93 */
471 	{ 93, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
472 	/* 94 */
473 	{ 94, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
474 	/* 95 */
475 	{ 95, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
476 	/* 96 */
477 	{ 96, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
478 	/* 97 */
479 	{ 97, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
480 	/* 98 */
481 	{ 98, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
482 	/* 99 */
483 	{ TYPE_SPF, "SPF", T_SPF, 1, MAXRDATALEN,
484 	  { RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
485 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
486 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
487 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
488 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
489 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
490 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
491 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
492 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
493 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
494 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
495 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
496 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
497 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
498 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT,
499 	    RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT, RDATA_WF_TEXT },
500 	  { RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
501 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
502 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
503 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
504 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
505 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
506 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
507 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
508 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
509 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
510 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
511 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
512 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
513 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
514 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT,
515 	    RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT, RDATA_ZF_TEXT } },
516 	/* 100 - UINFO */
517 	{ 100, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
518 	/* 101 - UID */
519 	{ 101, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
520 	/* 102 - GID */
521 	{ 102, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
522 	/* 103 - UNSPEC */
523 	{ 103, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
524 	/* 104 */
525 	{ TYPE_NID, "NID", T_NID, 2, 2,
526 	  { RDATA_WF_SHORT, RDATA_WF_ILNP64 },
527 	  { RDATA_ZF_SHORT, RDATA_ZF_ILNP64 } },
528 	/* 105 */
529 	{ TYPE_L32, "L32", T_L32, 2, 2,
530 	  { RDATA_WF_SHORT, RDATA_WF_A },
531 	  { RDATA_ZF_SHORT, RDATA_ZF_A } },
532 	/* 106 */
533 	{ TYPE_L64, "L64", T_L64, 2, 2,
534 	  { RDATA_WF_SHORT, RDATA_WF_ILNP64 },
535 	  { RDATA_ZF_SHORT, RDATA_ZF_ILNP64 } },
536 	/* 107 */
537 	{ TYPE_LP, "LP", T_LP, 2, 2,
538 	  { RDATA_WF_SHORT, RDATA_WF_UNCOMPRESSED_DNAME },
539 	  { RDATA_ZF_SHORT, RDATA_ZF_DNAME } },
540 	/* 108 */
541 	{ TYPE_EUI48, "EUI48", T_EUI48, 1, 1,
542 	  { RDATA_WF_EUI48 }, { RDATA_ZF_EUI48 } },
543 	/* 109 */
544 	{ TYPE_EUI64, "EUI64", T_EUI64, 1, 1,
545 	  { RDATA_WF_EUI64 }, { RDATA_ZF_EUI64 } },
546 	/* 110 */
547 	{ 110, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
548 	/* 111 */
549 	{ 111, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
550 	/* 112 */
551 	{ 112, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
552 	/* 113 */
553 	{ 113, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
554 	/* 114 */
555 	{ 114, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
556 	/* 115 */
557 	{ 115, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
558 	/* 116 */
559 	{ 116, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
560 	/* 117 */
561 	{ 117, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
562 	/* 118 */
563 	{ 118, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
564 	/* 119 */
565 	{ 119, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
566 	/* 120 */
567 	{ 120, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
568 	/* 121 */
569 	{ 121, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
570 	/* 122 */
571 	{ 122, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
572 	/* 123 */
573 	{ 123, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
574 	/* 124 */
575 	{ 124, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
576 	/* 125 */
577 	{ 125, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
578 	/* 126 */
579 	{ 126, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
580 	/* 127 */
581 	{ 127, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
582 	/* 128 */
583 	{ 128, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
584 	/* 129 */
585 	{ 129, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
586 	/* 130 */
587 	{ 130, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
588 	/* 131 */
589 	{ 131, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
590 	/* 132 */
591 	{ 132, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
592 	/* 133 */
593 	{ 133, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
594 	/* 134 */
595 	{ 134, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
596 	/* 135 */
597 	{ 135, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
598 	/* 136 */
599 	{ 136, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
600 	/* 137 */
601 	{ 137, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
602 	/* 138 */
603 	{ 138, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
604 	/* 139 */
605 	{ 139, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
606 	/* 140 */
607 	{ 140, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
608 	/* 141 */
609 	{ 141, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
610 	/* 142 */
611 	{ 142, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
612 	/* 143 */
613 	{ 143, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
614 	/* 144 */
615 	{ 144, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
616 	/* 145 */
617 	{ 145, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
618 	/* 146 */
619 	{ 146, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
620 	/* 147 */
621 	{ 147, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
622 	/* 148 */
623 	{ 148, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
624 	/* 149 */
625 	{ 149, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
626 	/* 150 */
627 	{ 150, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
628 	/* 151 */
629 	{ 151, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
630 	/* 152 */
631 	{ 152, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
632 	/* 153 */
633 	{ 153, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
634 	/* 154 */
635 	{ 154, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
636 	/* 155 */
637 	{ 155, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
638 	/* 156 */
639 	{ 156, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
640 	/* 157 */
641 	{ 157, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
642 	/* 158 */
643 	{ 158, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
644 	/* 159 */
645 	{ 159, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
646 	/* 160 */
647 	{ 160, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
648 	/* 161 */
649 	{ 161, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
650 	/* 162 */
651 	{ 162, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
652 	/* 163 */
653 	{ 163, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
654 	/* 164 */
655 	{ 164, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
656 	/* 165 */
657 	{ 165, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
658 	/* 166 */
659 	{ 166, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
660 	/* 167 */
661 	{ 167, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
662 	/* 168 */
663 	{ 168, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
664 	/* 169 */
665 	{ 169, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
666 	/* 170 */
667 	{ 170, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
668 	/* 171 */
669 	{ 171, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
670 	/* 172 */
671 	{ 172, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
672 	/* 173 */
673 	{ 173, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
674 	/* 174 */
675 	{ 174, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
676 	/* 175 */
677 	{ 175, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
678 	/* 176 */
679 	{ 176, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
680 	/* 177 */
681 	{ 177, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
682 	/* 178 */
683 	{ 178, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
684 	/* 179 */
685 	{ 179, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
686 	/* 180 */
687 	{ 180, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
688 	/* 181 */
689 	{ 181, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
690 	/* 182 */
691 	{ 182, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
692 	/* 183 */
693 	{ 183, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
694 	/* 184 */
695 	{ 184, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
696 	/* 185 */
697 	{ 185, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
698 	/* 186 */
699 	{ 186, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
700 	/* 187 */
701 	{ 187, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
702 	/* 188 */
703 	{ 188, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
704 	/* 189 */
705 	{ 189, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
706 	/* 190 */
707 	{ 190, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
708 	/* 191 */
709 	{ 191, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
710 	/* 192 */
711 	{ 192, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
712 	/* 193 */
713 	{ 193, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
714 	/* 194 */
715 	{ 194, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
716 	/* 195 */
717 	{ 195, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
718 	/* 196 */
719 	{ 196, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
720 	/* 197 */
721 	{ 197, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
722 	/* 198 */
723 	{ 198, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
724 	/* 199 */
725 	{ 199, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
726 	/* 200 */
727 	{ 200, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
728 	/* 201 */
729 	{ 201, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
730 	/* 202 */
731 	{ 202, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
732 	/* 203 */
733 	{ 203, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
734 	/* 204 */
735 	{ 204, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
736 	/* 205 */
737 	{ 205, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
738 	/* 206 */
739 	{ 206, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
740 	/* 207 */
741 	{ 207, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
742 	/* 208 */
743 	{ 208, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
744 	/* 209 */
745 	{ 209, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
746 	/* 210 */
747 	{ 210, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
748 	/* 211 */
749 	{ 211, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
750 	/* 212 */
751 	{ 212, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
752 	/* 213 */
753 	{ 213, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
754 	/* 214 */
755 	{ 214, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
756 	/* 215 */
757 	{ 215, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
758 	/* 216 */
759 	{ 216, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
760 	/* 217 */
761 	{ 217, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
762 	/* 218 */
763 	{ 218, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
764 	/* 219 */
765 	{ 219, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
766 	/* 220 */
767 	{ 220, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
768 	/* 221 */
769 	{ 221, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
770 	/* 222 */
771 	{ 222, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
772 	/* 223 */
773 	{ 223, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
774 	/* 224 */
775 	{ 224, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
776 	/* 225 */
777 	{ 225, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
778 	/* 226 */
779 	{ 226, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
780 	/* 227 */
781 	{ 227, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
782 	/* 228 */
783 	{ 228, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
784 	/* 229 */
785 	{ 229, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
786 	/* 230 */
787 	{ 230, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
788 	/* 231 */
789 	{ 231, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
790 	/* 232 */
791 	{ 232, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
792 	/* 233 */
793 	{ 233, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
794 	/* 234 */
795 	{ 234, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
796 	/* 235 */
797 	{ 235, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
798 	/* 236 */
799 	{ 236, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
800 	/* 237 */
801 	{ 237, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
802 	/* 238 */
803 	{ 238, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
804 	/* 239 */
805 	{ 239, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
806 	/* 240 */
807 	{ 240, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
808 	/* 241 */
809 	{ 241, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
810 	/* 242 */
811 	{ 242, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
812 	/* 243 */
813 	{ 243, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
814 	/* 244 */
815 	{ 244, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
816 	/* 245 */
817 	{ 245, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
818 	/* 246 */
819 	{ 246, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
820 	/* 247 */
821 	{ 247, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
822 	/* 248 */
823 	{ 248, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
824 	/* 249 - TKEY [RFC 2930] */
825 	{ 249, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
826 	/* 250 - TSIG [RFC 2845] */
827 	{ 250, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
828 	/* 251 - IXFR [RFC 1995] */
829 	{ 251, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
830 	/* 252 - AXFR [RFC 1035, RFC 5936] */
831 	{ 252, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
832 	/* 253 - MAILB [RFC 1035] */
833 	{ 253, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
834 	/* 254 - MAILA [RFC 1035] */
835 	{ 254, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
836 	/* 255 - * [RFC 1035, RFC 6895] */
837 	{ 255, NULL, T_UTYPE, 1, 1, { RDATA_WF_BINARY }, { RDATA_ZF_UNKNOWN } },
838 	/* 256 - URI */
839 	{ TYPE_URI, "URI", T_URI, 3, 3,
840 	  { RDATA_WF_SHORT, RDATA_WF_SHORT, RDATA_WF_LONG_TEXT },
841 	  { RDATA_ZF_SHORT, RDATA_ZF_SHORT, RDATA_ZF_LONG_TEXT } },
842 	/* 257 - CAA [RFC 6844] */
843 	{ TYPE_CAA, "CAA", T_CAA, 3, 3,
844 	  { RDATA_WF_BYTE, RDATA_WF_TEXT, RDATA_WF_LONG_TEXT },
845 	  { RDATA_ZF_BYTE, RDATA_ZF_TAG, RDATA_ZF_LONG_TEXT } },
846 	/* 258 - AVC */
847 	{ TYPE_AVC, "AVC", T_AVC, 1, 1,
848 	  { RDATA_WF_TEXTS },
849 	  { RDATA_ZF_TEXTS } },
850 
851 	/* 32768 - TA */
852 	/* 32769 */
853 	{ TYPE_DLV, "DLV", T_DLV, 4, 4,
854 	  { RDATA_WF_SHORT, RDATA_WF_BYTE, RDATA_WF_BYTE, RDATA_WF_BINARY },
855 	  { RDATA_ZF_SHORT, RDATA_ZF_ALGORITHM, RDATA_ZF_BYTE, RDATA_ZF_HEX } },
856 };
857 
858 rrtype_descriptor_type *
859 rrtype_descriptor_by_type(uint16_t type)
860 {
861 	if (type < RRTYPE_DESCRIPTORS_LENGTH)
862 		return &rrtype_descriptors[type];
863 	else if (type == TYPE_DLV)
864 		return &rrtype_descriptors[PSEUDO_TYPE_DLV];
865 	return &rrtype_descriptors[0];
866 }
867 
868 rrtype_descriptor_type *
869 rrtype_descriptor_by_name(const char *name)
870 {
871 	int i;
872 
873 	for (i = 0; i < RRTYPE_DESCRIPTORS_LENGTH; ++i) {
874 		if (rrtype_descriptors[i].name
875 		    && strcasecmp(rrtype_descriptors[i].name, name) == 0)
876 		{
877 			return &rrtype_descriptors[i];
878 		}
879 	}
880 
881 	if (rrtype_descriptors[PSEUDO_TYPE_DLV].name
882 	    && strcasecmp(rrtype_descriptors[PSEUDO_TYPE_DLV].name, name) == 0)
883 	{
884 		return &rrtype_descriptors[PSEUDO_TYPE_DLV];
885 	}
886 
887 	return NULL;
888 }
889 
890 const char *
891 rrtype_to_string(uint16_t rrtype)
892 {
893 	static char buf[20];
894 	rrtype_descriptor_type *descriptor = rrtype_descriptor_by_type(rrtype);
895 	if (descriptor->name) {
896 		return descriptor->name;
897 	} else {
898 		snprintf(buf, sizeof(buf), "TYPE%d", (int) rrtype);
899 		return buf;
900 	}
901 }
902 
903 /*
904  * Lookup the type in the ztypes lookup table.  If not found, check if
905  * the type uses the "TYPExxx" notation for unknown types.
906  *
907  * Return 0 if no type matches.
908  */
909 uint16_t
910 rrtype_from_string(const char *name)
911 {
912         char *end;
913         long rrtype;
914 	rrtype_descriptor_type *entry;
915 
916 	/* Because this routine is called during zone parse for every record,
917 	 * we optimise for frequently occurring records.
918 	 * Also, we optimise for 'IN' and numbers are not rr types, because
919 	 * during parse this routine is called for every rr class and TTL
920 	 * to determine that it is not an RR type */
921 	switch(name[0]) {
922 	case 'r':
923 	case 'R':
924 		if(strcasecmp(name+1, "RSIG") == 0) return TYPE_RRSIG;
925 		break;
926 	case 'n':
927 	case 'N':
928 		switch(name[1]) {
929 		case 's':
930 		case 'S':
931 			switch(name[2]) {
932 			case 0: return TYPE_NS;
933 			case 'e':
934 			case 'E':
935 				if(strcasecmp(name+2, "EC") == 0) return TYPE_NSEC;
936 				if(strcasecmp(name+2, "EC3") == 0) return TYPE_NSEC3;
937 				if(strcasecmp(name+2, "EC3PARAM") == 0) return TYPE_NSEC3PARAM;
938 				break;
939 			}
940 			break;
941 		}
942 		break;
943 	case 'd':
944 	case 'D':
945 		switch(name[1]) {
946 		case 's':
947 		case 'S':
948 			if(name[2]==0) return TYPE_DS;
949 			break;
950 		case 'n':
951 		case 'N':
952 			if(strcasecmp(name+2, "SKEY") == 0) return TYPE_DNSKEY;
953 			break;
954 		}
955 		break;
956 	case 'a':
957 	case 'A':
958 		switch(name[1]) {
959 		case 0:	return TYPE_A;
960 		case 'a':
961 		case 'A':
962 			if(strcasecmp(name+2, "AA") == 0) return TYPE_AAAA;
963 			break;
964 		}
965 		break;
966 	case 's':
967 	case 'S':
968 		if(strcasecmp(name+1, "OA") == 0) return TYPE_SOA;
969 		break;
970 	case 't':
971 	case 'T':
972 		if(strcasecmp(name+1, "XT") == 0) return TYPE_TXT;
973 		break;
974 	case '0':
975 	case '1':
976 	case '2':
977 	case '3':
978 	case '4':
979 	case '5':
980 	case '6':
981 	case '7':
982 	case '8':
983 	case '9':
984 		return 0; /* no RR types start with 0-9 */
985 	case 'i':
986 	case 'I':
987 		switch(name[1]) {
988 		case 'n':
989 		case 'N':
990 			return 0; /* 'IN' is a class not a type */
991 		}
992 		break;
993 	}
994 
995 	entry = rrtype_descriptor_by_name(name);
996 	if (entry) {
997 		return entry->type;
998 	}
999 
1000 	if (strlen(name) < 5)
1001 		return 0;
1002 
1003 	if (strncasecmp(name, "TYPE", 4) != 0)
1004 		return 0;
1005 
1006 	if (!isdigit((unsigned char)name[4]))
1007 		return 0;
1008 
1009 	/* The rest from the string must be a number.  */
1010 	rrtype = strtol(name + 4, &end, 10);
1011 	if (*end != '\0')
1012 		return 0;
1013 	if (rrtype < 0 || rrtype > 65535L)
1014 		return 0;
1015 
1016         return (uint16_t) rrtype;
1017 }
1018 
1019 const char *
1020 rrclass_to_string(uint16_t rrclass)
1021 {
1022 	static char buf[20];
1023 	lookup_table_type *entry = lookup_by_id(dns_rrclasses, rrclass);
1024 	if (entry) {
1025 		assert(strlen(entry->name) < sizeof(buf));
1026 		strlcpy(buf, entry->name, sizeof(buf));
1027 	} else {
1028 		snprintf(buf, sizeof(buf), "CLASS%d", (int) rrclass);
1029 	}
1030 	return buf;
1031 }
1032 
1033 uint16_t
1034 rrclass_from_string(const char *name)
1035 {
1036         char *end;
1037         long rrclass;
1038 	lookup_table_type *entry;
1039 
1040 	entry = lookup_by_name(dns_rrclasses, name);
1041 	if (entry) {
1042 		return (uint16_t) entry->id;
1043 	}
1044 
1045 	if (strlen(name) < 6)
1046 		return 0;
1047 
1048 	if (strncasecmp(name, "CLASS", 5) != 0)
1049 		return 0;
1050 
1051 	if (!isdigit((unsigned char)name[5]))
1052 		return 0;
1053 
1054 	/* The rest from the string must be a number.  */
1055 	rrclass = strtol(name + 5, &end, 10);
1056 	if (*end != '\0')
1057 		return 0;
1058 	if (rrclass < 0 || rrclass > 65535L)
1059 		return 0;
1060 
1061 	return (uint16_t) rrclass;
1062 }
1063