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.  */
28static 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
36static 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
858rrtype_descriptor_type *
859rrtype_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
868rrtype_descriptor_type *
869rrtype_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
890const char *
891rrtype_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 */
909uint16_t
910rrtype_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
1019const char *
1020rrclass_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
1033uint16_t
1034rrclass_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