1 /* $NetBSD: dbversion_test.c,v 1.1.1.5 2015/07/08 15:38:04 christos Exp $ */
2
3 /*
4 * Copyright (C) 2011, 2012, 2014, 2015 Internet Systems Consortium, Inc. ("ISC")
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
11 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
12 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
13 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
14 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
15 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
16 * PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 /* Id */
20
21 /*! \file */
22
23 #include <config.h>
24
25 #include <atf-c.h>
26
27 #include <stdlib.h>
28 #include <time.h>
29 #include <unistd.h>
30
31 #include <isc/file.h>
32 #include <isc/result.h>
33 #include <isc/serial.h>
34 #include <isc/stdtime.h>
35 #include <isc/msgcat.h>
36
37 #include <dns/db.h>
38 #include <dns/rdatalist.h>
39 #include <dns/rdataset.h>
40 #include <dns/rdatasetiter.h>
41 #include <dns/nsec3.h>
42
43 #include "dnstest.h"
44
45 static char tempname[11] = "dtXXXXXXXX";
46
47 static void
local_callback(const char * file,int line,isc_assertiontype_t type,const char * cond)48 local_callback(const char *file, int line, isc_assertiontype_t type,
49 const char *cond)
50 {
51 UNUSED(file); UNUSED(line); UNUSED(type); UNUSED(cond);
52 if (strcmp(tempname, "dtXXXXXXXX"))
53 unlink(tempname);
54 atf_tc_pass();
55 exit(0);
56 }
57
58 static dns_db_t *db1 = NULL, *db2 = NULL;
59 static dns_dbversion_t *v1 = NULL, *v2 = NULL;
60
61 static void
setup_db(void)62 setup_db(void) {
63 isc_result_t result;
64 result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone,
65 dns_rdataclass_in, 0, NULL, &db1);
66 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
67 dns_db_newversion(db1, &v1);
68
69 result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone,
70 dns_rdataclass_in, 0, NULL, &db2);
71 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
72 dns_db_newversion(db2, &v2);
73 }
74
75 static void
close_db(void)76 close_db(void) {
77 if (v1 != NULL) {
78 dns_db_closeversion(db1, &v1, ISC_FALSE);
79 ATF_REQUIRE_EQ(v1, NULL);
80 }
81 if (db1 != NULL) {
82 dns_db_detach(&db1);
83 ATF_REQUIRE_EQ(db1, NULL);
84 }
85
86 if (v2 != NULL) {
87 dns_db_closeversion(db2, &v2, ISC_FALSE);
88 ATF_REQUIRE_EQ(v2, NULL);
89 }
90 if (db2 != NULL) {
91 dns_db_detach(&db2);
92 ATF_REQUIRE_EQ(db2, NULL);
93 }
94 }
95
96 #define VERSION(callback) ((callback == NULL) ? v1 : v2)
97 #define VERSIONP(callback) ((callback == NULL) ? &v1 : &v2)
98 /*
99 * Individual unit tests
100 */
101 static void
attachversion(isc_assertioncallback_t callback)102 attachversion(isc_assertioncallback_t callback) {
103 isc_result_t result;
104 dns_dbversion_t *v = NULL;
105
106 result = dns_test_begin(NULL, ISC_FALSE);
107 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
108
109 setup_db();
110
111 isc_assertion_setcallback(callback);
112 dns_db_attachversion(db1, VERSION(callback), &v);
113 if (callback != NULL)
114 atf_tc_fail("dns_db_attachversion did not assert");
115
116 ATF_REQUIRE_EQ(v, v1);
117 dns_db_closeversion(db1, &v, ISC_FALSE);
118 ATF_REQUIRE_EQ(v, NULL);
119
120 close_db();
121 dns_test_end();
122 }
123
124 ATF_TC(attachversion);
ATF_TC_HEAD(attachversion,tc)125 ATF_TC_HEAD(attachversion, tc) {
126 atf_tc_set_md_var(tc, "descr", "check dns_db_attachversion passes with matching db/verison");
127 }
ATF_TC_BODY(attachversion,tc)128 ATF_TC_BODY(attachversion, tc) {
129
130 UNUSED(tc);
131
132 attachversion(NULL);
133 }
134
135 ATF_TC(attachversion_bad);
ATF_TC_HEAD(attachversion_bad,tc)136 ATF_TC_HEAD(attachversion_bad, tc) {
137 atf_tc_set_md_var(tc, "descr", "check dns_db_attachversion aborts with mis-matching db/verison");
138 }
ATF_TC_BODY(attachversion_bad,tc)139 ATF_TC_BODY(attachversion_bad, tc) {
140
141 UNUSED(tc);
142
143 attachversion(local_callback);
144 }
145
146 static void
closeversion(isc_assertioncallback_t callback)147 closeversion(isc_assertioncallback_t callback) {
148 isc_result_t result;
149
150 result = dns_test_begin(NULL, ISC_FALSE);
151 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
152
153 setup_db();
154
155 isc_assertion_setcallback(callback);
156 dns_db_closeversion(db1, VERSIONP(callback), ISC_FALSE);
157 if (callback != NULL)
158 atf_tc_fail("dns_db_closeversion did not assert");
159 ATF_REQUIRE_EQ(v1, NULL);
160
161 close_db();
162 dns_test_end();
163 }
164
165 ATF_TC(closeversion);
ATF_TC_HEAD(closeversion,tc)166 ATF_TC_HEAD(closeversion, tc) {
167 atf_tc_set_md_var(tc, "descr", "check dns_db_closeversion passes with matching db/verison");
168 }
ATF_TC_BODY(closeversion,tc)169 ATF_TC_BODY(closeversion, tc) {
170
171 UNUSED(tc);
172
173 closeversion(NULL);
174 }
175
176 ATF_TC(closeversion_bad);
ATF_TC_HEAD(closeversion_bad,tc)177 ATF_TC_HEAD(closeversion_bad, tc) {
178 atf_tc_set_md_var(tc, "descr", "check dns_db_closeversion asserts with mis-matching db/verison");
179 }
ATF_TC_BODY(closeversion_bad,tc)180 ATF_TC_BODY(closeversion_bad, tc) {
181
182 UNUSED(tc);
183
184 closeversion(local_callback);
185 }
186
187 static void
find(isc_assertioncallback_t callback)188 find(isc_assertioncallback_t callback) {
189 isc_result_t result;
190 dns_rdataset_t rdataset;
191 dns_fixedname_t fixed;
192
193 result = dns_test_begin(NULL, ISC_FALSE);
194 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
195
196 setup_db();
197
198 dns_rdataset_init(&rdataset);
199 dns_fixedname_init(&fixed);
200
201 isc_assertion_setcallback(callback);
202 result = dns_db_find(db1, dns_rootname, VERSION(callback),
203 dns_rdatatype_soa, 0, 0, NULL,
204 dns_fixedname_name(&fixed), &rdataset, NULL);
205 if (callback != NULL)
206 atf_tc_fail("dns_db_find did not assert");
207 ATF_REQUIRE_EQ(result, DNS_R_NXDOMAIN);
208
209 close_db();
210
211 dns_test_end();
212 }
213 ATF_TC(find);
ATF_TC_HEAD(find,tc)214 ATF_TC_HEAD(find, tc) {
215 atf_tc_set_md_var(tc, "descr", "check dns_db_find passes with matching db/version");
216 }
ATF_TC_BODY(find,tc)217 ATF_TC_BODY(find, tc) {
218
219 UNUSED(tc);
220
221 find(NULL);
222 }
223
224 ATF_TC(find_bad);
ATF_TC_HEAD(find_bad,tc)225 ATF_TC_HEAD(find_bad, tc) {
226 atf_tc_set_md_var(tc, "descr", "check dns_db_find asserts with mis-matching db/version");
227 }
ATF_TC_BODY(find_bad,tc)228 ATF_TC_BODY(find_bad, tc) {
229
230 UNUSED(tc);
231
232 find(local_callback);
233 }
234
235 static void
allrdatasets(isc_assertioncallback_t callback)236 allrdatasets(isc_assertioncallback_t callback) {
237 isc_result_t result;
238 dns_dbnode_t *node = NULL;
239 dns_rdatasetiter_t *iterator = NULL;
240
241 result = dns_test_begin(NULL, ISC_FALSE);
242 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
243
244 setup_db();
245
246 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
247 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
248
249 isc_assertion_setcallback(callback);
250 result = dns_db_allrdatasets(db1, node, VERSION(callback), 0,
251 &iterator);
252 if (callback != NULL)
253 atf_tc_fail("dns_db_allrdatasets did not assert");
254 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
255
256 dns_rdatasetiter_destroy(&iterator);
257 ATF_REQUIRE_EQ(iterator, NULL);
258
259 dns_db_detachnode(db1, &node);
260 ATF_REQUIRE_EQ(node, NULL);
261
262 close_db();
263
264 dns_test_end();
265 }
266
267 ATF_TC(allrdatasets);
ATF_TC_HEAD(allrdatasets,tc)268 ATF_TC_HEAD(allrdatasets, tc) {
269 atf_tc_set_md_var(tc, "descr", "check dns_db_allrdatasets passes with matching db/version");
270 }
ATF_TC_BODY(allrdatasets,tc)271 ATF_TC_BODY(allrdatasets, tc) {
272
273 UNUSED(tc);
274
275 allrdatasets(NULL);
276 }
277
278 ATF_TC(allrdatasets_bad);
ATF_TC_HEAD(allrdatasets_bad,tc)279 ATF_TC_HEAD(allrdatasets_bad, tc) {
280 atf_tc_set_md_var(tc, "descr", "check dns_db_allrdatasets aborts with mis-matching db/version");
281 }
ATF_TC_BODY(allrdatasets_bad,tc)282 ATF_TC_BODY(allrdatasets_bad, tc) {
283
284 UNUSED(tc);
285
286 allrdatasets(local_callback);
287 }
288
289 static void
findrdataset(isc_assertioncallback_t callback)290 findrdataset(isc_assertioncallback_t callback) {
291 isc_result_t result;
292 dns_rdataset_t rdataset;
293 dns_fixedname_t fixed;
294 dns_dbnode_t *node = NULL;
295
296 result = dns_test_begin(NULL, ISC_FALSE);
297 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
298
299 setup_db();
300
301 dns_rdataset_init(&rdataset);
302 dns_fixedname_init(&fixed);
303
304 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
305 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
306
307 isc_assertion_setcallback(callback);
308 result = dns_db_findrdataset(db1, node, VERSION(callback),
309 dns_rdatatype_soa, 0, 0, &rdataset, NULL);
310 if (callback != NULL)
311 atf_tc_fail("dns_db_findrdataset did not assert");
312 ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND);
313
314 dns_db_detachnode(db1, &node);
315 ATF_REQUIRE_EQ(node, NULL);
316
317 close_db();
318
319 dns_test_end();
320 }
321
322 ATF_TC(findrdataset);
ATF_TC_HEAD(findrdataset,tc)323 ATF_TC_HEAD(findrdataset, tc) {
324 atf_tc_set_md_var(tc, "descr", "check dns_db_findrdataset passes with matching db/version");
325 }
ATF_TC_BODY(findrdataset,tc)326 ATF_TC_BODY(findrdataset, tc) {
327
328 UNUSED(tc);
329
330 findrdataset(NULL);
331 }
332
333 ATF_TC(findrdataset_bad);
ATF_TC_HEAD(findrdataset_bad,tc)334 ATF_TC_HEAD(findrdataset_bad, tc) {
335 atf_tc_set_md_var(tc, "descr", "check dns_db_findrdataset aborts with mis-matching db/version");
336 }
ATF_TC_BODY(findrdataset_bad,tc)337 ATF_TC_BODY(findrdataset_bad, tc) {
338
339 UNUSED(tc);
340
341 findrdataset(local_callback);
342 }
343
344 static void
deleterdataset(isc_assertioncallback_t callback)345 deleterdataset(isc_assertioncallback_t callback) {
346 isc_result_t result;
347 dns_rdataset_t rdataset;
348 dns_fixedname_t fixed;
349 dns_dbnode_t *node = NULL;
350
351 result = dns_test_begin(NULL, ISC_FALSE);
352 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
353
354 setup_db();
355
356 dns_rdataset_init(&rdataset);
357 dns_fixedname_init(&fixed);
358
359 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
360 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
361
362 isc_assertion_setcallback(callback);
363 result = dns_db_deleterdataset(db1, node, VERSION(callback),
364 dns_rdatatype_soa, 0);
365 if (callback != NULL)
366 atf_tc_fail("dns_db_deleterdataset did not assert");
367 ATF_REQUIRE_EQ(result, DNS_R_UNCHANGED);
368
369 dns_db_detachnode(db1, &node);
370 ATF_REQUIRE_EQ(node, NULL);
371
372 close_db();
373
374 dns_test_end();
375 }
376
377 ATF_TC(deleterdataset);
ATF_TC_HEAD(deleterdataset,tc)378 ATF_TC_HEAD(deleterdataset, tc) {
379 atf_tc_set_md_var(tc, "descr", "check dns_db_deleterdataset passes with matching db/version");
380 }
ATF_TC_BODY(deleterdataset,tc)381 ATF_TC_BODY(deleterdataset, tc) {
382
383 UNUSED(tc);
384
385 deleterdataset(NULL);
386 }
387
388 ATF_TC(deleterdataset_bad);
ATF_TC_HEAD(deleterdataset_bad,tc)389 ATF_TC_HEAD(deleterdataset_bad, tc) {
390 atf_tc_set_md_var(tc, "descr", "check dns_db_deleterdataset aborts with mis-matching db/version");
391 }
ATF_TC_BODY(deleterdataset_bad,tc)392 ATF_TC_BODY(deleterdataset_bad, tc) {
393
394 UNUSED(tc);
395
396 deleterdataset(local_callback);
397 }
398
399 static void
subtract(isc_assertioncallback_t callback)400 subtract(isc_assertioncallback_t callback) {
401 isc_result_t result;
402 dns_rdataset_t rdataset;
403 dns_fixedname_t fixed;
404 dns_dbnode_t *node = NULL;
405 dns_rdatalist_t rdatalist;
406
407 result = dns_test_begin(NULL, ISC_FALSE);
408 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
409
410 setup_db();
411
412 dns_rdataset_init(&rdataset);
413 dns_rdatalist_init(&rdatalist);
414 dns_fixedname_init(&fixed);
415
416 rdatalist.rdclass = dns_rdataclass_in;
417
418 result = dns_rdatalist_tordataset(&rdatalist, &rdataset);
419 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
420
421 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
422 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
423
424 isc_assertion_setcallback(callback);
425 result = dns_db_subtractrdataset(db1, node, VERSION(callback),
426 &rdataset, 0, NULL);
427 if (callback != NULL)
428 atf_tc_fail("dns_db_dns_db_subtractrdataset did not assert");
429 ATF_REQUIRE_EQ(result, DNS_R_UNCHANGED);
430
431 dns_db_detachnode(db1, &node);
432 ATF_REQUIRE_EQ(node, NULL);
433
434 close_db();
435
436 dns_test_end();
437 }
438
439 ATF_TC(subtractrdataset);
ATF_TC_HEAD(subtractrdataset,tc)440 ATF_TC_HEAD(subtractrdataset, tc) {
441 atf_tc_set_md_var(tc, "descr", "check dns_db_subtractrdataset passes with matching db/version");
442 }
ATF_TC_BODY(subtractrdataset,tc)443 ATF_TC_BODY(subtractrdataset, tc) {
444
445 UNUSED(tc);
446
447 subtract(NULL);
448 }
449
450 ATF_TC(subtractrdataset_bad);
ATF_TC_HEAD(subtractrdataset_bad,tc)451 ATF_TC_HEAD(subtractrdataset_bad, tc) {
452 atf_tc_set_md_var(tc, "descr", "check dns_db_subtractrdataset aborts with mis-matching db/version");
453 }
ATF_TC_BODY(subtractrdataset_bad,tc)454 ATF_TC_BODY(subtractrdataset_bad, tc) {
455
456 UNUSED(tc);
457
458 subtract(local_callback);
459 }
460
461 static void
dump(isc_assertioncallback_t callback)462 dump(isc_assertioncallback_t callback) {
463 isc_result_t result;
464 FILE *f = NULL;
465
466 result = dns_test_begin(NULL, ISC_FALSE);
467 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
468
469 setup_db();
470
471 result = isc_file_openunique(tempname, &f);
472 fclose(f);
473 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
474
475 isc_assertion_setcallback(callback);
476 result = dns_db_dump(db1, VERSION(callback), tempname);
477 (void)unlink(tempname);
478 if (callback != NULL)
479 atf_tc_fail("dns_db_dump did not assert");
480 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
481
482 close_db();
483
484 dns_test_end();
485 }
486
487 ATF_TC(dump);
ATF_TC_HEAD(dump,tc)488 ATF_TC_HEAD(dump, tc) {
489 atf_tc_set_md_var(tc, "descr", "check dns_db_dump passes with matching db/version");
490 }
ATF_TC_BODY(dump,tc)491 ATF_TC_BODY(dump, tc) {
492
493 UNUSED(tc);
494
495 dump(NULL);
496 }
497
498 ATF_TC(dump_bad);
ATF_TC_HEAD(dump_bad,tc)499 ATF_TC_HEAD(dump_bad, tc) {
500 atf_tc_set_md_var(tc, "descr", "check dns_db_dump aborts with mis-matching db/version");
501 }
ATF_TC_BODY(dump_bad,tc)502 ATF_TC_BODY(dump_bad, tc) {
503
504 UNUSED(tc);
505
506 dump(local_callback);
507 }
508
509 static void
addrdataset(isc_assertioncallback_t callback)510 addrdataset(isc_assertioncallback_t callback) {
511 isc_result_t result;
512 dns_rdataset_t rdataset;
513 dns_fixedname_t fixed;
514 dns_dbnode_t *node = NULL;
515 dns_rdatalist_t rdatalist;
516
517 result = dns_test_begin(NULL, ISC_FALSE);
518 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
519
520 setup_db();
521
522 dns_rdataset_init(&rdataset);
523 dns_rdatalist_init(&rdatalist);
524 dns_fixedname_init(&fixed);
525
526 rdatalist.rdclass = dns_rdataclass_in;
527
528 result = dns_rdatalist_tordataset(&rdatalist, &rdataset);
529 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
530
531 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
532 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
533
534 isc_assertion_setcallback(callback);
535 result = dns_db_addrdataset(db1, node, VERSION(callback), 0, &rdataset,
536 0, NULL);
537 if (callback != NULL)
538 atf_tc_fail("dns_db_adddataset did not assert");
539 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
540
541 dns_db_detachnode(db1, &node);
542 ATF_REQUIRE_EQ(node, NULL);
543
544 close_db();
545
546 dns_test_end();
547 }
548
549 ATF_TC(addrdataset);
ATF_TC_HEAD(addrdataset,tc)550 ATF_TC_HEAD(addrdataset, tc) {
551 atf_tc_set_md_var(tc, "descr", "check dns_db_addrdataset passes with matching db/version");
552 }
ATF_TC_BODY(addrdataset,tc)553 ATF_TC_BODY(addrdataset, tc) {
554
555 UNUSED(tc);
556
557 addrdataset(NULL);
558 }
559
560 ATF_TC(addrdataset_bad);
ATF_TC_HEAD(addrdataset_bad,tc)561 ATF_TC_HEAD(addrdataset_bad, tc) {
562 atf_tc_set_md_var(tc, "descr", "check dns_db_addrdataset aborts with mis-matching db/version");
563 }
ATF_TC_BODY(addrdataset_bad,tc)564 ATF_TC_BODY(addrdataset_bad, tc) {
565
566 UNUSED(tc);
567
568 addrdataset(local_callback);
569 }
570
571 static void
getnsec3parameters(isc_assertioncallback_t callback)572 getnsec3parameters(isc_assertioncallback_t callback) {
573 isc_result_t result;
574 dns_hash_t hash;
575 isc_uint8_t flags;
576 isc_uint16_t iterations;
577 unsigned char salt[DNS_NSEC3_SALTSIZE];
578 size_t salt_length = sizeof(salt);
579
580 result = dns_test_begin(NULL, ISC_FALSE);
581 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
582
583 setup_db();
584
585 isc_assertion_setcallback(callback);
586 result = dns_db_getnsec3parameters(db1, VERSION(callback), &hash,
587 &flags, &iterations, salt,
588 &salt_length);
589 if (callback != NULL)
590 atf_tc_fail("dns_db_dump did not assert");
591 ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND);
592
593 close_db();
594
595 dns_test_end();
596 }
597
598 ATF_TC(getnsec3parameters);
ATF_TC_HEAD(getnsec3parameters,tc)599 ATF_TC_HEAD(getnsec3parameters, tc) {
600 atf_tc_set_md_var(tc, "descr", "check dns_db_getnsec3parameters passes with matching db/version");
601 }
ATF_TC_BODY(getnsec3parameters,tc)602 ATF_TC_BODY(getnsec3parameters, tc) {
603
604 UNUSED(tc);
605
606 getnsec3parameters(NULL);
607 }
608
609 ATF_TC(getnsec3parameters_bad);
ATF_TC_HEAD(getnsec3parameters_bad,tc)610 ATF_TC_HEAD(getnsec3parameters_bad, tc) {
611 atf_tc_set_md_var(tc, "descr", "check dns_db_getnsec3parameters aborts with mis-matching db/version");
612 }
ATF_TC_BODY(getnsec3parameters_bad,tc)613 ATF_TC_BODY(getnsec3parameters_bad, tc) {
614
615 UNUSED(tc);
616
617 getnsec3parameters(local_callback);
618 }
619
620 static void
resigned(isc_assertioncallback_t callback)621 resigned(isc_assertioncallback_t callback) {
622 isc_result_t result;
623 dns_rdataset_t rdataset, added;
624 dns_dbnode_t *node = NULL;
625 dns_rdatalist_t rdatalist;
626 dns_rdata_rrsig_t rrsig;
627 dns_rdata_t rdata = DNS_RDATA_INIT;
628 isc_buffer_t b;
629 unsigned char buf[1024];
630
631 result = dns_test_begin(NULL, ISC_FALSE);
632 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
633
634 setup_db();
635
636 /*
637 * Create a dummy RRSIG record and set a resigning time.
638 */
639 dns_rdataset_init(&added);
640 dns_rdataset_init(&rdataset);
641 dns_rdatalist_init(&rdatalist);
642 isc_buffer_init(&b, buf, sizeof(buf));
643
644 DNS_RDATACOMMON_INIT(&rrsig, dns_rdatatype_rrsig, dns_rdataclass_in);
645 rrsig.covered = dns_rdatatype_a;
646 rrsig.algorithm = 100;
647 rrsig.labels = 0;
648 rrsig.originalttl = 0;
649 rrsig.timeexpire = 3600;
650 rrsig.timesigned = 0;
651 rrsig.keyid = 0;
652 dns_name_init(&rrsig.signer, NULL);
653 dns_name_clone(dns_rootname, &rrsig.signer);
654 rrsig.siglen = 0;
655 rrsig.signature = NULL;
656
657 result = dns_rdata_fromstruct(&rdata, dns_rdataclass_in,
658 dns_rdatatype_rrsig, &rrsig, &b);
659 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
660
661 rdatalist.rdclass = dns_rdataclass_in;
662 rdatalist.type = dns_rdatatype_rrsig;
663 ISC_LIST_APPEND(rdatalist.rdata, &rdata, link);
664
665 result = dns_rdatalist_tordataset(&rdatalist, &rdataset);
666 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
667
668 rdataset.attributes |= DNS_RDATASETATTR_RESIGN;
669 rdataset.resign = 7200;
670
671 result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
672 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
673
674 result = dns_db_addrdataset(db1, node, v1, 0, &rdataset, 0, &added);
675 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
676
677 dns_db_detachnode(db1, &node);
678 ATF_REQUIRE_EQ(node, NULL);
679
680 isc_assertion_setcallback(callback);
681 dns_db_resigned(db1, &added, VERSION(callback));
682 if (callback != NULL)
683 atf_tc_fail("dns_db_resigned did not assert");
684
685 dns_rdataset_disassociate(&added);
686
687 close_db();
688
689 dns_test_end();
690 }
691
692 ATF_TC(resigned);
ATF_TC_HEAD(resigned,tc)693 ATF_TC_HEAD(resigned, tc) {
694 atf_tc_set_md_var(tc, "descr", "check dns_rdataset_resigned passes with matching db/version");
695 }
ATF_TC_BODY(resigned,tc)696 ATF_TC_BODY(resigned, tc) {
697
698 UNUSED(tc);
699
700 resigned(NULL);
701 }
702
703 ATF_TC(resigned_bad);
ATF_TC_HEAD(resigned_bad,tc)704 ATF_TC_HEAD(resigned_bad, tc) {
705 atf_tc_set_md_var(tc, "descr", "check dns_rdataset_resigned aborts with mis-matching db/version");
706 }
ATF_TC_BODY(resigned_bad,tc)707 ATF_TC_BODY(resigned_bad, tc) {
708
709 UNUSED(tc);
710
711 resigned(local_callback);
712 }
713
714 /*
715 * Main
716 */
ATF_TP_ADD_TCS(tp)717 ATF_TP_ADD_TCS(tp) {
718 ATF_TP_ADD_TC(tp, dump);
719 ATF_TP_ADD_TC(tp, dump_bad);
720 ATF_TP_ADD_TC(tp, find);
721 ATF_TP_ADD_TC(tp, find_bad);
722 ATF_TP_ADD_TC(tp, allrdatasets);
723 ATF_TP_ADD_TC(tp, allrdatasets_bad);
724 ATF_TP_ADD_TC(tp, findrdataset);
725 ATF_TP_ADD_TC(tp, findrdataset_bad);
726 ATF_TP_ADD_TC(tp, addrdataset);
727 ATF_TP_ADD_TC(tp, addrdataset_bad);
728 ATF_TP_ADD_TC(tp, deleterdataset);
729 ATF_TP_ADD_TC(tp, deleterdataset_bad);
730 ATF_TP_ADD_TC(tp, subtractrdataset);
731 ATF_TP_ADD_TC(tp, subtractrdataset_bad);
732 ATF_TP_ADD_TC(tp, attachversion);
733 ATF_TP_ADD_TC(tp, attachversion_bad);
734 ATF_TP_ADD_TC(tp, closeversion);
735 ATF_TP_ADD_TC(tp, closeversion_bad);
736 ATF_TP_ADD_TC(tp, getnsec3parameters);
737 ATF_TP_ADD_TC(tp, getnsec3parameters_bad);
738 ATF_TP_ADD_TC(tp, resigned);
739 ATF_TP_ADD_TC(tp, resigned_bad);
740
741 return (atf_no_error());
742 }
743