2 * Copyright (C) 2004, 2005, 2007, 2009-2012, 2015 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2002 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.
20 /* draft-ietf-dnsext-delegation-signer-05.txt */
22 #ifndef RDATA_GENERIC_DS_43_C
23 #define RDATA_GENERIC_DS_43_C
25 #define RRTYPE_DS_ATTRIBUTES \
26 (DNS_RDATATYPEATTR_DNSSEC|DNS_RDATATYPEATTR_ATPARENT)
33 static inline isc_result_t
34 generic_fromtext_ds(ARGS_FROMTEXT) {
48 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
50 if (token.value.as_ulong > 0xffffU)
52 RETERR(uint16_tobuffer(token.value.as_ulong, target));
57 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
59 RETTOK(dns_secalg_fromtext(&c, &token.value.as_textregion));
60 RETERR(mem_tobuffer(target, &c, 1));
65 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
67 if (token.value.as_ulong > 0xffU)
69 RETERR(uint8_tobuffer(token.value.as_ulong, target));
70 c = (unsigned char) token.value.as_ulong;
76 case DNS_DSDIGEST_SHA1:
77 length = ISC_SHA1_DIGESTLENGTH;
79 case DNS_DSDIGEST_SHA256:
80 length = ISC_SHA256_DIGESTLENGTH;
82 case DNS_DSDIGEST_GOST:
83 length = ISC_GOST_DIGESTLENGTH;
85 case DNS_DSDIGEST_SHA384:
86 length = ISC_SHA384_DIGESTLENGTH;
92 return (isc_hex_tobuffer(lexer, target, length));
95 static inline isc_result_t
96 fromtext_ds(ARGS_FROMTEXT) {
98 REQUIRE(type == dns_rdatatype_ds);
100 return (generic_fromtext_ds(rdclass, type, lexer, origin, options,
104 static inline isc_result_t
105 generic_totext_ds(ARGS_TOTEXT) {
107 char buf[sizeof("64000 ")];
110 REQUIRE(rdata->length != 0);
114 dns_rdata_toregion(rdata, &sr);
119 n = uint16_fromregion(&sr);
120 isc_region_consume(&sr, 2);
121 sprintf(buf, "%u ", n);
122 RETERR(str_totext(buf, target));
127 n = uint8_fromregion(&sr);
128 isc_region_consume(&sr, 1);
129 sprintf(buf, "%u ", n);
130 RETERR(str_totext(buf, target));
135 n = uint8_fromregion(&sr);
136 isc_region_consume(&sr, 1);
137 sprintf(buf, "%u", n);
138 RETERR(str_totext(buf, target));
143 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
144 RETERR(str_totext(" (", target));
145 RETERR(str_totext(tctx->linebreak, target));
146 if (tctx->width == 0) /* No splitting */
147 RETERR(isc_hex_totext(&sr, 0, "", target));
149 RETERR(isc_hex_totext(&sr, tctx->width - 2,
150 tctx->linebreak, target));
151 if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
152 RETERR(str_totext(" )", target));
153 return (ISC_R_SUCCESS);
156 static inline isc_result_t
157 totext_ds(ARGS_TOTEXT) {
159 REQUIRE(rdata->type == dns_rdatatype_ds);
161 return (generic_totext_ds(rdata, tctx, target));
164 static inline isc_result_t
165 generic_fromwire_ds(ARGS_FROMWIRE) {
173 isc_buffer_activeregion(source, &sr);
176 * Check digest lengths if we know them.
179 (sr.base[3] == DNS_DSDIGEST_SHA1 &&
180 sr.length < 4 + ISC_SHA1_DIGESTLENGTH) ||
181 (sr.base[3] == DNS_DSDIGEST_SHA256 &&
182 sr.length < 4 + ISC_SHA256_DIGESTLENGTH) ||
183 (sr.base[3] == DNS_DSDIGEST_GOST &&
184 sr.length < 4 + ISC_GOST_DIGESTLENGTH) ||
185 (sr.base[3] == DNS_DSDIGEST_SHA384 &&
186 sr.length < 4 + ISC_SHA384_DIGESTLENGTH))
187 return (ISC_R_UNEXPECTEDEND);
190 * Only copy digest lengths if we know them.
191 * If there is extra data dns_rdata_fromwire() will
194 if (sr.base[3] == DNS_DSDIGEST_SHA1)
195 sr.length = 4 + ISC_SHA1_DIGESTLENGTH;
196 else if (sr.base[3] == DNS_DSDIGEST_SHA256)
197 sr.length = 4 + ISC_SHA256_DIGESTLENGTH;
198 else if (sr.base[3] == DNS_DSDIGEST_GOST)
199 sr.length = 4 + ISC_GOST_DIGESTLENGTH;
200 else if (sr.base[3] == DNS_DSDIGEST_SHA384)
201 sr.length = 4 + ISC_SHA384_DIGESTLENGTH;
203 isc_buffer_forward(source, sr.length);
204 return (mem_tobuffer(target, sr.base, sr.length));
207 static inline isc_result_t
208 fromwire_ds(ARGS_FROMWIRE) {
210 REQUIRE(type == dns_rdatatype_ds);
212 return (generic_fromwire_ds(rdclass, type, source, dctx, options,
216 static inline isc_result_t
217 towire_ds(ARGS_TOWIRE) {
220 REQUIRE(rdata->type == dns_rdatatype_ds);
221 REQUIRE(rdata->length != 0);
225 dns_rdata_toregion(rdata, &sr);
226 return (mem_tobuffer(target, sr.base, sr.length));
230 compare_ds(ARGS_COMPARE) {
234 REQUIRE(rdata1->type == rdata2->type);
235 REQUIRE(rdata1->rdclass == rdata2->rdclass);
236 REQUIRE(rdata1->type == dns_rdatatype_ds);
237 REQUIRE(rdata1->length != 0);
238 REQUIRE(rdata2->length != 0);
240 dns_rdata_toregion(rdata1, &r1);
241 dns_rdata_toregion(rdata2, &r2);
242 return (isc_region_compare(&r1, &r2));
245 static inline isc_result_t
246 generic_fromstruct_ds(ARGS_FROMSTRUCT) {
247 dns_rdata_ds_t *ds = source;
249 REQUIRE(source != NULL);
250 REQUIRE(ds->common.rdtype == type);
251 REQUIRE(ds->common.rdclass == rdclass);
256 switch (ds->digest_type) {
257 case DNS_DSDIGEST_SHA1:
258 REQUIRE(ds->length == ISC_SHA1_DIGESTLENGTH);
260 case DNS_DSDIGEST_SHA256:
261 REQUIRE(ds->length == ISC_SHA256_DIGESTLENGTH);
263 case DNS_DSDIGEST_GOST:
264 REQUIRE(ds->length == ISC_GOST_DIGESTLENGTH);
266 case DNS_DSDIGEST_SHA384:
267 REQUIRE(ds->length == ISC_SHA384_DIGESTLENGTH);
271 RETERR(uint16_tobuffer(ds->key_tag, target));
272 RETERR(uint8_tobuffer(ds->algorithm, target));
273 RETERR(uint8_tobuffer(ds->digest_type, target));
275 return (mem_tobuffer(target, ds->digest, ds->length));
278 static inline isc_result_t
279 fromstruct_ds(ARGS_FROMSTRUCT) {
281 REQUIRE(type == dns_rdatatype_ds);
283 return (generic_fromstruct_ds(rdclass, type, source, target));
286 static inline isc_result_t
287 generic_tostruct_ds(ARGS_TOSTRUCT) {
288 dns_rdata_ds_t *ds = target;
291 REQUIRE(target != NULL);
292 REQUIRE(rdata->length != 0);
293 REQUIRE(ds->common.rdtype == rdata->type);
294 REQUIRE(ds->common.rdclass == rdata->rdclass);
295 REQUIRE(!ISC_LINK_LINKED(&ds->common, link));
297 dns_rdata_toregion(rdata, ®ion);
299 ds->key_tag = uint16_fromregion(®ion);
300 isc_region_consume(®ion, 2);
301 ds->algorithm = uint8_fromregion(®ion);
302 isc_region_consume(®ion, 1);
303 ds->digest_type = uint8_fromregion(®ion);
304 isc_region_consume(®ion, 1);
305 ds->length = region.length;
307 ds->digest = mem_maybedup(mctx, region.base, region.length);
308 if (ds->digest == NULL)
309 return (ISC_R_NOMEMORY);
312 return (ISC_R_SUCCESS);
315 static inline isc_result_t
316 tostruct_ds(ARGS_TOSTRUCT) {
317 dns_rdata_ds_t *ds = target;
319 REQUIRE(rdata->type == dns_rdatatype_ds);
320 REQUIRE(target != NULL);
322 ds->common.rdclass = rdata->rdclass;
323 ds->common.rdtype = rdata->type;
324 ISC_LINK_INIT(&ds->common, link);
326 return (generic_tostruct_ds(rdata, target, mctx));
330 freestruct_ds(ARGS_FREESTRUCT) {
331 dns_rdata_ds_t *ds = source;
334 REQUIRE(ds->common.rdtype == dns_rdatatype_ds);
336 if (ds->mctx == NULL)
339 if (ds->digest != NULL)
340 isc_mem_free(ds->mctx, ds->digest);
344 static inline isc_result_t
345 additionaldata_ds(ARGS_ADDLDATA) {
346 REQUIRE(rdata->type == dns_rdatatype_ds);
352 return (ISC_R_SUCCESS);
355 static inline isc_result_t
356 digest_ds(ARGS_DIGEST) {
359 REQUIRE(rdata->type == dns_rdatatype_ds);
361 dns_rdata_toregion(rdata, &r);
363 return ((digest)(arg, &r));
366 static inline isc_boolean_t
367 checkowner_ds(ARGS_CHECKOWNER) {
369 REQUIRE(type == dns_rdatatype_ds);
379 static inline isc_boolean_t
380 checknames_ds(ARGS_CHECKNAMES) {
382 REQUIRE(rdata->type == dns_rdatatype_ds);
392 casecompare_ds(ARGS_COMPARE) {
393 return (compare_ds(rdata1, rdata2));
396 #endif /* RDATA_GENERIC_DS_43_C */