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 *
rrtype_descriptor_by_type(uint16_t 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 *
rrtype_descriptor_by_name(const char * name)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 *
rrtype_to_string(uint16_t rrtype)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
rrtype_from_string(const char * name)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 *
rrclass_to_string(uint16_t rrclass)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
rrclass_from_string(const char * name)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