/contrib/bind9/lib/dns/rdata/generic/keydata_65533.c

  1/*
  2 * Copyright (C) 2009, 2012  Internet Systems Consortium, Inc. ("ISC")
  3 *
  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.
  7 *
  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.
 15 */
 16
 17/* $Id$ */
 18
 19#ifndef GENERIC_KEYDATA_65533_C
 20#define GENERIC_KEYDATA_65533_C 1
 21
 22#include <dst/dst.h>
 23
 24#define RRTYPE_KEYDATA_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC)
 25
 26static inline isc_result_t
 27fromtext_keydata(ARGS_FROMTEXT) {
 28	isc_token_t token;
 29	dns_secalg_t alg;
 30	dns_secproto_t proto;
 31	dns_keyflags_t flags;
 32	isc_uint32_t refresh, addhd, removehd;
 33
 34	REQUIRE(type == 65533);
 35
 36	UNUSED(type);
 37	UNUSED(rdclass);
 38	UNUSED(origin);
 39	UNUSED(options);
 40	UNUSED(callbacks);
 41
 42	/* refresh timer */
 43	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 44				      ISC_FALSE));
 45	RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &refresh));
 46	RETERR(uint32_tobuffer(refresh, target));
 47
 48	/* add hold-down */
 49	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 50				      ISC_FALSE));
 51	RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &addhd));
 52	RETERR(uint32_tobuffer(addhd, target));
 53
 54	/* remove hold-down */
 55	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 56				      ISC_FALSE));
 57	RETTOK(dns_time32_fromtext(DNS_AS_STR(token), &removehd));
 58	RETERR(uint32_tobuffer(removehd, target));
 59
 60	/* flags */
 61	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 62				      ISC_FALSE));
 63	RETTOK(dns_keyflags_fromtext(&flags, &token.value.as_textregion));
 64	RETERR(uint16_tobuffer(flags, target));
 65
 66	/* protocol */
 67	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 68				      ISC_FALSE));
 69	RETTOK(dns_secproto_fromtext(&proto, &token.value.as_textregion));
 70	RETERR(mem_tobuffer(target, &proto, 1));
 71
 72	/* algorithm */
 73	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
 74				      ISC_FALSE));
 75	RETTOK(dns_secalg_fromtext(&alg, &token.value.as_textregion));
 76	RETERR(mem_tobuffer(target, &alg, 1));
 77
 78	/* No Key? */
 79	if ((flags & 0xc000) == 0xc000)
 80		return (ISC_R_SUCCESS);
 81
 82	return (isc_base64_tobuffer(lexer, target, -1));
 83}
 84
 85static inline isc_result_t
 86totext_keydata(ARGS_TOTEXT) {
 87	isc_region_t sr;
 88	char buf[sizeof("64000")];
 89	unsigned int flags;
 90	unsigned char algorithm;
 91	unsigned long when;
 92
 93	REQUIRE(rdata->type == 65533);
 94	REQUIRE(rdata->length != 0);
 95
 96	dns_rdata_toregion(rdata, &sr);
 97
 98	/* refresh timer */
 99	when = uint32_fromregion(&sr);
100	isc_region_consume(&sr, 4);
101	RETERR(dns_time32_totext(when, target));
102	RETERR(str_totext(" ", target));
103
104	/* add hold-down */
105	when = uint32_fromregion(&sr);
106	isc_region_consume(&sr, 4);
107	RETERR(dns_time32_totext(when, target));
108	RETERR(str_totext(" ", target));
109
110	/* remove hold-down */
111	when = uint32_fromregion(&sr);
112	isc_region_consume(&sr, 4);
113	RETERR(dns_time32_totext(when, target));
114	RETERR(str_totext(" ", target));
115
116	/* flags */
117	flags = uint16_fromregion(&sr);
118	isc_region_consume(&sr, 2);
119	sprintf(buf, "%u", flags);
120	RETERR(str_totext(buf, target));
121	RETERR(str_totext(" ", target));
122
123	/* protocol */
124	sprintf(buf, "%u", sr.base[0]);
125	isc_region_consume(&sr, 1);
126	RETERR(str_totext(buf, target));
127	RETERR(str_totext(" ", target));
128
129	/* algorithm */
130	algorithm = sr.base[0];
131	sprintf(buf, "%u", algorithm);
132	isc_region_consume(&sr, 1);
133	RETERR(str_totext(buf, target));
134
135	/* No Key? */
136	if ((flags & 0xc000) == 0xc000)
137		return (ISC_R_SUCCESS);
138
139	/* key */
140	if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
141		RETERR(str_totext(" (", target));
142	RETERR(str_totext(tctx->linebreak, target));
143	RETERR(isc_base64_totext(&sr, tctx->width - 2,
144				 tctx->linebreak, target));
145
146	if ((tctx->flags & DNS_STYLEFLAG_COMMENT) != 0)
147		RETERR(str_totext(tctx->linebreak, target));
148	else if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
149		RETERR(str_totext(" ", target));
150
151	if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
152		RETERR(str_totext(")", target));
153
154	if ((tctx->flags & DNS_STYLEFLAG_COMMENT) != 0) {
155		isc_region_t tmpr;
156
157		RETERR(str_totext(" ; key id = ", target));
158		dns_rdata_toregion(rdata, &tmpr);
159		/* Skip over refresh, addhd, and removehd */
160		isc_region_consume(&tmpr, 12);
161		sprintf(buf, "%u", dst_region_computeid(&tmpr, algorithm));
162		RETERR(str_totext(buf, target));
163	}
164	return (ISC_R_SUCCESS);
165}
166
167static inline isc_result_t
168fromwire_keydata(ARGS_FROMWIRE) {
169	isc_region_t sr;
170
171	REQUIRE(type == 65533);
172
173	UNUSED(type);
174	UNUSED(rdclass);
175	UNUSED(dctx);
176	UNUSED(options);
177
178	isc_buffer_activeregion(source, &sr);
179	if (sr.length < 4)
180		return (ISC_R_UNEXPECTEDEND);
181
182	isc_buffer_forward(source, sr.length);
183	return (mem_tobuffer(target, sr.base, sr.length));
184}
185
186static inline isc_result_t
187towire_keydata(ARGS_TOWIRE) {
188	isc_region_t sr;
189
190	REQUIRE(rdata->type == 65533);
191	REQUIRE(rdata->length != 0);
192
193	UNUSED(cctx);
194
195	dns_rdata_toregion(rdata, &sr);
196	return (mem_tobuffer(target, sr.base, sr.length));
197}
198
199static inline int
200compare_keydata(ARGS_COMPARE) {
201	isc_region_t r1;
202	isc_region_t r2;
203
204	REQUIRE(rdata1->type == rdata2->type);
205	REQUIRE(rdata1->rdclass == rdata2->rdclass);
206	REQUIRE(rdata1->type == 65533);
207	REQUIRE(rdata1->length != 0);
208	REQUIRE(rdata2->length != 0);
209
210	dns_rdata_toregion(rdata1, &r1);
211	dns_rdata_toregion(rdata2, &r2);
212	return (isc_region_compare(&r1, &r2));
213}
214
215static inline isc_result_t
216fromstruct_keydata(ARGS_FROMSTRUCT) {
217	dns_rdata_keydata_t *keydata = source;
218
219	REQUIRE(type == 65533);
220	REQUIRE(source != NULL);
221	REQUIRE(keydata->common.rdtype == type);
222	REQUIRE(keydata->common.rdclass == rdclass);
223
224	UNUSED(type);
225	UNUSED(rdclass);
226
227	/* Refresh timer */
228	RETERR(uint32_tobuffer(keydata->refresh, target));
229
230	/* Add hold-down */
231	RETERR(uint32_tobuffer(keydata->addhd, target));
232
233	/* Remove hold-down */
234	RETERR(uint32_tobuffer(keydata->removehd, target));
235
236	/* Flags */
237	RETERR(uint16_tobuffer(keydata->flags, target));
238
239	/* Protocol */
240	RETERR(uint8_tobuffer(keydata->protocol, target));
241
242	/* Algorithm */
243	RETERR(uint8_tobuffer(keydata->algorithm, target));
244
245	/* Data */
246	return (mem_tobuffer(target, keydata->data, keydata->datalen));
247}
248
249static inline isc_result_t
250tostruct_keydata(ARGS_TOSTRUCT) {
251	dns_rdata_keydata_t *keydata = target;
252	isc_region_t sr;
253
254	REQUIRE(rdata->type == 65533);
255	REQUIRE(target != NULL);
256	REQUIRE(rdata->length != 0);
257
258	keydata->common.rdclass = rdata->rdclass;
259	keydata->common.rdtype = rdata->type;
260	ISC_LINK_INIT(&keydata->common, link);
261
262	dns_rdata_toregion(rdata, &sr);
263
264	/* Refresh timer */
265	if (sr.length < 4)
266		return (ISC_R_UNEXPECTEDEND);
267	keydata->refresh = uint32_fromregion(&sr);
268	isc_region_consume(&sr, 4);
269
270	/* Add hold-down */
271	if (sr.length < 4)
272		return (ISC_R_UNEXPECTEDEND);
273	keydata->addhd = uint32_fromregion(&sr);
274	isc_region_consume(&sr, 4);
275
276	/* Remove hold-down */
277	if (sr.length < 4)
278		return (ISC_R_UNEXPECTEDEND);
279	keydata->removehd = uint32_fromregion(&sr);
280	isc_region_consume(&sr, 4);
281
282	/* Flags */
283	if (sr.length < 2)
284		return (ISC_R_UNEXPECTEDEND);
285	keydata->flags = uint16_fromregion(&sr);
286	isc_region_consume(&sr, 2);
287
288	/* Protocol */
289	if (sr.length < 1)
290		return (ISC_R_UNEXPECTEDEND);
291	keydata->protocol = uint8_fromregion(&sr);
292	isc_region_consume(&sr, 1);
293
294	/* Algorithm */
295	if (sr.length < 1)
296		return (ISC_R_UNEXPECTEDEND);
297	keydata->algorithm = uint8_fromregion(&sr);
298	isc_region_consume(&sr, 1);
299
300	/* Data */
301	keydata->datalen = sr.length;
302	keydata->data = mem_maybedup(mctx, sr.base, keydata->datalen);
303	if (keydata->data == NULL)
304		return (ISC_R_NOMEMORY);
305
306	keydata->mctx = mctx;
307	return (ISC_R_SUCCESS);
308}
309
310static inline void
311freestruct_keydata(ARGS_FREESTRUCT) {
312	dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *) source;
313
314	REQUIRE(source != NULL);
315	REQUIRE(keydata->common.rdtype == 65533);
316
317	if (keydata->mctx == NULL)
318		return;
319
320	if (keydata->data != NULL)
321		isc_mem_free(keydata->mctx, keydata->data);
322	keydata->mctx = NULL;
323}
324
325static inline isc_result_t
326additionaldata_keydata(ARGS_ADDLDATA) {
327	REQUIRE(rdata->type == 65533);
328
329	UNUSED(rdata);
330	UNUSED(add);
331	UNUSED(arg);
332
333	return (ISC_R_SUCCESS);
334}
335
336static inline isc_result_t
337digest_keydata(ARGS_DIGEST) {
338	isc_region_t r;
339
340	REQUIRE(rdata->type == 65533);
341
342	dns_rdata_toregion(rdata, &r);
343
344	return ((digest)(arg, &r));
345}
346
347static inline isc_boolean_t
348checkowner_keydata(ARGS_CHECKOWNER) {
349
350	REQUIRE(type == 65533);
351
352	UNUSED(name);
353	UNUSED(type);
354	UNUSED(rdclass);
355	UNUSED(wildcard);
356
357	return (ISC_TRUE);
358}
359
360static inline isc_boolean_t
361checknames_keydata(ARGS_CHECKNAMES) {
362
363	REQUIRE(rdata->type == 65533);
364
365	UNUSED(rdata);
366	UNUSED(owner);
367	UNUSED(bad);
368
369	return (ISC_TRUE);
370}
371
372static inline int
373casecompare_keydata(ARGS_COMPARE) {
374	return (compare_keydata(rdata1, rdata2));
375}
376
377#endif /* GENERIC_KEYDATA_65533_C */