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