2 * Copyright (C) 2004, 2005, 2007, 2009 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
18 /* $Id: dnskey_48.c,v 1.10 2009-12-04 22:06:37 tbox Exp $ */
21 * Reviewed: Wed Mar 15 16:47:10 PST 2000 by halley.
26 #ifndef RDATA_GENERIC_DNSKEY_48_C
27 #define RDATA_GENERIC_DNSKEY_48_C
31 #define RRTYPE_DNSKEY_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC)
33 static inline isc_result_t
34 fromtext_dnskey(ARGS_FROMTEXT) {
49 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
51 RETTOK(dns_keyflags_fromtext(&flags, &token.value.as_textregion));
52 RETERR(uint16_tobuffer(flags, target));
55 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
57 RETTOK(dns_secproto_fromtext(&proto, &token.value.as_textregion));
58 RETERR(mem_tobuffer(target, &proto, 1));
61 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
63 RETTOK(dns_secalg_fromtext(&alg, &token.value.as_textregion));
64 RETERR(mem_tobuffer(target, &alg, 1));
67 if ((flags & 0xc000) == 0xc000)
68 return (ISC_R_SUCCESS);
70 return (isc_base64_tobuffer(lexer, target, -1));
73 static inline isc_result_t
74 totext_dnskey(ARGS_TOTEXT) {
76 char buf[sizeof("64000")];
78 unsigned char algorithm;
79 char namebuf[DNS_NAME_FORMATSIZE];
81 REQUIRE(rdata->type == 48);
82 REQUIRE(rdata->length != 0);
84 dns_rdata_toregion(rdata, &sr);
87 flags = uint16_fromregion(&sr);
88 isc_region_consume(&sr, 2);
89 sprintf(buf, "%u", flags);
90 RETERR(str_totext(buf, target));
91 RETERR(str_totext(" ", target));
94 sprintf(buf, "%u", sr.base[0]);
95 isc_region_consume(&sr, 1);
96 RETERR(str_totext(buf, target));
97 RETERR(str_totext(" ", target));
100 algorithm = sr.base[0];
101 sprintf(buf, "%u", algorithm);
102 isc_region_consume(&sr, 1);
103 RETERR(str_totext(buf, target));
106 if ((flags & 0xc000) == 0xc000)
107 return (ISC_R_SUCCESS);
109 if ((tctx->flags & DNS_STYLEFLAG_COMMENT) != 0 &&
110 algorithm == DNS_KEYALG_PRIVATEDNS) {
112 dns_name_init(&name, NULL);
113 dns_name_fromregion(&name, &sr);
114 dns_name_format(&name, namebuf, sizeof(namebuf));
119 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
120 RETERR(str_totext(" (", target));
121 RETERR(str_totext(tctx->linebreak, target));
122 RETERR(isc_base64_totext(&sr, tctx->width - 2,
123 tctx->linebreak, target));
125 if ((tctx->flags & DNS_STYLEFLAG_COMMENT) != 0)
126 RETERR(str_totext(tctx->linebreak, target));
127 else if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
128 RETERR(str_totext(" ", target));
130 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
131 RETERR(str_totext(")", target));
133 if ((tctx->flags & DNS_STYLEFLAG_COMMENT) != 0) {
136 RETERR(str_totext(" ; key id = ", target));
137 dns_rdata_toregion(rdata, &tmpr);
138 sprintf(buf, "%u", dst_region_computeid(&tmpr, algorithm));
139 RETERR(str_totext(buf, target));
140 if (algorithm == DNS_KEYALG_PRIVATEDNS) {
141 RETERR(str_totext(tctx->linebreak, target));
142 RETERR(str_totext("; alg = ", target));
143 RETERR(str_totext(namebuf, target));
146 return (ISC_R_SUCCESS);
149 static inline isc_result_t
150 fromwire_dnskey(ARGS_FROMWIRE) {
151 unsigned char algorithm;
161 isc_buffer_activeregion(source, &sr);
163 return (ISC_R_UNEXPECTEDEND);
165 algorithm = sr.base[3];
166 RETERR(mem_tobuffer(target, sr.base, 4));
167 isc_region_consume(&sr, 4);
168 isc_buffer_forward(source, 4);
170 if (algorithm == DNS_KEYALG_PRIVATEDNS) {
172 dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE);
173 dns_name_init(&name, NULL);
174 RETERR(dns_name_fromwire(&name, source, dctx, options, target));
176 isc_buffer_activeregion(source, &sr);
177 isc_buffer_forward(source, sr.length);
178 return (mem_tobuffer(target, sr.base, sr.length));
181 static inline isc_result_t
182 towire_dnskey(ARGS_TOWIRE) {
185 REQUIRE(rdata->type == 48);
186 REQUIRE(rdata->length != 0);
190 dns_rdata_toregion(rdata, &sr);
191 return (mem_tobuffer(target, sr.base, sr.length));
195 compare_dnskey(ARGS_COMPARE) {
199 REQUIRE(rdata1->type == rdata2->type);
200 REQUIRE(rdata1->rdclass == rdata2->rdclass);
201 REQUIRE(rdata1->type == 48);
202 REQUIRE(rdata1->length != 0);
203 REQUIRE(rdata2->length != 0);
205 dns_rdata_toregion(rdata1, &r1);
206 dns_rdata_toregion(rdata2, &r2);
207 return (isc_region_compare(&r1, &r2));
210 static inline isc_result_t
211 fromstruct_dnskey(ARGS_FROMSTRUCT) {
212 dns_rdata_dnskey_t *dnskey = source;
215 REQUIRE(source != NULL);
216 REQUIRE(dnskey->common.rdtype == type);
217 REQUIRE(dnskey->common.rdclass == rdclass);
223 RETERR(uint16_tobuffer(dnskey->flags, target));
226 RETERR(uint8_tobuffer(dnskey->protocol, target));
229 RETERR(uint8_tobuffer(dnskey->algorithm, target));
232 return (mem_tobuffer(target, dnskey->data, dnskey->datalen));
235 static inline isc_result_t
236 tostruct_dnskey(ARGS_TOSTRUCT) {
237 dns_rdata_dnskey_t *dnskey = target;
240 REQUIRE(rdata->type == 48);
241 REQUIRE(target != NULL);
242 REQUIRE(rdata->length != 0);
244 dnskey->common.rdclass = rdata->rdclass;
245 dnskey->common.rdtype = rdata->type;
246 ISC_LINK_INIT(&dnskey->common, link);
248 dns_rdata_toregion(rdata, &sr);
252 return (ISC_R_UNEXPECTEDEND);
253 dnskey->flags = uint16_fromregion(&sr);
254 isc_region_consume(&sr, 2);
258 return (ISC_R_UNEXPECTEDEND);
259 dnskey->protocol = uint8_fromregion(&sr);
260 isc_region_consume(&sr, 1);
264 return (ISC_R_UNEXPECTEDEND);
265 dnskey->algorithm = uint8_fromregion(&sr);
266 isc_region_consume(&sr, 1);
269 dnskey->datalen = sr.length;
270 dnskey->data = mem_maybedup(mctx, sr.base, dnskey->datalen);
271 if (dnskey->data == NULL)
272 return (ISC_R_NOMEMORY);
275 return (ISC_R_SUCCESS);
279 freestruct_dnskey(ARGS_FREESTRUCT) {
280 dns_rdata_dnskey_t *dnskey = (dns_rdata_dnskey_t *) source;
282 REQUIRE(source != NULL);
283 REQUIRE(dnskey->common.rdtype == 48);
285 if (dnskey->mctx == NULL)
288 if (dnskey->data != NULL)
289 isc_mem_free(dnskey->mctx, dnskey->data);
293 static inline isc_result_t
294 additionaldata_dnskey(ARGS_ADDLDATA) {
295 REQUIRE(rdata->type == 48);
301 return (ISC_R_SUCCESS);
304 static inline isc_result_t
305 digest_dnskey(ARGS_DIGEST) {
308 REQUIRE(rdata->type == 48);
310 dns_rdata_toregion(rdata, &r);
312 return ((digest)(arg, &r));
315 static inline isc_boolean_t
316 checkowner_dnskey(ARGS_CHECKOWNER) {
328 static inline isc_boolean_t
329 checknames_dnskey(ARGS_CHECKNAMES) {
331 REQUIRE(rdata->type == 48);
341 casecompare_dnskey(ARGS_COMPARE) {
344 * Treat ALG 253 (private DNS) subtype name case sensistively.
346 return (compare_dnskey(rdata1, rdata2));
349 #endif /* RDATA_GENERIC_DNSKEY_48_C */