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 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 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 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 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); 125 ATF_TC_HEAD(attachversion, tc) { 126 atf_tc_set_md_var(tc, "descr", "check dns_db_attachversion passes with matching db/verison"); 127 } 128 ATF_TC_BODY(attachversion, tc) { 129 130 UNUSED(tc); 131 132 attachversion(NULL); 133 } 134 135 ATF_TC(attachversion_bad); 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 } 139 ATF_TC_BODY(attachversion_bad, tc) { 140 141 UNUSED(tc); 142 143 attachversion(local_callback); 144 } 145 146 static void 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); 166 ATF_TC_HEAD(closeversion, tc) { 167 atf_tc_set_md_var(tc, "descr", "check dns_db_closeversion passes with matching db/verison"); 168 } 169 ATF_TC_BODY(closeversion, tc) { 170 171 UNUSED(tc); 172 173 closeversion(NULL); 174 } 175 176 ATF_TC(closeversion_bad); 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 } 180 ATF_TC_BODY(closeversion_bad, tc) { 181 182 UNUSED(tc); 183 184 closeversion(local_callback); 185 } 186 187 static void 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); 214 ATF_TC_HEAD(find, tc) { 215 atf_tc_set_md_var(tc, "descr", "check dns_db_find passes with matching db/version"); 216 } 217 ATF_TC_BODY(find, tc) { 218 219 UNUSED(tc); 220 221 find(NULL); 222 } 223 224 ATF_TC(find_bad); 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 } 228 ATF_TC_BODY(find_bad, tc) { 229 230 UNUSED(tc); 231 232 find(local_callback); 233 } 234 235 static void 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); 268 ATF_TC_HEAD(allrdatasets, tc) { 269 atf_tc_set_md_var(tc, "descr", "check dns_db_allrdatasets passes with matching db/version"); 270 } 271 ATF_TC_BODY(allrdatasets, tc) { 272 273 UNUSED(tc); 274 275 allrdatasets(NULL); 276 } 277 278 ATF_TC(allrdatasets_bad); 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 } 282 ATF_TC_BODY(allrdatasets_bad, tc) { 283 284 UNUSED(tc); 285 286 allrdatasets(local_callback); 287 } 288 289 static void 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); 323 ATF_TC_HEAD(findrdataset, tc) { 324 atf_tc_set_md_var(tc, "descr", "check dns_db_findrdataset passes with matching db/version"); 325 } 326 ATF_TC_BODY(findrdataset, tc) { 327 328 UNUSED(tc); 329 330 findrdataset(NULL); 331 } 332 333 ATF_TC(findrdataset_bad); 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 } 337 ATF_TC_BODY(findrdataset_bad, tc) { 338 339 UNUSED(tc); 340 341 findrdataset(local_callback); 342 } 343 344 static void 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); 378 ATF_TC_HEAD(deleterdataset, tc) { 379 atf_tc_set_md_var(tc, "descr", "check dns_db_deleterdataset passes with matching db/version"); 380 } 381 ATF_TC_BODY(deleterdataset, tc) { 382 383 UNUSED(tc); 384 385 deleterdataset(NULL); 386 } 387 388 ATF_TC(deleterdataset_bad); 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 } 392 ATF_TC_BODY(deleterdataset_bad, tc) { 393 394 UNUSED(tc); 395 396 deleterdataset(local_callback); 397 } 398 399 static void 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); 440 ATF_TC_HEAD(subtractrdataset, tc) { 441 atf_tc_set_md_var(tc, "descr", "check dns_db_subtractrdataset passes with matching db/version"); 442 } 443 ATF_TC_BODY(subtractrdataset, tc) { 444 445 UNUSED(tc); 446 447 subtract(NULL); 448 } 449 450 ATF_TC(subtractrdataset_bad); 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 } 454 ATF_TC_BODY(subtractrdataset_bad, tc) { 455 456 UNUSED(tc); 457 458 subtract(local_callback); 459 } 460 461 static void 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); 488 ATF_TC_HEAD(dump, tc) { 489 atf_tc_set_md_var(tc, "descr", "check dns_db_dump passes with matching db/version"); 490 } 491 ATF_TC_BODY(dump, tc) { 492 493 UNUSED(tc); 494 495 dump(NULL); 496 } 497 498 ATF_TC(dump_bad); 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 } 502 ATF_TC_BODY(dump_bad, tc) { 503 504 UNUSED(tc); 505 506 dump(local_callback); 507 } 508 509 static void 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); 550 ATF_TC_HEAD(addrdataset, tc) { 551 atf_tc_set_md_var(tc, "descr", "check dns_db_addrdataset passes with matching db/version"); 552 } 553 ATF_TC_BODY(addrdataset, tc) { 554 555 UNUSED(tc); 556 557 addrdataset(NULL); 558 } 559 560 ATF_TC(addrdataset_bad); 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 } 564 ATF_TC_BODY(addrdataset_bad, tc) { 565 566 UNUSED(tc); 567 568 addrdataset(local_callback); 569 } 570 571 static void 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); 599 ATF_TC_HEAD(getnsec3parameters, tc) { 600 atf_tc_set_md_var(tc, "descr", "check dns_db_getnsec3parameters passes with matching db/version"); 601 } 602 ATF_TC_BODY(getnsec3parameters, tc) { 603 604 UNUSED(tc); 605 606 getnsec3parameters(NULL); 607 } 608 609 ATF_TC(getnsec3parameters_bad); 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 } 613 ATF_TC_BODY(getnsec3parameters_bad, tc) { 614 615 UNUSED(tc); 616 617 getnsec3parameters(local_callback); 618 } 619 620 static void 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); 693 ATF_TC_HEAD(resigned, tc) { 694 atf_tc_set_md_var(tc, "descr", "check dns_rdataset_resigned passes with matching db/version"); 695 } 696 ATF_TC_BODY(resigned, tc) { 697 698 UNUSED(tc); 699 700 resigned(NULL); 701 } 702 703 ATF_TC(resigned_bad); 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 } 707 ATF_TC_BODY(resigned_bad, tc) { 708 709 UNUSED(tc); 710 711 resigned(local_callback); 712 } 713 714 /* 715 * Main 716 */ 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