2 * Copyright (C) 2009, 2011, 2012 Internet Systems Consortium, Inc. ("ISC")
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
9 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
10 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
11 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
12 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
13 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
14 * PERFORMANCE OF THIS SOFTWARE.
19 #ifndef GENERIC_KEYDATA_65533_C
20 #define GENERIC_KEYDATA_65533_C 1
24 #define RRTYPE_KEYDATA_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC)
26 static inline isc_result_t
27 fromtext_keydata(ARGS_FROMTEXT) {
32 isc_uint32_t refresh, addhd, removehd;
34 REQUIRE(type == 65533);
43 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
45 RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &refresh));
46 RETERR(uint32_tobuffer(refresh, target));
49 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
51 RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &addhd));
52 RETERR(uint32_tobuffer(addhd, target));
54 /* remove hold-down */
55 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
57 RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &removehd));
58 RETERR(uint32_tobuffer(removehd, target));
61 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
63 RETTOK(dns_keyflags_fromtext(&flags, &token.value.as_textregion));
64 RETERR(uint16_tobuffer(flags, target));
67 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
69 RETTOK(dns_secproto_fromtext(&proto, &token.value.as_textregion));
70 RETERR(mem_tobuffer(target, &proto, 1));
73 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
75 RETTOK(dns_secalg_fromtext(&alg, &token.value.as_textregion));
76 RETERR(mem_tobuffer(target, &alg, 1));
79 if ((flags & 0xc000) == 0xc000)
80 return (ISC_R_SUCCESS);
82 return (isc_base64_tobuffer(lexer, target, -1));
85 static inline isc_result_t
86 totext_keydata(ARGS_TOTEXT) {
88 char buf[sizeof("64000")];
90 unsigned char algorithm;
92 char algbuf[DNS_NAME_FORMATSIZE];
95 REQUIRE(rdata->type == 65533);
96 REQUIRE(rdata->length != 0);
98 dns_rdata_toregion(rdata, &sr);
101 when = uint32_fromregion(&sr);
102 isc_region_consume(&sr, 4);
103 RETERR(dns_time32_totext(when, target));
104 RETERR(str_totext(" ", target));
107 when = uint32_fromregion(&sr);
108 isc_region_consume(&sr, 4);
109 RETERR(dns_time32_totext(when, target));
110 RETERR(str_totext(" ", target));
112 /* remove hold-down */
113 when = uint32_fromregion(&sr);
114 isc_region_consume(&sr, 4);
115 RETERR(dns_time32_totext(when, target));
116 RETERR(str_totext(" ", target));
119 flags = uint16_fromregion(&sr);
120 isc_region_consume(&sr, 2);
121 sprintf(buf, "%u", flags);
122 RETERR(str_totext(buf, target));
123 RETERR(str_totext(" ", target));
124 if ((flags & DNS_KEYFLAG_KSK) != 0) {
125 if (flags & DNS_KEYFLAG_REVOKE)
126 keyinfo = "revoked KSK";
133 sprintf(buf, "%u", sr.base[0]);
134 isc_region_consume(&sr, 1);
135 RETERR(str_totext(buf, target));
136 RETERR(str_totext(" ", target));
139 algorithm = sr.base[0];
140 sprintf(buf, "%u", algorithm);
141 isc_region_consume(&sr, 1);
142 RETERR(str_totext(buf, target));
145 if ((flags & 0xc000) == 0xc000)
146 return (ISC_R_SUCCESS);
149 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
150 RETERR(str_totext(" (", target));
151 RETERR(str_totext(tctx->linebreak, target));
152 if (tctx->width == 0) /* No splitting */
153 RETERR(isc_base64_totext(&sr, 60, "", target));
155 RETERR(isc_base64_totext(&sr, tctx->width - 2,
156 tctx->linebreak, target));
158 if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0)
159 RETERR(str_totext(tctx->linebreak, target));
160 else if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
161 RETERR(str_totext(" ", target));
163 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
164 RETERR(str_totext(")", target));
166 if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0) {
169 RETERR(str_totext(" ; ", target));
170 RETERR(str_totext(keyinfo, target));
171 dns_secalg_format((dns_secalg_t) algorithm, algbuf,
173 RETERR(str_totext("; alg = ", target));
174 RETERR(str_totext(algbuf, target));
175 RETERR(str_totext("; key id = ", target));
176 dns_rdata_toregion(rdata, &tmpr);
177 /* Skip over refresh, addhd, and removehd */
178 isc_region_consume(&tmpr, 12);
179 sprintf(buf, "%u", dst_region_computeid(&tmpr, algorithm));
180 RETERR(str_totext(buf, target));
182 return (ISC_R_SUCCESS);
185 static inline isc_result_t
186 fromwire_keydata(ARGS_FROMWIRE) {
189 REQUIRE(type == 65533);
196 isc_buffer_activeregion(source, &sr);
198 return (ISC_R_UNEXPECTEDEND);
200 isc_buffer_forward(source, sr.length);
201 return (mem_tobuffer(target, sr.base, sr.length));
204 static inline isc_result_t
205 towire_keydata(ARGS_TOWIRE) {
208 REQUIRE(rdata->type == 65533);
209 REQUIRE(rdata->length != 0);
213 dns_rdata_toregion(rdata, &sr);
214 return (mem_tobuffer(target, sr.base, sr.length));
218 compare_keydata(ARGS_COMPARE) {
222 REQUIRE(rdata1->type == rdata2->type);
223 REQUIRE(rdata1->rdclass == rdata2->rdclass);
224 REQUIRE(rdata1->type == 65533);
225 REQUIRE(rdata1->length != 0);
226 REQUIRE(rdata2->length != 0);
228 dns_rdata_toregion(rdata1, &r1);
229 dns_rdata_toregion(rdata2, &r2);
230 return (isc_region_compare(&r1, &r2));
233 static inline isc_result_t
234 fromstruct_keydata(ARGS_FROMSTRUCT) {
235 dns_rdata_keydata_t *keydata = source;
237 REQUIRE(type == 65533);
238 REQUIRE(source != NULL);
239 REQUIRE(keydata->common.rdtype == type);
240 REQUIRE(keydata->common.rdclass == rdclass);
246 RETERR(uint32_tobuffer(keydata->refresh, target));
249 RETERR(uint32_tobuffer(keydata->addhd, target));
251 /* Remove hold-down */
252 RETERR(uint32_tobuffer(keydata->removehd, target));
255 RETERR(uint16_tobuffer(keydata->flags, target));
258 RETERR(uint8_tobuffer(keydata->protocol, target));
261 RETERR(uint8_tobuffer(keydata->algorithm, target));
264 return (mem_tobuffer(target, keydata->data, keydata->datalen));
267 static inline isc_result_t
268 tostruct_keydata(ARGS_TOSTRUCT) {
269 dns_rdata_keydata_t *keydata = target;
272 REQUIRE(rdata->type == 65533);
273 REQUIRE(target != NULL);
274 REQUIRE(rdata->length != 0);
276 keydata->common.rdclass = rdata->rdclass;
277 keydata->common.rdtype = rdata->type;
278 ISC_LINK_INIT(&keydata->common, link);
280 dns_rdata_toregion(rdata, &sr);
284 return (ISC_R_UNEXPECTEDEND);
285 keydata->refresh = uint32_fromregion(&sr);
286 isc_region_consume(&sr, 4);
290 return (ISC_R_UNEXPECTEDEND);
291 keydata->addhd = uint32_fromregion(&sr);
292 isc_region_consume(&sr, 4);
294 /* Remove hold-down */
296 return (ISC_R_UNEXPECTEDEND);
297 keydata->removehd = uint32_fromregion(&sr);
298 isc_region_consume(&sr, 4);
302 return (ISC_R_UNEXPECTEDEND);
303 keydata->flags = uint16_fromregion(&sr);
304 isc_region_consume(&sr, 2);
308 return (ISC_R_UNEXPECTEDEND);
309 keydata->protocol = uint8_fromregion(&sr);
310 isc_region_consume(&sr, 1);
314 return (ISC_R_UNEXPECTEDEND);
315 keydata->algorithm = uint8_fromregion(&sr);
316 isc_region_consume(&sr, 1);
319 keydata->datalen = sr.length;
320 keydata->data = mem_maybedup(mctx, sr.base, keydata->datalen);
321 if (keydata->data == NULL)
322 return (ISC_R_NOMEMORY);
324 keydata->mctx = mctx;
325 return (ISC_R_SUCCESS);
329 freestruct_keydata(ARGS_FREESTRUCT) {
330 dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *) source;
332 REQUIRE(source != NULL);
333 REQUIRE(keydata->common.rdtype == 65533);
335 if (keydata->mctx == NULL)
338 if (keydata->data != NULL)
339 isc_mem_free(keydata->mctx, keydata->data);
340 keydata->mctx = NULL;
343 static inline isc_result_t
344 additionaldata_keydata(ARGS_ADDLDATA) {
345 REQUIRE(rdata->type == 65533);
351 return (ISC_R_SUCCESS);
354 static inline isc_result_t
355 digest_keydata(ARGS_DIGEST) {
358 REQUIRE(rdata->type == 65533);
360 dns_rdata_toregion(rdata, &r);
362 return ((digest)(arg, &r));
365 static inline isc_boolean_t
366 checkowner_keydata(ARGS_CHECKOWNER) {
368 REQUIRE(type == 65533);
378 static inline isc_boolean_t
379 checknames_keydata(ARGS_CHECKNAMES) {
381 REQUIRE(rdata->type == 65533);
391 casecompare_keydata(ARGS_COMPARE) {
392 return (compare_keydata(rdata1, rdata2));
395 #endif /* GENERIC_KEYDATA_65533_C */