OpenDNSSEC-enforcer 2.1.10
policy.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014 Jerry Lundström <lundstrom.jerry@gmail.com>
3 * Copyright (c) 2014 .SE (The Internet Infrastructure Foundation).
4 * Copyright (c) 2014 OpenDNSSEC AB (svb)
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
22 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
24 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30#include "policy.h"
31#include "db_error.h"
32
33
34#include <string.h>
35
39 { NULL, 0 }
40};
41
47 { NULL, 0 }
48};
49
55static db_object_t* __policy_new_object(const db_connection_t* connection) {
56 db_object_field_list_t* object_field_list;
57 db_object_field_t* object_field;
58 db_object_t* object;
59
60 if (!(object = db_object_new())
61 || db_object_set_connection(object, connection)
62 || db_object_set_table(object, "policy")
63 || db_object_set_primary_key_name(object, "id")
64 || !(object_field_list = db_object_field_list_new()))
65 {
66 db_object_free(object);
67 return NULL;
68 }
69
70 if (!(object_field = db_object_field_new())
71 || db_object_field_set_name(object_field, "id")
73 || db_object_field_list_add(object_field_list, object_field))
74 {
75 db_object_field_free(object_field);
76 db_object_field_list_free(object_field_list);
77 db_object_free(object);
78 return NULL;
79 }
80
81 if (!(object_field = db_object_field_new())
82 || db_object_field_set_name(object_field, "rev")
84 || db_object_field_list_add(object_field_list, object_field))
85 {
86 db_object_field_free(object_field);
87 db_object_field_list_free(object_field_list);
88 db_object_free(object);
89 return NULL;
90 }
91
92 if (!(object_field = db_object_field_new())
93 || db_object_field_set_name(object_field, "name")
95 || db_object_field_list_add(object_field_list, object_field))
96 {
97 db_object_field_free(object_field);
98 db_object_field_list_free(object_field_list);
99 db_object_free(object);
100 return NULL;
101 }
102
103 if (!(object_field = db_object_field_new())
104 || db_object_field_set_name(object_field, "description")
105 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
106 || db_object_field_list_add(object_field_list, object_field))
107 {
108 db_object_field_free(object_field);
109 db_object_field_list_free(object_field_list);
110 db_object_free(object);
111 return NULL;
112 }
113
114 if (!(object_field = db_object_field_new())
115 || db_object_field_set_name(object_field, "signaturesResign")
117 || db_object_field_list_add(object_field_list, object_field))
118 {
119 db_object_field_free(object_field);
120 db_object_field_list_free(object_field_list);
121 db_object_free(object);
122 return NULL;
123 }
124
125 if (!(object_field = db_object_field_new())
126 || db_object_field_set_name(object_field, "signaturesRefresh")
128 || db_object_field_list_add(object_field_list, object_field))
129 {
130 db_object_field_free(object_field);
131 db_object_field_list_free(object_field_list);
132 db_object_free(object);
133 return NULL;
134 }
135
136 if (!(object_field = db_object_field_new())
137 || db_object_field_set_name(object_field, "signaturesJitter")
139 || db_object_field_list_add(object_field_list, object_field))
140 {
141 db_object_field_free(object_field);
142 db_object_field_list_free(object_field_list);
143 db_object_free(object);
144 return NULL;
145 }
146
147 if (!(object_field = db_object_field_new())
148 || db_object_field_set_name(object_field, "signaturesInceptionOffset")
150 || db_object_field_list_add(object_field_list, object_field))
151 {
152 db_object_field_free(object_field);
153 db_object_field_list_free(object_field_list);
154 db_object_free(object);
155 return NULL;
156 }
157
158 if (!(object_field = db_object_field_new())
159 || db_object_field_set_name(object_field, "signaturesValidityDefault")
161 || db_object_field_list_add(object_field_list, object_field))
162 {
163 db_object_field_free(object_field);
164 db_object_field_list_free(object_field_list);
165 db_object_free(object);
166 return NULL;
167 }
168
169 if (!(object_field = db_object_field_new())
170 || db_object_field_set_name(object_field, "signaturesValidityDenial")
172 || db_object_field_list_add(object_field_list, object_field))
173 {
174 db_object_field_free(object_field);
175 db_object_field_list_free(object_field_list);
176 db_object_free(object);
177 return NULL;
178 }
179
180 if (!(object_field = db_object_field_new())
181 || db_object_field_set_name(object_field, "signaturesValidityKeyset")
183 || db_object_field_list_add(object_field_list, object_field))
184 {
185 db_object_field_free(object_field);
186 db_object_field_list_free(object_field_list);
187 db_object_free(object);
188 return NULL;
189 }
190
191 if (!(object_field = db_object_field_new())
192 || db_object_field_set_name(object_field, "signaturesMaxZoneTtl")
194 || db_object_field_list_add(object_field_list, object_field))
195 {
196 db_object_field_free(object_field);
197 db_object_field_list_free(object_field_list);
198 db_object_free(object);
199 return NULL;
200 }
201
202 if (!(object_field = db_object_field_new())
203 || db_object_field_set_name(object_field, "denialType")
204 || db_object_field_set_type(object_field, DB_TYPE_ENUM)
206 || db_object_field_list_add(object_field_list, object_field))
207 {
208 db_object_field_free(object_field);
209 db_object_field_list_free(object_field_list);
210 db_object_free(object);
211 return NULL;
212 }
213
214 if (!(object_field = db_object_field_new())
215 || db_object_field_set_name(object_field, "denialOptout")
217 || db_object_field_list_add(object_field_list, object_field))
218 {
219 db_object_field_free(object_field);
220 db_object_field_list_free(object_field_list);
221 db_object_free(object);
222 return NULL;
223 }
224
225 if (!(object_field = db_object_field_new())
226 || db_object_field_set_name(object_field, "denialTtl")
228 || db_object_field_list_add(object_field_list, object_field))
229 {
230 db_object_field_free(object_field);
231 db_object_field_list_free(object_field_list);
232 db_object_free(object);
233 return NULL;
234 }
235
236 if (!(object_field = db_object_field_new())
237 || db_object_field_set_name(object_field, "denialResalt")
239 || db_object_field_list_add(object_field_list, object_field))
240 {
241 db_object_field_free(object_field);
242 db_object_field_list_free(object_field_list);
243 db_object_free(object);
244 return NULL;
245 }
246
247 if (!(object_field = db_object_field_new())
248 || db_object_field_set_name(object_field, "denialAlgorithm")
250 || db_object_field_list_add(object_field_list, object_field))
251 {
252 db_object_field_free(object_field);
253 db_object_field_list_free(object_field_list);
254 db_object_free(object);
255 return NULL;
256 }
257
258 if (!(object_field = db_object_field_new())
259 || db_object_field_set_name(object_field, "denialIterations")
261 || db_object_field_list_add(object_field_list, object_field))
262 {
263 db_object_field_free(object_field);
264 db_object_field_list_free(object_field_list);
265 db_object_free(object);
266 return NULL;
267 }
268
269 if (!(object_field = db_object_field_new())
270 || db_object_field_set_name(object_field, "denialSaltLength")
272 || db_object_field_list_add(object_field_list, object_field))
273 {
274 db_object_field_free(object_field);
275 db_object_field_list_free(object_field_list);
276 db_object_free(object);
277 return NULL;
278 }
279
280 if (!(object_field = db_object_field_new())
281 || db_object_field_set_name(object_field, "denialSalt")
282 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
283 || db_object_field_list_add(object_field_list, object_field))
284 {
285 db_object_field_free(object_field);
286 db_object_field_list_free(object_field_list);
287 db_object_free(object);
288 return NULL;
289 }
290
291 if (!(object_field = db_object_field_new())
292 || db_object_field_set_name(object_field, "denialSaltLastChange")
294 || db_object_field_list_add(object_field_list, object_field))
295 {
296 db_object_field_free(object_field);
297 db_object_field_list_free(object_field_list);
298 db_object_free(object);
299 return NULL;
300 }
301
302 if (!(object_field = db_object_field_new())
303 || db_object_field_set_name(object_field, "keysTtl")
305 || db_object_field_list_add(object_field_list, object_field))
306 {
307 db_object_field_free(object_field);
308 db_object_field_list_free(object_field_list);
309 db_object_free(object);
310 return NULL;
311 }
312
313 if (!(object_field = db_object_field_new())
314 || db_object_field_set_name(object_field, "keysRetireSafety")
316 || db_object_field_list_add(object_field_list, object_field))
317 {
318 db_object_field_free(object_field);
319 db_object_field_list_free(object_field_list);
320 db_object_free(object);
321 return NULL;
322 }
323
324 if (!(object_field = db_object_field_new())
325 || db_object_field_set_name(object_field, "keysPublishSafety")
327 || db_object_field_list_add(object_field_list, object_field))
328 {
329 db_object_field_free(object_field);
330 db_object_field_list_free(object_field_list);
331 db_object_free(object);
332 return NULL;
333 }
334
335 if (!(object_field = db_object_field_new())
336 || db_object_field_set_name(object_field, "keysShared")
338 || db_object_field_list_add(object_field_list, object_field))
339 {
340 db_object_field_free(object_field);
341 db_object_field_list_free(object_field_list);
342 db_object_free(object);
343 return NULL;
344 }
345
346 if (!(object_field = db_object_field_new())
347 || db_object_field_set_name(object_field, "keysPurgeAfter")
349 || db_object_field_list_add(object_field_list, object_field))
350 {
351 db_object_field_free(object_field);
352 db_object_field_list_free(object_field_list);
353 db_object_free(object);
354 return NULL;
355 }
356
357 if (!(object_field = db_object_field_new())
358 || db_object_field_set_name(object_field, "zonePropagationDelay")
360 || db_object_field_list_add(object_field_list, object_field))
361 {
362 db_object_field_free(object_field);
363 db_object_field_list_free(object_field_list);
364 db_object_free(object);
365 return NULL;
366 }
367
368 if (!(object_field = db_object_field_new())
369 || db_object_field_set_name(object_field, "zoneSoaTtl")
371 || db_object_field_list_add(object_field_list, object_field))
372 {
373 db_object_field_free(object_field);
374 db_object_field_list_free(object_field_list);
375 db_object_free(object);
376 return NULL;
377 }
378
379 if (!(object_field = db_object_field_new())
380 || db_object_field_set_name(object_field, "zoneSoaMinimum")
382 || db_object_field_list_add(object_field_list, object_field))
383 {
384 db_object_field_free(object_field);
385 db_object_field_list_free(object_field_list);
386 db_object_free(object);
387 return NULL;
388 }
389
390 if (!(object_field = db_object_field_new())
391 || db_object_field_set_name(object_field, "zoneSoaSerial")
392 || db_object_field_set_type(object_field, DB_TYPE_ENUM)
394 || db_object_field_list_add(object_field_list, object_field))
395 {
396 db_object_field_free(object_field);
397 db_object_field_list_free(object_field_list);
398 db_object_free(object);
399 return NULL;
400 }
401
402 if (!(object_field = db_object_field_new())
403 || db_object_field_set_name(object_field, "parentRegistrationDelay")
405 || db_object_field_list_add(object_field_list, object_field))
406 {
407 db_object_field_free(object_field);
408 db_object_field_list_free(object_field_list);
409 db_object_free(object);
410 return NULL;
411 }
412
413 if (!(object_field = db_object_field_new())
414 || db_object_field_set_name(object_field, "parentPropagationDelay")
416 || db_object_field_list_add(object_field_list, object_field))
417 {
418 db_object_field_free(object_field);
419 db_object_field_list_free(object_field_list);
420 db_object_free(object);
421 return NULL;
422 }
423
424 if (!(object_field = db_object_field_new())
425 || db_object_field_set_name(object_field, "parentDsTtl")
427 || db_object_field_list_add(object_field_list, object_field))
428 {
429 db_object_field_free(object_field);
430 db_object_field_list_free(object_field_list);
431 db_object_free(object);
432 return NULL;
433 }
434
435 if (!(object_field = db_object_field_new())
436 || db_object_field_set_name(object_field, "parentSoaTtl")
438 || db_object_field_list_add(object_field_list, object_field))
439 {
440 db_object_field_free(object_field);
441 db_object_field_list_free(object_field_list);
442 db_object_free(object);
443 return NULL;
444 }
445
446 if (!(object_field = db_object_field_new())
447 || db_object_field_set_name(object_field, "parentSoaMinimum")
449 || db_object_field_list_add(object_field_list, object_field))
450 {
451 db_object_field_free(object_field);
452 db_object_field_list_free(object_field_list);
453 db_object_free(object);
454 return NULL;
455 }
456
457 if (!(object_field = db_object_field_new())
458 || db_object_field_set_name(object_field, "passthrough")
460 || db_object_field_list_add(object_field_list, object_field))
461 {
462 db_object_field_free(object_field);
463 db_object_field_list_free(object_field_list);
464 db_object_free(object);
465 return NULL;
466 }
467
468 if (db_object_set_object_field_list(object, object_field_list)) {
469 db_object_field_list_free(object_field_list);
470 db_object_free(object);
471 return NULL;
472 }
473
474 return object;
475}
476
477/* POLICY */
478
481 (policy_t*)calloc(1, sizeof(policy_t));
482
483 if (policy) {
484 if (!(policy->dbo = __policy_new_object(connection))) {
485 free(policy);
486 return NULL;
487 }
492 policy->denial_salt = strdup("");
494 }
495
496 return policy;
497}
498
500 policy_t* new_policy;
501
502 if (!policy) {
503 return NULL;
504 }
505 if (!policy->dbo) {
506 return NULL;
507 }
508
509 if (!(new_policy = policy_new(db_object_connection(policy->dbo)))
510 || policy_copy(new_policy, policy))
511 {
512 policy_free(new_policy);
513 return NULL;
514 }
515 return new_policy;
516}
517
519 if (policy) {
520 if (policy->dbo) {
522 }
525 if (policy->name) {
526 free(policy->name);
527 }
528 if (policy->description) {
529 free(policy->description);
530 }
531 if (policy->denial_salt) {
532 free(policy->denial_salt);
533 }
534 if (policy->policy_key_list) {
536 }
537 if (policy->zone_list) {
539 }
540 if (policy->hsm_key_list) {
542 }
543 free(policy);
544 }
545}
546
548 char* name_text = NULL;
549 char* description_text = NULL;
550 char* denial_salt_text = NULL;
551
552 if (!policy) {
553 return DB_ERROR_UNKNOWN;
554 }
555 if (!policy_copy) {
556 return DB_ERROR_UNKNOWN;
557 }
558
559 if (policy_copy->name) {
560 if (!(name_text = strdup(policy_copy->name))) {
561 return DB_ERROR_UNKNOWN;
562 }
563 }
564 if (policy_copy->description) {
565 if (!(description_text = strdup(policy_copy->description))) {
566 if (name_text) {
567 free(name_text);
568 }
569 return DB_ERROR_UNKNOWN;
570 }
571 }
572 if (policy_copy->denial_salt) {
573 if (!(denial_salt_text = strdup(policy_copy->denial_salt))) {
574 if (name_text) {
575 free(name_text);
576 }
577 if (description_text) {
578 free(description_text);
579 }
580 return DB_ERROR_UNKNOWN;
581 }
582 }
583 if (db_value_copy(&(policy->id), &(policy_copy->id))) {
584 if (name_text) {
585 free(name_text);
586 }
587 if (description_text) {
588 free(description_text);
589 }
590 if (denial_salt_text) {
591 free(denial_salt_text);
592 }
593 return DB_ERROR_UNKNOWN;
594 }
595 if (db_value_copy(&(policy->rev), &(policy_copy->rev))) {
596 if (name_text) {
597 free(name_text);
598 }
599 if (description_text) {
600 free(description_text);
601 }
602 if (denial_salt_text) {
603 free(denial_salt_text);
604 }
605 return DB_ERROR_UNKNOWN;
606 }
607 if (policy->policy_key_list) {
609 policy->policy_key_list = NULL;
610 }
611 if (policy_copy->policy_key_list
613 {
614 if (name_text) {
615 free(name_text);
616 }
617 if (description_text) {
618 free(description_text);
619 }
620 if (denial_salt_text) {
621 free(denial_salt_text);
622 }
623 return DB_ERROR_UNKNOWN;
624 }
625 if (policy->zone_list) {
627 policy->zone_list = NULL;
628 }
629 if (policy_copy->zone_list
631 {
632 if (name_text) {
633 free(name_text);
634 }
635 if (description_text) {
636 free(description_text);
637 }
638 if (denial_salt_text) {
639 free(denial_salt_text);
640 }
641 return DB_ERROR_UNKNOWN;
642 }
643 if (policy->hsm_key_list) {
645 policy->hsm_key_list = NULL;
646 }
647 if (policy_copy->hsm_key_list
649 {
650 if (name_text) {
651 free(name_text);
652 }
653 if (description_text) {
654 free(description_text);
655 }
656 if (denial_salt_text) {
657 free(denial_salt_text);
658 }
659 return DB_ERROR_UNKNOWN;
660 }
661 if (policy->name) {
662 free(policy->name);
663 }
664 policy->name = name_text;
665 if (policy->description) {
666 free(policy->description);
667 }
668 policy->description = description_text;
669 policy->signatures_resign = policy_copy->signatures_resign;
670 policy->signatures_refresh = policy_copy->signatures_refresh;
671 policy->signatures_jitter = policy_copy->signatures_jitter;
672 policy->signatures_inception_offset = policy_copy->signatures_inception_offset;
673 policy->signatures_validity_default = policy_copy->signatures_validity_default;
674 policy->signatures_validity_denial = policy_copy->signatures_validity_denial;
675 policy->signatures_validity_keyset = policy_copy->signatures_validity_keyset;
676 policy->signatures_max_zone_ttl = policy_copy->signatures_max_zone_ttl;
677 policy->denial_type = policy_copy->denial_type;
678 policy->denial_optout = policy_copy->denial_optout;
679 policy->denial_ttl = policy_copy->denial_ttl;
680 policy->denial_resalt = policy_copy->denial_resalt;
681 policy->denial_algorithm = policy_copy->denial_algorithm;
682 policy->denial_iterations = policy_copy->denial_iterations;
683 policy->denial_salt_length = policy_copy->denial_salt_length;
684 if (policy->denial_salt) {
685 free(policy->denial_salt);
686 }
687 policy->denial_salt = denial_salt_text;
688 policy->denial_salt_last_change = policy_copy->denial_salt_last_change;
689 policy->keys_ttl = policy_copy->keys_ttl;
690 policy->keys_retire_safety = policy_copy->keys_retire_safety;
691 policy->keys_publish_safety = policy_copy->keys_publish_safety;
692 policy->keys_shared = policy_copy->keys_shared;
693 policy->keys_purge_after = policy_copy->keys_purge_after;
694 policy->zone_propagation_delay = policy_copy->zone_propagation_delay;
695 policy->zone_soa_ttl = policy_copy->zone_soa_ttl;
696 policy->zone_soa_minimum = policy_copy->zone_soa_minimum;
697 policy->zone_soa_serial = policy_copy->zone_soa_serial;
698 policy->parent_registration_delay = policy_copy->parent_registration_delay;
699 policy->parent_propagation_delay = policy_copy->parent_propagation_delay;
700 policy->parent_ds_ttl = policy_copy->parent_ds_ttl;
701 policy->parent_soa_ttl = policy_copy->parent_soa_ttl;
702 policy->parent_soa_minimum = policy_copy->parent_soa_minimum;
703 policy->passthrough = policy_copy->passthrough;
704 return DB_OK;
705}
706
708 const db_value_set_t* value_set;
709 int denial_type;
710 int zone_soa_serial;
711
712 if (!policy) {
713 return DB_ERROR_UNKNOWN;
714 }
715 if (!result) {
716 return DB_ERROR_UNKNOWN;
717 }
718
721 if (policy->name) {
722 free(policy->name);
723 }
724 policy->name = NULL;
725 if (policy->description) {
726 free(policy->description);
727 }
728 policy->description = NULL;
729 if (policy->denial_salt) {
730 free(policy->denial_salt);
731 }
732 policy->denial_salt = NULL;
734 if (!(value_set = db_result_value_set(result))
735 || db_value_set_size(value_set) != 36
736 || db_value_copy(&(policy->id), db_value_set_at(value_set, 0))
737 || db_value_copy(&(policy->rev), db_value_set_at(value_set, 1))
738 || db_value_to_text(db_value_set_at(value_set, 2), &(policy->name))
755 || db_value_to_text(db_value_set_at(value_set, 19), &(policy->denial_salt))
757 || db_value_to_uint32(db_value_set_at(value_set, 21), &(policy->keys_ttl))
772 {
773 return DB_ERROR_UNKNOWN;
774 }
775
776 if (denial_type == (policy_denial_type_t)POLICY_DENIAL_TYPE_NSEC) {
778 }
779 else if (denial_type == (policy_denial_type_t)POLICY_DENIAL_TYPE_NSEC3) {
781 }
782 else {
783 return DB_ERROR_UNKNOWN;
784 }
785
788 }
791 }
792 else if (zone_soa_serial == (policy_zone_soa_serial_t)POLICY_ZONE_SOA_SERIAL_UNIXTIME) {
794 }
795 else if (zone_soa_serial == (policy_zone_soa_serial_t)POLICY_ZONE_SOA_SERIAL_KEEP) {
797 }
798 else {
799 return DB_ERROR_UNKNOWN;
800 }
801
802 return DB_OK;
803}
804
806 if (!policy) {
807 return NULL;
808 }
809
810 return &(policy->id);
811}
812
813const char* policy_name(const policy_t* policy) {
814 if (!policy) {
815 return NULL;
816 }
817
818 return policy->name;
819}
820
821const char* policy_description(const policy_t* policy) {
822 if (!policy) {
823 return NULL;
824 }
825
826 return policy->description;
827}
828
830 if (!policy) {
831 return 0;
832 }
833
835}
836
838 if (!policy) {
839 return 0;
840 }
841
843}
844
846 if (!policy) {
847 return 0;
848 }
849
851}
852
854 if (!policy) {
855 return 0;
856 }
857
859}
860
862 if (!policy) {
863 return 0;
864 }
865
867}
868
870 if (!policy) {
871 return 0;
872 }
873
875}
876
878 if (!policy) {
879 return 0;
880 }
881
883}
884
886 if (!policy) {
887 return 0;
888 }
889
891}
892
894 if (!policy) {
896 }
897
898 return policy->denial_type;
899}
900
902 if (!policy) {
903 return 0;
904 }
905
906 return policy->denial_optout;
907}
908
909unsigned int policy_denial_ttl(const policy_t* policy) {
910 if (!policy) {
911 return 0;
912 }
913
914 return policy->denial_ttl;
915}
916
918 if (!policy) {
919 return 0;
920 }
921
922 return policy->denial_resalt;
923}
924
926 if (!policy) {
927 return 0;
928 }
929
930 return policy->denial_algorithm;
931}
932
934 if (!policy) {
935 return 0;
936 }
937
939}
940
942 if (!policy) {
943 return 0;
944 }
945
947}
948
949const char* policy_denial_salt(const policy_t* policy) {
950 if (!policy) {
951 return NULL;
952 }
953
954 return policy->denial_salt;
955}
956
958 if (!policy) {
959 return 0;
960 }
961
963}
964
965unsigned int policy_keys_ttl(const policy_t* policy) {
966 if (!policy) {
967 return 0;
968 }
969
970 return policy->keys_ttl;
971}
972
974 if (!policy) {
975 return 0;
976 }
977
979}
980
982 if (!policy) {
983 return 0;
984 }
985
987}
988
989unsigned int policy_keys_shared(const policy_t* policy) {
990 if (!policy) {
991 return 0;
992 }
993
994 return policy->keys_shared;
995}
996
998 if (!policy) {
999 return 0;
1000 }
1001
1002 return policy->keys_purge_after;
1003}
1004
1006 if (!policy) {
1007 return 0;
1008 }
1009
1011}
1012
1014 if (!policy) {
1015 return 0;
1016 }
1017
1018 return policy->zone_soa_ttl;
1019}
1020
1022 if (!policy) {
1023 return 0;
1024 }
1025
1026 return policy->zone_soa_minimum;
1027}
1028
1031
1032 if (!policy) {
1033 return NULL;
1034 }
1035
1036 while (enum_set->text) {
1037 if (enum_set->value == policy->zone_soa_serial) {
1038 return enum_set->text;
1039 }
1040 enum_set++;
1041 }
1042 return NULL;
1043}
1044
1046 if (!policy) {
1047 return 0;
1048 }
1049
1051}
1052
1054 if (!policy) {
1055 return 0;
1056 }
1057
1059}
1060
1062 if (!policy) {
1063 return 0;
1064 }
1065
1066 return policy->parent_ds_ttl;
1067}
1068
1070 if (!policy) {
1071 return 0;
1072 }
1073
1074 return policy->parent_soa_ttl;
1075}
1076
1078 if (!policy) {
1079 return 0;
1080 }
1081
1082 return policy->parent_soa_minimum;
1083}
1084
1085unsigned int policy_passthrough(const policy_t* policy) {
1086 if (!policy) {
1087 return 0;
1088 }
1089
1090 return policy->passthrough;
1091}
1092
1094
1095 if (!policy) {
1096 return NULL;
1097 }
1098 if (!policy->dbo) {
1099 return NULL;
1100 }
1101
1102 if (!policy->zone_list
1104 {
1105 return NULL;
1106 }
1107
1108 return policy->zone_list;
1109}
1110
1112 db_clause_list_t* clause_list;
1113
1114 if (!policy) {
1115 return DB_ERROR_UNKNOWN;
1116 }
1117 if (!policy->dbo) {
1118 return DB_ERROR_UNKNOWN;
1119 }
1120
1121 if (policy->zone_list) {
1123 policy->zone_list = NULL;
1124 }
1125
1126 if (!(clause_list = db_clause_list_new())
1127 || !zone_db_policy_id_clause(clause_list, policy_id(policy))
1131 {
1133 policy->zone_list = NULL;
1134 db_clause_list_free(clause_list);
1135 return DB_ERROR_UNKNOWN;
1136 }
1137 db_clause_list_free(clause_list);
1138
1139 return DB_OK;
1140}
1141
1142int policy_set_name(policy_t* policy, const char* name_text) {
1143 char* new_name;
1144
1145 if (!policy) {
1146 return DB_ERROR_UNKNOWN;
1147 }
1148 if (!name_text) {
1149 return DB_ERROR_UNKNOWN;
1150 }
1151
1152 if (!(new_name = strdup(name_text))) {
1153 return DB_ERROR_UNKNOWN;
1154 }
1155
1156 if (policy->name) {
1157 free(policy->name);
1158 }
1159 policy->name = new_name;
1160
1161 return DB_OK;
1162}
1163
1164int policy_set_description(policy_t* policy, const char* description_text) {
1165 char* new_description;
1166
1167 if (!policy) {
1168 return DB_ERROR_UNKNOWN;
1169 }
1170 if (!description_text) {
1171 return DB_ERROR_UNKNOWN;
1172 }
1173
1174 if (!(new_description = strdup(description_text))) {
1175 return DB_ERROR_UNKNOWN;
1176 }
1177
1178 if (policy->description) {
1179 free(policy->description);
1180 }
1181 policy->description = new_description;
1182
1183 return DB_OK;
1184}
1185
1186int policy_set_signatures_resign(policy_t* policy, unsigned int signatures_resign) {
1187 if (!policy) {
1188 return DB_ERROR_UNKNOWN;
1189 }
1190
1191 policy->signatures_resign = signatures_resign;
1192
1193 return DB_OK;
1194}
1195
1196int policy_set_signatures_refresh(policy_t* policy, unsigned int signatures_refresh) {
1197 if (!policy) {
1198 return DB_ERROR_UNKNOWN;
1199 }
1200
1201 policy->signatures_refresh = signatures_refresh;
1202
1203 return DB_OK;
1204}
1205
1206int policy_set_signatures_jitter(policy_t* policy, unsigned int signatures_jitter) {
1207 if (!policy) {
1208 return DB_ERROR_UNKNOWN;
1209 }
1210
1211 policy->signatures_jitter = signatures_jitter;
1212
1213 return DB_OK;
1214}
1215
1216int policy_set_signatures_inception_offset(policy_t* policy, unsigned int signatures_inception_offset) {
1217 if (!policy) {
1218 return DB_ERROR_UNKNOWN;
1219 }
1220
1221 policy->signatures_inception_offset = signatures_inception_offset;
1222
1223 return DB_OK;
1224}
1225
1226int policy_set_signatures_validity_default(policy_t* policy, unsigned int signatures_validity_default) {
1227 if (!policy) {
1228 return DB_ERROR_UNKNOWN;
1229 }
1230
1231 policy->signatures_validity_default = signatures_validity_default;
1232
1233 return DB_OK;
1234}
1235
1236int policy_set_signatures_validity_denial(policy_t* policy, unsigned int signatures_validity_denial) {
1237 if (!policy) {
1238 return DB_ERROR_UNKNOWN;
1239 }
1240
1241 policy->signatures_validity_denial = signatures_validity_denial;
1242
1243 return DB_OK;
1244}
1245
1246int policy_set_signatures_validity_keyset(policy_t* policy, unsigned int signatures_validity_keyset) {
1247 if (!policy) {
1248 return DB_ERROR_UNKNOWN;
1249 }
1250
1251 policy->signatures_validity_keyset = signatures_validity_keyset;
1252
1253 return DB_OK;
1254}
1255
1256int policy_set_signatures_max_zone_ttl(policy_t* policy, unsigned int signatures_max_zone_ttl) {
1257 if (!policy) {
1258 return DB_ERROR_UNKNOWN;
1259 }
1260
1261 policy->signatures_max_zone_ttl = signatures_max_zone_ttl;
1262
1263 return DB_OK;
1264}
1265
1267 if (!policy) {
1268 return DB_ERROR_UNKNOWN;
1269 }
1270 if (denial_type == POLICY_DENIAL_TYPE_INVALID) {
1271 return DB_ERROR_UNKNOWN;
1272 }
1273
1274 policy->denial_type = denial_type;
1275
1276 return DB_OK;
1277}
1278
1279int policy_set_denial_optout(policy_t* policy, unsigned int denial_optout) {
1280 if (!policy) {
1281 return DB_ERROR_UNKNOWN;
1282 }
1283
1284 policy->denial_optout = denial_optout;
1285
1286 return DB_OK;
1287}
1288
1289int policy_set_denial_ttl(policy_t* policy, unsigned int denial_ttl) {
1290 if (!policy) {
1291 return DB_ERROR_UNKNOWN;
1292 }
1293
1294 policy->denial_ttl = denial_ttl;
1295
1296 return DB_OK;
1297}
1298
1299int policy_set_denial_resalt(policy_t* policy, unsigned int denial_resalt) {
1300 if (!policy) {
1301 return DB_ERROR_UNKNOWN;
1302 }
1303
1304 policy->denial_resalt = denial_resalt;
1305
1306 return DB_OK;
1307}
1308
1309int policy_set_denial_algorithm(policy_t* policy, unsigned int denial_algorithm) {
1310 if (!policy) {
1311 return DB_ERROR_UNKNOWN;
1312 }
1313
1314 if (denial_algorithm > 255) {
1315 return DB_ERROR_UNKNOWN;
1316 }
1317
1318 policy->denial_algorithm = denial_algorithm;
1319
1320 return DB_OK;
1321}
1322
1323int policy_set_denial_iterations(policy_t* policy, unsigned int denial_iterations) {
1324 if (!policy) {
1325 return DB_ERROR_UNKNOWN;
1326 }
1327
1328 if (denial_iterations > 65535) {
1329 return DB_ERROR_UNKNOWN;
1330 }
1331
1332 policy->denial_iterations = denial_iterations;
1333
1334 return DB_OK;
1335}
1336
1337int policy_set_denial_salt_length(policy_t* policy, unsigned int denial_salt_length) {
1338 if (!policy) {
1339 return DB_ERROR_UNKNOWN;
1340 }
1341
1342 if (denial_salt_length > 255) {
1343 return DB_ERROR_UNKNOWN;
1344 }
1345
1346 policy->denial_salt_length = denial_salt_length;
1347
1348 return DB_OK;
1349}
1350
1351int policy_set_denial_salt(policy_t* policy, const char* denial_salt_text) {
1352 char* new_denial_salt;
1353
1354 if (!policy) {
1355 return DB_ERROR_UNKNOWN;
1356 }
1357 if (!denial_salt_text) {
1358 return DB_ERROR_UNKNOWN;
1359 }
1360
1361 if (!(new_denial_salt = strdup(denial_salt_text))) {
1362 return DB_ERROR_UNKNOWN;
1363 }
1364
1365 if (policy->denial_salt) {
1366 free(policy->denial_salt);
1367 }
1368 policy->denial_salt = new_denial_salt;
1369
1370 return DB_OK;
1371}
1372
1373int policy_set_denial_salt_last_change(policy_t* policy, unsigned int denial_salt_last_change) {
1374 if (!policy) {
1375 return DB_ERROR_UNKNOWN;
1376 }
1377
1378 policy->denial_salt_last_change = denial_salt_last_change;
1379
1380 return DB_OK;
1381}
1382
1383int policy_set_keys_ttl(policy_t* policy, unsigned int keys_ttl) {
1384 if (!policy) {
1385 return DB_ERROR_UNKNOWN;
1386 }
1387
1388 policy->keys_ttl = keys_ttl;
1389
1390 return DB_OK;
1391}
1392
1393int policy_set_keys_retire_safety(policy_t* policy, unsigned int keys_retire_safety) {
1394 if (!policy) {
1395 return DB_ERROR_UNKNOWN;
1396 }
1397
1398 policy->keys_retire_safety = keys_retire_safety;
1399
1400 return DB_OK;
1401}
1402
1403int policy_set_keys_publish_safety(policy_t* policy, unsigned int keys_publish_safety) {
1404 if (!policy) {
1405 return DB_ERROR_UNKNOWN;
1406 }
1407
1408 policy->keys_publish_safety = keys_publish_safety;
1409
1410 return DB_OK;
1411}
1412
1413int policy_set_keys_shared(policy_t* policy, unsigned int keys_shared) {
1414 if (!policy) {
1415 return DB_ERROR_UNKNOWN;
1416 }
1417
1418 policy->keys_shared = keys_shared;
1419
1420 return DB_OK;
1421}
1422
1423int policy_set_keys_purge_after(policy_t* policy, unsigned int keys_purge_after) {
1424 if (!policy) {
1425 return DB_ERROR_UNKNOWN;
1426 }
1427
1428 policy->keys_purge_after = keys_purge_after;
1429
1430 return DB_OK;
1431}
1432
1433int policy_set_zone_propagation_delay(policy_t* policy, unsigned int zone_propagation_delay) {
1434 if (!policy) {
1435 return DB_ERROR_UNKNOWN;
1436 }
1437
1438 policy->zone_propagation_delay = zone_propagation_delay;
1439
1440 return DB_OK;
1441}
1442
1443int policy_set_zone_soa_ttl(policy_t* policy, unsigned int zone_soa_ttl) {
1444 if (!policy) {
1445 return DB_ERROR_UNKNOWN;
1446 }
1447
1448 policy->zone_soa_ttl = zone_soa_ttl;
1449
1450 return DB_OK;
1451}
1452
1453int policy_set_zone_soa_minimum(policy_t* policy, unsigned int zone_soa_minimum) {
1454 if (!policy) {
1455 return DB_ERROR_UNKNOWN;
1456 }
1457
1458 policy->zone_soa_minimum = zone_soa_minimum;
1459
1460 return DB_OK;
1461}
1462
1463int policy_set_zone_soa_serial_text(policy_t* policy, const char* zone_soa_serial) {
1465
1466 if (!policy) {
1467 return DB_ERROR_UNKNOWN;
1468 }
1469
1470 while (enum_set->text) {
1471 if (!strcmp(enum_set->text, zone_soa_serial)) {
1472 policy->zone_soa_serial = enum_set->value;
1473 return DB_OK;
1474 }
1475 enum_set++;
1476 }
1477 return DB_ERROR_UNKNOWN;
1478}
1479
1480int policy_set_parent_registration_delay(policy_t* policy, unsigned int parent_registration_delay) {
1481 if (!policy) {
1482 return DB_ERROR_UNKNOWN;
1483 }
1484
1485 policy->parent_registration_delay = parent_registration_delay;
1486
1487 return DB_OK;
1488}
1489
1490int policy_set_parent_propagation_delay(policy_t* policy, unsigned int parent_propagation_delay) {
1491 if (!policy) {
1492 return DB_ERROR_UNKNOWN;
1493 }
1494
1495 policy->parent_propagation_delay = parent_propagation_delay;
1496
1497 return DB_OK;
1498}
1499
1500int policy_set_parent_ds_ttl(policy_t* policy, unsigned int parent_ds_ttl) {
1501 if (!policy) {
1502 return DB_ERROR_UNKNOWN;
1503 }
1504
1505 policy->parent_ds_ttl = parent_ds_ttl;
1506
1507 return DB_OK;
1508}
1509
1510int policy_set_parent_soa_ttl(policy_t* policy, unsigned int parent_soa_ttl) {
1511 if (!policy) {
1512 return DB_ERROR_UNKNOWN;
1513 }
1514
1515 policy->parent_soa_ttl = parent_soa_ttl;
1516
1517 return DB_OK;
1518}
1519
1520int policy_set_parent_soa_minimum(policy_t* policy, unsigned int parent_soa_minimum) {
1521 if (!policy) {
1522 return DB_ERROR_UNKNOWN;
1523 }
1524
1525 policy->parent_soa_minimum = parent_soa_minimum;
1526
1527 return DB_OK;
1528}
1529
1530int policy_set_passthrough(policy_t* policy, unsigned int passthrough) {
1531 if (!policy) {
1532 return DB_ERROR_UNKNOWN;
1533 }
1534
1535 policy->passthrough = passthrough;
1536
1537 return DB_OK;
1538}
1539
1541 db_clause_t* clause;
1542
1543 if (!clause_list) {
1544 return NULL;
1545 }
1546
1547 if (!(clause = db_clause_new())
1548 || db_clause_set_field(clause, "denialType")
1552 || db_clause_list_add(clause_list, clause))
1553 {
1554 db_clause_free(clause);
1555 return NULL;
1556 }
1557
1558 return clause;
1559}
1560
1562 db_object_field_list_t* object_field_list;
1563 db_object_field_t* object_field;
1564 db_value_set_t* value_set;
1565 int ret;
1566
1567 if (!policy) {
1568 return DB_ERROR_UNKNOWN;
1569 }
1570 if (!policy->dbo) {
1571 return DB_ERROR_UNKNOWN;
1572 }
1573 if (!db_value_not_empty(&(policy->id))) {
1574 return DB_ERROR_UNKNOWN;
1575 }
1576 if (!db_value_not_empty(&(policy->rev))) {
1577 return DB_ERROR_UNKNOWN;
1578 }
1579 if (!policy->name) {
1580 return DB_ERROR_UNKNOWN;
1581 }
1582 if (!policy->description) {
1583 return DB_ERROR_UNKNOWN;
1584 }
1585 if (!policy->denial_salt) {
1586 return DB_ERROR_UNKNOWN;
1587 }
1588 /* TODO: validate content more */
1589
1590 if (!(object_field_list = db_object_field_list_new())) {
1591 return DB_ERROR_UNKNOWN;
1592 }
1593
1594 if (!(object_field = db_object_field_new())
1595 || db_object_field_set_name(object_field, "name")
1596 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
1597 || db_object_field_list_add(object_field_list, object_field))
1598 {
1599 db_object_field_free(object_field);
1600 db_object_field_list_free(object_field_list);
1601 return DB_ERROR_UNKNOWN;
1602 }
1603
1604 if (!(object_field = db_object_field_new())
1605 || db_object_field_set_name(object_field, "description")
1606 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
1607 || db_object_field_list_add(object_field_list, object_field))
1608 {
1609 db_object_field_free(object_field);
1610 db_object_field_list_free(object_field_list);
1611 return DB_ERROR_UNKNOWN;
1612 }
1613
1614 if (!(object_field = db_object_field_new())
1615 || db_object_field_set_name(object_field, "signaturesResign")
1617 || db_object_field_list_add(object_field_list, object_field))
1618 {
1619 db_object_field_free(object_field);
1620 db_object_field_list_free(object_field_list);
1621 return DB_ERROR_UNKNOWN;
1622 }
1623
1624 if (!(object_field = db_object_field_new())
1625 || db_object_field_set_name(object_field, "signaturesRefresh")
1627 || db_object_field_list_add(object_field_list, object_field))
1628 {
1629 db_object_field_free(object_field);
1630 db_object_field_list_free(object_field_list);
1631 return DB_ERROR_UNKNOWN;
1632 }
1633
1634 if (!(object_field = db_object_field_new())
1635 || db_object_field_set_name(object_field, "signaturesJitter")
1637 || db_object_field_list_add(object_field_list, object_field))
1638 {
1639 db_object_field_free(object_field);
1640 db_object_field_list_free(object_field_list);
1641 return DB_ERROR_UNKNOWN;
1642 }
1643
1644 if (!(object_field = db_object_field_new())
1645 || db_object_field_set_name(object_field, "signaturesInceptionOffset")
1647 || db_object_field_list_add(object_field_list, object_field))
1648 {
1649 db_object_field_free(object_field);
1650 db_object_field_list_free(object_field_list);
1651 return DB_ERROR_UNKNOWN;
1652 }
1653
1654 if (!(object_field = db_object_field_new())
1655 || db_object_field_set_name(object_field, "signaturesValidityDefault")
1657 || db_object_field_list_add(object_field_list, object_field))
1658 {
1659 db_object_field_free(object_field);
1660 db_object_field_list_free(object_field_list);
1661 return DB_ERROR_UNKNOWN;
1662 }
1663
1664 if (!(object_field = db_object_field_new())
1665 || db_object_field_set_name(object_field, "signaturesValidityDenial")
1667 || db_object_field_list_add(object_field_list, object_field))
1668 {
1669 db_object_field_free(object_field);
1670 db_object_field_list_free(object_field_list);
1671 return DB_ERROR_UNKNOWN;
1672 }
1673
1674 if (!(object_field = db_object_field_new())
1675 || db_object_field_set_name(object_field, "signaturesValidityKeyset")
1677 || db_object_field_list_add(object_field_list, object_field))
1678 {
1679 db_object_field_free(object_field);
1680 db_object_field_list_free(object_field_list);
1681 return DB_ERROR_UNKNOWN;
1682 }
1683
1684 if (!(object_field = db_object_field_new())
1685 || db_object_field_set_name(object_field, "signaturesMaxZoneTtl")
1687 || db_object_field_list_add(object_field_list, object_field))
1688 {
1689 db_object_field_free(object_field);
1690 db_object_field_list_free(object_field_list);
1691 return DB_ERROR_UNKNOWN;
1692 }
1693
1694 if (!(object_field = db_object_field_new())
1695 || db_object_field_set_name(object_field, "denialType")
1696 || db_object_field_set_type(object_field, DB_TYPE_ENUM)
1698 || db_object_field_list_add(object_field_list, object_field))
1699 {
1700 db_object_field_free(object_field);
1701 db_object_field_list_free(object_field_list);
1702 return DB_ERROR_UNKNOWN;
1703 }
1704
1705 if (!(object_field = db_object_field_new())
1706 || db_object_field_set_name(object_field, "denialOptout")
1708 || db_object_field_list_add(object_field_list, object_field))
1709 {
1710 db_object_field_free(object_field);
1711 db_object_field_list_free(object_field_list);
1712 return DB_ERROR_UNKNOWN;
1713 }
1714
1715 if (!(object_field = db_object_field_new())
1716 || db_object_field_set_name(object_field, "denialTtl")
1718 || db_object_field_list_add(object_field_list, object_field))
1719 {
1720 db_object_field_free(object_field);
1721 db_object_field_list_free(object_field_list);
1722 return DB_ERROR_UNKNOWN;
1723 }
1724
1725 if (!(object_field = db_object_field_new())
1726 || db_object_field_set_name(object_field, "denialResalt")
1728 || db_object_field_list_add(object_field_list, object_field))
1729 {
1730 db_object_field_free(object_field);
1731 db_object_field_list_free(object_field_list);
1732 return DB_ERROR_UNKNOWN;
1733 }
1734
1735 if (!(object_field = db_object_field_new())
1736 || db_object_field_set_name(object_field, "denialAlgorithm")
1738 || db_object_field_list_add(object_field_list, object_field))
1739 {
1740 db_object_field_free(object_field);
1741 db_object_field_list_free(object_field_list);
1742 return DB_ERROR_UNKNOWN;
1743 }
1744
1745 if (!(object_field = db_object_field_new())
1746 || db_object_field_set_name(object_field, "denialIterations")
1748 || db_object_field_list_add(object_field_list, object_field))
1749 {
1750 db_object_field_free(object_field);
1751 db_object_field_list_free(object_field_list);
1752 return DB_ERROR_UNKNOWN;
1753 }
1754
1755 if (!(object_field = db_object_field_new())
1756 || db_object_field_set_name(object_field, "denialSaltLength")
1758 || db_object_field_list_add(object_field_list, object_field))
1759 {
1760 db_object_field_free(object_field);
1761 db_object_field_list_free(object_field_list);
1762 return DB_ERROR_UNKNOWN;
1763 }
1764
1765 if (!(object_field = db_object_field_new())
1766 || db_object_field_set_name(object_field, "denialSalt")
1767 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
1768 || db_object_field_list_add(object_field_list, object_field))
1769 {
1770 db_object_field_free(object_field);
1771 db_object_field_list_free(object_field_list);
1772 return DB_ERROR_UNKNOWN;
1773 }
1774
1775 if (!(object_field = db_object_field_new())
1776 || db_object_field_set_name(object_field, "denialSaltLastChange")
1778 || db_object_field_list_add(object_field_list, object_field))
1779 {
1780 db_object_field_free(object_field);
1781 db_object_field_list_free(object_field_list);
1782 return DB_ERROR_UNKNOWN;
1783 }
1784
1785 if (!(object_field = db_object_field_new())
1786 || db_object_field_set_name(object_field, "keysTtl")
1788 || db_object_field_list_add(object_field_list, object_field))
1789 {
1790 db_object_field_free(object_field);
1791 db_object_field_list_free(object_field_list);
1792 return DB_ERROR_UNKNOWN;
1793 }
1794
1795 if (!(object_field = db_object_field_new())
1796 || db_object_field_set_name(object_field, "keysRetireSafety")
1798 || db_object_field_list_add(object_field_list, object_field))
1799 {
1800 db_object_field_free(object_field);
1801 db_object_field_list_free(object_field_list);
1802 return DB_ERROR_UNKNOWN;
1803 }
1804
1805 if (!(object_field = db_object_field_new())
1806 || db_object_field_set_name(object_field, "keysPublishSafety")
1808 || db_object_field_list_add(object_field_list, object_field))
1809 {
1810 db_object_field_free(object_field);
1811 db_object_field_list_free(object_field_list);
1812 return DB_ERROR_UNKNOWN;
1813 }
1814
1815 if (!(object_field = db_object_field_new())
1816 || db_object_field_set_name(object_field, "keysShared")
1818 || db_object_field_list_add(object_field_list, object_field))
1819 {
1820 db_object_field_free(object_field);
1821 db_object_field_list_free(object_field_list);
1822 return DB_ERROR_UNKNOWN;
1823 }
1824
1825 if (!(object_field = db_object_field_new())
1826 || db_object_field_set_name(object_field, "keysPurgeAfter")
1828 || db_object_field_list_add(object_field_list, object_field))
1829 {
1830 db_object_field_free(object_field);
1831 db_object_field_list_free(object_field_list);
1832 return DB_ERROR_UNKNOWN;
1833 }
1834
1835 if (!(object_field = db_object_field_new())
1836 || db_object_field_set_name(object_field, "zonePropagationDelay")
1838 || db_object_field_list_add(object_field_list, object_field))
1839 {
1840 db_object_field_free(object_field);
1841 db_object_field_list_free(object_field_list);
1842 return DB_ERROR_UNKNOWN;
1843 }
1844
1845 if (!(object_field = db_object_field_new())
1846 || db_object_field_set_name(object_field, "zoneSoaTtl")
1848 || db_object_field_list_add(object_field_list, object_field))
1849 {
1850 db_object_field_free(object_field);
1851 db_object_field_list_free(object_field_list);
1852 return DB_ERROR_UNKNOWN;
1853 }
1854
1855 if (!(object_field = db_object_field_new())
1856 || db_object_field_set_name(object_field, "zoneSoaMinimum")
1858 || db_object_field_list_add(object_field_list, object_field))
1859 {
1860 db_object_field_free(object_field);
1861 db_object_field_list_free(object_field_list);
1862 return DB_ERROR_UNKNOWN;
1863 }
1864
1865 if (!(object_field = db_object_field_new())
1866 || db_object_field_set_name(object_field, "zoneSoaSerial")
1867 || db_object_field_set_type(object_field, DB_TYPE_ENUM)
1869 || db_object_field_list_add(object_field_list, object_field))
1870 {
1871 db_object_field_free(object_field);
1872 db_object_field_list_free(object_field_list);
1873 return DB_ERROR_UNKNOWN;
1874 }
1875
1876 if (!(object_field = db_object_field_new())
1877 || db_object_field_set_name(object_field, "parentRegistrationDelay")
1879 || db_object_field_list_add(object_field_list, object_field))
1880 {
1881 db_object_field_free(object_field);
1882 db_object_field_list_free(object_field_list);
1883 return DB_ERROR_UNKNOWN;
1884 }
1885
1886 if (!(object_field = db_object_field_new())
1887 || db_object_field_set_name(object_field, "parentPropagationDelay")
1889 || db_object_field_list_add(object_field_list, object_field))
1890 {
1891 db_object_field_free(object_field);
1892 db_object_field_list_free(object_field_list);
1893 return DB_ERROR_UNKNOWN;
1894 }
1895
1896 if (!(object_field = db_object_field_new())
1897 || db_object_field_set_name(object_field, "parentDsTtl")
1899 || db_object_field_list_add(object_field_list, object_field))
1900 {
1901 db_object_field_free(object_field);
1902 db_object_field_list_free(object_field_list);
1903 return DB_ERROR_UNKNOWN;
1904 }
1905
1906 if (!(object_field = db_object_field_new())
1907 || db_object_field_set_name(object_field, "parentSoaTtl")
1909 || db_object_field_list_add(object_field_list, object_field))
1910 {
1911 db_object_field_free(object_field);
1912 db_object_field_list_free(object_field_list);
1913 return DB_ERROR_UNKNOWN;
1914 }
1915
1916 if (!(object_field = db_object_field_new())
1917 || db_object_field_set_name(object_field, "parentSoaMinimum")
1919 || db_object_field_list_add(object_field_list, object_field))
1920 {
1921 db_object_field_free(object_field);
1922 db_object_field_list_free(object_field_list);
1923 return DB_ERROR_UNKNOWN;
1924 }
1925
1926 if (!(object_field = db_object_field_new())
1927 || db_object_field_set_name(object_field, "passthrough")
1929 || db_object_field_list_add(object_field_list, object_field))
1930 {
1931 db_object_field_free(object_field);
1932 db_object_field_list_free(object_field_list);
1933 return DB_ERROR_UNKNOWN;
1934 }
1935
1936 if (!(value_set = db_value_set_new(34))) {
1937 db_object_field_list_free(object_field_list);
1938 return DB_ERROR_UNKNOWN;
1939 }
1940
1941 if (db_value_from_text(db_value_set_get(value_set, 0), policy->name)
1949 || (db_value_from_uint32(db_value_set_get(value_set, 8), policy->signatures_validity_keyset) && 0) /* not an error, the database layer cannot handle optional fields */
1975 {
1976 db_value_set_free(value_set);
1977 db_object_field_list_free(object_field_list);
1978 return DB_ERROR_UNKNOWN;
1979 }
1980
1981 ret = db_object_create(policy->dbo, object_field_list, value_set);
1982 db_value_set_free(value_set);
1983 db_object_field_list_free(object_field_list);
1984 return ret;
1985}
1986
1988 db_clause_list_t* clause_list;
1989 db_clause_t* clause;
1990 db_result_list_t* result_list;
1991 const db_result_t* result;
1992
1993 if (!policy) {
1994 return DB_ERROR_UNKNOWN;
1995 }
1996 if (!policy->dbo) {
1997 return DB_ERROR_UNKNOWN;
1998 }
1999 if (!id) {
2000 return DB_ERROR_UNKNOWN;
2001 }
2002 if (db_value_not_empty(id)) {
2003 return DB_ERROR_UNKNOWN;
2004 }
2005
2006 if (!(clause_list = db_clause_list_new())) {
2007 return DB_ERROR_UNKNOWN;
2008 }
2009 if (!(clause = db_clause_new())
2010 || db_clause_set_field(clause, "id")
2012 || db_value_copy(db_clause_get_value(clause), id)
2013 || db_clause_list_add(clause_list, clause))
2014 {
2015 db_clause_free(clause);
2016 db_clause_list_free(clause_list);
2017 return DB_ERROR_UNKNOWN;
2018 }
2019
2020 result_list = db_object_read(policy->dbo, NULL, clause_list);
2021 db_clause_list_free(clause_list);
2022
2023 if (result_list) {
2024 result = db_result_list_next(result_list);
2025 if (result) {
2026 if (policy_from_result(policy, result)) {
2027 db_result_list_free(result_list);
2028 return DB_ERROR_UNKNOWN;
2029 }
2030
2031 db_result_list_free(result_list);
2032 return DB_OK;
2033 }
2034 }
2035
2036 db_result_list_free(result_list);
2037 return DB_ERROR_UNKNOWN;
2038}
2039
2040int policy_get_by_name(policy_t* policy, const char* name) {
2041 db_clause_list_t* clause_list;
2042 db_clause_t* clause;
2043 db_result_list_t* result_list;
2044 const db_result_t* result;
2045
2046 if (!policy) {
2047 return DB_ERROR_UNKNOWN;
2048 }
2049 if (!policy->dbo) {
2050 return DB_ERROR_UNKNOWN;
2051 }
2052 if (!name) {
2053 return DB_ERROR_UNKNOWN;
2054 }
2055
2056 if (!(clause_list = db_clause_list_new())) {
2057 return DB_ERROR_UNKNOWN;
2058 }
2059 if (!(clause = db_clause_new())
2060 || db_clause_set_field(clause, "name")
2062 || db_value_from_text(db_clause_get_value(clause), name)
2063 || db_clause_list_add(clause_list, clause))
2064 {
2065 db_clause_free(clause);
2066 db_clause_list_free(clause_list);
2067 return DB_ERROR_UNKNOWN;
2068 }
2069
2070 result_list = db_object_read(policy->dbo, NULL, clause_list);
2071 db_clause_list_free(clause_list);
2072
2073 if (result_list) {
2074 result = db_result_list_next(result_list);
2075 if (result) {
2076 if (policy_from_result(policy, result)) {
2077 db_result_list_free(result_list);
2078 return DB_ERROR_UNKNOWN;
2079 }
2080
2081 db_result_list_free(result_list);
2082 return DB_OK;
2083 }
2084 }
2085
2086 db_result_list_free(result_list);
2087 return DB_ERROR_UNKNOWN;
2088}
2089
2090policy_t* policy_new_get_by_name(const db_connection_t* connection, const char* name) {
2092
2093 if (!connection) {
2094 return NULL;
2095 }
2096 if (!name) {
2097 return NULL;
2098 }
2099
2100 if (!(policy = policy_new(connection))
2101 || policy_get_by_name(policy, name))
2102 {
2104 return NULL;
2105 }
2106
2107 return policy;
2108}
2109
2111 db_object_field_list_t* object_field_list;
2112 db_object_field_t* object_field;
2113 db_value_set_t* value_set;
2114 db_clause_list_t* clause_list;
2115 db_clause_t* clause;
2116 int ret;
2117
2118 if (!policy) {
2119 return DB_ERROR_UNKNOWN;
2120 }
2121 if (!policy->dbo) {
2122 return DB_ERROR_UNKNOWN;
2123 }
2124 if (db_value_not_empty(&(policy->id))) {
2125 return DB_ERROR_UNKNOWN;
2126 }
2127 if (db_value_not_empty(&(policy->rev))) {
2128 return DB_ERROR_UNKNOWN;
2129 }
2130 if (!policy->name) {
2131 return DB_ERROR_UNKNOWN;
2132 }
2133 if (!policy->description) {
2134 return DB_ERROR_UNKNOWN;
2135 }
2136 if (!policy->denial_salt) {
2137 return DB_ERROR_UNKNOWN;
2138 }
2139 /* TODO: validate content more */
2140
2141 if (!(object_field_list = db_object_field_list_new())) {
2142 return DB_ERROR_UNKNOWN;
2143 }
2144
2145 if (!(object_field = db_object_field_new())
2146 || db_object_field_set_name(object_field, "name")
2147 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
2148 || db_object_field_list_add(object_field_list, object_field))
2149 {
2150 db_object_field_free(object_field);
2151 db_object_field_list_free(object_field_list);
2152 return DB_ERROR_UNKNOWN;
2153 }
2154
2155 if (!(object_field = db_object_field_new())
2156 || db_object_field_set_name(object_field, "description")
2157 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
2158 || db_object_field_list_add(object_field_list, object_field))
2159 {
2160 db_object_field_free(object_field);
2161 db_object_field_list_free(object_field_list);
2162 return DB_ERROR_UNKNOWN;
2163 }
2164
2165 if (!(object_field = db_object_field_new())
2166 || db_object_field_set_name(object_field, "signaturesResign")
2168 || db_object_field_list_add(object_field_list, object_field))
2169 {
2170 db_object_field_free(object_field);
2171 db_object_field_list_free(object_field_list);
2172 return DB_ERROR_UNKNOWN;
2173 }
2174
2175 if (!(object_field = db_object_field_new())
2176 || db_object_field_set_name(object_field, "signaturesRefresh")
2178 || db_object_field_list_add(object_field_list, object_field))
2179 {
2180 db_object_field_free(object_field);
2181 db_object_field_list_free(object_field_list);
2182 return DB_ERROR_UNKNOWN;
2183 }
2184
2185 if (!(object_field = db_object_field_new())
2186 || db_object_field_set_name(object_field, "signaturesJitter")
2188 || db_object_field_list_add(object_field_list, object_field))
2189 {
2190 db_object_field_free(object_field);
2191 db_object_field_list_free(object_field_list);
2192 return DB_ERROR_UNKNOWN;
2193 }
2194
2195 if (!(object_field = db_object_field_new())
2196 || db_object_field_set_name(object_field, "signaturesInceptionOffset")
2198 || db_object_field_list_add(object_field_list, object_field))
2199 {
2200 db_object_field_free(object_field);
2201 db_object_field_list_free(object_field_list);
2202 return DB_ERROR_UNKNOWN;
2203 }
2204
2205 if (!(object_field = db_object_field_new())
2206 || db_object_field_set_name(object_field, "signaturesValidityDefault")
2208 || db_object_field_list_add(object_field_list, object_field))
2209 {
2210 db_object_field_free(object_field);
2211 db_object_field_list_free(object_field_list);
2212 return DB_ERROR_UNKNOWN;
2213 }
2214
2215 if (!(object_field = db_object_field_new())
2216 || db_object_field_set_name(object_field, "signaturesValidityDenial")
2218 || db_object_field_list_add(object_field_list, object_field))
2219 {
2220 db_object_field_free(object_field);
2221 db_object_field_list_free(object_field_list);
2222 return DB_ERROR_UNKNOWN;
2223 }
2224
2225 if (!(object_field = db_object_field_new())
2226 || db_object_field_set_name(object_field, "signaturesValidityKeyset")
2228 || db_object_field_list_add(object_field_list, object_field))
2229 {
2230 db_object_field_free(object_field);
2231 db_object_field_list_free(object_field_list);
2232 return DB_ERROR_UNKNOWN;
2233 }
2234
2235 if (!(object_field = db_object_field_new())
2236 || db_object_field_set_name(object_field, "signaturesMaxZoneTtl")
2238 || db_object_field_list_add(object_field_list, object_field))
2239 {
2240 db_object_field_free(object_field);
2241 db_object_field_list_free(object_field_list);
2242 return DB_ERROR_UNKNOWN;
2243 }
2244
2245 if (!(object_field = db_object_field_new())
2246 || db_object_field_set_name(object_field, "denialType")
2247 || db_object_field_set_type(object_field, DB_TYPE_ENUM)
2249 || db_object_field_list_add(object_field_list, object_field))
2250 {
2251 db_object_field_free(object_field);
2252 db_object_field_list_free(object_field_list);
2253 return DB_ERROR_UNKNOWN;
2254 }
2255
2256 if (!(object_field = db_object_field_new())
2257 || db_object_field_set_name(object_field, "denialOptout")
2259 || db_object_field_list_add(object_field_list, object_field))
2260 {
2261 db_object_field_free(object_field);
2262 db_object_field_list_free(object_field_list);
2263 return DB_ERROR_UNKNOWN;
2264 }
2265
2266 if (!(object_field = db_object_field_new())
2267 || db_object_field_set_name(object_field, "denialTtl")
2269 || db_object_field_list_add(object_field_list, object_field))
2270 {
2271 db_object_field_free(object_field);
2272 db_object_field_list_free(object_field_list);
2273 return DB_ERROR_UNKNOWN;
2274 }
2275
2276 if (!(object_field = db_object_field_new())
2277 || db_object_field_set_name(object_field, "denialResalt")
2279 || db_object_field_list_add(object_field_list, object_field))
2280 {
2281 db_object_field_free(object_field);
2282 db_object_field_list_free(object_field_list);
2283 return DB_ERROR_UNKNOWN;
2284 }
2285
2286 if (!(object_field = db_object_field_new())
2287 || db_object_field_set_name(object_field, "denialAlgorithm")
2289 || db_object_field_list_add(object_field_list, object_field))
2290 {
2291 db_object_field_free(object_field);
2292 db_object_field_list_free(object_field_list);
2293 return DB_ERROR_UNKNOWN;
2294 }
2295
2296 if (!(object_field = db_object_field_new())
2297 || db_object_field_set_name(object_field, "denialIterations")
2299 || db_object_field_list_add(object_field_list, object_field))
2300 {
2301 db_object_field_free(object_field);
2302 db_object_field_list_free(object_field_list);
2303 return DB_ERROR_UNKNOWN;
2304 }
2305
2306 if (!(object_field = db_object_field_new())
2307 || db_object_field_set_name(object_field, "denialSaltLength")
2309 || db_object_field_list_add(object_field_list, object_field))
2310 {
2311 db_object_field_free(object_field);
2312 db_object_field_list_free(object_field_list);
2313 return DB_ERROR_UNKNOWN;
2314 }
2315
2316 if (!(object_field = db_object_field_new())
2317 || db_object_field_set_name(object_field, "denialSalt")
2318 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
2319 || db_object_field_list_add(object_field_list, object_field))
2320 {
2321 db_object_field_free(object_field);
2322 db_object_field_list_free(object_field_list);
2323 return DB_ERROR_UNKNOWN;
2324 }
2325
2326 if (!(object_field = db_object_field_new())
2327 || db_object_field_set_name(object_field, "denialSaltLastChange")
2329 || db_object_field_list_add(object_field_list, object_field))
2330 {
2331 db_object_field_free(object_field);
2332 db_object_field_list_free(object_field_list);
2333 return DB_ERROR_UNKNOWN;
2334 }
2335
2336 if (!(object_field = db_object_field_new())
2337 || db_object_field_set_name(object_field, "keysTtl")
2339 || db_object_field_list_add(object_field_list, object_field))
2340 {
2341 db_object_field_free(object_field);
2342 db_object_field_list_free(object_field_list);
2343 return DB_ERROR_UNKNOWN;
2344 }
2345
2346 if (!(object_field = db_object_field_new())
2347 || db_object_field_set_name(object_field, "keysRetireSafety")
2349 || db_object_field_list_add(object_field_list, object_field))
2350 {
2351 db_object_field_free(object_field);
2352 db_object_field_list_free(object_field_list);
2353 return DB_ERROR_UNKNOWN;
2354 }
2355
2356 if (!(object_field = db_object_field_new())
2357 || db_object_field_set_name(object_field, "keysPublishSafety")
2359 || db_object_field_list_add(object_field_list, object_field))
2360 {
2361 db_object_field_free(object_field);
2362 db_object_field_list_free(object_field_list);
2363 return DB_ERROR_UNKNOWN;
2364 }
2365
2366 if (!(object_field = db_object_field_new())
2367 || db_object_field_set_name(object_field, "keysShared")
2369 || db_object_field_list_add(object_field_list, object_field))
2370 {
2371 db_object_field_free(object_field);
2372 db_object_field_list_free(object_field_list);
2373 return DB_ERROR_UNKNOWN;
2374 }
2375
2376 if (!(object_field = db_object_field_new())
2377 || db_object_field_set_name(object_field, "keysPurgeAfter")
2379 || db_object_field_list_add(object_field_list, object_field))
2380 {
2381 db_object_field_free(object_field);
2382 db_object_field_list_free(object_field_list);
2383 return DB_ERROR_UNKNOWN;
2384 }
2385
2386 if (!(object_field = db_object_field_new())
2387 || db_object_field_set_name(object_field, "zonePropagationDelay")
2389 || db_object_field_list_add(object_field_list, object_field))
2390 {
2391 db_object_field_free(object_field);
2392 db_object_field_list_free(object_field_list);
2393 return DB_ERROR_UNKNOWN;
2394 }
2395
2396 if (!(object_field = db_object_field_new())
2397 || db_object_field_set_name(object_field, "zoneSoaTtl")
2399 || db_object_field_list_add(object_field_list, object_field))
2400 {
2401 db_object_field_free(object_field);
2402 db_object_field_list_free(object_field_list);
2403 return DB_ERROR_UNKNOWN;
2404 }
2405
2406 if (!(object_field = db_object_field_new())
2407 || db_object_field_set_name(object_field, "zoneSoaMinimum")
2409 || db_object_field_list_add(object_field_list, object_field))
2410 {
2411 db_object_field_free(object_field);
2412 db_object_field_list_free(object_field_list);
2413 return DB_ERROR_UNKNOWN;
2414 }
2415
2416 if (!(object_field = db_object_field_new())
2417 || db_object_field_set_name(object_field, "zoneSoaSerial")
2418 || db_object_field_set_type(object_field, DB_TYPE_ENUM)
2420 || db_object_field_list_add(object_field_list, object_field))
2421 {
2422 db_object_field_free(object_field);
2423 db_object_field_list_free(object_field_list);
2424 return DB_ERROR_UNKNOWN;
2425 }
2426
2427 if (!(object_field = db_object_field_new())
2428 || db_object_field_set_name(object_field, "parentRegistrationDelay")
2430 || db_object_field_list_add(object_field_list, object_field))
2431 {
2432 db_object_field_free(object_field);
2433 db_object_field_list_free(object_field_list);
2434 return DB_ERROR_UNKNOWN;
2435 }
2436
2437 if (!(object_field = db_object_field_new())
2438 || db_object_field_set_name(object_field, "parentPropagationDelay")
2440 || db_object_field_list_add(object_field_list, object_field))
2441 {
2442 db_object_field_free(object_field);
2443 db_object_field_list_free(object_field_list);
2444 return DB_ERROR_UNKNOWN;
2445 }
2446
2447 if (!(object_field = db_object_field_new())
2448 || db_object_field_set_name(object_field, "parentDsTtl")
2450 || db_object_field_list_add(object_field_list, object_field))
2451 {
2452 db_object_field_free(object_field);
2453 db_object_field_list_free(object_field_list);
2454 return DB_ERROR_UNKNOWN;
2455 }
2456
2457 if (!(object_field = db_object_field_new())
2458 || db_object_field_set_name(object_field, "parentSoaTtl")
2460 || db_object_field_list_add(object_field_list, object_field))
2461 {
2462 db_object_field_free(object_field);
2463 db_object_field_list_free(object_field_list);
2464 return DB_ERROR_UNKNOWN;
2465 }
2466
2467 if (!(object_field = db_object_field_new())
2468 || db_object_field_set_name(object_field, "parentSoaMinimum")
2470 || db_object_field_list_add(object_field_list, object_field))
2471 {
2472 db_object_field_free(object_field);
2473 db_object_field_list_free(object_field_list);
2474 return DB_ERROR_UNKNOWN;
2475 }
2476
2477 if (!(object_field = db_object_field_new())
2478 || db_object_field_set_name(object_field, "passthrough")
2480 || db_object_field_list_add(object_field_list, object_field))
2481 {
2482 db_object_field_free(object_field);
2483 db_object_field_list_free(object_field_list);
2484 return DB_ERROR_UNKNOWN;
2485 }
2486
2487 if (!(value_set = db_value_set_new(34))) {
2488 db_object_field_list_free(object_field_list);
2489 return DB_ERROR_UNKNOWN;
2490 }
2491
2492 if (db_value_from_text(db_value_set_get(value_set, 0), policy->name)
2500 || (db_value_from_uint32(db_value_set_get(value_set, 8), policy->signatures_validity_keyset) && 0) /* the database layer cannot handle optional fields */
2526 {
2527 db_value_set_free(value_set);
2528 db_object_field_list_free(object_field_list);
2529 return DB_ERROR_UNKNOWN;
2530 }
2531
2532 if (!(clause_list = db_clause_list_new())) {
2533 db_value_set_free(value_set);
2534 db_object_field_list_free(object_field_list);
2535 return DB_ERROR_UNKNOWN;
2536 }
2537
2538 if (!(clause = db_clause_new())
2539 || db_clause_set_field(clause, "id")
2542 || db_clause_list_add(clause_list, clause))
2543 {
2544 db_clause_free(clause);
2545 db_clause_list_free(clause_list);
2546 db_value_set_free(value_set);
2547 db_object_field_list_free(object_field_list);
2548 return DB_ERROR_UNKNOWN;
2549 }
2550
2551 if (!(clause = db_clause_new())
2552 || db_clause_set_field(clause, "rev")
2555 || db_clause_list_add(clause_list, clause))
2556 {
2557 db_clause_free(clause);
2558 db_clause_list_free(clause_list);
2559 db_value_set_free(value_set);
2560 db_object_field_list_free(object_field_list);
2561 return DB_ERROR_UNKNOWN;
2562 }
2563
2564 ret = db_object_update(policy->dbo, object_field_list, value_set, clause_list);
2565 db_value_set_free(value_set);
2566 db_object_field_list_free(object_field_list);
2567 db_clause_list_free(clause_list);
2568 return ret;
2569}
2570
2572 db_clause_list_t* clause_list;
2573 db_clause_t* clause;
2574 int ret;
2575
2576 if (!policy) {
2577 return DB_ERROR_UNKNOWN;
2578 }
2579 if (!policy->dbo) {
2580 return DB_ERROR_UNKNOWN;
2581 }
2582 if (db_value_not_empty(&(policy->id))) {
2583 return DB_ERROR_UNKNOWN;
2584 }
2585
2586 if (!(clause_list = db_clause_list_new())) {
2587 return DB_ERROR_UNKNOWN;
2588 }
2589
2590 if (!(clause = db_clause_new())
2591 || db_clause_set_field(clause, "id")
2594 || db_clause_list_add(clause_list, clause))
2595 {
2596 db_clause_free(clause);
2597 db_clause_list_free(clause_list);
2598 return DB_ERROR_UNKNOWN;
2599 }
2600
2601 if (!(clause = db_clause_new())
2602 || db_clause_set_field(clause, "rev")
2605 || db_clause_list_add(clause_list, clause))
2606 {
2607 db_clause_free(clause);
2608 db_clause_list_free(clause_list);
2609 return DB_ERROR_UNKNOWN;
2610 }
2611
2612 ret = db_object_delete(policy->dbo, clause_list);
2613 db_clause_list_free(clause_list);
2614 return ret;
2615}
2616
2617/* POLICY LIST */
2618
2619
2620
2623 (policy_list_t*)calloc(1, sizeof(policy_list_t));
2624
2625 if (policy_list) {
2626 if (!(policy_list->dbo = __policy_new_object(connection))) {
2627 free(policy_list);
2628 return NULL;
2629 }
2630 }
2631
2632 return policy_list;
2633}
2634
2637
2638 if (!from_policy_list) {
2639 return NULL;
2640 }
2641 if (!from_policy_list->dbo) {
2642 return NULL;
2643 }
2644
2645 if (!(policy_list = policy_list_new(db_object_connection(from_policy_list->dbo)))
2646 || policy_list_copy(policy_list, from_policy_list))
2647 {
2649 return NULL;
2650 }
2651 return policy_list;
2652}
2653
2655 if (!policy_list) {
2656 return DB_ERROR_UNKNOWN;
2657 }
2658
2660
2661 return DB_OK;
2662}
2663
2665 size_t i;
2666
2667 if (policy_list) {
2668 if (policy_list->dbo) {
2670 }
2671 if (policy_list->result_list) {
2673 }
2674 if (policy_list->policy) {
2676 }
2677 for (i = 0; i < policy_list->object_list_size; i++) {
2678 if (policy_list->object_list[i]) {
2680 }
2681 }
2682 if (policy_list->object_list) {
2683 free(policy_list->object_list);
2684 }
2685 free(policy_list);
2686 }
2687}
2688
2690 size_t i;
2691
2692 if (!policy_list) {
2693 return DB_ERROR_UNKNOWN;
2694 }
2695 if (!from_policy_list) {
2696 return DB_ERROR_UNKNOWN;
2697 }
2698 if (from_policy_list->object_list && !from_policy_list->object_list_size) {
2699 return DB_ERROR_UNKNOWN;
2700 }
2701
2702 if (policy_list->result_list) {
2704 policy_list->result_list = NULL;
2705 }
2706 if (from_policy_list->result_list
2707 && !(policy_list->result_list = db_result_list_new_copy(from_policy_list->result_list)))
2708 {
2709 return DB_ERROR_UNKNOWN;
2710 }
2711
2712 policy_list->object_store = from_policy_list->object_store;
2713 for (i = 0; i < policy_list->object_list_size; i++) {
2714 if (policy_list->object_list[i]) {
2716 }
2717 }
2719 if (policy_list->object_list) {
2720 free(policy_list->object_list);
2721 policy_list->object_list = NULL;
2722 }
2723 if (from_policy_list->object_list) {
2724 if (!(policy_list->object_list = (policy_t**)calloc(from_policy_list->object_list_size, sizeof(policy_t*)))) {
2725 return DB_ERROR_UNKNOWN;
2726 }
2727 policy_list->object_list_size = from_policy_list->object_list_size;
2728 for (i = 0; i < from_policy_list->object_list_size; i++) {
2729 if (!from_policy_list->object_list[i]) {
2730 continue;
2731 }
2732 if (!(policy_list->object_list[i] = policy_new_copy(from_policy_list->object_list[i]))) {
2733 return DB_ERROR_UNKNOWN;
2734 }
2735 }
2736 }
2739 policy_list->associated_fetch = from_policy_list->associated_fetch;
2740
2741 return DB_OK;
2742}
2743
2744static int policy_list_get_associated(policy_list_t* policy_list) {
2745 size_t j, count;
2746 int cmp;
2747 size_t i;
2748 db_clause_list_t* clause_list;
2749 db_clause_t* clause;
2750 const policy_t* policy;
2752 const policy_key_t* policy_key;
2753 zone_list_db_t* zone_list;
2754 const zone_db_t* zone;
2756 const hsm_key_t* hsm_key;
2757
2758 if (!policy_list) {
2759 return DB_ERROR_UNKNOWN;
2760 }
2761 if (!policy_list->dbo) {
2762 return DB_ERROR_UNKNOWN;
2763 }
2765 return DB_ERROR_UNKNOWN;
2766 }
2767 if (!policy_list->result_list) {
2768 return DB_ERROR_UNKNOWN;
2769 }
2770 if (policy_list->object_list) {
2771 return DB_ERROR_UNKNOWN;
2772 }
2773
2775 while (policy) {
2777 }
2778
2779 if (!(clause_list = db_clause_list_new())) {
2780 return DB_ERROR_UNKNOWN;
2781 }
2783 while (policy) {
2784 if (!(clause = db_clause_new())
2785 || db_clause_set_field(clause, "policyId")
2789 || db_clause_list_add(clause_list, clause))
2790 {
2791 db_clause_free(clause);
2792 db_clause_list_free(clause_list);
2793 return DB_ERROR_UNKNOWN;
2794 }
2795
2797 }
2798
2802 {
2804 db_clause_list_free(clause_list);
2805 return DB_ERROR_UNKNOWN;
2806 }
2807
2808 for (i = 0; i < policy_list->object_list_size; i++) {
2809 if (!(policy_list->object_list[i])) {
2810 return DB_ERROR_UNKNOWN;
2811 }
2812
2813 count = 0;
2815 while (policy_key) {
2818 db_clause_list_free(clause_list);
2819 return DB_ERROR_UNKNOWN;
2820 }
2821 if (!cmp) {
2822 count++;
2823 }
2825 }
2829 }
2832 db_clause_list_free(clause_list);
2833 return DB_ERROR_UNKNOWN;
2834 }
2835 if (count) {
2836 if (!(policy_list->object_list[i]->policy_key_list->object_list = (policy_key_t**)calloc(count, sizeof(policy_key_t*)))) {
2838 db_clause_list_free(clause_list);
2839 return DB_ERROR_UNKNOWN;
2840 }
2841
2842 j = 0;
2844 while (policy_key) {
2845 if (j >= count) {
2847 db_clause_list_free(clause_list);
2848 return DB_ERROR_UNKNOWN;
2849 }
2852 db_clause_list_free(clause_list);
2853 return DB_ERROR_UNKNOWN;
2854 }
2855 if (!cmp) {
2858 db_clause_list_free(clause_list);
2859 return DB_ERROR_UNKNOWN;
2860 }
2861 j++;
2862 }
2864 }
2865 if (j != count) {
2867 db_clause_list_free(clause_list);
2868 return DB_ERROR_UNKNOWN;
2869 }
2870 }
2874 }
2875
2877 || zone_list_db_object_store(zone_list)
2878 || zone_list_db_get_by_clauses(zone_list, clause_list))
2879 {
2880 zone_list_db_free(zone_list);
2881 db_clause_list_free(clause_list);
2882 return DB_ERROR_UNKNOWN;
2883 }
2884
2885 for (i = 0; i < policy_list->object_list_size; i++) {
2886 if (!(policy_list->object_list[i])) {
2887 zone_list_db_free(zone_list);
2888 db_clause_list_free(clause_list);
2889 return DB_ERROR_UNKNOWN;
2890 }
2891
2892 count = 0;
2893 zone = zone_list_db_begin(zone_list);
2894 while (zone) {
2896 zone_list_db_free(zone_list);
2897 db_clause_list_free(clause_list);
2898 return DB_ERROR_UNKNOWN;
2899 }
2900 if (!cmp) {
2901 count++;
2902 }
2903 zone = zone_list_db_next(zone_list);
2904 }
2907 policy_list->object_list[i]->zone_list = NULL;
2908 }
2910 zone_list_db_free(zone_list);
2911 db_clause_list_free(clause_list);
2912 return DB_ERROR_UNKNOWN;
2913 }
2914 if (count) {
2915 if (!(policy_list->object_list[i]->zone_list->object_list = (zone_db_t**)calloc(count, sizeof(zone_db_t*)))) {
2916 zone_list_db_free(zone_list);
2917 db_clause_list_free(clause_list);
2918 return DB_ERROR_UNKNOWN;
2919 }
2920
2921 j = 0;
2922 zone = zone_list_db_begin(zone_list);
2923 while (zone) {
2924 if (j >= count) {
2925 zone_list_db_free(zone_list);
2926 db_clause_list_free(clause_list);
2927 return DB_ERROR_UNKNOWN;
2928 }
2930 zone_list_db_free(zone_list);
2931 db_clause_list_free(clause_list);
2932 return DB_ERROR_UNKNOWN;
2933 }
2934 if (!cmp) {
2936 zone_list_db_free(zone_list);
2937 db_clause_list_free(clause_list);
2938 return DB_ERROR_UNKNOWN;
2939 }
2940 j++;
2941 }
2942 zone = zone_list_db_next(zone_list);
2943 }
2944 if (j != count) {
2945 zone_list_db_free(zone_list);
2946 db_clause_list_free(clause_list);
2947 return DB_ERROR_UNKNOWN;
2948 }
2949 }
2953 }
2954 zone_list_db_free(zone_list);
2955
2959 {
2961 db_clause_list_free(clause_list);
2962 return DB_ERROR_UNKNOWN;
2963 }
2964
2965 for (i = 0; i < policy_list->object_list_size; i++) {
2966 if (!(policy_list->object_list[i])) {
2968 return DB_ERROR_UNKNOWN;
2969 }
2970
2971 count = 0;
2973 while (hsm_key) {
2976 db_clause_list_free(clause_list);
2977 return DB_ERROR_UNKNOWN;
2978 }
2979 if (!cmp) {
2980 count++;
2981 }
2983 }
2987 }
2990 db_clause_list_free(clause_list);
2991 return DB_ERROR_UNKNOWN;
2992 }
2993 if (count) {
2994 if (!(policy_list->object_list[i]->hsm_key_list->object_list = (hsm_key_t**)calloc(count, sizeof(hsm_key_t*)))) {
2996 db_clause_list_free(clause_list);
2997 return DB_ERROR_UNKNOWN;
2998 }
2999
3000 j = 0;
3002 while (hsm_key) {
3003 if (j >= count) {
3005 db_clause_list_free(clause_list);
3006 return DB_ERROR_UNKNOWN;
3007 }
3010 db_clause_list_free(clause_list);
3011 return DB_ERROR_UNKNOWN;
3012 }
3013 if (!cmp) {
3016 db_clause_list_free(clause_list);
3017 return DB_ERROR_UNKNOWN;
3018 }
3019 j++;
3020 }
3022 }
3023 if (j != count) {
3025 db_clause_list_free(clause_list);
3026 return DB_ERROR_UNKNOWN;
3027 }
3028 }
3032 }
3033 db_clause_list_free(clause_list);
3035
3037 return DB_OK;
3038}
3039
3041 size_t i;
3042
3043 if (!policy_list) {
3044 return DB_ERROR_UNKNOWN;
3045 }
3046 if (!policy_list->dbo) {
3047 return DB_ERROR_UNKNOWN;
3048 }
3049
3050 if (policy_list->result_list) {
3052 }
3054 for (i = 0; i < policy_list->object_list_size; i++) {
3055 if (policy_list->object_list[i]) {
3057 }
3058 }
3061 }
3062 if (policy_list->object_list) {
3063 free(policy_list->object_list);
3064 policy_list->object_list = NULL;
3065 }
3066 if (!(policy_list->result_list = db_object_read(policy_list->dbo, NULL, NULL))
3068 {
3069 return DB_ERROR_UNKNOWN;
3070 }
3072 && policy_list_get_associated(policy_list))
3073 {
3074 return DB_ERROR_UNKNOWN;
3075 }
3076 return DB_OK;
3077}
3078
3081
3082 if (!connection) {
3083 return NULL;
3084 }
3085
3086 if (!(policy_list = policy_list_new(connection))
3088 {
3090 return NULL;
3091 }
3092
3093 return policy_list;
3094}
3095
3097 size_t i;
3098
3099 if (!policy_list) {
3100 return DB_ERROR_UNKNOWN;
3101 }
3102 if (!clause_list) {
3103 return DB_ERROR_UNKNOWN;
3104 }
3105 if (!policy_list->dbo) {
3106 return DB_ERROR_UNKNOWN;
3107 }
3108
3109 if (policy_list->result_list) {
3111 }
3113 for (i = 0; i < policy_list->object_list_size; i++) {
3114 if (policy_list->object_list[i]) {
3116 }
3117 }
3120 }
3121 if (policy_list->object_list) {
3122 free(policy_list->object_list);
3123 policy_list->object_list = NULL;
3124 }
3125 if (!(policy_list->result_list = db_object_read(policy_list->dbo, NULL, clause_list))
3127 {
3128 return DB_ERROR_UNKNOWN;
3129 }
3131 && policy_list_get_associated(policy_list))
3132 {
3133 return DB_ERROR_UNKNOWN;
3134 }
3135 return DB_OK;
3136}
3137
3140
3141 if (!connection) {
3142 return NULL;
3143 }
3144 if (!clause_list) {
3145 return NULL;
3146 }
3147
3148 if (!(policy_list = policy_list_new(connection))
3149 || policy_list_get_by_clauses(policy_list, clause_list))
3150 {
3152 return NULL;
3153 }
3154
3155 return policy_list;
3156}
3157
3159 const db_result_t* result;
3160
3161 if (!policy_list) {
3162 return NULL;
3163 }
3164
3166 if (!policy_list->object_list) {
3167 if (!policy_list->result_list) {
3168 return NULL;
3169 }
3171 return NULL;
3172 }
3174 return NULL;
3175 }
3177 }
3178 if (!(policy_list->object_list[0])) {
3179 if (!policy_list->result_list) {
3180 return NULL;
3181 }
3182 if (!(result = db_result_list_begin(policy_list->result_list))) {
3183 return NULL;
3184 }
3186 return NULL;
3187 }
3188 if (policy_from_result(policy_list->object_list[0], result)) {
3189 return NULL;
3190 }
3191 }
3193 return policy_list->object_list[0];
3194 }
3195
3196 if (!policy_list->result_list) {
3197 return NULL;
3198 }
3199
3200 if (!(result = db_result_list_begin(policy_list->result_list))) {
3201 return NULL;
3202 }
3203 if (!policy_list->policy) {
3205 return NULL;
3206 }
3207 }
3208 if (policy_from_result(policy_list->policy, result)) {
3209 return NULL;
3210 }
3211 return policy_list->policy;
3212}
3213
3215 const db_result_t* result;
3216
3217 if (!policy_list) {
3218 return NULL;
3219 }
3220
3222 if (!policy_list->object_list) {
3223 if (!policy_list->result_list) {
3224 return NULL;
3225 }
3227 return NULL;
3228 }
3230 return NULL;
3231 }
3234 }
3235 else if (policy_list->object_list_first) {
3238 }
3239 else {
3241 }
3243 return NULL;
3244 }
3246 if (!policy_list->result_list) {
3247 return NULL;
3248 }
3249 if (!(result = db_result_list_next(policy_list->result_list))) {
3250 return NULL;
3251 }
3253 return NULL;
3254 }
3256 return NULL;
3257 }
3258 }
3260 }
3261
3262 if (!policy_list->result_list) {
3263 return NULL;
3264 }
3265
3266 if (!(result = db_result_list_next(policy_list->result_list))) {
3267 return NULL;
3268 }
3269 if (!policy_list->policy) {
3271 return NULL;
3272 }
3273 }
3274 if (policy_from_result(policy_list->policy, result)) {
3275 return NULL;
3276 }
3277 return policy_list->policy;
3278}
3279
3281 const db_result_t* result;
3283
3284 if (!policy_list) {
3285 return NULL;
3286 }
3287
3290 return NULL;
3291 }
3294 return NULL;
3295 }
3296 return policy;
3297 }
3298
3299 if (!policy_list->result_list) {
3300 return NULL;
3301 }
3302
3303 if (!(result = db_result_list_next(policy_list->result_list))) {
3304 return NULL;
3305 }
3307 return NULL;
3308 }
3309 if (policy_from_result(policy, result)) {
3311 return NULL;
3312 }
3313 return policy;
3314}
void db_clause_free(db_clause_t *clause)
Definition: db_clause.c:56
db_clause_list_t * db_clause_list_new(void)
Definition: db_clause.c:202
db_clause_t * db_clause_new(void)
Definition: db_clause.c:43
db_value_t * db_clause_get_value(db_clause_t *clause)
Definition: db_clause.c:187
int db_clause_list_add(db_clause_list_t *clause_list, db_clause_t *clause)
Definition: db_clause.c:226
void db_clause_list_free(db_clause_list_t *clause_list)
Definition: db_clause.c:209
int db_clause_set_operator(db_clause_t *clause, db_clause_operator_t clause_operator)
Definition: db_clause.c:142
int db_clause_set_field(db_clause_t *clause, const char *field)
Definition: db_clause.c:109
int db_clause_set_type(db_clause_t *clause, db_clause_type_t type)
Definition: db_clause.c:130
@ DB_CLAUSE_OPERATOR_AND
Definition: db_clause.h:97
@ DB_CLAUSE_OPERATOR_OR
Definition: db_clause.h:101
@ DB_CLAUSE_EQUAL
Definition: db_clause.h:44
#define DB_ERROR_UNKNOWN
Definition: db_error.h:40
#define DB_OK
Definition: db_error.h:36
const db_connection_t * db_object_connection(const db_object_t *object)
Definition: db_object.c:320
db_object_field_t * db_object_field_new(void)
Definition: db_object.c:40
int db_object_update(const db_object_t *object, const db_object_field_list_t *object_field_list, const db_value_set_t *value_set, const db_clause_list_t *clause_list)
Definition: db_object.c:441
int db_object_field_list_add(db_object_field_list_t *object_field_list, db_object_field_t *object_field)
Definition: db_object.c:254
db_object_t * db_object_new(void)
Definition: db_object.c:304
int db_object_set_table(db_object_t *object, const char *table)
Definition: db_object.c:356
int db_object_field_set_name(db_object_field_t *object_field, const char *name)
Definition: db_object.c:110
int db_object_set_connection(db_object_t *object, const db_connection_t *connection)
Definition: db_object.c:341
db_result_list_t * db_object_read(const db_object_t *object, const db_join_list_t *join_list, const db_clause_list_t *clause_list)
Definition: db_object.c:424
int db_object_field_set_type(db_object_field_t *object_field, db_type_t type)
Definition: db_object.c:122
int db_object_field_set_enum_set(db_object_field_t *object_field, const db_enum_t *enum_set)
Definition: db_object.c:134
void db_object_free(db_object_t *object)
Definition: db_object.c:311
db_object_field_list_t * db_object_field_list_new(void)
Definition: db_object.c:174
int db_object_set_object_field_list(db_object_t *object, db_object_field_list_t *object_field_list)
Definition: db_object.c:386
void db_object_field_free(db_object_field_t *object_field)
Definition: db_object.c:69
int db_object_create(const db_object_t *object, const db_object_field_list_t *object_field_list, const db_value_set_t *value_set)
Definition: db_object.c:401
int db_object_delete(const db_object_t *object, const db_clause_list_t *clause_list)
Definition: db_object.c:464
void db_object_field_list_free(db_object_field_list_t *object_field_list)
Definition: db_object.c:199
int db_object_set_primary_key_name(db_object_t *object, const char *primary_key_name)
Definition: db_object.c:371
int db_result_list_fetch_all(db_result_list_t *result_list)
Definition: db_result.c:341
size_t db_result_list_size(const db_result_list_t *result_list)
Definition: db_result.c:333
const db_result_t * db_result_list_next(db_result_list_t *result_list)
Definition: db_result.c:310
const db_result_t * db_result_list_begin(db_result_list_t *result_list)
Definition: db_result.c:290
void db_result_list_free(db_result_list_t *result_list)
Definition: db_result.c:160
db_result_list_t * db_result_list_new_copy(const db_result_list_t *from_result_list)
Definition: db_result.c:142
const db_value_set_t * db_result_value_set(const db_result_t *result)
Definition: db_result.c:97
@ DB_TYPE_PRIMARY_KEY
Definition: db_type.h:62
@ DB_TYPE_REVISION
Definition: db_type.h:97
@ DB_TYPE_TEXT
Definition: db_type.h:82
@ DB_TYPE_ENUM
Definition: db_type.h:86
@ DB_TYPE_UINT32
Definition: db_type.h:70
const db_value_t * db_value_set_at(const db_value_set_t *value_set, size_t at)
Definition: db_value.c:742
int db_value_from_enum_value(db_value_t *value, int enum_value, const db_enum_t *enum_set)
Definition: db_value.c:572
db_value_t * db_value_set_get(db_value_set_t *value_set, size_t at)
Definition: db_value.c:756
void db_value_set_free(db_value_set_t *value_set)
Definition: db_value.c:697
int db_value_from_uint32(db_value_t *value, db_type_uint32_t from_uint32)
Definition: db_value.c:492
db_value_set_t * db_value_set_new(size_t size)
Definition: db_value.c:622
int db_value_from_text(db_value_t *value, const char *from_text)
Definition: db_value.c:531
int db_value_copy(db_value_t *value, const db_value_t *from_value)
Definition: db_value.c:77
int db_value_cmp(const db_value_t *value_a, const db_value_t *value_b, int *result)
Definition: db_value.c:102
size_t db_value_set_size(const db_value_set_t *value_set)
Definition: db_value.c:734
int db_value_to_uint32(const db_value_t *value, db_type_uint32_t *to_uint32)
Definition: db_value.c:372
int db_value_to_text(const db_value_t *value, char **to_text)
Definition: db_value.c:417
int db_value_not_empty(const db_value_t *value)
Definition: db_value.c:347
int db_value_to_enum_value(const db_value_t *value, int *to_int, const db_enum_t *enum_set)
Definition: db_value.c:438
void db_value_reset(db_value_t *value)
Definition: db_value.c:60
hsm_key_list_t * hsm_key_list_new_copy(const hsm_key_list_t *from_hsm_key_list)
Definition: hsm_key.c:1467
int hsm_key_list_object_store(hsm_key_list_t *hsm_key_list)
Definition: hsm_key.c:1486
const hsm_key_t * hsm_key_list_next(hsm_key_list_t *hsm_key_list)
Definition: hsm_key.c:1924
const hsm_key_t * hsm_key_list_begin(hsm_key_list_t *hsm_key_list)
Definition: hsm_key.c:1832
void hsm_key_list_free(hsm_key_list_t *hsm_key_list)
Definition: hsm_key.c:1496
hsm_key_list_t * hsm_key_list_new(const db_connection_t *connection)
Definition: hsm_key.c:1453
const db_value_t * hsm_key_policy_id(const hsm_key_t *hsm_key)
Definition: hsm_key.c:512
hsm_key_t * hsm_key_new_copy(const hsm_key_t *hsm_key)
Definition: hsm_key.c:267
int hsm_key_list_get_by_clauses(hsm_key_list_t *hsm_key_list, const db_clause_list_t *clause_list)
Definition: hsm_key.c:1684
unsigned int policy_denial_salt_length(const policy_t *policy)
Definition: policy.c:941
int policy_set_name(policy_t *policy, const char *name_text)
Definition: policy.c:1142
unsigned int policy_zone_propagation_delay(const policy_t *policy)
Definition: policy.c:1005
unsigned int policy_denial_iterations(const policy_t *policy)
Definition: policy.c:933
int policy_set_parent_ds_ttl(policy_t *policy, unsigned int parent_ds_ttl)
Definition: policy.c:1500
int policy_set_denial_type(policy_t *policy, policy_denial_type_t denial_type)
Definition: policy.c:1266
int policy_set_denial_ttl(policy_t *policy, unsigned int denial_ttl)
Definition: policy.c:1289
unsigned int policy_denial_optout(const policy_t *policy)
Definition: policy.c:901
unsigned int policy_parent_soa_minimum(const policy_t *policy)
Definition: policy.c:1077
int policy_set_signatures_resign(policy_t *policy, unsigned int signatures_resign)
Definition: policy.c:1186
unsigned int policy_signatures_validity_denial(const policy_t *policy)
Definition: policy.c:869
unsigned int policy_keys_purge_after(const policy_t *policy)
Definition: policy.c:997
policy_t * policy_new(const db_connection_t *connection)
Definition: policy.c:479
int policy_set_denial_iterations(policy_t *policy, unsigned int denial_iterations)
Definition: policy.c:1323
unsigned int policy_parent_ds_ttl(const policy_t *policy)
Definition: policy.c:1061
unsigned int policy_signatures_resign(const policy_t *policy)
Definition: policy.c:829
int policy_set_parent_soa_minimum(policy_t *policy, unsigned int parent_soa_minimum)
Definition: policy.c:1520
zone_list_db_t * policy_zone_list(policy_t *policy)
Definition: policy.c:1093
void policy_list_free(policy_list_t *policy_list)
Definition: policy.c:2664
const policy_t * policy_list_begin(policy_list_t *policy_list)
Definition: policy.c:3158
int policy_set_signatures_inception_offset(policy_t *policy, unsigned int signatures_inception_offset)
Definition: policy.c:1216
db_clause_t * policy_denial_type_clause(db_clause_list_t *clause_list, policy_denial_type_t denial_type)
Definition: policy.c:1540
int policy_set_zone_propagation_delay(policy_t *policy, unsigned int zone_propagation_delay)
Definition: policy.c:1433
unsigned int policy_keys_ttl(const policy_t *policy)
Definition: policy.c:965
const policy_t * policy_list_next(policy_list_t *policy_list)
Definition: policy.c:3214
policy_list_t * policy_list_new_get_by_clauses(const db_connection_t *connection, const db_clause_list_t *clause_list)
Definition: policy.c:3138
unsigned int policy_parent_propagation_delay(const policy_t *policy)
Definition: policy.c:1053
int policy_set_keys_purge_after(policy_t *policy, unsigned int keys_purge_after)
Definition: policy.c:1423
unsigned int policy_zone_soa_ttl(const policy_t *policy)
Definition: policy.c:1013
policy_list_t * policy_list_new_get(const db_connection_t *connection)
Definition: policy.c:3079
unsigned int policy_denial_salt_last_change(const policy_t *policy)
Definition: policy.c:957
unsigned int policy_zone_soa_minimum(const policy_t *policy)
Definition: policy.c:1021
unsigned int policy_passthrough(const policy_t *policy)
Definition: policy.c:1085
policy_t * policy_new_get_by_name(const db_connection_t *connection, const char *name)
Definition: policy.c:2090
const char * policy_denial_salt(const policy_t *policy)
Definition: policy.c:949
unsigned int policy_signatures_refresh(const policy_t *policy)
Definition: policy.c:837
unsigned int policy_denial_ttl(const policy_t *policy)
Definition: policy.c:909
unsigned int policy_signatures_max_zone_ttl(const policy_t *policy)
Definition: policy.c:885
int policy_get_by_name(policy_t *policy, const char *name)
Definition: policy.c:2040
policy_t * policy_new_copy(const policy_t *policy)
Definition: policy.c:499
int policy_set_parent_soa_ttl(policy_t *policy, unsigned int parent_soa_ttl)
Definition: policy.c:1510
const char * policy_name(const policy_t *policy)
Definition: policy.c:813
int policy_set_denial_resalt(policy_t *policy, unsigned int denial_resalt)
Definition: policy.c:1299
const db_enum_t policy_enum_set_zone_soa_serial[]
Definition: policy.c:42
int policy_retrieve_zone_list(policy_t *policy)
Definition: policy.c:1111
unsigned int policy_keys_shared(const policy_t *policy)
Definition: policy.c:989
int policy_create(policy_t *policy)
Definition: policy.c:1561
int policy_set_denial_salt_last_change(policy_t *policy, unsigned int denial_salt_last_change)
Definition: policy.c:1373
int policy_list_copy(policy_list_t *policy_list, const policy_list_t *from_policy_list)
Definition: policy.c:2689
int policy_copy(policy_t *policy, const policy_t *policy_copy)
Definition: policy.c:547
int policy_set_denial_algorithm(policy_t *policy, unsigned int denial_algorithm)
Definition: policy.c:1309
int policy_set_parent_registration_delay(policy_t *policy, unsigned int parent_registration_delay)
Definition: policy.c:1480
int policy_set_zone_soa_serial_text(policy_t *policy, const char *zone_soa_serial)
Definition: policy.c:1463
int policy_from_result(policy_t *policy, const db_result_t *result)
Definition: policy.c:707
policy_list_t * policy_list_new_copy(const policy_list_t *from_policy_list)
Definition: policy.c:2635
const db_value_t * policy_id(const policy_t *policy)
Definition: policy.c:805
unsigned int policy_signatures_jitter(const policy_t *policy)
Definition: policy.c:845
policy_list_t * policy_list_new(const db_connection_t *connection)
Definition: policy.c:2621
int policy_list_object_store(policy_list_t *policy_list)
Definition: policy.c:2654
unsigned int policy_parent_registration_delay(const policy_t *policy)
Definition: policy.c:1045
int policy_set_denial_salt(policy_t *policy, const char *denial_salt_text)
Definition: policy.c:1351
int policy_list_get_by_clauses(policy_list_t *policy_list, const db_clause_list_t *clause_list)
Definition: policy.c:3096
int policy_set_parent_propagation_delay(policy_t *policy, unsigned int parent_propagation_delay)
Definition: policy.c:1490
int policy_set_denial_optout(policy_t *policy, unsigned int denial_optout)
Definition: policy.c:1279
policy_t * policy_list_get_next(policy_list_t *policy_list)
Definition: policy.c:3280
unsigned int policy_signatures_inception_offset(const policy_t *policy)
Definition: policy.c:853
policy_denial_type_t policy_denial_type(const policy_t *policy)
Definition: policy.c:893
int policy_set_signatures_max_zone_ttl(policy_t *policy, unsigned int signatures_max_zone_ttl)
Definition: policy.c:1256
int policy_set_signatures_jitter(policy_t *policy, unsigned int signatures_jitter)
Definition: policy.c:1206
int policy_set_description(policy_t *policy, const char *description_text)
Definition: policy.c:1164
int policy_set_keys_shared(policy_t *policy, unsigned int keys_shared)
Definition: policy.c:1413
unsigned int policy_parent_soa_ttl(const policy_t *policy)
Definition: policy.c:1069
int policy_get_by_id(policy_t *policy, const db_value_t *id)
Definition: policy.c:1987
int policy_list_get(policy_list_t *policy_list)
Definition: policy.c:3040
int policy_set_denial_salt_length(policy_t *policy, unsigned int denial_salt_length)
Definition: policy.c:1337
const char * policy_zone_soa_serial_text(const policy_t *policy)
Definition: policy.c:1029
int policy_set_signatures_validity_keyset(policy_t *policy, unsigned int signatures_validity_keyset)
Definition: policy.c:1246
int policy_set_signatures_validity_default(policy_t *policy, unsigned int signatures_validity_default)
Definition: policy.c:1226
int policy_delete(policy_t *policy)
Definition: policy.c:2571
unsigned int policy_denial_algorithm(const policy_t *policy)
Definition: policy.c:925
unsigned int policy_signatures_validity_default(const policy_t *policy)
Definition: policy.c:861
int policy_set_signatures_refresh(policy_t *policy, unsigned int signatures_refresh)
Definition: policy.c:1196
void policy_free(policy_t *policy)
Definition: policy.c:518
int policy_set_keys_ttl(policy_t *policy, unsigned int keys_ttl)
Definition: policy.c:1383
const char * policy_description(const policy_t *policy)
Definition: policy.c:821
const db_enum_t policy_enum_set_denial_type[]
Definition: policy.c:36
int policy_set_signatures_validity_denial(policy_t *policy, unsigned int signatures_validity_denial)
Definition: policy.c:1236
int policy_set_passthrough(policy_t *policy, unsigned int passthrough)
Definition: policy.c:1530
unsigned int policy_denial_resalt(const policy_t *policy)
Definition: policy.c:917
unsigned int policy_keys_publish_safety(const policy_t *policy)
Definition: policy.c:981
int policy_set_zone_soa_minimum(policy_t *policy, unsigned int zone_soa_minimum)
Definition: policy.c:1453
int policy_set_keys_publish_safety(policy_t *policy, unsigned int keys_publish_safety)
Definition: policy.c:1403
unsigned int policy_keys_retire_safety(const policy_t *policy)
Definition: policy.c:973
int policy_set_keys_retire_safety(policy_t *policy, unsigned int keys_retire_safety)
Definition: policy.c:1393
int policy_update(policy_t *policy)
Definition: policy.c:2110
unsigned int policy_signatures_validity_keyset(const policy_t *policy)
Definition: policy.c:877
int policy_set_zone_soa_ttl(policy_t *policy, unsigned int zone_soa_ttl)
Definition: policy.c:1443
@ POLICY_ZONE_SOA_SERIAL_COUNTER
Definition: policy.h:49
@ POLICY_ZONE_SOA_SERIAL_KEEP
Definition: policy.h:52
@ POLICY_ZONE_SOA_SERIAL_UNIXTIME
Definition: policy.h:51
@ POLICY_ZONE_SOA_SERIAL_INVALID
Definition: policy.h:48
@ POLICY_ZONE_SOA_SERIAL_DATECOUNTER
Definition: policy.h:50
enum policy_zone_soa_serial policy_zone_soa_serial_t
@ POLICY_DENIAL_TYPE_INVALID
Definition: policy.h:41
@ POLICY_DENIAL_TYPE_NSEC
Definition: policy.h:42
@ POLICY_DENIAL_TYPE_NSEC3
Definition: policy.h:43
enum policy_denial_type policy_denial_type_t
policy_key_list_t * policy_key_list_new_copy(const policy_key_list_t *from_policy_key_list)
Definition: policy_key.c:977
int policy_key_list_object_store(policy_key_list_t *policy_key_list)
Definition: policy_key.c:996
const policy_key_t * policy_key_list_begin(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1322
const db_value_t * policy_key_policy_id(const policy_key_t *policy_key)
Definition: policy_key.c:478
policy_key_list_t * policy_key_list_new(const db_connection_t *connection)
Definition: policy_key.c:963
const policy_key_t * policy_key_list_next(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1378
policy_key_t * policy_key_new_copy(const policy_key_t *policy_key)
Definition: policy_key.c:227
void policy_key_list_free(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1006
int policy_key_list_get_by_clauses(policy_key_list_t *policy_key_list, const db_clause_list_t *clause_list)
Definition: policy_key.c:1194
int value
Definition: db_enum.h:40
const char * text
Definition: db_enum.h:39
int object_store
Definition: hsm_key.h:441
hsm_key_t ** object_list
Definition: hsm_key.h:442
int object_list_first
Definition: hsm_key.h:445
size_t object_list_size
Definition: hsm_key.h:443
policy_key_t ** object_list
Definition: policy_key.h:328
size_t object_list_size
Definition: policy_key.h:329
db_result_list_t * result_list
Definition: policy.h:735
policy_t ** object_list
Definition: policy.h:739
int object_store
Definition: policy.h:738
db_object_t * dbo
Definition: policy.h:734
int associated_fetch
Definition: policy.h:743
size_t object_list_position
Definition: policy.h:741
size_t object_list_size
Definition: policy.h:740
policy_t * policy
Definition: policy.h:737
int object_list_first
Definition: policy.h:742
Definition: policy.h:60
unsigned int parent_ds_ttl
Definition: policy.h:97
unsigned int keys_purge_after
Definition: policy.h:90
unsigned int parent_registration_delay
Definition: policy.h:95
unsigned int signatures_resign
Definition: policy.h:69
unsigned int keys_publish_safety
Definition: policy.h:88
unsigned int zone_soa_minimum
Definition: policy.h:93
hsm_key_list_t * hsm_key_list
Definition: policy.h:102
char * name
Definition: policy.h:64
unsigned int parent_soa_ttl
Definition: policy.h:98
char * description
Definition: policy.h:68
unsigned int denial_iterations
Definition: policy.h:82
unsigned int parent_propagation_delay
Definition: policy.h:96
unsigned int keys_shared
Definition: policy.h:89
unsigned int zone_propagation_delay
Definition: policy.h:91
unsigned int zone_soa_ttl
Definition: policy.h:92
unsigned int denial_algorithm
Definition: policy.h:81
unsigned int denial_optout
Definition: policy.h:78
policy_denial_type_t denial_type
Definition: policy.h:77
unsigned int denial_resalt
Definition: policy.h:80
unsigned int signatures_validity_default
Definition: policy.h:73
unsigned int denial_salt_length
Definition: policy.h:83
unsigned int signatures_jitter
Definition: policy.h:71
unsigned int signatures_validity_denial
Definition: policy.h:74
unsigned int passthrough
Definition: policy.h:67
policy_key_list_t * policy_key_list
Definition: policy.h:100
zone_list_db_t * zone_list
Definition: policy.h:101
db_value_t id
Definition: policy.h:62
db_object_t * dbo
Definition: policy.h:61
unsigned int signatures_inception_offset
Definition: policy.h:72
char * denial_salt
Definition: policy.h:84
policy_zone_soa_serial_t zone_soa_serial
Definition: policy.h:94
unsigned int denial_salt_last_change
Definition: policy.h:85
unsigned int denial_ttl
Definition: policy.h:79
unsigned int keys_retire_safety
Definition: policy.h:87
unsigned int signatures_refresh
Definition: policy.h:70
db_value_t rev
Definition: policy.h:63
unsigned int parent_soa_minimum
Definition: policy.h:99
unsigned int signatures_max_zone_ttl
Definition: policy.h:76
unsigned int keys_ttl
Definition: policy.h:86
unsigned int signatures_validity_keyset
Definition: policy.h:75
int object_store
Definition: zone_db.h:471
size_t object_list_size
Definition: zone_db.h:473
int object_list_first
Definition: zone_db.h:475
zone_db_t ** object_list
Definition: zone_db.h:472
int zone_list_db_object_store(zone_list_db_t *zone_list)
Definition: zone_db.c:1979
zone_list_db_t * zone_list_db_new_copy(const zone_list_db_t *from_zone_list)
Definition: zone_db.c:1960
const db_value_t * zone_db_policy_id(const zone_db_t *zone)
Definition: zone_db.c:736
const zone_db_t * zone_list_db_begin(zone_list_db_t *zone_list)
Definition: zone_db.c:2547
zone_list_db_t * zone_list_db_new(const db_connection_t *connection)
Definition: zone_db.c:1946
int zone_list_db_get_by_clauses(zone_list_db_t *zone_list, const db_clause_list_t *clause_list)
Definition: zone_db.c:2419
db_clause_t * zone_db_policy_id_clause(db_clause_list_t *clause_list, const db_value_t *policy_id)
Definition: zone_db.c:1179
const zone_db_t * zone_list_db_next(zone_list_db_t *zone_list)
Definition: zone_db.c:2603
void zone_list_db_free(zone_list_db_t *zone_list)
Definition: zone_db.c:1989
zone_db_t * zone_db_new_copy(const zone_db_t *zone)
Definition: zone_db.c:306