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 
36 const db_enum_t policy_key_enum_set_role[] = {
37     { "KSK", (policy_key_role_t)POLICY_KEY_ROLE_KSK },
38     { "ZSK", (policy_key_role_t)POLICY_KEY_ROLE_ZSK },
39     { "CSK", (policy_key_role_t)POLICY_KEY_ROLE_CSK },
40     { NULL, 0 }
41 };
42 
43 /**
44  * Create a new policy key object.
45  * \param[in] connection a db_connection_t pointer.
46  * \return a policy_key_t pointer or NULL on error.
47  */
__policy_key_new_object(const db_connection_t * connection)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")
65         || db_object_field_set_type(object_field, DB_TYPE_PRIMARY_KEY)
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")
76         || db_object_field_set_type(object_field, DB_TYPE_REVISION)
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 
policy_key_new(const db_connection_t * connection)209 policy_key_t* policy_key_new(const db_connection_t* connection) {
210     policy_key_t* policy_key =
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 
policy_key_new_copy(const policy_key_t * policy_key)227 policy_key_t* policy_key_new_copy(const policy_key_t* policy_key) {
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 
policy_key_free(policy_key_t * policy_key)246 void policy_key_free(policy_key_t* policy_key) {
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 
policy_key_reset(policy_key_t * policy_key)264 void policy_key_reset(policy_key_t* policy_key) {
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 
policy_key_copy(policy_key_t * policy_key,const policy_key_t * policy_key_copy)289 int policy_key_copy(policy_key_t* policy_key, const policy_key_t* policy_key_copy) {
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 
policy_key_cmp(const policy_key_t * policy_key_a,const policy_key_t * policy_key_b)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 
policy_key_from_result(policy_key_t * policy_key,const db_result_t * result)426 int policy_key_from_result(policy_key_t* policy_key, const db_result_t* result) {
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 
policy_key_policy_id(const policy_key_t * policy_key)478 const db_value_t* policy_key_policy_id(const policy_key_t* policy_key) {
479     if (!policy_key) {
480         return NULL;
481     }
482 
483     return &(policy_key->policy_id);
484 }
485 
policy_key_role(const policy_key_t * policy_key)486 policy_key_role_t policy_key_role(const policy_key_t* policy_key) {
487     if (!policy_key) {
488         return POLICY_KEY_ROLE_INVALID;
489     }
490 
491     return policy_key->role;
492 }
493 
policy_key_role_text(const policy_key_t * policy_key)494 const char* policy_key_role_text(const policy_key_t* policy_key) {
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 
policy_key_algorithm(const policy_key_t * policy_key)510 unsigned int policy_key_algorithm(const policy_key_t* policy_key) {
511     if (!policy_key) {
512         return 0;
513     }
514 
515     return policy_key->algorithm;
516 }
517 
policy_key_bits(const policy_key_t * policy_key)518 unsigned int policy_key_bits(const policy_key_t* policy_key) {
519     if (!policy_key) {
520         return 0;
521     }
522 
523     return policy_key->bits;
524 }
525 
policy_key_lifetime(const policy_key_t * policy_key)526 unsigned int policy_key_lifetime(const policy_key_t* policy_key) {
527     if (!policy_key) {
528         return 0;
529     }
530 
531     return policy_key->lifetime;
532 }
533 
policy_key_repository(const policy_key_t * policy_key)534 const char* policy_key_repository(const policy_key_t* policy_key) {
535     if (!policy_key) {
536         return NULL;
537     }
538 
539     return policy_key->repository;
540 }
541 
policy_key_standby(const policy_key_t * policy_key)542 int policy_key_standby(const policy_key_t* policy_key) {
543     if (!policy_key) {
544         return -1;
545     }
546 
547     return policy_key->standby;
548 }
549 
policy_key_manual_rollover(const policy_key_t * policy_key)550 unsigned int policy_key_manual_rollover(const policy_key_t* policy_key) {
551     if (!policy_key) {
552         return 0;
553     }
554 
555     return policy_key->manual_rollover;
556 }
557 
policy_key_rfc5011(const policy_key_t * policy_key)558 unsigned int policy_key_rfc5011(const policy_key_t* policy_key) {
559     if (!policy_key) {
560         return 0;
561     }
562 
563     return policy_key->rfc5011;
564 }
565 
policy_key_minimize(const policy_key_t * policy_key)566 unsigned int policy_key_minimize(const policy_key_t* policy_key) {
567     if (!policy_key) {
568         return 0;
569     }
570 
571     return policy_key->minimize;
572 }
573 
policy_key_set_policy_id(policy_key_t * policy_key,const db_value_t * policy_id)574 int policy_key_set_policy_id(policy_key_t* policy_key, const db_value_t* policy_id) {
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 
policy_key_set_role(policy_key_t * policy_key,policy_key_role_t role)593 int policy_key_set_role(policy_key_t* policy_key, policy_key_role_t role) {
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 
policy_key_set_algorithm(policy_key_t * policy_key,unsigned int algorithm)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 
policy_key_set_bits(policy_key_t * policy_key,unsigned int bits)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 
policy_key_set_lifetime(policy_key_t * policy_key,unsigned int lifetime)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 
policy_key_set_repository(policy_key_t * policy_key,const char * repository_text)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 
policy_key_set_standby(policy_key_t * policy_key,unsigned int standby)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 
policy_key_set_manual_rollover(policy_key_t * policy_key,unsigned int manual_rollover)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 
policy_key_set_rfc5011(policy_key_t * policy_key,unsigned int rfc5011)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 
policy_key_set_minimize(policy_key_t * policy_key,unsigned int minimize)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 
policy_key_create(policy_key_t * policy_key)702 int policy_key_create(policy_key_t* policy_key) {
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 
policy_key_get_by_id(policy_key_t * policy_key,const db_value_t * id)860 int policy_key_get_by_id(policy_key_t* policy_key, const db_value_t* id) {
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")
884         || db_clause_set_type(clause, DB_CLAUSE_EQUAL)
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 
policy_key_delete(policy_key_t * policy_key)913 int policy_key_delete(policy_key_t* policy_key) {
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")
934         || db_clause_set_type(clause, DB_CLAUSE_EQUAL)
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")
945         || db_clause_set_type(clause, DB_CLAUSE_EQUAL)
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 
policy_key_list_new(const db_connection_t * connection)963 policy_key_list_t* policy_key_list_new(const db_connection_t* connection) {
964     policy_key_list_t* policy_key_list =
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 
policy_key_list_new_copy(const policy_key_list_t * from_policy_key_list)977 policy_key_list_t* policy_key_list_new_copy(const policy_key_list_t* from_policy_key_list) {
978     policy_key_list_t* policy_key_list;
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 
policy_key_list_object_store(policy_key_list_t * policy_key_list)996 int policy_key_list_object_store(policy_key_list_t* policy_key_list) {
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 
policy_key_list_free(policy_key_list_t * policy_key_list)1006 void policy_key_list_free(policy_key_list_t* policy_key_list) {
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 
policy_key_list_copy(policy_key_list_t * policy_key_list,const policy_key_list_t * from_policy_key_list)1034 int policy_key_list_copy(policy_key_list_t* policy_key_list, const policy_key_list_t* from_policy_key_list) {
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 
policy_key_list_get_associated(policy_key_list_t * policy_key_list)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")
1145                 || db_clause_set_type(clause, DB_CLAUSE_EQUAL)
1146                 || db_clause_set_operator(clause, DB_CLAUSE_OPERATOR_OR)
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 
policy_key_list_get_by_clauses(policy_key_list_t * policy_key_list,const db_clause_list_t * clause_list)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 
policy_key_list_get_by_policy_id(policy_key_list_t * policy_key_list,const db_value_t * policy_id)1236 int policy_key_list_get_by_policy_id(policy_key_list_t* policy_key_list, const db_value_t* policy_id) {
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")
1259         || db_clause_set_type(clause, DB_CLAUSE_EQUAL)
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 
policy_key_list_new_get_by_policy_id(const db_connection_t * connection,const db_value_t * policy_id)1299 policy_key_list_t* policy_key_list_new_get_by_policy_id(const db_connection_t* connection, const db_value_t* policy_id) {
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 
policy_key_list_begin(policy_key_list_t * policy_key_list)1322 const policy_key_t* policy_key_list_begin(policy_key_list_t* policy_key_list) {
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 
policy_key_list_next(policy_key_list_t * policy_key_list)1378 const policy_key_t* policy_key_list_next(policy_key_list_t* policy_key_list) {
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 
policy_key_list_get_next(policy_key_list_t * policy_key_list)1444 policy_key_t* policy_key_list_get_next(policy_key_list_t* policy_key_list) {
1445     const db_result_t* result;
1446     policy_key_t* policy_key;
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 
policy_key_list_size(policy_key_list_t * policy_key_list)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 
policy_key_get_by_policyid_and_role(policy_key_t * policy_key,const db_value_t * policyid,const policy_key_role_t role)1498 int policy_key_get_by_policyid_and_role(policy_key_t* policy_key, const db_value_t* policyid, const policy_key_role_t role) {
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")
1519         || db_clause_set_type(clause, DB_CLAUSE_EQUAL)
1520         || db_clause_set_operator(clause, DB_CLAUSE_OPERATOR_AND)
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")
1531         || db_clause_set_type(clause, DB_CLAUSE_EQUAL)
1532         || db_clause_set_operator(clause, DB_CLAUSE_OPERATOR_AND)
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 
policy_key_new_get_by_policyid_and_role(const db_connection_t * connection,const db_value_t * policyid,const policy_key_role_t role)1562 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) {
1563     policy_key_t* policy_key;
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 }
1574