dlv_32769.c 7.54 KB
Newer Older
1
/*
Automatic Updater's avatar
Automatic Updater committed
2
 * Copyright (C) 2004, 2006, 2007, 2009-2011  Internet Systems Consortium, Inc. ("ISC")
3
 *
Automatic Updater's avatar
Automatic Updater committed
4
 * Permission to use, copy, modify, and/or distribute this software for any
5
6
7
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
Mark Andrews's avatar
Mark Andrews committed
8
9
10
11
12
13
14
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
15
16
 */

Mark Andrews's avatar
Mark Andrews committed
17
/* $Id$ */
18
19
20

/* draft-ietf-dnsext-delegation-signer-05.txt */

21
22
#ifndef RDATA_GENERIC_DLV_32769_C
#define RDATA_GENERIC_DLV_32769_C
23
24
25

#define RRTYPE_DLV_ATTRIBUTES 0

26
27
28
29
30
31
#include <isc/sha1.h>
#include <isc/sha2.h>

#include <dns/ds.h>


32
33
34
static inline isc_result_t
fromtext_dlv(ARGS_FROMTEXT) {
	isc_token_t token;
35
36
	unsigned char c;
	int length;
37

38
	REQUIRE(type == 32769);
39
40
41
42
43
44
45
46
47
48
49
50

	UNUSED(type);
	UNUSED(rdclass);
	UNUSED(origin);
	UNUSED(options);
	UNUSED(callbacks);

	/*
	 * Key tag.
	 */
	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
				      ISC_FALSE));
Mark Andrews's avatar
Mark Andrews committed
51
	if (token.value.as_ulong > 0xffffU)
52
53
54
55
56
57
58
59
		RETTOK(ISC_R_RANGE);
	RETERR(uint16_tobuffer(token.value.as_ulong, target));

	/*
	 * Algorithm.
	 */
	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
				      ISC_FALSE));
Mark Andrews's avatar
Mark Andrews committed
60
	if (token.value.as_ulong > 0xffU)
61
62
63
64
65
66
67
68
		RETTOK(ISC_R_RANGE);
	RETERR(uint8_tobuffer(token.value.as_ulong, target));

	/*
	 * Digest type.
	 */
	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
				      ISC_FALSE));
Mark Andrews's avatar
Mark Andrews committed
69
	if (token.value.as_ulong > 0xffU)
70
71
		RETTOK(ISC_R_RANGE);
	RETERR(uint8_tobuffer(token.value.as_ulong, target));
72
	c = (unsigned char) token.value.as_ulong;
73
74
75
76

	/*
	 * Digest.
	 */
77
78
	switch (c) {
	case DNS_DSDIGEST_SHA1:
79
		length = ISC_SHA1_DIGESTLENGTH;
80
81
		break;
	case DNS_DSDIGEST_SHA256:
82
		length = ISC_SHA256_DIGESTLENGTH;
83
84
85
86
87
		break;
	case DNS_DSDIGEST_GOST:
		length = ISC_GOST_DIGESTLENGTH;
		break;
	default:
88
		length = -1;
89
90
		break;
	}
91
92
93
94
95
96
97
98
99
	return (isc_hex_tobuffer(lexer, target, -1));
}

static inline isc_result_t
totext_dlv(ARGS_TOTEXT) {
	isc_region_t sr;
	char buf[sizeof("64000 ")];
	unsigned int n;

100
	REQUIRE(rdata->type == 32769);
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
	REQUIRE(rdata->length != 0);

	UNUSED(tctx);

	dns_rdata_toregion(rdata, &sr);

	/*
	 * Key tag.
	 */
	n = uint16_fromregion(&sr);
	isc_region_consume(&sr, 2);
	sprintf(buf, "%u ", n);
	RETERR(str_totext(buf, target));

	/*
	 * Algorithm.
	 */
	n = uint8_fromregion(&sr);
	isc_region_consume(&sr, 1);
	sprintf(buf, "%u ", n);
	RETERR(str_totext(buf, target));

	/*
	 * Digest type.
	 */
	n = uint8_fromregion(&sr);
	isc_region_consume(&sr, 1);
	sprintf(buf, "%u", n);
	RETERR(str_totext(buf, target));

	/*
	 * Digest.
	 */
	if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
		RETERR(str_totext(" (", target));
	RETERR(str_totext(tctx->linebreak, target));
137
138
139
140
141
	if (tctx->width == 0) /* No splitting */
		RETERR(isc_hex_totext(&sr, 0, "", target));
	else
		RETERR(isc_hex_totext(&sr, tctx->width - 2,
				      tctx->linebreak, target));
142
143
144
145
146
147
148
149
150
	if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
		RETERR(str_totext(" )", target));
	return (ISC_R_SUCCESS);
}

