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