OpenDNSSEC-enforcer 2.1.12
policy_key.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_key.h"
31#include "db_error.h"
32
33
34#include <string.h>
35
40 { NULL, 0 }
41};
42
48static db_object_t* __policy_key_new_object(const db_connection_t* connection) {
49 db_object_field_list_t* object_field_list;
50 db_object_field_t* object_field;
51 db_object_t* object;
52
53 if (!(object = db_object_new())
54 || db_object_set_connection(object, connection)
55 || db_object_set_table(object, "policyKey")
56 || db_object_set_primary_key_name(object, "id")
57 || !(object_field_list = db_object_field_list_new()))
58 {
59 db_object_free(object);
60 return NULL;
61 }
62
63 if (!(object_field = db_object_field_new())
64 || db_object_field_set_name(object_field, "id")
66 || db_object_field_list_add(object_field_list, object_field))
67 {
68 db_object_field_free(object_field);
69 db_object_field_list_free(object_field_list);
70 db_object_free(object);
71 return NULL;
72 }
73
74 if (!(object_field = db_object_field_new())
75 || db_object_field_set_name(object_field, "rev")
77 || db_object_field_list_add(object_field_list, object_field))
78 {
79 db_object_field_free(object_field);
80 db_object_field_list_free(object_field_list);
81 db_object_free(object);
82 return NULL;
83 }
84
85 if (!(object_field = db_object_field_new())
86 || db_object_field_set_name(object_field, "policyId")
88 || db_object_field_list_add(object_field_list, object_field))
89 {
90 db_object_field_free(object_field);
91 db_object_field_list_free(object_field_list);
92 db_object_free(object);
93 return NULL;
94 }
95
96 if (!(object_field = db_object_field_new())
97 || db_object_field_set_name(object_field, "role")
100 || db_object_field_list_add(object_field_list, object_field))
101 {
102 db_object_field_free(object_field);
103 db_object_field_list_free(object_field_list);
104 db_object_free(object);
105 return NULL;
106 }
107
108 if (!(object_field = db_object_field_new())
109 || db_object_field_set_name(object_field, "algorithm")
111 || db_object_field_list_add(object_field_list, object_field))
112 {
113 db_object_field_free(object_field);
114 db_object_field_list_free(object_field_list);
115 db_object_free(object);
116 return NULL;
117 }
118
119 if (!(object_field = db_object_field_new())
120 || db_object_field_set_name(object_field, "bits")
122 || db_object_field_list_add(object_field_list, object_field))
123 {
124 db_object_field_free(object_field);
125 db_object_field_list_free(object_field_list);
126 db_object_free(object);
127 return NULL;
128 }
129
130 if (!(object_field = db_object_field_new())
131 || db_object_field_set_name(object_field, "lifetime")
133 || db_object_field_list_add(object_field_list, object_field))
134 {
135 db_object_field_free(object_field);
136 db_object_field_list_free(object_field_list);
137 db_object_free(object);
138 return NULL;
139 }
140
141 if (!(object_field = db_object_field_new())
142 || db_object_field_set_name(object_field, "repository")
143 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
144 || db_object_field_list_add(object_field_list, object_field))
145 {
146 db_object_field_free(object_field);
147 db_object_field_list_free(object_field_list);
148 db_object_free(object);
149 return NULL;
150 }
151
152 if (!(object_field = db_object_field_new())
153 || db_object_field_set_name(object_field, "standby")
155 || db_object_field_list_add(object_field_list, object_field))
156 {
157 db_object_field_free(object_field);
158 db_object_field_list_free(object_field_list);
159 db_object_free(object);
160 return NULL;
161 }
162
163 if (!(object_field = db_object_field_new())
164 || db_object_field_set_name(object_field, "manualRollover")
166 || db_object_field_list_add(object_field_list, object_field))
167 {
168 db_object_field_free(object_field);
169 db_object_field_list_free(object_field_list);
170 db_object_free(object);
171 return NULL;
172 }
173
174 if (!(object_field = db_object_field_new())
175 || db_object_field_set_name(object_field, "rfc5011")
177 || db_object_field_list_add(object_field_list, object_field))
178 {
179 db_object_field_free(object_field);
180 db_object_field_list_free(object_field_list);
181 db_object_free(object);
182 return NULL;
183 }
184
185 if (!(object_field = db_object_field_new())
186 || db_object_field_set_name(object_field, "minimize")
188 || db_object_field_list_add(object_field_list, object_field))
189 {
190 db_object_field_free(object_field);
191 db_object_field_list_free(object_field_list);
192 db_object_free(object);
193 return NULL;
194 }
195
196 if (db_object_set_object_field_list(object, object_field_list)) {
197 db_object_field_list_free(object_field_list);
198 db_object_free(object);
199 return NULL;
200 }
201
202 return object;
203}
204
205/* POLICY KEY */
206
207
208
211 (policy_key_t*)calloc(1, sizeof(policy_key_t));
212
213 if (policy_key) {
214 if (!(policy_key->dbo = __policy_key_new_object(connection))) {
215 free(policy_key);
216 return NULL;
217 }
222 }
223
224 return policy_key;
225}
226
228 policy_key_t* new_policy_key;
229
230 if (!policy_key) {
231 return NULL;
232 }
233 if (!policy_key->dbo) {
234 return NULL;
235 }
236
237 if (!(new_policy_key = policy_key_new(db_object_connection(policy_key->dbo)))
238 || policy_key_copy(new_policy_key, policy_key))
239 {
240 policy_key_free(new_policy_key);
241 return NULL;
242 }
243 return new_policy_key;
244}
245
247 if (policy_key) {
248 if (policy_key->dbo) {
250 }
256 }
257 if (policy_key->repository) {
258 free(policy_key->repository);
259 }
260 free(policy_key);
261 }
262}
263
265 if (policy_key) {
272 }
276 policy_key->bits = 0;
277 policy_key->lifetime = 0;
278 if (policy_key->repository) {
279 free(policy_key->repository);
280 policy_key->repository = NULL;
281 }
282 policy_key->standby = 0;
284 policy_key->rfc5011 = 0;
285 policy_key->minimize = 0;
286 }
287}
288
290 char* repository_text = NULL;
291
292 if (!policy_key) {
293 return DB_ERROR_UNKNOWN;
294 }
295 if (!policy_key_copy) {
296 return DB_ERROR_UNKNOWN;
297 }
298
299 if (policy_key_copy->repository) {
300 if (!(repository_text = strdup(policy_key_copy->repository))) {
301 return DB_ERROR_UNKNOWN;
302 }
303 }
304 if (db_value_copy(&(policy_key->id), &(policy_key_copy->id))) {
305 if (repository_text) {
306 free(repository_text);
307 }
308 return DB_ERROR_UNKNOWN;
309 }
310 if (db_value_copy(&(policy_key->rev), &(policy_key_copy->rev))) {
311 if (repository_text) {
312 free(repository_text);
313 }
314 return DB_ERROR_UNKNOWN;
315 }
316 if (db_value_copy(&(policy_key->policy_id), &(policy_key_copy->policy_id))) {
317 if (repository_text) {
318 free(repository_text);
319 }
320 return DB_ERROR_UNKNOWN;
321 }
325 }
326 if (policy_key_copy->private_policy_id
327 && !(policy_key->private_policy_id = policy_new_copy(policy_key_copy->private_policy_id)))
328 {
329 if (repository_text) {
330 free(repository_text);
331 }
332 return DB_ERROR_UNKNOWN;
333 }
335 if (!policy_key_copy->private_policy_id
336 && policy_key_copy->associated_policy_id
337 && !(policy_key->private_policy_id = policy_new_copy(policy_key_copy->associated_policy_id)))
338 {
339 if (repository_text) {
340 free(repository_text);
341 }
342 return DB_ERROR_UNKNOWN;
343 }
348 if (policy_key->repository) {
349 free(policy_key->repository);
350 }
351 policy_key->repository = repository_text;
353 policy_key->manual_rollover = policy_key_copy->manual_rollover;
356 return DB_OK;
357}
358
359int policy_key_cmp(const policy_key_t* policy_key_a, const policy_key_t* policy_key_b) {
360 int ret;
361
362 if (!policy_key_a && !policy_key_b) {
363 return 0;
364 }
365 if (!policy_key_a && policy_key_b) {
366 return -1;
367 }
368 if (policy_key_a && !policy_key_b) {
369 return 1;
370 }
371
372 ret = 0;
373 db_value_cmp(&(policy_key_a->policy_id), &(policy_key_b->policy_id), &ret);
374 if (ret) {
375 return ret;
376 }
377
378 if (policy_key_a->role != policy_key_b->role) {
379 return policy_key_a->role < policy_key_b->role ? -1 : 1;
380 }
381
382 if (policy_key_a->algorithm != policy_key_b->algorithm) {
383 return policy_key_a->algorithm < policy_key_b->algorithm ? -1 : 1;
384 }
385
386 if (policy_key_a->bits != policy_key_b->bits) {
387 return policy_key_a->bits < policy_key_b->bits ? -1 : 1;
388 }
389
390 if (policy_key_a->lifetime != policy_key_b->lifetime) {
391 return policy_key_a->lifetime < policy_key_b->lifetime ? -1 : 1;
392 }
393
394 if (policy_key_a->repository && policy_key_b->repository) {
395 if ((ret = strcmp(policy_key_a->repository, policy_key_b->repository))) {
396 return ret;
397 }
398 }
399 else {
400 if (!policy_key_a->repository && policy_key_b->repository) {
401 return -1;
402 }
403 if (policy_key_a->repository && !policy_key_b->repository) {
404 return -1;
405 }
406 }
407
408 if (policy_key_a->standby != policy_key_b->standby) {
409 return policy_key_a->standby < policy_key_b->standby ? -1 : 1;
410 }
411
412 if (policy_key_a->manual_rollover != policy_key_b->manual_rollover) {
413 return policy_key_a->manual_rollover < policy_key_b->manual_rollover ? -1 : 1;
414 }
415
416 if (policy_key_a->rfc5011 != policy_key_b->rfc5011) {
417 return policy_key_a->rfc5011 < policy_key_b->rfc5011 ? -1 : 1;
418 }
419
420 if (policy_key_a->minimize != policy_key_b->minimize) {
421 return policy_key_a->minimize < policy_key_b->minimize ? -1 : 1;
422 }
423 return 0;
424}
425
427 const db_value_set_t* value_set;
428 int role;
429
430 if (!policy_key) {
431 return DB_ERROR_UNKNOWN;
432 }
433 if (!result) {
434 return DB_ERROR_UNKNOWN;
435 }
436
440 if (policy_key->repository) {
441 free(policy_key->repository);
442 }
443 policy_key->repository = NULL;
444 if (!(value_set = db_result_value_set(result))
445 || db_value_set_size(value_set) != 12
446 || db_value_copy(&(policy_key->id), db_value_set_at(value_set, 0))
447 || db_value_copy(&(policy_key->rev), db_value_set_at(value_set, 1))
458 {
459 return DB_ERROR_UNKNOWN;
460 }
461
464 }
465 else if (role == (policy_key_role_t)POLICY_KEY_ROLE_ZSK) {
467 }
468 else if (role == (policy_key_role_t)POLICY_KEY_ROLE_CSK) {
470 }
471 else {
472 return DB_ERROR_UNKNOWN;
473 }
474
475 return DB_OK;
476}
477
479 if (!policy_key) {
480 return NULL;
481 }
482
483 return &(policy_key->policy_id);
484}
485
487 if (!policy_key) {
489 }
490
491 return policy_key->role;
492}
493
495 const db_enum_t* enum_set = policy_key_enum_set_role;
496
497 if (!policy_key) {
498 return NULL;
499 }
500
501 while (enum_set->text) {
502 if (enum_set->value == policy_key->role) {
503 return enum_set->text;
504 }
505 enum_set++;
506 }
507 return NULL;
508}
509
511 if (!policy_key) {
512 return 0;
513 }
514
515 return policy_key->algorithm;
516}
517
519 if (!policy_key) {
520 return 0;
521 }
522
523 return policy_key->bits;
524}
525
527 if (!policy_key) {
528 return 0;
529 }
530
531 return policy_key->lifetime;
532}
533
535 if (!policy_key) {
536 return NULL;
537 }
538
539 return policy_key->repository;
540}
541
543 if (!policy_key) {
544 return -1;
545 }
546
547 return policy_key->standby;
548}
549
551 if (!policy_key) {
552 return 0;
553 }
554
556}
557
559 if (!policy_key) {
560 return 0;
561 }
562
563 return policy_key->rfc5011;
564}
565
567 if (!policy_key) {
568 return 0;
569 }
570
571 return policy_key->minimize;
572}
573
575 if (!policy_key) {
576 return DB_ERROR_UNKNOWN;
577 }
578 if (!policy_id) {
579 return DB_ERROR_UNKNOWN;
580 }
582 return DB_ERROR_UNKNOWN;
583 }
584
587 return DB_ERROR_UNKNOWN;
588 }
589
590 return DB_OK;
591}
592
594 if (!policy_key) {
595 return DB_ERROR_UNKNOWN;
596 }
597 if (role == POLICY_KEY_ROLE_INVALID) {
598 return DB_ERROR_UNKNOWN;
599 }
600
601 policy_key->role = role;
602
603 return DB_OK;
604}
605
606int policy_key_set_algorithm(policy_key_t* policy_key, unsigned int algorithm) {
607 if (!policy_key) {
608 return DB_ERROR_UNKNOWN;
609 }
610
611 if (algorithm > 255) {
612 return DB_ERROR_UNKNOWN;
613 }
614
615 policy_key->algorithm = algorithm;
616
617 return DB_OK;
618}
619
621 if (!policy_key) {
622 return DB_ERROR_UNKNOWN;
623 }
624
625 policy_key->bits = bits;
626
627 return DB_OK;
628}
629
630int policy_key_set_lifetime(policy_key_t* policy_key, unsigned int lifetime) {
631 if (!policy_key) {
632 return DB_ERROR_UNKNOWN;
633 }
634
635 policy_key->lifetime = lifetime;
636
637 return DB_OK;
638}
639
640int policy_key_set_repository(policy_key_t* policy_key, const char* repository_text) {
641 char* new_repository;
642
643 if (!policy_key) {
644 return DB_ERROR_UNKNOWN;
645 }
646 if (!repository_text) {
647 return DB_ERROR_UNKNOWN;
648 }
649
650 if (!(new_repository = strdup(repository_text))) {
651 return DB_ERROR_UNKNOWN;
652 }
653
654 if (policy_key->repository) {
655 free(policy_key->repository);
656 }
657 policy_key->repository = new_repository;
658
659 return DB_OK;
660}
661
662int policy_key_set_standby(policy_key_t* policy_key, unsigned int standby) {
663 if (!policy_key) {
664 return DB_ERROR_UNKNOWN;
665 }
666
667 policy_key->standby = standby;
668
669 return DB_OK;
670}
671
672int policy_key_set_manual_rollover(policy_key_t* policy_key, unsigned int manual_rollover) {
673 if (!policy_key) {
674 return DB_ERROR_UNKNOWN;
675 }
676
677 policy_key->manual_rollover = manual_rollover;
678
679 return DB_OK;
680}
681
682int policy_key_set_rfc5011(policy_key_t* policy_key, unsigned int rfc5011) {
683 if (!policy_key) {
684 return DB_ERROR_UNKNOWN;
685 }
686
687 policy_key->rfc5011 = rfc5011;
688
689 return DB_OK;
690}
691
692int policy_key_set_minimize(policy_key_t* policy_key, unsigned int minimize) {
693 if (!policy_key) {
694 return DB_ERROR_UNKNOWN;
695 }
696
697 policy_key->minimize = minimize;
698
699 return DB_OK;
700}
701
703 db_object_field_list_t* object_field_list;
704 db_object_field_t* object_field;
705 db_value_set_t* value_set;
706 int ret;
707
708 if (!policy_key) {
709 return DB_ERROR_UNKNOWN;
710 }
711 if (!policy_key->dbo) {
712 return DB_ERROR_UNKNOWN;
713 }
714 if (!db_value_not_empty(&(policy_key->id))) {
715 return DB_ERROR_UNKNOWN;
716 }
718 return DB_ERROR_UNKNOWN;
719 }
721 return DB_ERROR_UNKNOWN;
722 }
723 if (!policy_key->repository) {
724 return DB_ERROR_UNKNOWN;
725 }
726 /* TODO: validate content more */
727
728 if (!(object_field_list = db_object_field_list_new())) {
729 return DB_ERROR_UNKNOWN;
730 }
731
732 if (!(object_field = db_object_field_new())
733 || db_object_field_set_name(object_field, "policyId")
734 || db_object_field_set_type(object_field, DB_TYPE_ANY)
735 || db_object_field_list_add(object_field_list, object_field))
736 {
737 db_object_field_free(object_field);
738 db_object_field_list_free(object_field_list);
739 return DB_ERROR_UNKNOWN;
740 }
741
742 if (!(object_field = db_object_field_new())
743 || db_object_field_set_name(object_field, "role")
744 || db_object_field_set_type(object_field, DB_TYPE_ENUM)
746 || db_object_field_list_add(object_field_list, object_field))
747 {
748 db_object_field_free(object_field);
749 db_object_field_list_free(object_field_list);
750 return DB_ERROR_UNKNOWN;
751 }
752
753 if (!(object_field = db_object_field_new())
754 || db_object_field_set_name(object_field, "algorithm")
756 || db_object_field_list_add(object_field_list, object_field))
757 {
758 db_object_field_free(object_field);
759 db_object_field_list_free(object_field_list);
760 return DB_ERROR_UNKNOWN;
761 }
762
763 if (!(object_field = db_object_field_new())
764 || db_object_field_set_name(object_field, "bits")
766 || db_object_field_list_add(object_field_list, object_field))
767 {
768 db_object_field_free(object_field);
769 db_object_field_list_free(object_field_list);
770 return DB_ERROR_UNKNOWN;
771 }
772
773 if (!(object_field = db_object_field_new())
774 || db_object_field_set_name(object_field, "lifetime")
776 || db_object_field_list_add(object_field_list, object_field))
777 {
778 db_object_field_free(object_field);
779 db_object_field_list_free(object_field_list);
780 return DB_ERROR_UNKNOWN;
781 }
782
783 if (!(object_field = db_object_field_new())
784 || db_object_field_set_name(object_field, "repository")
785 || db_object_field_set_type(object_field, DB_TYPE_TEXT)
786 || db_object_field_list_add(object_field_list, object_field))
787 {
788 db_object_field_free(object_field);
789 db_object_field_list_free(object_field_list);
790 return DB_ERROR_UNKNOWN;
791 }
792
793 if (!(object_field = db_object_field_new())
794 || db_object_field_set_name(object_field, "standby")
796 || db_object_field_list_add(object_field_list, object_field))
797 {
798 db_object_field_free(object_field);
799 db_object_field_list_free(object_field_list);
800 return DB_ERROR_UNKNOWN;
801 }
802
803 if (!(object_field = db_object_field_new())
804 || db_object_field_set_name(object_field, "manualRollover")
806 || db_object_field_list_add(object_field_list, object_field))
807 {
808 db_object_field_free(object_field);
809 db_object_field_list_free(object_field_list);
810 return DB_ERROR_UNKNOWN;
811 }
812
813 if (!(object_field = db_object_field_new())
814 || db_object_field_set_name(object_field, "rfc5011")
816 || db_object_field_list_add(object_field_list, object_field))
817 {
818 db_object_field_free(object_field);
819 db_object_field_list_free(object_field_list);
820 return DB_ERROR_UNKNOWN;
821 }
822
823 if (!(object_field = db_object_field_new())
824 || db_object_field_set_name(object_field, "minimize")
826 || db_object_field_list_add(object_field_list, object_field))
827 {
828 db_object_field_free(object_field);
829 db_object_field_list_free(object_field_list);
830 return DB_ERROR_UNKNOWN;
831 }
832
833 if (!(value_set = db_value_set_new(10))) {
834 db_object_field_list_free(object_field_list);
835 return DB_ERROR_UNKNOWN;
836 }
837
838 if (db_value_copy(db_value_set_get(value_set, 0), &(policy_key->policy_id))
848 {
849 db_value_set_free(value_set);
850 db_object_field_list_free(object_field_list);
851 return DB_ERROR_UNKNOWN;
852 }
853
854 ret = db_object_create(policy_key->dbo, object_field_list, value_set);
855 db_value_set_free(value_set);
856 db_object_field_list_free(object_field_list);
857 return ret;
858}
859
861 db_clause_list_t* clause_list;
862 db_clause_t* clause;
863 db_result_list_t* result_list;
864 const db_result_t* result;
865
866 if (!policy_key) {
867 return DB_ERROR_UNKNOWN;
868 }
869 if (!policy_key->dbo) {
870 return DB_ERROR_UNKNOWN;
871 }
872 if (!id) {
873 return DB_ERROR_UNKNOWN;
874 }
875 if (db_value_not_empty(id)) {
876 return DB_ERROR_UNKNOWN;
877 }
878
879 if (!(clause_list = db_clause_list_new())) {
880 return DB_ERROR_UNKNOWN;
881 }
882 if (!(clause = db_clause_new())
883 || db_clause_set_field(clause, "id")
885 || db_value_copy(db_clause_get_value(clause), id)
886 || db_clause_list_add(clause_list, clause))
887 {
888 db_clause_free(clause);
889 db_clause_list_free(clause_list);
890 return DB_ERROR_UNKNOWN;
891 }
892
893 result_list = db_object_read(policy_key->dbo, NULL, clause_list);
894 db_clause_list_free(clause_list);
895
896 if (result_list) {
897 result = db_result_list_next(result_list);
898 if (result) {
899 if (policy_key_from_result(policy_key, result)) {
900 db_result_list_free(result_list);
901 return DB_ERROR_UNKNOWN;
902 }
903
904 db_result_list_free(result_list);
905 return DB_OK;
906 }
907 }
908
909 db_result_list_free(result_list);
910 return DB_ERROR_UNKNOWN;
911}
912
914 db_clause_list_t* clause_list;
915 db_clause_t* clause;
916 int ret;
917
918 if (!policy_key) {
919 return DB_ERROR_UNKNOWN;
920 }
921 if (!policy_key->dbo) {
922 return DB_ERROR_UNKNOWN;
923 }
925 return DB_ERROR_UNKNOWN;
926 }
927
928 if (!(clause_list = db_clause_list_new())) {
929 return DB_ERROR_UNKNOWN;
930 }
931
932 if (!(clause = db_clause_new())
933 || db_clause_set_field(clause, "id")
936 || db_clause_list_add(clause_list, clause))
937 {
938 db_clause_free(clause);
939 db_clause_list_free(clause_list);
940 return DB_ERROR_UNKNOWN;
941 }
942
943 if (!(clause = db_clause_new())
944 || db_clause_set_field(clause, "rev")
947 || db_clause_list_add(clause_list, clause))
948 {
949 db_clause_free(clause);
950 db_clause_list_free(clause_list);
951 return DB_ERROR_UNKNOWN;
952 }
953
954 ret = db_object_delete(policy_key->dbo, clause_list);
955 db_clause_list_free(clause_list);
956 return ret;
957}
958
959/* POLICY KEY LIST */
960
961
962
965 (policy_key_list_t*)calloc(1, sizeof(policy_key_list_t));
966
967 if (policy_key_list) {
968 if (!(policy_key_list->dbo = __policy_key_new_object(connection))) {
969 free(policy_key_list);
970 return NULL;
971 }
972 }
973
974 return policy_key_list;
975}
976
979
980 if (!from_policy_key_list) {
981 return NULL;
982 }
983 if (!from_policy_key_list->dbo) {
984 return NULL;
985 }
986
987 if (!(policy_key_list = policy_key_list_new(db_object_connection(from_policy_key_list->dbo)))
988 || policy_key_list_copy(policy_key_list, from_policy_key_list))
989 {
991 return NULL;
992 }
993 return policy_key_list;
994}
995
997 if (!policy_key_list) {
998 return DB_ERROR_UNKNOWN;
999 }
1000
1002
1003 return DB_OK;
1004}
1005
1007 size_t i;
1008
1009 if (policy_key_list) {
1010 if (policy_key_list->dbo) {
1012 }
1015 }
1018 }
1019 for (i = 0; i < policy_key_list->object_list_size; i++) {
1020 if (policy_key_list->object_list[i]) {
1022 }
1023 }
1026 }
1029 }
1030 free(policy_key_list);
1031 }
1032}
1033
1035 size_t i;
1036
1037 if (!policy_key_list) {
1038 return DB_ERROR_UNKNOWN;
1039 }
1040 if (!from_policy_key_list) {
1041 return DB_ERROR_UNKNOWN;
1042 }
1043 if (from_policy_key_list->object_list && !from_policy_key_list->object_list_size) {
1044 return DB_ERROR_UNKNOWN;
1045 }
1046
1050 }
1051 if (from_policy_key_list->result_list
1052 && !(policy_key_list->result_list = db_result_list_new_copy(from_policy_key_list->result_list)))
1053 {
1054 return DB_ERROR_UNKNOWN;
1055 }
1056
1057 policy_key_list->object_store = from_policy_key_list->object_store;
1058 for (i = 0; i < policy_key_list->object_list_size; i++) {
1059 if (policy_key_list->object_list[i]) {
1061 }
1062 }
1067 }
1068 if (from_policy_key_list->object_list) {
1069 if (!(policy_key_list->object_list = (policy_key_t**)calloc(from_policy_key_list->object_list_size, sizeof(policy_key_t*)))) {
1070 return DB_ERROR_UNKNOWN;
1071 }
1072 policy_key_list->object_list_size = from_policy_key_list->object_list_size;
1073 for (i = 0; i < from_policy_key_list->object_list_size; i++) {
1074 if (!from_policy_key_list->object_list[i]) {
1075 continue;
1076 }
1077 if (!(policy_key_list->object_list[i] = policy_key_new_copy(from_policy_key_list->object_list[i]))) {
1078 return DB_ERROR_UNKNOWN;
1079 }
1080 }
1081 }
1084 policy_key_list->associated_fetch = from_policy_key_list->associated_fetch;
1085
1086 if (from_policy_key_list->policy_id_list
1087 && !(policy_key_list->policy_id_list = policy_list_new_copy(from_policy_key_list->policy_id_list)))
1088 {
1089 return DB_ERROR_UNKNOWN;
1090 }
1091
1092 return DB_OK;
1093}
1094
1095static int policy_key_list_get_associated(policy_key_list_t* policy_key_list) {
1096 const db_clause_t* clause_walk;
1097 const policy_t* policy_policy_id;
1098 int cmp;
1099 size_t i;
1100 db_clause_list_t* clause_list;
1101 db_clause_t* clause;
1102 const policy_key_t* policy_key;
1103
1104 if (!policy_key_list) {
1105 return DB_ERROR_UNKNOWN;
1106 }
1107 if (!policy_key_list->dbo) {
1108 return DB_ERROR_UNKNOWN;
1109 }
1111 return DB_ERROR_UNKNOWN;
1112 }
1114 return DB_ERROR_UNKNOWN;
1115 }
1117 return DB_ERROR_UNKNOWN;
1118 }
1119
1123 }
1124
1125 if (!(clause_list = db_clause_list_new())) {
1126 return DB_ERROR_UNKNOWN;
1127 }
1129 while (policy_key) {
1130 cmp = 1;
1131 clause_walk = db_clause_list_begin(clause_list);
1132 while (clause_walk) {
1133 if (db_value_cmp(db_clause_value(clause_walk), policy_key_policy_id(policy_key), &cmp)) {
1134 db_clause_list_free(clause_list);
1135 return DB_ERROR_UNKNOWN;
1136 }
1137 if (!cmp) {
1138 break;
1139 }
1140 clause_walk = db_clause_next(clause_walk);
1141 }
1142 if (cmp) {
1143 if (!(clause = db_clause_new())
1144 || db_clause_set_field(clause, "id")
1148 || db_clause_list_add(clause_list, clause))
1149 {
1150 db_clause_free(clause);
1151 db_clause_list_free(clause_list);
1152 return DB_ERROR_UNKNOWN;
1153 }
1154 }
1155
1157 }
1158
1162 {
1166 }
1167 db_clause_list_free(clause_list);
1168 return DB_ERROR_UNKNOWN;
1169 }
1170 db_clause_list_free(clause_list);
1171
1172 for (i = 0; i < policy_key_list->object_list_size; i++) {
1173 if (!(policy_key_list->object_list[i])) {
1174 return DB_ERROR_UNKNOWN;
1175 }
1176
1178 while (policy_policy_id) {
1179 if (db_value_cmp(policy_key_policy_id(policy_key_list->object_list[i]), policy_id(policy_policy_id), &cmp)) {
1180 return DB_ERROR_UNKNOWN;
1181 }
1182 if (!cmp) {
1183 policy_key_list->object_list[i]->associated_policy_id = policy_policy_id;
1184 }
1185
1186 policy_policy_id = policy_list_next(policy_key_list->policy_id_list);
1187 }
1188 }
1189
1191 return DB_OK;
1192}
1193
1195 size_t i;
1196
1197 if (!policy_key_list) {
1198 return DB_ERROR_UNKNOWN;
1199 }
1200 if (!clause_list) {
1201 return DB_ERROR_UNKNOWN;
1202 }
1203 if (!policy_key_list->dbo) {
1204 return DB_ERROR_UNKNOWN;
1205 }
1206
1209 }
1211 for (i = 0; i < policy_key_list->object_list_size; i++) {
1212 if (policy_key_list->object_list[i]) {
1214 }
1215 }
1218 }
1222 }
1223 if (!(policy_key_list->result_list = db_object_read(policy_key_list->dbo, NULL, clause_list))
1225 {
1226 return DB_ERROR_UNKNOWN;
1227 }
1229 && policy_key_list_get_associated(policy_key_list))
1230 {
1231 return DB_ERROR_UNKNOWN;
1232 }
1233 return DB_OK;
1234}
1235
1237 db_clause_list_t* clause_list;
1238 db_clause_t* clause;
1239 size_t i;
1240
1241 if (!policy_key_list) {
1242 return DB_ERROR_UNKNOWN;
1243 }
1244 if (!policy_key_list->dbo) {
1245 return DB_ERROR_UNKNOWN;
1246 }
1247 if (!policy_id) {
1248 return DB_ERROR_UNKNOWN;
1249 }
1251 return DB_ERROR_UNKNOWN;
1252 }
1253
1254 if (!(clause_list = db_clause_list_new())) {
1255 return DB_ERROR_UNKNOWN;
1256 }
1257 if (!(clause = db_clause_new())
1258 || db_clause_set_field(clause, "policyId")
1261 || db_clause_list_add(clause_list, clause))
1262 {
1263 db_clause_free(clause);
1264 db_clause_list_free(clause_list);
1265 return DB_ERROR_UNKNOWN;
1266 }
1267
1270 }
1272 for (i = 0; i < policy_key_list->object_list_size; i++) {
1273 if (policy_key_list->object_list[i]) {
1275 }
1276 }
1279 }
1283 }
1284 if (!(policy_key_list->result_list = db_object_read(policy_key_list->dbo, NULL, clause_list))
1286 {
1287 db_clause_list_free(clause_list);
1288 return DB_ERROR_UNKNOWN;
1289 }
1290 db_clause_list_free(clause_list);
1292 && policy_key_list_get_associated(policy_key_list))
1293 {
1294 return DB_ERROR_UNKNOWN;
1295 }
1296 return DB_OK;
1297}
1298
1301
1302 if (!connection) {
1303 return NULL;
1304 }
1305 if (!policy_id) {
1306 return NULL;
1307 }
1309 return NULL;
1310 }
1311
1312 if (!(policy_key_list = policy_key_list_new(connection))
1314 {
1316 return NULL;
1317 }
1318
1319 return policy_key_list;
1320}
1321
1323 const db_result_t* result;
1324
1325 if (!policy_key_list) {
1326 return NULL;
1327 }
1328
1332 return NULL;
1333 }
1335 return NULL;
1336 }
1338 return NULL;
1339 }
1341 }
1342 if (!(policy_key_list->object_list[0])) {
1344 return NULL;
1345 }
1347 return NULL;
1348 }
1350 return NULL;
1351 }
1353 return NULL;
1354 }
1355 }
1357 return policy_key_list->object_list[0];
1358 }
1359
1361 return NULL;
1362 }
1363
1365 return NULL;
1366 }
1369 return NULL;
1370 }
1371 }
1373 return NULL;
1374 }
1376}
1377
1379 const db_result_t* result;
1380
1381 if (!policy_key_list) {
1382 return NULL;
1383 }
1384
1388 return NULL;
1389 }
1391 return NULL;
1392 }
1394 return NULL;
1395 }
1398 }
1402 }
1403 else {
1405 }
1407 return NULL;
1408 }
1411 return NULL;
1412 }
1414 return NULL;
1415 }
1417 return NULL;
1418 }
1420 return NULL;
1421 }
1422 }
1424 }
1425
1427 return NULL;
1428 }
1429
1431 return NULL;
1432 }
1435 return NULL;
1436 }
1437 }
1439 return NULL;
1440 }
1442}
1443
1445 const db_result_t* result;
1447
1448 if (!policy_key_list) {
1449 return NULL;
1450 }
1451
1454 return NULL;
1455 }
1458 return NULL;
1459 }
1460 return policy_key;
1461 }
1462
1464 return NULL;
1465 }
1466
1468 return NULL;
1469 }
1471 return NULL;
1472 }
1473 if (policy_key_from_result(policy_key, result)) {
1475 return NULL;
1476 }
1477 return policy_key;
1478}
1479
1481 if (!policy_key_list) {
1482 return 0;
1483 }
1484
1487 {
1489 }
1490
1492 return 0;
1493 }
1494
1496}
1497
1499 db_clause_list_t* clause_list;
1500 db_clause_t* clause;
1501 db_result_list_t* result_list;
1502 const db_result_t* result;
1503
1504 if (!policy_key) {
1505 return DB_ERROR_UNKNOWN;
1506 }
1507 if (!policy_key->dbo) {
1508 return DB_ERROR_UNKNOWN;
1509 }
1510 if (!policyid || !role) {
1511 return DB_ERROR_UNKNOWN;
1512 }
1513
1514 if (!(clause_list = db_clause_list_new())) {
1515 return DB_ERROR_UNKNOWN;
1516 }
1517 if (!(clause = db_clause_new())
1518 || db_clause_set_field(clause, "policyId")
1521 || db_value_copy(db_clause_get_value(clause), policyid)
1522 || db_clause_list_add(clause_list, clause))
1523 {
1524 db_clause_free(clause);
1525 db_clause_list_free(clause_list);
1526 return DB_ERROR_UNKNOWN;
1527 }
1528
1529 if (!(clause = db_clause_new())
1530 || db_clause_set_field(clause, "role")
1534 || db_clause_list_add(clause_list, clause))
1535 {
1536 db_clause_free(clause);
1537 db_clause_list_free(clause_list);
1538 return DB_ERROR_UNKNOWN;
1539 }
1540
1541
1542 result_list = db_object_read(policy_key->dbo, NULL, clause_list);
1543 db_clause_list_free(clause_list);
1544
1545 if (result_list) {
1546 result = db_result_list_next(result_list);
1547 if (result) {
1548 if (policy_key_from_result(policy_key, result)) {
1549 db_result_list_free(result_list);
1550 return DB_ERROR_UNKNOWN;
1551 }
1552
1553 db_result_list_free(result_list);
1554 return DB_OK;
1555 }
1556 }
1557
1558 db_result_list_free(result_list);
1559 return DB_ERROR_UNKNOWN;
1560}
1561
1564 if (!connection || !policyid || !role)
1565 return NULL;
1566
1567 if (!(policy_key = policy_key_new(connection))
1568 || policy_key_get_by_policyid_and_role(policy_key, policyid, role)) {
1570 return NULL;
1571 }
1572 return policy_key;
1573}
const db_value_t * db_clause_value(const db_clause_t *clause)
Definition: db_clause.c:85
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
const db_clause_t * db_clause_next(const db_clause_t *clause)
Definition: db_clause.c:179
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
const db_clause_t * db_clause_list_begin(const db_clause_list_t *clause_list)
Definition: db_clause.c:255
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_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
@ DB_TYPE_ANY
Definition: db_type.h:90
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
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
const policy_t * policy_list_next(policy_list_t *policy_list)
Definition: policy.c:3214
policy_t * policy_new_copy(const policy_t *policy)
Definition: policy.c:499
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
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
int policy_list_get_by_clauses(policy_list_t *policy_list, const db_clause_list_t *clause_list)
Definition: policy.c:3096
void policy_free(policy_t *policy)
Definition: policy.c:518
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_set_minimize(policy_key_t *policy_key, unsigned int minimize)
Definition: policy_key.c:692
size_t policy_key_list_size(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1480
void policy_key_reset(policy_key_t *policy_key)
Definition: policy_key.c:264
policy_key_role_t policy_key_role(const policy_key_t *policy_key)
Definition: policy_key.c:486
int policy_key_set_role(policy_key_t *policy_key, policy_key_role_t role)
Definition: policy_key.c:593
int policy_key_set_standby(policy_key_t *policy_key, unsigned int standby)
Definition: policy_key.c:662
int policy_key_list_object_store(policy_key_list_t *policy_key_list)
Definition: policy_key.c:996
const db_enum_t policy_key_enum_set_role[]
Definition: policy_key.c:36
int policy_key_set_bits(policy_key_t *policy_key, unsigned int bits)
Definition: policy_key.c:620
policy_key_t * policy_key_new_get_by_policyid_and_role(const db_connection_t *connection, const db_value_t *policyid, const policy_key_role_t role)
Definition: policy_key.c:1562
unsigned int policy_key_minimize(const policy_key_t *policy_key)
Definition: policy_key.c:566
unsigned int policy_key_lifetime(const policy_key_t *policy_key)
Definition: policy_key.c:526
policy_key_t * policy_key_new(const db_connection_t *connection)
Definition: policy_key.c:209
int policy_key_set_manual_rollover(policy_key_t *policy_key, unsigned int manual_rollover)
Definition: policy_key.c:672
int policy_key_get_by_policyid_and_role(policy_key_t *policy_key, const db_value_t *policyid, const policy_key_role_t role)
Definition: policy_key.c:1498
const policy_key_t * policy_key_list_begin(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1322
unsigned int policy_key_manual_rollover(const policy_key_t *policy_key)
Definition: policy_key.c:550
int policy_key_copy(policy_key_t *policy_key, const policy_key_t *policy_key_copy)
Definition: policy_key.c:289
int policy_key_cmp(const policy_key_t *policy_key_a, const policy_key_t *policy_key_b)
Definition: policy_key.c:359
int policy_key_delete(policy_key_t *policy_key)
Definition: policy_key.c:913
policy_key_list_t * policy_key_list_new_get_by_policy_id(const db_connection_t *connection, const db_value_t *policy_id)
Definition: policy_key.c:1299
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
int policy_key_set_rfc5011(policy_key_t *policy_key, unsigned int rfc5011)
Definition: policy_key.c:682
policy_key_t * policy_key_new_copy(const policy_key_t *policy_key)
Definition: policy_key.c:227
int policy_key_set_algorithm(policy_key_t *policy_key, unsigned int algorithm)
Definition: policy_key.c:606
int policy_key_get_by_id(policy_key_t *policy_key, const db_value_t *id)
Definition: policy_key.c:860
int policy_key_set_lifetime(policy_key_t *policy_key, unsigned int lifetime)
Definition: policy_key.c:630
const char * policy_key_repository(const policy_key_t *policy_key)
Definition: policy_key.c:534
void policy_key_list_free(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1006
const char * policy_key_role_text(const policy_key_t *policy_key)
Definition: policy_key.c:494
void policy_key_free(policy_key_t *policy_key)
Definition: policy_key.c:246
int policy_key_list_copy(policy_key_list_t *policy_key_list, const policy_key_list_t *from_policy_key_list)
Definition: policy_key.c:1034
int policy_key_set_policy_id(policy_key_t *policy_key, const db_value_t *policy_id)
Definition: policy_key.c:574
policy_key_t * policy_key_list_get_next(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1444
int policy_key_from_result(policy_key_t *policy_key, const db_result_t *result)
Definition: policy_key.c:426
unsigned int policy_key_algorithm(const policy_key_t *policy_key)
Definition: policy_key.c:510
int policy_key_set_repository(policy_key_t *policy_key, const char *repository_text)
Definition: policy_key.c:640
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 policy_key_create(policy_key_t *policy_key)
Definition: policy_key.c:702
unsigned int policy_key_rfc5011(const policy_key_t *policy_key)
Definition: policy_key.c:558
unsigned int policy_key_bits(const policy_key_t *policy_key)
Definition: policy_key.c:518
int policy_key_standby(const policy_key_t *policy_key)
Definition: policy_key.c:542
int policy_key_list_get_by_policy_id(policy_key_list_t *policy_key_list, const db_value_t *policy_id)
Definition: policy_key.c:1236
@ POLICY_KEY_ROLE_KSK
Definition: policy_key.h:42
@ POLICY_KEY_ROLE_CSK
Definition: policy_key.h:44
@ POLICY_KEY_ROLE_ZSK
Definition: policy_key.h:43
@ POLICY_KEY_ROLE_INVALID
Definition: policy_key.h:41
enum policy_key_role policy_key_role_t
int value
Definition: db_enum.h:40
const char * text
Definition: db_enum.h:39
policy_key_t ** object_list
Definition: policy_key.h:328
policy_key_t * policy_key
Definition: policy_key.h:326
db_result_list_t * result_list
Definition: policy_key.h:324
size_t object_list_position
Definition: policy_key.h:330
size_t object_list_size
Definition: policy_key.h:329
policy_list_t * policy_id_list
Definition: policy_key.h:333
db_object_t * dbo
Definition: policy_key.h:323
unsigned int standby
Definition: policy_key.h:66
const policy_t * associated_policy_id
Definition: policy_key.h:59
db_value_t policy_id
Definition: policy_key.h:58
unsigned int rfc5011
Definition: policy_key.h:68
policy_key_role_t role
Definition: policy_key.h:61
db_value_t rev
Definition: policy_key.h:57
policy_t * private_policy_id
Definition: policy_key.h:60
unsigned int minimize
Definition: policy_key.h:69
db_value_t id
Definition: policy_key.h:56
unsigned int bits
Definition: policy_key.h:63
unsigned int lifetime
Definition: policy_key.h:64
db_object_t * dbo
Definition: policy_key.h:55
unsigned int algorithm
Definition: policy_key.h:62
char * repository
Definition: policy_key.h:65
unsigned int manual_rollover
Definition: policy_key.h:67
Definition: policy.h:60