static inline isc_result_t
fromwire_dlv(ARGS_FROMWIRE) {
	isc_region_t sr;

151
	REQUIRE(type == 32769);
152
153
154
155
156
157
158

	UNUSED(type);
	UNUSED(rdclass);
	UNUSED(dctx);
	UNUSED(options);

	isc_buffer_activeregion(source, &sr);
Automatic Updater's avatar
Automatic Updater committed
159

160
161
162
163
164
165
166
	/*
	 * Check digest lengths if we know them.
	 */
	if (sr.length < 4 ||
	    (sr.base[3] == DNS_DSDIGEST_SHA1 &&
	     sr.length < 4 + ISC_SHA1_DIGESTLENGTH) ||
	    (sr.base[3] == DNS_DSDIGEST_SHA256 &&
167
168
169
	     sr.length < 4 + ISC_SHA256_DIGESTLENGTH) ||
	    (sr.base[3] == DNS_DSDIGEST_GOST &&
	     sr.length < 4 + ISC_GOST_DIGESTLENGTH))
170
171
		return (ISC_R_UNEXPECTEDEND);

172
173
174
175
176
177
178
179
180
	/*
	 * Only copy digest lengths if we know them.
	 * If there is extra data dns_rdata_fromwire() will
	 * detect that.
	 */
	if (sr.base[3] == DNS_DSDIGEST_SHA1)
		sr.length = 4 + ISC_SHA1_DIGESTLENGTH;
	else if (sr.base[3] == DNS_DSDIGEST_SHA256)
		sr.length = 4 + ISC_SHA256_DIGESTLENGTH;
181
182
	else if (sr.base[3] == DNS_DSDIGEST_GOST)
		sr.length = 4 + ISC_GOST_DIGESTLENGTH;
Automatic Updater's avatar
Automatic Updater committed
183

184
185
186
187
188
189
190
191
	isc_buffer_forward(source, sr.length);
	return (mem_tobuffer(target, sr.base, sr.length));
}

static inline isc_result_t
towire_dlv(ARGS_TOWIRE) {
	isc_region_t sr;

192
	REQUIRE(rdata->type == 32769);
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
	REQUIRE(rdata->length != 0);

	UNUSED(cctx);

	dns_rdata_toregion(rdata, &sr);
	return (mem_tobuffer(target, sr.base, sr.length));
}

static inline int
compare_dlv(ARGS_COMPARE) {
	isc_region_t r1;
	isc_region_t r2;

	REQUIRE(rdata1->type == rdata2->type);
	REQUIRE(rdata1->rdclass == rdata2->rdclass);
208
	REQUIRE(rdata1->type == 32769);
209
210
211
212
213
214
215
216
217
218
219
220
	REQUIRE(rdata1->length != 0);
	REQUIRE(rdata2->length != 0);

	dns_rdata_toregion(rdata1, &r1);
	dns_rdata_toregion(rdata2, &r2);
	return (isc_region_compare(&r1, &r2));
}

