OpenDNSSEC-enforcer  2.0.4
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 
48 static 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")
87  || db_object_field_set_type(object_field, DB_TYPE_ANY)
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")
98  || db_object_field_set_type(object_field, DB_TYPE_ENUM)
99  || db_object_field_set_enum_set(object_field, policy_key_enum_set_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")
110  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
121  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
132  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
154  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
165  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
176  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
187  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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  }
218  db_value_reset(&(policy_key->id));
219  db_value_reset(&(policy_key->rev));
220  db_value_reset(&(policy_key->policy_id));
221  policy_key->role = POLICY_KEY_ROLE_INVALID;
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) {
249  db_object_free(policy_key->dbo);
250  }
251  db_value_reset(&(policy_key->id));
252  db_value_reset(&(policy_key->rev));
253  db_value_reset(&(policy_key->policy_id));
254  if (policy_key->private_policy_id) {
255  policy_free(policy_key->private_policy_id);
256  }
257  if (policy_key->repository) {
258  free(policy_key->repository);
259  }
260  free(policy_key);
261  }
262 }
263 
265  if (policy_key) {
266  db_value_reset(&(policy_key->id));
267  db_value_reset(&(policy_key->rev));
268  db_value_reset(&(policy_key->policy_id));
269  if (policy_key->private_policy_id) {
270  policy_free(policy_key->private_policy_id);
271  policy_key->private_policy_id = NULL;
272  }
273  policy_key->associated_policy_id = NULL;
274  policy_key->role = POLICY_KEY_ROLE_INVALID;
275  policy_key->algorithm = 0;
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;
283  policy_key->manual_rollover = 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  }
322  if (policy_key->private_policy_id) {
323  policy_free(policy_key->private_policy_id);
324  policy_key->private_policy_id = NULL;
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  }
334  policy_key->associated_policy_id = NULL;
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  }
344  policy_key->role = policy_key_copy->role;
345  policy_key->algorithm = policy_key_copy->algorithm;
346  policy_key->bits = policy_key_copy->bits;
347  policy_key->lifetime = policy_key_copy->lifetime;
348  if (policy_key->repository) {
349  free(policy_key->repository);
350  }
351  policy_key->repository = repository_text;
352  policy_key->standby = policy_key_copy->standby;
353  policy_key->manual_rollover = policy_key_copy->manual_rollover;
354  policy_key->rfc5011 = policy_key_copy->rfc5011;
355  policy_key->minimize = policy_key_copy->minimize;
356  return DB_OK;
357 }
358 
359 int 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 
437  db_value_reset(&(policy_key->id));
438  db_value_reset(&(policy_key->rev));
439  db_value_reset(&(policy_key->policy_id));
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))
448  || db_value_copy(&(policy_key->policy_id), db_value_set_at(value_set, 2))
449  || db_value_to_enum_value(db_value_set_at(value_set, 3), &role, policy_key_enum_set_role)
450  || db_value_to_uint32(db_value_set_at(value_set, 4), &(policy_key->algorithm))
451  || db_value_to_uint32(db_value_set_at(value_set, 5), &(policy_key->bits))
452  || db_value_to_uint32(db_value_set_at(value_set, 6), &(policy_key->lifetime))
453  || db_value_to_text(db_value_set_at(value_set, 7), &(policy_key->repository))
454  || db_value_to_uint32(db_value_set_at(value_set, 8), &(policy_key->standby))
455  || db_value_to_uint32(db_value_set_at(value_set, 9), &(policy_key->manual_rollover))
456  || db_value_to_uint32(db_value_set_at(value_set, 10), &(policy_key->rfc5011))
457  || db_value_to_uint32(db_value_set_at(value_set, 11), &(policy_key->minimize)))
458  {
459  return DB_ERROR_UNKNOWN;
460  }
461 
462  if (role == (policy_key_role_t)POLICY_KEY_ROLE_KSK) {
463  policy_key->role = POLICY_KEY_ROLE_KSK;
464  }
465  else if (role == (policy_key_role_t)POLICY_KEY_ROLE_ZSK) {
466  policy_key->role = POLICY_KEY_ROLE_ZSK;
467  }
468  else if (role == (policy_key_role_t)POLICY_KEY_ROLE_CSK) {
469  policy_key->role = 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 
555  return policy_key->manual_rollover;
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  }
581  if (db_value_not_empty(policy_id)) {
582  return DB_ERROR_UNKNOWN;
583  }
584 
585  db_value_reset(&(policy_key->policy_id));
586  if (db_value_copy(&(policy_key->policy_id), policy_id)) {
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 
606 int 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 
620 int policy_key_set_bits(policy_key_t* policy_key, unsigned int bits) {
621  if (!policy_key) {
622  return DB_ERROR_UNKNOWN;
623  }
624 
625  policy_key->bits = bits;
626 
627  return DB_OK;
628 }
629 
630 int 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 
640 int 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 
662 int 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 
672 int 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 
682 int 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 
692 int 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  }
717  if (!db_value_not_empty(&(policy_key->rev))) {
718  return DB_ERROR_UNKNOWN;
719  }
720  if (db_value_not_empty(&(policy_key->policy_id))) {
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)
745  || db_object_field_set_enum_set(object_field, policy_key_enum_set_role)
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")
755  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
765  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
775  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
795  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
805  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
815  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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")
825  || db_object_field_set_type(object_field, DB_TYPE_UINT32)
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))
839  || db_value_from_enum_value(db_value_set_get(value_set, 1), policy_key->role, policy_key_enum_set_role)
840  || db_value_from_uint32(db_value_set_get(value_set, 2), policy_key->algorithm)
841  || db_value_from_uint32(db_value_set_get(value_set, 3), policy_key->bits)
842  || db_value_from_uint32(db_value_set_get(value_set, 4), policy_key->lifetime)
843  || db_value_from_text(db_value_set_get(value_set, 5), policy_key->repository)
844  || db_value_from_uint32(db_value_set_get(value_set, 6), policy_key->standby)
845  || db_value_from_uint32(db_value_set_get(value_set, 7), policy_key->manual_rollover)
846  || db_value_from_uint32(db_value_set_get(value_set, 8), policy_key->rfc5011)
847  || db_value_from_uint32(db_value_set_get(value_set, 9), policy_key->minimize))
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  }
924  if (db_value_not_empty(&(policy_key->id))) {
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")
935  || db_value_copy(db_clause_get_value(clause), &(policy_key->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")
946  || db_value_copy(db_clause_get_value(clause), &(policy_key->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  {
990  policy_key_list_free(policy_key_list);
991  return NULL;
992  }
993  return policy_key_list;
994 }
995 
997  if (!policy_key_list) {
998  return DB_ERROR_UNKNOWN;
999  }
1000 
1001  policy_key_list->object_store = 1;
1002 
1003  return DB_OK;
1004 }
1005 
1007  size_t i;
1008 
1009  if (policy_key_list) {
1010  if (policy_key_list->dbo) {
1011  db_object_free(policy_key_list->dbo);
1012  }
1013  if (policy_key_list->result_list) {
1014  db_result_list_free(policy_key_list->result_list);
1015  }
1016  if (policy_key_list->policy_key) {
1017  policy_key_free(policy_key_list->policy_key);
1018  }
1019  for (i = 0; i < policy_key_list->object_list_size; i++) {
1020  if (policy_key_list->object_list[i]) {
1021  policy_key_free(policy_key_list->object_list[i]);
1022  }
1023  }
1024  if (policy_key_list->object_list) {
1025  free(policy_key_list->object_list);
1026  }
1027  if (policy_key_list->policy_id_list) {
1028  policy_list_free(policy_key_list->policy_id_list);
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 
1047  if (policy_key_list->result_list) {
1048  db_result_list_free(policy_key_list->result_list);
1049  policy_key_list->result_list = NULL;
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]) {
1060  policy_key_free(policy_key_list->object_list[i]);
1061  }
1062  }
1063  policy_key_list->object_list_size = 0;
1064  if (policy_key_list->object_list) {
1065  free(policy_key_list->object_list);
1066  policy_key_list->object_list = NULL;
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  }
1082  policy_key_list->object_list_position = 0;;
1083  policy_key_list->object_list_first = 1;
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 
1095 static 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  }
1110  if (!policy_key_list->associated_fetch) {
1111  return DB_ERROR_UNKNOWN;
1112  }
1113  if (!policy_key_list->result_list) {
1114  return DB_ERROR_UNKNOWN;
1115  }
1116  if (policy_key_list->object_list) {
1117  return DB_ERROR_UNKNOWN;
1118  }
1119 
1120  if (policy_key_list->policy_id_list) {
1121  policy_list_free(policy_key_list->policy_id_list);
1122  policy_key_list->policy_id_list = NULL;
1123  }
1124 
1125  if (!(clause_list = db_clause_list_new())) {
1126  return DB_ERROR_UNKNOWN;
1127  }
1128  policy_key = policy_key_list_begin(policy_key_list);
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")
1147  || db_value_copy(db_clause_get_value(clause), policy_key_policy_id(policy_key))
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 
1156  policy_key = policy_key_list_next(policy_key_list);
1157  }
1158 
1159  if (!(policy_key_list->policy_id_list = policy_list_new(db_object_connection(policy_key_list->dbo)))
1160  || policy_list_object_store(policy_key_list->policy_id_list)
1161  || policy_list_get_by_clauses(policy_key_list->policy_id_list, clause_list))
1162  {
1163  if (policy_key_list->policy_id_list) {
1164  policy_list_free(policy_key_list->policy_id_list);
1165  policy_key_list->policy_id_list = NULL;
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 
1177  policy_policy_id = policy_list_begin(policy_key_list->policy_id_list);
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 
1190  policy_key_list->object_list_first = 1;
1191  return DB_OK;
1192 }
1193 
1194 int policy_key_list_get_by_clauses(policy_key_list_t* policy_key_list, const db_clause_list_t* clause_list) {
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 
1207  if (policy_key_list->result_list) {
1208  db_result_list_free(policy_key_list->result_list);
1209  }
1210  if (policy_key_list->object_list_size) {
1211  for (i = 0; i < policy_key_list->object_list_size; i++) {
1212  if (policy_key_list->object_list[i]) {
1213  policy_key_free(policy_key_list->object_list[i]);
1214  }
1215  }
1216  policy_key_list->object_list_size = 0;
1217  policy_key_list->object_list_first = 0;
1218  }
1219  if (policy_key_list->object_list) {
1220  free(policy_key_list->object_list);
1221  policy_key_list->object_list = NULL;
1222  }
1223  if (!(policy_key_list->result_list = db_object_read(policy_key_list->dbo, NULL, clause_list))
1224  || db_result_list_fetch_all(policy_key_list->result_list))
1225  {
1226  return DB_ERROR_UNKNOWN;
1227  }
1228  if (policy_key_list->associated_fetch
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  }
1250  if (db_value_not_empty(policy_id)) {
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")
1260  || db_value_copy(db_clause_get_value(clause), policy_id)
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 
1268  if (policy_key_list->result_list) {
1269  db_result_list_free(policy_key_list->result_list);
1270  }
1271  if (policy_key_list->object_list_size) {
1272  for (i = 0; i < policy_key_list->object_list_size; i++) {
1273  if (policy_key_list->object_list[i]) {
1274  policy_key_free(policy_key_list->object_list[i]);
1275  }
1276  }
1277  policy_key_list->object_list_size = 0;
1278  policy_key_list->object_list_first = 0;
1279  }
1280  if (policy_key_list->object_list) {
1281  free(policy_key_list->object_list);
1282  policy_key_list->object_list = NULL;
1283  }
1284  if (!(policy_key_list->result_list = db_object_read(policy_key_list->dbo, NULL, clause_list))
1285  || db_result_list_fetch_all(policy_key_list->result_list))
1286  {
1287  db_clause_list_free(clause_list);
1288  return DB_ERROR_UNKNOWN;
1289  }
1290  db_clause_list_free(clause_list);
1291  if (policy_key_list->associated_fetch
1292  && policy_key_list_get_associated(policy_key_list))
1293  {
1294  return DB_ERROR_UNKNOWN;
1295  }
1296  return DB_OK;
1297 }
1298 
1300  policy_key_list_t* policy_key_list;
1301 
1302  if (!connection) {
1303  return NULL;
1304  }
1305  if (!policy_id) {
1306  return NULL;
1307  }
1308  if (db_value_not_empty(policy_id)) {
1309  return NULL;
1310  }
1311 
1312  if (!(policy_key_list = policy_key_list_new(connection))
1313  || policy_key_list_get_by_policy_id(policy_key_list, policy_id))
1314  {
1315  policy_key_list_free(policy_key_list);
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 
1329  if (policy_key_list->object_store) {
1330  if (!policy_key_list->object_list) {
1331  if (!policy_key_list->result_list) {
1332  return NULL;
1333  }
1334  if (!db_result_list_size(policy_key_list->result_list)) {
1335  return NULL;
1336  }
1337  if (!(policy_key_list->object_list = (policy_key_t**)calloc(db_result_list_size(policy_key_list->result_list), sizeof(policy_key_t*)))) {
1338  return NULL;
1339  }
1340  policy_key_list->object_list_size = db_result_list_size(policy_key_list->result_list);
1341  }
1342  if (!(policy_key_list->object_list[0])) {
1343  if (!policy_key_list->result_list) {
1344  return NULL;
1345  }
1346  if (!(result = db_result_list_begin(policy_key_list->result_list))) {
1347  return NULL;
1348  }
1349  if (!(policy_key_list->object_list[0] = policy_key_new(db_object_connection(policy_key_list->dbo)))) {
1350  return NULL;
1351  }
1352  if (policy_key_from_result(policy_key_list->object_list[0], result)) {
1353  return NULL;
1354  }
1355  }
1356  policy_key_list->object_list_position = 0;
1357  return policy_key_list->object_list[0];
1358  }
1359 
1360  if (!policy_key_list->result_list) {
1361  return NULL;
1362  }
1363 
1364  if (!(result = db_result_list_begin(policy_key_list->result_list))) {
1365  return NULL;
1366  }
1367  if (!policy_key_list->policy_key) {
1368  if (!(policy_key_list->policy_key = policy_key_new(db_object_connection(policy_key_list->dbo)))) {
1369  return NULL;
1370  }
1371  }
1372  if (policy_key_from_result(policy_key_list->policy_key, result)) {
1373  return NULL;
1374  }
1375  return policy_key_list->policy_key;
1376 }
1377 
1379  const db_result_t* result;
1380 
1381  if (!policy_key_list) {
1382  return NULL;
1383  }
1384 
1385  if (policy_key_list->object_store) {
1386  if (!policy_key_list->object_list) {
1387  if (!policy_key_list->result_list) {
1388  return NULL;
1389  }
1390  if (!db_result_list_size(policy_key_list->result_list)) {
1391  return NULL;
1392  }
1393  if (!(policy_key_list->object_list = (policy_key_t**)calloc(db_result_list_size(policy_key_list->result_list), sizeof(policy_key_t*)))) {
1394  return NULL;
1395  }
1396  policy_key_list->object_list_size = db_result_list_size(policy_key_list->result_list);
1397  policy_key_list->object_list_position = 0;
1398  }
1399  else if (policy_key_list->object_list_first) {
1400  policy_key_list->object_list_first = 0;
1401  policy_key_list->object_list_position = 0;
1402  }
1403  else {
1404  policy_key_list->object_list_position++;
1405  }
1406  if (policy_key_list->object_list_position >= policy_key_list->object_list_size) {
1407  return NULL;
1408  }
1409  if (!(policy_key_list->object_list[policy_key_list->object_list_position])) {
1410  if (!policy_key_list->result_list) {
1411  return NULL;
1412  }
1413  if (!(result = db_result_list_next(policy_key_list->result_list))) {
1414  return NULL;
1415  }
1416  if (!(policy_key_list->object_list[policy_key_list->object_list_position] = policy_key_new(db_object_connection(policy_key_list->dbo)))) {
1417  return NULL;
1418  }
1419  if (policy_key_from_result(policy_key_list->object_list[policy_key_list->object_list_position], result)) {
1420  return NULL;
1421  }
1422  }
1423  return policy_key_list->object_list[policy_key_list->object_list_position];
1424  }
1425 
1426  if (!policy_key_list->result_list) {
1427  return NULL;
1428  }
1429 
1430  if (!(result = db_result_list_next(policy_key_list->result_list))) {
1431  return NULL;
1432  }
1433  if (!policy_key_list->policy_key) {
1434  if (!(policy_key_list->policy_key = policy_key_new(db_object_connection(policy_key_list->dbo)))) {
1435  return NULL;
1436  }
1437  }
1438  if (policy_key_from_result(policy_key_list->policy_key, result)) {
1439  return NULL;
1440  }
1441  return policy_key_list->policy_key;
1442 }
1443 
1445  const db_result_t* result;
1447 
1448  if (!policy_key_list) {
1449  return NULL;
1450  }
1451 
1452  if (policy_key_list->object_store) {
1453  if (!(policy_key = policy_key_new(db_object_connection(policy_key_list->dbo)))) {
1454  return NULL;
1455  }
1456  if (policy_key_copy(policy_key, policy_key_list_next(policy_key_list))) {
1457  policy_key_free(policy_key);
1458  return NULL;
1459  }
1460  return policy_key;
1461  }
1462 
1463  if (!policy_key_list->result_list) {
1464  return NULL;
1465  }
1466 
1467  if (!(result = db_result_list_next(policy_key_list->result_list))) {
1468  return NULL;
1469  }
1470  if (!(policy_key = policy_key_new(db_object_connection(policy_key_list->dbo)))) {
1471  return NULL;
1472  }
1473  if (policy_key_from_result(policy_key, result)) {
1474  policy_key_free(policy_key);
1475  return NULL;
1476  }
1477  return policy_key;
1478 }
1479 
1480 size_t policy_key_list_size(policy_key_list_t* policy_key_list) {
1481  if (!policy_key_list) {
1482  return 0;
1483  }
1484 
1485  if (policy_key_list->object_store
1486  && policy_key_list->object_list)
1487  {
1488  return policy_key_list->object_list_size;
1489  }
1490 
1491  if (!policy_key_list->result_list) {
1492  return 0;
1493  }
1494 
1495  return db_result_list_size(policy_key_list->result_list);
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")
1533  || db_value_from_enum_value(db_clause_get_value(clause), role, policy_key_enum_set_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)) {
1569  policy_key_free(policy_key);
1570  return NULL;
1571  }
1572  return policy_key;
1573 }
policy_key_t * policy_key_list_get_next(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1444
const policy_key_t * policy_key_list_next(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1378
policy_key_list_t * policy_key_list_new(const db_connection_t *connection)
Definition: policy_key.c:963
size_t object_list_position
Definition: policy_key.h:330
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
unsigned int standby
Definition: policy_key.h:66
int db_value_from_uint32(db_value_t *value, db_type_uint32_t from_uint32)
Definition: db_value.c:492
int db_object_set_object_field_list(db_object_t *object, db_object_field_list_t *object_field_list)
Definition: db_object.c:386
int db_value_from_enum_value(db_value_t *value, int enum_value, const db_enum_t *enum_set)
Definition: db_value.c:572
int db_object_set_primary_key_name(db_object_t *object, const char *primary_key_name)
Definition: db_object.c:371
unsigned int manual_rollover
Definition: policy_key.h:67
unsigned int algorithm
Definition: policy_key.h:62
db_object_field_list_t * db_object_field_list_new(void)
Definition: db_object.c:174
void policy_list_free(policy_list_t *policy_list)
Definition: policy.c:2664
int db_object_field_set_name(db_object_field_t *object_field, const char *name)
Definition: db_object.c:110
db_value_t id
Definition: policy_key.h:56
const db_value_t * db_value_set_at(const db_value_set_t *value_set, size_t at)
Definition: db_value.c:742
const policy_t * policy_list_begin(policy_list_t *policy_list)
Definition: policy.c:3155
void db_value_set_free(db_value_set_t *value_set)
Definition: db_value.c:697
int db_value_to_uint32(const db_value_t *value, db_type_uint32_t *to_uint32)
Definition: db_value.c:372
#define DB_ERROR_UNKNOWN
Definition: db_error.h:40
db_value_t rev
Definition: policy_key.h:57
int db_value_copy(db_value_t *value, const db_value_t *from_value)
Definition: db_value.c:77
db_clause_list_t * db_clause_list_new(void)
Definition: db_clause.c:202
int policy_key_set_minimize(policy_key_t *policy_key, unsigned int minimize)
Definition: policy_key.c:692
db_clause_t * db_clause_new(void)
Definition: db_clause.c:43
int db_object_field_set_type(db_object_field_t *object_field, db_type_t type)
Definition: db_object.c:122
int policy_key_delete(policy_key_t *policy_key)
Definition: policy_key.c:913
int policy_key_copy(policy_key_t *policy_key, const policy_key_t *policy_key_copy)
Definition: policy_key.c:289
policy_key_t ** object_list
Definition: policy_key.h:328
int db_clause_set_type(db_clause_t *clause, db_clause_type_t type)
Definition: db_clause.c:130
int policy_list_get_by_clauses(policy_list_t *policy_list, const db_clause_list_t *clause_list)
Definition: policy.c:3093
policy_key_t * policy_key
Definition: policy_key.h:326
int db_object_set_connection(db_object_t *object, const db_connection_t *connection)
Definition: db_object.c:341
int db_value_not_empty(const db_value_t *value)
Definition: db_value.c:347
int db_value_from_text(db_value_t *value, const char *from_text)
Definition: db_value.c:531
const db_connection_t * db_object_connection(const db_object_t *object)
Definition: db_object.c:320
const policy_t * associated_policy_id
Definition: policy_key.h:59
unsigned int policy_key_rfc5011(const policy_key_t *policy_key)
Definition: policy_key.c:558
int policy_key_set_manual_rollover(policy_key_t *policy_key, unsigned int manual_rollover)
Definition: policy_key.c:672
int policy_key_set_bits(policy_key_t *policy_key, unsigned int bits)
Definition: policy_key.c:620
const db_clause_t * db_clause_list_begin(const db_clause_list_t *clause_list)
Definition: db_clause.c:255
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 db_clause_set_field(db_clause_t *clause, const char *field)
Definition: db_clause.c:109
void db_clause_list_free(db_clause_list_t *clause_list)
Definition: db_clause.c:209
db_result_list_t * db_result_list_new_copy(const db_result_list_t *from_result_list)
Definition: db_result.c:142
size_t db_value_set_size(const db_value_set_t *value_set)
Definition: db_value.c:734
int policy_key_from_result(policy_key_t *policy_key, const db_result_t *result)
Definition: policy_key.c:426
size_t policy_key_list_size(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1480
const db_clause_t * db_clause_next(const db_clause_t *clause)
Definition: db_clause.c:179
int policy_list_object_store(policy_list_t *policy_list)
Definition: policy.c:2654
policy_key_role_t policy_key_role(const policy_key_t *policy_key)
Definition: policy_key.c:486
int policy_key_set_standby(policy_key_t *policy_key, unsigned int standby)
Definition: policy_key.c:662
int db_value_to_text(const db_value_t *value, char **to_text)
Definition: db_value.c:417
int db_clause_list_add(db_clause_list_t *clause_list, db_clause_t *clause)
Definition: db_clause.c:226
int db_value_cmp(const db_value_t *value_a, const db_value_t *value_b, int *result)
Definition: db_value.c:102
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
policy_list_t * policy_id_list
Definition: policy_key.h:333
void db_object_free(db_object_t *object)
Definition: db_object.c:311
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
void db_result_list_free(db_result_list_t *result_list)
Definition: db_result.c:160
const char * policy_key_repository(const policy_key_t *policy_key)
Definition: policy_key.c:534
void policy_free(policy_t *policy)
Definition: policy.c:518
size_t object_list_size
Definition: policy_key.h:329
int policy_key_cmp(const policy_key_t *policy_key_a, const policy_key_t *policy_key_b)
Definition: policy_key.c:359
int db_clause_set_operator(db_clause_t *clause, db_clause_operator_t clause_operator)
Definition: db_clause.c:142
void db_value_reset(db_value_t *value)
Definition: db_value.c:60
unsigned int policy_key_lifetime(const policy_key_t *policy_key)
Definition: policy_key.c:526
db_object_field_t * db_object_field_new(void)
Definition: db_object.c:40
int policy_key_set_lifetime(policy_key_t *policy_key, unsigned int lifetime)
Definition: policy_key.c:630
int db_object_delete(const db_object_t *object, const db_clause_list_t *clause_list)
Definition: db_object.c:464
unsigned int lifetime
Definition: policy_key.h:64
size_t db_result_list_size(const db_result_list_t *result_list)
Definition: db_result.c:333
int value
Definition: db_enum.h:40
void db_object_field_free(db_object_field_t *object_field)
Definition: db_object.c:69
int policy_key_set_policy_id(policy_key_t *policy_key, const db_value_t *policy_id)
Definition: policy_key.c:574
unsigned int policy_key_minimize(const policy_key_t *policy_key)
Definition: policy_key.c:566
void db_clause_free(db_clause_t *clause)
Definition: db_clause.c:56
db_value_set_t * db_value_set_new(size_t size)
Definition: db_value.c:622
const db_result_t * db_result_list_next(db_result_list_t *result_list)
Definition: db_result.c:310
policy_t * policy_new_copy(const policy_t *policy)
Definition: policy.c:499
int policy_key_set_role(policy_key_t *policy_key, policy_key_role_t role)
Definition: policy_key.c:593
int policy_key_standby(const policy_key_t *policy_key)
Definition: policy_key.c:542
int db_object_field_set_enum_set(db_object_field_t *object_field, const db_enum_t *enum_set)
Definition: db_object.c:134
const char * policy_key_role_text(const policy_key_t *policy_key)
Definition: policy_key.c:494
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
policy_list_t * policy_list_new(const db_connection_t *connection)
Definition: policy.c:2621
unsigned int policy_key_manual_rollover(const policy_key_t *policy_key)
Definition: policy_key.c:550
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
char * repository
Definition: policy_key.h:65
void db_object_field_list_free(db_object_field_list_t *object_field_list)
Definition: db_object.c:199
int policy_key_get_by_id(policy_key_t *policy_key, const db_value_t *id)
Definition: policy_key.c:860
policy_list_t * policy_list_new_copy(const policy_list_t *from_policy_list)
Definition: policy.c:2635
const policy_t * policy_list_next(policy_list_t *policy_list)
Definition: policy.c:3211
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
db_object_t * db_object_new(void)
Definition: db_object.c:304
#define DB_OK
Definition: db_error.h:36
int policy_key_set_repository(policy_key_t *policy_key, const char *repository_text)
Definition: policy_key.c:640
unsigned int minimize
Definition: policy_key.h:69
const char * text
Definition: db_enum.h:39
const db_enum_t policy_key_enum_set_role[]
Definition: policy_key.c:36
Definition: policy.h:60
db_object_t * dbo
Definition: policy_key.h:55
const db_value_set_t * db_result_value_set(const db_result_t *result)
Definition: db_result.c:97
int db_object_set_table(db_object_t *object, const char *table)
Definition: db_object.c:356
db_result_list_t * result_list
Definition: policy_key.h:324
unsigned int policy_key_algorithm(const policy_key_t *policy_key)
Definition: policy_key.c:510
int db_result_list_fetch_all(db_result_list_t *result_list)
Definition: db_result.c:341
const db_result_t * db_result_list_begin(db_result_list_t *result_list)
Definition: db_result.c:290
policy_t * private_policy_id
Definition: policy_key.h:60
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
const db_value_t * db_clause_value(const db_clause_t *clause)
Definition: db_clause.c:85
unsigned int bits
Definition: policy_key.h:63
policy_key_t * policy_key_new_copy(const policy_key_t *policy_key)
Definition: policy_key.c:227
unsigned int policy_key_bits(const policy_key_t *policy_key)
Definition: policy_key.c:518
void policy_key_list_free(policy_key_list_t *policy_key_list)
Definition: policy_key.c:1006
int policy_key_set_rfc5011(policy_key_t *policy_key, unsigned int rfc5011)
Definition: policy_key.c:682
const db_value_t * policy_id(const policy_t *policy)
Definition: policy.c:805
enum policy_key_role policy_key_role_t
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
unsigned int rfc5011
Definition: policy_key.h:68
policy_key_t * policy_key_new(const db_connection_t *connection)
Definition: policy_key.c:209
policy_key_role_t role
Definition: policy_key.h:61
void policy_key_reset(policy_key_t *policy_key)
Definition: policy_key.c:264
db_object_t * dbo
Definition: policy_key.h:323
int policy_key_list_object_store(policy_key_list_t *policy_key_list)
Definition: policy_key.c:996
policy_key_list_t * policy_key_list_new_copy(const policy_key_list_t *from_policy_key_list)
Definition: policy_key.c:977
db_value_t * db_clause_get_value(db_clause_t *clause)
Definition: db_clause.c:187
db_value_t policy_id
Definition: policy_key.h:58
void policy_key_free(policy_key_t *policy_key)
Definition: policy_key.c:246
int policy_key_set_algorithm(policy_key_t *policy_key, unsigned int algorithm)
Definition: policy_key.c:606
db_value_t * db_value_set_get(db_value_set_t *value_set, size_t at)
Definition: db_value.c:756
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
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
int policy_key_create(policy_key_t *policy_key)
Definition: policy_key.c:702