1/*
2 * validator/val_kentry.c - validator key entry definition.
3 *
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 *
15 * Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 *
19 * Neither the name of the NLNET LABS nor the names of its contributors may
20 * be used to endorse or promote products derived from this software without
21 * specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
| 1/*
2 * validator/val_kentry.c - validator key entry definition.
3 *
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 *
15 * Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 *
19 * Neither the name of the NLNET LABS nor the names of its contributors may
20 * be used to endorse or promote products derived from this software without
21 * specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 * POSSIBILITY OF SUCH DAMAGE.
| 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
34 */
35
36/**
37 * \file
38 *
39 * This file contains functions for dealing with validator key entries.
40 */
41#include "config.h"
| 34 */
35
36/**
37 * \file
38 *
39 * This file contains functions for dealing with validator key entries.
40 */
41#include "config.h"
|
42#include <ldns/ldns.h>
| |
43#include "validator/val_kentry.h"
44#include "util/data/packed_rrset.h"
45#include "util/data/dname.h"
46#include "util/storage/lookup3.h"
47#include "util/regional.h"
48#include "util/net_help.h"
| 42#include "validator/val_kentry.h"
43#include "util/data/packed_rrset.h"
44#include "util/data/dname.h"
45#include "util/storage/lookup3.h"
46#include "util/regional.h"
47#include "util/net_help.h"
|
| 48#include "ldns/rrdef.h"
49#include "ldns/keyraw.h"
|
49
50size_t
51key_entry_sizefunc(void* key, void* data)
52{
53 struct key_entry_key* kk = (struct key_entry_key*)key;
54 struct key_entry_data* kd = (struct key_entry_data*)data;
55 size_t s = sizeof(*kk) + kk->namelen;
56 s += sizeof(*kd) + lock_get_mem(&kk->entry.lock);
57 if(kd->rrset_data)
58 s += packed_rrset_sizeof(kd->rrset_data);
59 if(kd->reason)
60 s += strlen(kd->reason)+1;
61 if(kd->algo)
62 s += strlen((char*)kd->algo)+1;
63 return s;
64}
65
66int
67key_entry_compfunc(void* k1, void* k2)
68{
69 struct key_entry_key* n1 = (struct key_entry_key*)k1;
70 struct key_entry_key* n2 = (struct key_entry_key*)k2;
71 if(n1->key_class != n2->key_class) {
72 if(n1->key_class < n2->key_class)
73 return -1;
74 return 1;
75 }
76 return query_dname_compare(n1->name, n2->name);
77}
78
79void
80key_entry_delkeyfunc(void* key, void* ATTR_UNUSED(userarg))
81{
82 struct key_entry_key* kk = (struct key_entry_key*)key;
83 if(!key)
84 return;
85 lock_rw_destroy(&kk->entry.lock);
86 free(kk->name);
87 free(kk);
88}
89
90void
91key_entry_deldatafunc(void* data, void* ATTR_UNUSED(userarg))
92{
93 struct key_entry_data* kd = (struct key_entry_data*)data;
94 free(kd->reason);
95 free(kd->rrset_data);
96 free(kd->algo);
97 free(kd);
98}
99
100void
101key_entry_hash(struct key_entry_key* kk)
102{
103 kk->entry.hash = 0x654;
104 kk->entry.hash = hashlittle(&kk->key_class, sizeof(kk->key_class),
105 kk->entry.hash);
106 kk->entry.hash = dname_query_hash(kk->name, kk->entry.hash);
107}
108
109struct key_entry_key*
110key_entry_copy_toregion(struct key_entry_key* kkey, struct regional* region)
111{
112 struct key_entry_key* newk;
113 newk = regional_alloc_init(region, kkey, sizeof(*kkey));
114 if(!newk)
115 return NULL;
116 newk->name = regional_alloc_init(region, kkey->name, kkey->namelen);
117 if(!newk->name)
118 return NULL;
119 newk->entry.key = newk;
120 if(newk->entry.data) {
121 /* copy data element */
122 struct key_entry_data *d = (struct key_entry_data*)
123 kkey->entry.data;
124 struct key_entry_data *newd;
125 newd = regional_alloc_init(region, d, sizeof(*d));
126 if(!newd)
127 return NULL;
128 /* copy rrset */
129 if(d->rrset_data) {
130 newd->rrset_data = regional_alloc_init(region,
131 d->rrset_data,
132 packed_rrset_sizeof(d->rrset_data));
133 if(!newd->rrset_data)
134 return NULL;
135 packed_rrset_ptr_fixup(newd->rrset_data);
136 }
137 if(d->reason) {
138 newd->reason = regional_strdup(region, d->reason);
139 if(!newd->reason)
140 return NULL;
141 }
142 if(d->algo) {
143 newd->algo = (uint8_t*)regional_strdup(region,
144 (char*)d->algo);
145 if(!newd->algo)
146 return NULL;
147 }
148 newk->entry.data = newd;
149 }
150 return newk;
151}
152
153struct key_entry_key*
154key_entry_copy(struct key_entry_key* kkey)
155{
156 struct key_entry_key* newk;
157 if(!kkey)
158 return NULL;
159 newk = memdup(kkey, sizeof(*kkey));
160 if(!newk)
161 return NULL;
162 newk->name = memdup(kkey->name, kkey->namelen);
163 if(!newk->name) {
164 free(newk);
165 return NULL;
166 }
167 lock_rw_init(&newk->entry.lock);
168 newk->entry.key = newk;
169 if(newk->entry.data) {
170 /* copy data element */
171 struct key_entry_data *d = (struct key_entry_data*)
172 kkey->entry.data;
173 struct key_entry_data *newd;
174 newd = memdup(d, sizeof(*d));
175 if(!newd) {
176 free(newk->name);
177 free(newk);
178 return NULL;
179 }
180 /* copy rrset */
181 if(d->rrset_data) {
182 newd->rrset_data = memdup(d->rrset_data,
183 packed_rrset_sizeof(d->rrset_data));
184 if(!newd->rrset_data) {
185 free(newd);
186 free(newk->name);
187 free(newk);
188 return NULL;
189 }
190 packed_rrset_ptr_fixup(newd->rrset_data);
191 }
192 if(d->reason) {
193 newd->reason = strdup(d->reason);
194 if(!newd->reason) {
195 free(newd->rrset_data);
196 free(newd);
197 free(newk->name);
198 free(newk);
199 return NULL;
200 }
201 }
202 if(d->algo) {
203 newd->algo = (uint8_t*)strdup((char*)d->algo);
204 if(!newd->algo) {
205 free(newd->rrset_data);
206 free(newd->reason);
207 free(newd);
208 free(newk->name);
209 free(newk);
210 return NULL;
211 }
212 }
213 newk->entry.data = newd;
214 }
215 return newk;
216}
217
218int
219key_entry_isnull(struct key_entry_key* kkey)
220{
221 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
222 return (!d->isbad && d->rrset_data == NULL);
223}
224
225int
226key_entry_isgood(struct key_entry_key* kkey)
227{
228 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
229 return (!d->isbad && d->rrset_data != NULL);
230}
231
232int
233key_entry_isbad(struct key_entry_key* kkey)
234{
235 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
236 return (int)(d->isbad);
237}
238
239void
240key_entry_set_reason(struct key_entry_key* kkey, char* reason)
241{
242 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
243 d->reason = reason;
244}
245
246char*
247key_entry_get_reason(struct key_entry_key* kkey)
248{
249 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
250 return d->reason;
251}
252
253/** setup key entry in region */
254static int
255key_entry_setup(struct regional* region,
256 uint8_t* name, size_t namelen, uint16_t dclass,
257 struct key_entry_key** k, struct key_entry_data** d)
258{
259 *k = regional_alloc(region, sizeof(**k));
260 if(!*k)
261 return 0;
262 memset(*k, 0, sizeof(**k));
263 (*k)->entry.key = *k;
264 (*k)->name = regional_alloc_init(region, name, namelen);
265 if(!(*k)->name)
266 return 0;
267 (*k)->namelen = namelen;
268 (*k)->key_class = dclass;
269 *d = regional_alloc(region, sizeof(**d));
270 if(!*d)
271 return 0;
272 (*k)->entry.data = *d;
273 return 1;
274}
275
276struct key_entry_key*
277key_entry_create_null(struct regional* region,
| 50
51size_t
52key_entry_sizefunc(void* key, void* data)
53{
54 struct key_entry_key* kk = (struct key_entry_key*)key;
55 struct key_entry_data* kd = (struct key_entry_data*)data;
56 size_t s = sizeof(*kk) + kk->namelen;
57 s += sizeof(*kd) + lock_get_mem(&kk->entry.lock);
58 if(kd->rrset_data)
59 s += packed_rrset_sizeof(kd->rrset_data);
60 if(kd->reason)
61 s += strlen(kd->reason)+1;
62 if(kd->algo)
63 s += strlen((char*)kd->algo)+1;
64 return s;
65}
66
67int
68key_entry_compfunc(void* k1, void* k2)
69{
70 struct key_entry_key* n1 = (struct key_entry_key*)k1;
71 struct key_entry_key* n2 = (struct key_entry_key*)k2;
72 if(n1->key_class != n2->key_class) {
73 if(n1->key_class < n2->key_class)
74 return -1;
75 return 1;
76 }
77 return query_dname_compare(n1->name, n2->name);
78}
79
80void
81key_entry_delkeyfunc(void* key, void* ATTR_UNUSED(userarg))
82{
83 struct key_entry_key* kk = (struct key_entry_key*)key;
84 if(!key)
85 return;
86 lock_rw_destroy(&kk->entry.lock);
87 free(kk->name);
88 free(kk);
89}
90
91void
92key_entry_deldatafunc(void* data, void* ATTR_UNUSED(userarg))
93{
94 struct key_entry_data* kd = (struct key_entry_data*)data;
95 free(kd->reason);
96 free(kd->rrset_data);
97 free(kd->algo);
98 free(kd);
99}
100
101void
102key_entry_hash(struct key_entry_key* kk)
103{
104 kk->entry.hash = 0x654;
105 kk->entry.hash = hashlittle(&kk->key_class, sizeof(kk->key_class),
106 kk->entry.hash);
107 kk->entry.hash = dname_query_hash(kk->name, kk->entry.hash);
108}
109
110struct key_entry_key*
111key_entry_copy_toregion(struct key_entry_key* kkey, struct regional* region)
112{
113 struct key_entry_key* newk;
114 newk = regional_alloc_init(region, kkey, sizeof(*kkey));
115 if(!newk)
116 return NULL;
117 newk->name = regional_alloc_init(region, kkey->name, kkey->namelen);
118 if(!newk->name)
119 return NULL;
120 newk->entry.key = newk;
121 if(newk->entry.data) {
122 /* copy data element */
123 struct key_entry_data *d = (struct key_entry_data*)
124 kkey->entry.data;
125 struct key_entry_data *newd;
126 newd = regional_alloc_init(region, d, sizeof(*d));
127 if(!newd)
128 return NULL;
129 /* copy rrset */
130 if(d->rrset_data) {
131 newd->rrset_data = regional_alloc_init(region,
132 d->rrset_data,
133 packed_rrset_sizeof(d->rrset_data));
134 if(!newd->rrset_data)
135 return NULL;
136 packed_rrset_ptr_fixup(newd->rrset_data);
137 }
138 if(d->reason) {
139 newd->reason = regional_strdup(region, d->reason);
140 if(!newd->reason)
141 return NULL;
142 }
143 if(d->algo) {
144 newd->algo = (uint8_t*)regional_strdup(region,
145 (char*)d->algo);
146 if(!newd->algo)
147 return NULL;
148 }
149 newk->entry.data = newd;
150 }
151 return newk;
152}
153
154struct key_entry_key*
155key_entry_copy(struct key_entry_key* kkey)
156{
157 struct key_entry_key* newk;
158 if(!kkey)
159 return NULL;
160 newk = memdup(kkey, sizeof(*kkey));
161 if(!newk)
162 return NULL;
163 newk->name = memdup(kkey->name, kkey->namelen);
164 if(!newk->name) {
165 free(newk);
166 return NULL;
167 }
168 lock_rw_init(&newk->entry.lock);
169 newk->entry.key = newk;
170 if(newk->entry.data) {
171 /* copy data element */
172 struct key_entry_data *d = (struct key_entry_data*)
173 kkey->entry.data;
174 struct key_entry_data *newd;
175 newd = memdup(d, sizeof(*d));
176 if(!newd) {
177 free(newk->name);
178 free(newk);
179 return NULL;
180 }
181 /* copy rrset */
182 if(d->rrset_data) {
183 newd->rrset_data = memdup(d->rrset_data,
184 packed_rrset_sizeof(d->rrset_data));
185 if(!newd->rrset_data) {
186 free(newd);
187 free(newk->name);
188 free(newk);
189 return NULL;
190 }
191 packed_rrset_ptr_fixup(newd->rrset_data);
192 }
193 if(d->reason) {
194 newd->reason = strdup(d->reason);
195 if(!newd->reason) {
196 free(newd->rrset_data);
197 free(newd);
198 free(newk->name);
199 free(newk);
200 return NULL;
201 }
202 }
203 if(d->algo) {
204 newd->algo = (uint8_t*)strdup((char*)d->algo);
205 if(!newd->algo) {
206 free(newd->rrset_data);
207 free(newd->reason);
208 free(newd);
209 free(newk->name);
210 free(newk);
211 return NULL;
212 }
213 }
214 newk->entry.data = newd;
215 }
216 return newk;
217}
218
219int
220key_entry_isnull(struct key_entry_key* kkey)
221{
222 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
223 return (!d->isbad && d->rrset_data == NULL);
224}
225
226int
227key_entry_isgood(struct key_entry_key* kkey)
228{
229 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
230 return (!d->isbad && d->rrset_data != NULL);
231}
232
233int
234key_entry_isbad(struct key_entry_key* kkey)
235{
236 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
237 return (int)(d->isbad);
238}
239
240void
241key_entry_set_reason(struct key_entry_key* kkey, char* reason)
242{
243 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
244 d->reason = reason;
245}
246
247char*
248key_entry_get_reason(struct key_entry_key* kkey)
249{
250 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
251 return d->reason;
252}
253
254/** setup key entry in region */
255static int
256key_entry_setup(struct regional* region,
257 uint8_t* name, size_t namelen, uint16_t dclass,
258 struct key_entry_key** k, struct key_entry_data** d)
259{
260 *k = regional_alloc(region, sizeof(**k));
261 if(!*k)
262 return 0;
263 memset(*k, 0, sizeof(**k));
264 (*k)->entry.key = *k;
265 (*k)->name = regional_alloc_init(region, name, namelen);
266 if(!(*k)->name)
267 return 0;
268 (*k)->namelen = namelen;
269 (*k)->key_class = dclass;
270 *d = regional_alloc(region, sizeof(**d));
271 if(!*d)
272 return 0;
273 (*k)->entry.data = *d;
274 return 1;
275}
276
277struct key_entry_key*
278key_entry_create_null(struct regional* region,
|
278 uint8_t* name, size_t namelen, uint16_t dclass, uint32_t ttl,
279 uint32_t now)
| 279 uint8_t* name, size_t namelen, uint16_t dclass, time_t ttl,
280 time_t now)
|
280{
281 struct key_entry_key* k;
282 struct key_entry_data* d;
283 if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
284 return NULL;
285 d->ttl = now + ttl;
286 d->isbad = 0;
287 d->reason = NULL;
288 d->rrset_type = LDNS_RR_TYPE_DNSKEY;
289 d->rrset_data = NULL;
290 d->algo = NULL;
291 return k;
292}
293
294struct key_entry_key*
295key_entry_create_rrset(struct regional* region,
296 uint8_t* name, size_t namelen, uint16_t dclass,
| 281{
282 struct key_entry_key* k;
283 struct key_entry_data* d;
284 if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
285 return NULL;
286 d->ttl = now + ttl;
287 d->isbad = 0;
288 d->reason = NULL;
289 d->rrset_type = LDNS_RR_TYPE_DNSKEY;
290 d->rrset_data = NULL;
291 d->algo = NULL;
292 return k;
293}
294
295struct key_entry_key*
296key_entry_create_rrset(struct regional* region,
297 uint8_t* name, size_t namelen, uint16_t dclass,
|
297 struct ub_packed_rrset_key* rrset, uint8_t* sigalg, uint32_t now)
| 298 struct ub_packed_rrset_key* rrset, uint8_t* sigalg, time_t now)
|
298{
299 struct key_entry_key* k;
300 struct key_entry_data* d;
301 struct packed_rrset_data* rd = (struct packed_rrset_data*)
302 rrset->entry.data;
303 if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
304 return NULL;
305 d->ttl = rd->ttl + now;
306 d->isbad = 0;
307 d->reason = NULL;
308 d->rrset_type = ntohs(rrset->rk.type);
309 d->rrset_data = (struct packed_rrset_data*)regional_alloc_init(region,
310 rd, packed_rrset_sizeof(rd));
311 if(!d->rrset_data)
312 return NULL;
313 if(sigalg) {
314 d->algo = (uint8_t*)regional_strdup(region, (char*)sigalg);
315 if(!d->algo)
316 return NULL;
317 } else d->algo = NULL;
318 packed_rrset_ptr_fixup(d->rrset_data);
319 return k;
320}
321
322struct key_entry_key*
323key_entry_create_bad(struct regional* region,
| 299{
300 struct key_entry_key* k;
301 struct key_entry_data* d;
302 struct packed_rrset_data* rd = (struct packed_rrset_data*)
303 rrset->entry.data;
304 if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
305 return NULL;
306 d->ttl = rd->ttl + now;
307 d->isbad = 0;
308 d->reason = NULL;
309 d->rrset_type = ntohs(rrset->rk.type);
310 d->rrset_data = (struct packed_rrset_data*)regional_alloc_init(region,
311 rd, packed_rrset_sizeof(rd));
312 if(!d->rrset_data)
313 return NULL;
314 if(sigalg) {
315 d->algo = (uint8_t*)regional_strdup(region, (char*)sigalg);
316 if(!d->algo)
317 return NULL;
318 } else d->algo = NULL;
319 packed_rrset_ptr_fixup(d->rrset_data);
320 return k;
321}
322
323struct key_entry_key*
324key_entry_create_bad(struct regional* region,
|
324 uint8_t* name, size_t namelen, uint16_t dclass, uint32_t ttl,
325 uint32_t now)
| 325 uint8_t* name, size_t namelen, uint16_t dclass, time_t ttl,
326 time_t now)
|
326{
327 struct key_entry_key* k;
328 struct key_entry_data* d;
329 if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
330 return NULL;
331 d->ttl = now + ttl;
332 d->isbad = 1;
333 d->reason = NULL;
334 d->rrset_type = LDNS_RR_TYPE_DNSKEY;
335 d->rrset_data = NULL;
336 d->algo = NULL;
337 return k;
338}
339
340struct ub_packed_rrset_key*
341key_entry_get_rrset(struct key_entry_key* kkey, struct regional* region)
342{
343 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
344 struct ub_packed_rrset_key* rrk;
345 struct packed_rrset_data* rrd;
346 if(!d || !d->rrset_data)
347 return NULL;
348 rrk = regional_alloc(region, sizeof(*rrk));
349 if(!rrk)
350 return NULL;
351 memset(rrk, 0, sizeof(*rrk));
352 rrk->rk.dname = regional_alloc_init(region, kkey->name, kkey->namelen);
353 if(!rrk->rk.dname)
354 return NULL;
355 rrk->rk.dname_len = kkey->namelen;
356 rrk->rk.type = htons(d->rrset_type);
357 rrk->rk.rrset_class = htons(kkey->key_class);
358 rrk->entry.key = rrk;
359 rrd = regional_alloc_init(region, d->rrset_data,
360 packed_rrset_sizeof(d->rrset_data));
361 if(!rrd)
362 return NULL;
363 rrk->entry.data = rrd;
364 packed_rrset_ptr_fixup(rrd);
365 return rrk;
366}
367
368/** Get size of key in keyset */
369static size_t
370dnskey_get_keysize(struct packed_rrset_data* data, size_t idx)
371{
372 unsigned char* pk;
373 unsigned int pklen = 0;
374 int algo;
375 if(data->rr_len[idx] < 2+5)
376 return 0;
377 algo = (int)data->rr_data[idx][2+3];
378 pk = (unsigned char*)data->rr_data[idx]+2+4;
379 pklen = (unsigned)data->rr_len[idx]-2-4;
| 327{
328 struct key_entry_key* k;
329 struct key_entry_data* d;
330 if(!key_entry_setup(region, name, namelen, dclass, &k, &d))
331 return NULL;
332 d->ttl = now + ttl;
333 d->isbad = 1;
334 d->reason = NULL;
335 d->rrset_type = LDNS_RR_TYPE_DNSKEY;
336 d->rrset_data = NULL;
337 d->algo = NULL;
338 return k;
339}
340
341struct ub_packed_rrset_key*
342key_entry_get_rrset(struct key_entry_key* kkey, struct regional* region)
343{
344 struct key_entry_data* d = (struct key_entry_data*)kkey->entry.data;
345 struct ub_packed_rrset_key* rrk;
346 struct packed_rrset_data* rrd;
347 if(!d || !d->rrset_data)
348 return NULL;
349 rrk = regional_alloc(region, sizeof(*rrk));
350 if(!rrk)
351 return NULL;
352 memset(rrk, 0, sizeof(*rrk));
353 rrk->rk.dname = regional_alloc_init(region, kkey->name, kkey->namelen);
354 if(!rrk->rk.dname)
355 return NULL;
356 rrk->rk.dname_len = kkey->namelen;
357 rrk->rk.type = htons(d->rrset_type);
358 rrk->rk.rrset_class = htons(kkey->key_class);
359 rrk->entry.key = rrk;
360 rrd = regional_alloc_init(region, d->rrset_data,
361 packed_rrset_sizeof(d->rrset_data));
362 if(!rrd)
363 return NULL;
364 rrk->entry.data = rrd;
365 packed_rrset_ptr_fixup(rrd);
366 return rrk;
367}
368
369/** Get size of key in keyset */
370static size_t
371dnskey_get_keysize(struct packed_rrset_data* data, size_t idx)
372{
373 unsigned char* pk;
374 unsigned int pklen = 0;
375 int algo;
376 if(data->rr_len[idx] < 2+5)
377 return 0;
378 algo = (int)data->rr_data[idx][2+3];
379 pk = (unsigned char*)data->rr_data[idx]+2+4;
380 pklen = (unsigned)data->rr_len[idx]-2-4;
|
380 return ldns_rr_dnskey_key_size_raw(pk, pklen, algo);
| 381 return sldns_rr_dnskey_key_size_raw(pk, pklen, algo);
|
381}
382
383/** get dnskey flags from data */
384static uint16_t
385kd_get_flags(struct packed_rrset_data* data, size_t idx)
386{
387 uint16_t f;
388 if(data->rr_len[idx] < 2+2)
389 return 0;
390 memmove(&f, data->rr_data[idx]+2, 2);
391 f = ntohs(f);
392 return f;
393}
394
395size_t
396key_entry_keysize(struct key_entry_key* kkey)
397{
398 struct packed_rrset_data* d;
399 /* compute size of smallest ZSK key in the rrset */
400 size_t i;
401 size_t bits = 0;
402 if(!key_entry_isgood(kkey))
403 return 0;
404 d = ((struct key_entry_data*)kkey->entry.data)->rrset_data;
405 for(i=0; i<d->count; i++) {
406 if(!(kd_get_flags(d, i) & DNSKEY_BIT_ZSK))
407 continue;
408 if(i==0 || dnskey_get_keysize(d, i) < bits)
409 bits = dnskey_get_keysize(d, i);
410 }
411 return bits;
412}
| 382}
383
384/** get dnskey flags from data */
385static uint16_t
386kd_get_flags(struct packed_rrset_data* data, size_t idx)
387{
388 uint16_t f;
389 if(data->rr_len[idx] < 2+2)
390 return 0;
391 memmove(&f, data->rr_data[idx]+2, 2);
392 f = ntohs(f);
393 return f;
394}
395
396size_t
397key_entry_keysize(struct key_entry_key* kkey)
398{
399 struct packed_rrset_data* d;
400 /* compute size of smallest ZSK key in the rrset */
401 size_t i;
402 size_t bits = 0;
403 if(!key_entry_isgood(kkey))
404 return 0;
405 d = ((struct key_entry_data*)kkey->entry.data)->rrset_data;
406 for(i=0; i<d->count; i++) {
407 if(!(kd_get_flags(d, i) & DNSKEY_BIT_ZSK))
408 continue;
409 if(i==0 || dnskey_get_keysize(d, i) < bits)
410 bits = dnskey_get_keysize(d, i);
411 }
412 return bits;
413}
|