static inline isc_result_t
fromstruct_dlv(ARGS_FROMSTRUCT) {
	dns_rdata_dlv_t *dlv = source;

221
	REQUIRE(type == 32769);
222
223
224
	REQUIRE(source != NULL);
	REQUIRE(dlv->common.rdtype == type);
	REQUIRE(dlv->common.rdclass == rdclass);
225
226
227
228
229
230
231
	switch (dlv->digest_type) {
	case DNS_DSDIGEST_SHA1:
		REQUIRE(dlv->length == ISC_SHA1_DIGESTLENGTH);
		break;
	case DNS_DSDIGEST_SHA256:
		REQUIRE(dlv->length == ISC_SHA256_DIGESTLENGTH);
		break;
232
233
234
	case DNS_DSDIGEST_GOST:
		REQUIRE(dlv->length == ISC_GOST_DIGESTLENGTH);
		break;
235
	}
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

	UNUSED(type);
	UNUSED(rdclass);

	RETERR(uint16_tobuffer(dlv->key_tag, target));
	RETERR(uint8_tobuffer(dlv->algorithm, target));
	RETERR(uint8_tobuffer(dlv->digest_type, target));

	return (mem_tobuffer(target, dlv->digest, dlv->length));
}

static inline isc_result_t
tostruct_dlv(ARGS_TOSTRUCT) {
	dns_rdata_dlv_t *dlv = target;
	isc_region_t region;

252
	REQUIRE(rdata->type == 32769);
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
	REQUIRE(target != NULL);
	REQUIRE(rdata->length != 0);

	dlv->common.rdclass = rdata->rdclass;
	dlv->common.rdtype = rdata->type;
	ISC_LINK_INIT(&dlv->common, link);

	dns_rdata_toregion(rdata, &region);

	dlv->key_tag = uint16_fromregion(&region);
	isc_region_consume(&region, 2);
	dlv->algorithm = uint8_fromregion(&region);
	isc_region_consume(&region, 1);
	dlv->digest_type = uint8_fromregion(&region);
	isc_region_consume(&region, 1);
	dlv->length = region.length;

	dlv->digest = mem_maybedup(mctx, region.base, region.length);
	if (dlv->digest == NULL)
		return (ISC_R_NOMEMORY);

	dlv->mctx = mctx;
	return (ISC_R_SUCCESS);
}

static inline void
freestruct_dlv(ARGS_FREESTRUCT) {
	dns_rdata_dlv_t *dlv = source;

	REQUIRE(dlv != NULL);
283
	REQUIRE(dlv->common.rdtype == 32769);
284
285
286
287
288
289
290
291
292
293
294

	if (dlv->mctx == NULL)
		return;

	if (dlv->digest != NULL)
		isc_mem_free(dlv->mctx, dlv->digest);
	dlv->mctx = NULL;
}

static inline isc_result_t
additionaldata_dlv(ARGS_ADDLDATA) {
295
	REQUIRE(rdata->type == 32769);
296
297
298
299
300
301
302
303
304
305
306
307

	UNUSED(rdata);
	UNUSED(add);
	UNUSED(arg);

	return (ISC_R_SUCCESS);
}

static inline isc_result_t
digest_dlv(ARGS_DIGEST) {
	isc_region_t r;

308
	REQUIRE(rdata->type == 32769);
309
310
311
312
313
314
315
316
317

	dns_rdata_toregion(rdata, &r);

	return ((digest)(arg, &r));
}

static inline isc_boolean_t
checkowner_dlv(ARGS_CHECKOWNER) {

318
	REQUIRE(type == 32769);
319
320
321
322
323
324
325
326
327
328
329
330

	UNUSED(name);
	UNUSED(type);
	UNUSED(rdclass);
	UNUSED(wildcard);

	return (ISC_TRUE);
}

static inline isc_boolean_t
checknames_dlv(ARGS_CHECKNAMES) {

331
	REQUIRE(rdata->type == 32769);
332
333
334
335
336
337
338
339

	UNUSED(rdata);
	UNUSED(owner);
	UNUSED(bad);

	return (ISC_TRUE);
}

340
341
342
343
344
static inline int
casecompare_dlv(ARGS_COMPARE) {
	return (compare_dlv(rdata1, rdata2));
}

345
#endif	/* RDATA_GENERIC_DLV_32769_C */