1 /* $NetBSD: t_db.c,v 1.7 2014/12/10 04:37:53 christos Exp $ */ 2 3 /* 4 * Copyright (C) 2004, 2005, 2007, 2009, 2011-2013 Internet Systems Consortium, Inc. ("ISC") 5 * Copyright (C) 1999-2001 Internet Software Consortium. 6 * 7 * Permission to use, copy, modify, and/or distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH 12 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 13 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, 14 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 15 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 16 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /* Id: t_db.c,v 1.41 2011/03/12 04:59:46 tbox Exp */ 21 22 #include <config.h> 23 24 #include <ctype.h> 25 #include <stdlib.h> 26 27 #include <isc/entropy.h> 28 #include <isc/hash.h> 29 #include <isc/mem.h> 30 #include <isc/string.h> 31 #include <isc/util.h> 32 33 #include <dns/db.h> 34 #include <dns/fixedname.h> 35 #include <dns/rdata.h> 36 #include <dns/rdataclass.h> 37 #include <dns/rdatatype.h> 38 #include <dns/rdatalist.h> 39 #include <dns/rdataset.h> 40 #include <dns/result.h> 41 42 #include <tests/t_api.h> 43 44 static isc_result_t 45 t_create(const char *db_type, const char *origin, const char *class, 46 const char *model, isc_mem_t *mctx, dns_db_t **db) 47 { 48 int len; 49 isc_result_t dns_result; 50 dns_dbtype_t dbtype; 51 isc_textregion_t region; 52 isc_buffer_t origin_buffer; 53 dns_fixedname_t dns_origin; 54 dns_rdataclass_t rdataclass; 55 56 57 dbtype = dns_dbtype_zone; 58 if (strcasecmp(model, "cache") == 0) 59 dbtype = dns_dbtype_cache; 60 61 dns_fixedname_init(&dns_origin); 62 len = strlen(origin); 63 isc_buffer_constinit(&origin_buffer, origin, len); 64 isc_buffer_add(&origin_buffer, len); 65 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_origin), 66 &origin_buffer, NULL, 0, NULL); 67 if (dns_result != ISC_R_SUCCESS) { 68 t_info("dns_name_fromtext failed %s\n", 69 dns_result_totext(dns_result)); 70 return(dns_result); 71 } 72 73 DE_CONST(class, region.base); 74 region.length = strlen(class); 75 dns_result = dns_rdataclass_fromtext(&rdataclass, ®ion); 76 if (dns_result != ISC_R_SUCCESS) { 77 t_info("dns_rdataclass_fromtext failed %s\n", 78 dns_result_totext(dns_result)); 79 return(dns_result); 80 } 81 82 dns_result = dns_db_create(mctx, db_type, 83 dns_fixedname_name(&dns_origin), 84 dbtype, rdataclass, 0, NULL, db); 85 if (dns_result != ISC_R_SUCCESS) 86 t_info("dns_db_create failed %s\n", 87 dns_result_totext(dns_result)); 88 89 return(dns_result); 90 91 } 92 93 static int 94 t_dns_db_load(char **av) { 95 char *filename; 96 char *db_type; 97 char *origin; 98 char *model; 99 char *class; 100 char *expected_load_result; 101 char *findname; 102 char *find_type; 103 char *expected_find_result; 104 105 int result; 106 int len; 107 dns_db_t *db; 108 isc_result_t dns_result; 109 isc_result_t isc_result; 110 isc_mem_t *mctx; 111 isc_entropy_t *ectx; 112 dns_dbnode_t *nodep; 113 isc_textregion_t textregion; 114 isc_buffer_t findname_buffer; 115 dns_fixedname_t dns_findname; 116 dns_fixedname_t dns_foundname; 117 dns_rdataset_t rdataset; 118 dns_rdatatype_t rdatatype; 119 dns_dbversion_t *versionp; 120 isc_result_t exp_load_result; 121 isc_result_t exp_find_result; 122 123 db = NULL; 124 mctx = NULL; 125 ectx = NULL; 126 filename = T_ARG(0); 127 db_type = T_ARG(1); 128 origin = T_ARG(2); 129 model = T_ARG(3); 130 class = T_ARG(4); 131 expected_load_result = T_ARG(5); 132 findname = T_ARG(6); 133 find_type = T_ARG(7); 134 expected_find_result = T_ARG(8); 135 136 t_info("testing using file %s and name %s\n", filename, findname); 137 138 exp_load_result = t_dns_result_fromtext(expected_load_result); 139 exp_find_result = t_dns_result_fromtext(expected_find_result); 140 141 isc_result = isc_mem_create(0, 0, &mctx); 142 if (isc_result != ISC_R_SUCCESS) { 143 t_info("isc_mem_create failed %s\n", 144 isc_result_totext(isc_result)); 145 return(T_UNRESOLVED); 146 } 147 148 isc_result = isc_entropy_create(mctx, &ectx); 149 if (isc_result != ISC_R_SUCCESS) { 150 t_info("isc_entropy_create failed %s\n", 151 isc_result_totext(isc_result)); 152 isc_mem_destroy(&mctx); 153 return(T_UNRESOLVED); 154 } 155 156 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 157 if (isc_result != ISC_R_SUCCESS) { 158 t_info("isc_hash_create failed %s\n", 159 isc_result_totext(isc_result)); 160 isc_entropy_detach(&ectx); 161 isc_mem_destroy(&mctx); 162 return(T_UNRESOLVED); 163 } 164 165 dns_result = t_create(db_type, origin, class, model, mctx, &db); 166 if (dns_result != ISC_R_SUCCESS) { 167 isc_hash_destroy(); 168 isc_entropy_detach(&ectx); 169 isc_mem_destroy(&mctx); 170 return(T_UNRESOLVED); 171 } 172 173 dns_result = dns_db_load(db, filename); 174 if (dns_result != exp_load_result) { 175 t_info("dns_db_load returned %s, expected %s\n", 176 dns_result_totext(dns_result), 177 dns_result_totext(exp_load_result)); 178 dns_db_detach(&db); 179 isc_hash_destroy(); 180 isc_entropy_detach(&ectx); 181 isc_mem_destroy(&mctx); 182 return(T_FAIL); 183 } 184 if (dns_result != ISC_R_SUCCESS) { 185 result = T_PASS; 186 goto cleanup_db; 187 } 188 189 dns_fixedname_init(&dns_findname); 190 len = strlen(findname); 191 isc_buffer_init(&findname_buffer, findname, len); 192 isc_buffer_add(&findname_buffer, len); 193 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_findname), 194 &findname_buffer, NULL, 0, NULL); 195 if (dns_result != ISC_R_SUCCESS) { 196 t_info("dns_name_fromtext failed %s\n", 197 dns_result_totext(dns_result)); 198 dns_db_detach(&db); 199 isc_hash_destroy(); 200 isc_entropy_detach(&ectx); 201 isc_mem_destroy(&mctx); 202 return(T_UNRESOLVED); 203 } 204 205 textregion.base = find_type; 206 textregion.length = strlen(find_type); 207 dns_result = dns_rdatatype_fromtext(&rdatatype, &textregion); 208 if (dns_result != ISC_R_SUCCESS) { 209 t_info("dns_rdatatype_fromtext %s failed %s\n", 210 find_type, 211 dns_result_totext(dns_result)); 212 dns_db_detach(&db); 213 isc_hash_destroy(); 214 isc_entropy_detach(&ectx); 215 isc_mem_destroy(&mctx); 216 return(T_UNRESOLVED); 217 } 218 219 versionp = NULL; 220 dns_fixedname_init(&dns_foundname); 221 dns_rdataset_init(&rdataset); 222 if (dns_db_iszone(db)) 223 dns_db_currentversion(db, &versionp); 224 nodep = NULL; 225 226 dns_result = dns_db_find(db, 227 dns_fixedname_name(&dns_findname), 228 versionp, 229 rdatatype, 230 DNS_DBFIND_GLUEOK, 231 0, 232 &nodep, 233 dns_fixedname_name(&dns_foundname), 234 &rdataset, NULL); 235 236 if (dns_result != exp_find_result) { 237 t_info("dns_db_find returned %s, expected %s\n", 238 dns_result_totext(dns_result), 239 dns_result_totext(exp_find_result)); 240 result = T_FAIL; 241 } else { 242 result = T_PASS; 243 } 244 245 if (dns_result != ISC_R_NOTFOUND) { 246 dns_db_detachnode(db, &nodep); 247 if (dns_rdataset_isassociated(&rdataset)) 248 dns_rdataset_disassociate(&rdataset); 249 } 250 251 if (dns_db_iszone(db)) 252 dns_db_closeversion(db, &versionp, ISC_FALSE); 253 cleanup_db: 254 dns_db_detach(&db); 255 isc_hash_destroy(); 256 isc_entropy_detach(&ectx); 257 isc_mem_destroy(&mctx); 258 return(result); 259 } 260 261 static const char *a1 = 262 "A call to dns_db_load(db, filename) loads the contents of " 263 "the database in filename into db."; 264 265 static void 266 t1(void) { 267 int result; 268 269 t_assert("dns_db_load", 1, T_REQUIRED, "%s", a1); 270 result = t_eval("dns_db_load_data", t_dns_db_load, 9); 271 t_result(result); 272 } 273 274 275 static const char *a2 = 276 "When the database db has cache semantics, a call to " 277 "dns_db_iscache(db) returns ISC_TRUE."; 278 279 static int 280 t_dns_db_zc_x(char *filename, char *db_type, char *origin, char *class, 281 dns_dbtype_t dbtype, isc_boolean_t(*cf)(dns_db_t *), 282 isc_boolean_t exp_result) 283 { 284 int result; 285 int len; 286 dns_db_t *db; 287 isc_result_t dns_result; 288 isc_result_t isc_result; 289 isc_mem_t *mctx; 290 isc_entropy_t *ectx; 291 dns_rdataclass_t rdataclass; 292 isc_textregion_t textregion; 293 isc_buffer_t origin_buffer; 294 dns_fixedname_t dns_origin; 295 296 db = NULL; 297 mctx = NULL; 298 ectx = NULL; 299 300 t_info("testing using file %s\n", filename); 301 302 dns_fixedname_init(&dns_origin); 303 len = strlen(origin); 304 isc_buffer_init(&origin_buffer, origin, len); 305 isc_buffer_add(&origin_buffer, len); 306 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_origin), 307 &origin_buffer, NULL, 0, NULL); 308 if (dns_result != ISC_R_SUCCESS) { 309 t_info("dns_name_fromtext failed %s\n", 310 dns_result_totext(dns_result)); 311 return(T_UNRESOLVED); 312 } 313 314 textregion.base = class; 315 textregion.length = strlen(class); 316 dns_result = dns_rdataclass_fromtext(&rdataclass, &textregion); 317 if (dns_result != ISC_R_SUCCESS) { 318 t_info("dns_rdataclass_fromtext failed %s\n", 319 dns_result_totext(dns_result)); 320 return(T_UNRESOLVED); 321 } 322 323 isc_result = isc_mem_create(0, 0, &mctx); 324 if (isc_result != ISC_R_SUCCESS) { 325 t_info("isc_mem_create failed %s\n", 326 isc_result_totext(isc_result)); 327 return(T_UNRESOLVED); 328 } 329 330 isc_result = isc_entropy_create(mctx, &ectx); 331 if (isc_result != ISC_R_SUCCESS) { 332 t_info("isc_entropy_create failed %s\n", 333 isc_result_totext(isc_result)); 334 isc_mem_destroy(&mctx); 335 return(T_UNRESOLVED); 336 } 337 338 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 339 if (isc_result != ISC_R_SUCCESS) { 340 t_info("isc_hash_create failed %s\n", 341 isc_result_totext(isc_result)); 342 isc_entropy_detach(&ectx); 343 isc_mem_destroy(&mctx); 344 return(T_UNRESOLVED); 345 } 346 347 dns_result = dns_db_create(mctx, db_type, 348 dns_fixedname_name(&dns_origin), 349 dbtype, rdataclass, 0, NULL, &db); 350 if (dns_result != ISC_R_SUCCESS) { 351 t_info("dns_db_create failed %s\n", 352 dns_result_totext(dns_result)); 353 isc_hash_destroy(); 354 isc_entropy_detach(&ectx); 355 isc_mem_destroy(&mctx); 356 return(T_UNRESOLVED); 357 } 358 359 dns_result = dns_db_load(db, filename); 360 if (dns_result == ISC_R_SUCCESS) { 361 if ((*cf)(db) == exp_result) 362 result = T_PASS; 363 else 364 result = T_FAIL; 365 } else { 366 t_info("dns_db_load failed %s\n", 367 dns_result_totext(dns_result)); 368 result = T_FAIL; 369 } 370 371 dns_db_detach(&db); 372 isc_hash_destroy(); 373 isc_entropy_detach(&ectx); 374 isc_mem_destroy(&mctx); 375 return(result); 376 } 377 378 static int 379 test_dns_db_zc_x(const char *filename, dns_dbtype_t dbtype, 380 isc_boolean_t(*cf)(dns_db_t *), isc_boolean_t exp_result) 381 { 382 383 FILE *fp; 384 char *p; 385 int line; 386 int cnt; 387 int result; 388 int nfails; 389 int nprobs; 390 char *tokens[T_MAXTOKS]; 391 392 nfails = 0; 393 nprobs = 0; 394 395 fp = fopen(filename, "r"); 396 if (fp != NULL) { 397 line = 0; 398 while ((p = t_fgetbs(fp)) != NULL) { 399 400 ++line; 401 402 /* 403 * Skip comment lines. 404 */ 405 if ((isspace((unsigned char)*p)) || (*p == '#')) { 406 (void)free(p); 407 continue; 408 } 409 410 cnt = t_bustline(p, tokens); 411 if (cnt == 4) { 412 result = t_dns_db_zc_x(tokens[0], /* file */ 413 tokens[1], /* type */ 414 tokens[2], /* origin */ 415 tokens[3], /* class */ 416 dbtype, /* cache */ 417 cf, /* check func */ 418 exp_result);/* expect */ 419 if (result != T_PASS) { 420 if (result == T_FAIL) 421 ++nfails; 422 else 423 ++nprobs; 424 } 425 } else { 426 t_info("bad format in %s at line %d\n", 427 filename, line); 428 ++nprobs; 429 } 430 431 (void)free(p); 432 } 433 (void)fclose(fp); 434 } else { 435 t_info("Missing datafile %s\n", filename); 436 ++nprobs; 437 } 438 439 result = T_UNRESOLVED; 440 441 if (nfails == 0 && nprobs == 0) 442 result = T_PASS; 443 else if (nfails) 444 result = T_FAIL; 445 446 return(result); 447 } 448 449 static void 450 t2(void) { 451 int result; 452 453 t_assert("dns_db_iscache", 2, T_REQUIRED, "%s", a2); 454 result = test_dns_db_zc_x("dns_db_iscache_1_data", 455 dns_dbtype_cache, dns_db_iscache, ISC_TRUE); 456 t_result(result); 457 } 458 459 460 static const char *a3 = 461 "When the database db has zone semantics, a call to " 462 "dns_db_iscache(db) returns ISC_FALSE."; 463 464 465 static void 466 t3(void) { 467 int result; 468 469 t_assert("dns_db_iscache", 3, T_REQUIRED, "%s", a3); 470 result = test_dns_db_zc_x("dns_db_iscache_2_data", 471 dns_dbtype_zone, dns_db_iscache, ISC_FALSE); 472 t_result(result); 473 } 474 475 476 static const char *a4 = 477 "When the database db has zone semantics, a call to " 478 "dns_db_iszone(db) returns ISC_TRUE."; 479 480 481 static void 482 t4(void) { 483 int result; 484 485 t_assert("dns_db_iszone", 4, T_REQUIRED, "%s", a4); 486 result = test_dns_db_zc_x("dns_db_iszone_1_data", 487 dns_dbtype_zone, dns_db_iszone, ISC_TRUE); 488 t_result(result); 489 } 490 491 492 static const char *a5 = 493 "When the database db has cache semantics, a call to " 494 "dns_db_iszone(db) returns ISC_FALSE."; 495 496 static void 497 t5(void) { 498 int result; 499 500 t_assert("dns_db_iszone", 5, T_REQUIRED, "%s", a5); 501 result = test_dns_db_zc_x("dns_db_iszone_2_data", 502 dns_dbtype_cache, dns_db_iszone, ISC_FALSE); 503 t_result(result); 504 } 505 506 static int 507 t_dns_db_origin(char **av) { 508 509 char *filename; 510 char *origin; 511 512 int result; 513 int len; 514 int order; 515 isc_result_t dns_result; 516 isc_result_t isc_result; 517 isc_mem_t *mctx; 518 isc_entropy_t *ectx; 519 dns_db_t *db; 520 dns_fixedname_t dns_origin; 521 dns_fixedname_t dns_dborigin; 522 isc_buffer_t origin_buffer; 523 524 db = NULL; 525 mctx = NULL; 526 ectx = NULL; 527 528 filename = T_ARG(0); 529 origin = T_ARG(1); 530 531 t_info("testing with database %s and origin %s\n", 532 filename, origin); 533 534 isc_result = isc_mem_create(0, 0, &mctx); 535 if (isc_result != ISC_R_SUCCESS) { 536 t_info("isc_mem_create failed %s\n", 537 isc_result_totext(isc_result)); 538 return(T_UNRESOLVED); 539 } 540 541 isc_result = isc_entropy_create(mctx, &ectx); 542 if (isc_result != ISC_R_SUCCESS) { 543 t_info("isc_entropy_create failed %s\n", 544 isc_result_totext(isc_result)); 545 isc_mem_destroy(&mctx); 546 return(T_UNRESOLVED); 547 } 548 549 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 550 if (isc_result != ISC_R_SUCCESS) { 551 t_info("isc_hash_create failed %s\n", 552 isc_result_totext(isc_result)); 553 isc_entropy_detach(&ectx); 554 isc_mem_destroy(&mctx); 555 return(T_UNRESOLVED); 556 } 557 558 dns_result = t_create("rbt", origin, "in", "isc_true", mctx, &db); 559 if (dns_result != ISC_R_SUCCESS) { 560 t_info("t_create failed %s\n", 561 dns_result_totext(dns_result)); 562 isc_hash_destroy(); 563 isc_entropy_detach(&ectx); 564 isc_mem_destroy(&mctx); 565 return(T_UNRESOLVED); 566 } 567 dns_fixedname_init(&dns_origin); 568 dns_fixedname_init(&dns_dborigin); 569 570 len = strlen(origin); 571 isc_buffer_init(&origin_buffer, origin, len); 572 isc_buffer_add(&origin_buffer, len); 573 574 dns_result = dns_db_load(db, filename); 575 if (dns_result != ISC_R_SUCCESS) { 576 t_info("dns_db_load failed %s\n", 577 dns_result_totext(dns_result)); 578 dns_db_detach(&db); 579 isc_hash_destroy(); 580 isc_entropy_detach(&ectx); 581 isc_mem_destroy(&mctx); 582 return(T_UNRESOLVED); 583 } 584 585 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_origin), 586 &origin_buffer, NULL, 0, NULL); 587 if (dns_result != ISC_R_SUCCESS) { 588 t_info("dns_name_fromtext failed %s\n", 589 dns_result_totext(dns_result)); 590 dns_db_detach(&db); 591 isc_hash_destroy(); 592 isc_entropy_detach(&ectx); 593 isc_mem_destroy(&mctx); 594 return(T_UNRESOLVED); 595 } 596 order = dns_name_compare(dns_fixedname_name(&dns_origin), 597 dns_db_origin(db)); 598 if (order == 0) { 599 result = T_PASS; 600 } else { 601 t_info("dns_name_compare returned %d\n", order); 602 result = T_FAIL; 603 } 604 605 dns_db_detach(&db); 606 isc_hash_destroy(); 607 isc_entropy_detach(&ectx); 608 isc_mem_destroy(&mctx); 609 return(result); 610 611 } 612 613 static const char *a6 = 614 "A call to dns_db_origin(db) returns the origin of the database."; 615 616 static void 617 t6(void) { 618 int result; 619 620 t_assert("dns_db_origin", 6, T_REQUIRED, "%s", a6); 621 result = t_eval("dns_db_origin_data", t_dns_db_origin, 2); 622 t_result(result); 623 } 624 625 626 static const char *a7 = 627 "A call to dns_db_class(db) returns the class of the database."; 628 629 630 #define CLASSBUFLEN 256 631 632 static int 633 t_dns_db_class(char **av) { 634 635 char *filename; 636 char *class; 637 638 int result; 639 isc_result_t dns_result; 640 isc_result_t isc_result; 641 isc_mem_t *mctx; 642 isc_entropy_t *ectx; 643 dns_db_t *db; 644 dns_rdataclass_t rdataclass; 645 dns_rdataclass_t db_rdataclass; 646 isc_textregion_t textregion; 647 648 filename = T_ARG(0); 649 class = T_ARG(1); 650 db = NULL; 651 mctx = NULL; 652 ectx = NULL; 653 654 t_info("testing with database %s and class %s\n", 655 filename, class); 656 657 textregion.base = class; 658 textregion.length = strlen(class); 659 dns_result = dns_rdataclass_fromtext(&rdataclass, &textregion); 660 if (dns_result != ISC_R_SUCCESS) { 661 t_info("dns_rdataclass_fromtext failed %s\n", 662 dns_result_totext(dns_result)); 663 return(T_UNRESOLVED); 664 } 665 666 isc_result = isc_mem_create(0, 0, &mctx); 667 if (isc_result != ISC_R_SUCCESS) { 668 t_info("isc_mem_create failed %s\n", 669 isc_result_totext(isc_result)); 670 return(T_UNRESOLVED); 671 } 672 673 isc_result = isc_entropy_create(mctx, &ectx); 674 if (isc_result != ISC_R_SUCCESS) { 675 t_info("isc_entropy_create failed %s\n", 676 isc_result_totext(isc_result)); 677 isc_mem_destroy(&mctx); 678 return(T_UNRESOLVED); 679 } 680 681 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 682 if (isc_result != ISC_R_SUCCESS) { 683 t_info("isc_hash_create failed %s\n", 684 isc_result_totext(isc_result)); 685 isc_entropy_detach(&ectx); 686 isc_mem_destroy(&mctx); 687 return(T_UNRESOLVED); 688 } 689 690 dns_result = t_create("rbt", ".", class, "isc_true", mctx, &db); 691 if (dns_result != ISC_R_SUCCESS) { 692 t_info("t_create failed %s\n", 693 dns_result_totext(dns_result)); 694 isc_hash_destroy(); 695 isc_entropy_detach(&ectx); 696 isc_mem_destroy(&mctx); 697 return(T_UNRESOLVED); 698 } 699 700 dns_result = dns_db_load(db, filename); 701 if (dns_result != ISC_R_SUCCESS) { 702 t_info("dns_db_load failed %s\n", 703 dns_result_totext(dns_result)); 704 dns_db_detach(&db); 705 isc_hash_destroy(); 706 isc_entropy_detach(&ectx); 707 isc_mem_destroy(&mctx); 708 return(T_UNRESOLVED); 709 } 710 711 db_rdataclass = dns_db_class(db); 712 if (db_rdataclass == rdataclass) 713 result = T_PASS; 714 else { 715 char classbuf[DNS_RDATACLASS_FORMATSIZE]; 716 dns_rdataclass_format(db_rdataclass, 717 classbuf, sizeof(classbuf)); 718 t_info("dns_db_class returned %s, expected %s\n", 719 classbuf, class); 720 result = T_FAIL; 721 } 722 723 dns_db_detach(&db); 724 isc_hash_destroy(); 725 isc_entropy_detach(&ectx); 726 isc_mem_destroy(&mctx); 727 return(result); 728 729 } 730 static void 731 t7(void) { 732 int result; 733 734 t_assert("dns_db_class", 7, T_REQUIRED, "%s", a7); 735 result = t_eval("dns_db_class_data", t_dns_db_class, 2); 736 t_result(result); 737 } 738 739 740 static const char *a8 = 741 "A call to dns_db_currentversion() opens the current " 742 "version for reading."; 743 744 static int 745 t_dns_db_currentversion(char **av) { 746 char *filename; 747 char *db_type; 748 char *origin; 749 char *class; 750 char *model; 751 char *findname; 752 char *findtype; 753 754 int result; 755 int len; 756 dns_db_t *db; 757 isc_result_t dns_result; 758 isc_result_t isc_result; 759 isc_mem_t *mctx; 760 isc_entropy_t *ectx; 761 dns_dbnode_t *nodep; 762 isc_textregion_t textregion; 763 isc_buffer_t findname_buffer; 764 dns_fixedname_t dns_findname; 765 dns_fixedname_t dns_foundname; 766 dns_rdataset_t rdataset; 767 dns_rdatatype_t rdatatype; 768 dns_dbversion_t *cversionp; 769 dns_dbversion_t *nversionp; 770 771 filename = T_ARG(0); 772 db_type = T_ARG(1); 773 origin = T_ARG(2); 774 class = T_ARG(3); 775 model = T_ARG(4); 776 findname = T_ARG(5); 777 findtype = T_ARG(6); 778 db = NULL; 779 mctx = NULL; 780 ectx = NULL; 781 782 t_info("testing using file %s and name %s\n", filename, findname); 783 784 isc_result = isc_mem_create(0, 0, &mctx); 785 if (isc_result != ISC_R_SUCCESS) { 786 t_info("isc_mem_create failed %s\n", 787 isc_result_totext(isc_result)); 788 return(T_UNRESOLVED); 789 } 790 791 isc_result = isc_entropy_create(mctx, &ectx); 792 if (isc_result != ISC_R_SUCCESS) { 793 t_info("isc_entropy_create failed %s\n", 794 isc_result_totext(isc_result)); 795 isc_mem_destroy(&mctx); 796 return(T_UNRESOLVED); 797 } 798 799 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 800 if (isc_result != ISC_R_SUCCESS) { 801 t_info("isc_hash_create failed %s\n", 802 isc_result_totext(isc_result)); 803 isc_entropy_detach(&ectx); 804 isc_mem_destroy(&mctx); 805 return(T_UNRESOLVED); 806 } 807 808 dns_result = t_create(db_type, origin, class, model, mctx, &db); 809 if (dns_result != ISC_R_SUCCESS) { 810 isc_hash_destroy(); 811 isc_entropy_detach(&ectx); 812 isc_mem_destroy(&mctx); 813 return(T_UNRESOLVED); 814 } 815 816 dns_result = dns_db_load(db, filename); 817 if (dns_result != ISC_R_SUCCESS) { 818 t_info("dns_db_load returned %s\n", 819 dns_result_totext(dns_result)); 820 dns_db_detach(&db); 821 isc_hash_destroy(); 822 isc_entropy_detach(&ectx); 823 isc_mem_destroy(&mctx); 824 return(T_UNRESOLVED); 825 } 826 827 dns_fixedname_init(&dns_findname); 828 len = strlen(findname); 829 isc_buffer_init(&findname_buffer, findname, len); 830 isc_buffer_add(&findname_buffer, len); 831 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_findname), 832 &findname_buffer, NULL, 0, NULL); 833 if (dns_result != ISC_R_SUCCESS) { 834 t_info("dns_name_fromtext failed %s\n", 835 dns_result_totext(dns_result)); 836 dns_db_detach(&db); 837 isc_hash_destroy(); 838 isc_entropy_detach(&ectx); 839 isc_mem_destroy(&mctx); 840 return(T_UNRESOLVED); 841 } 842 843 textregion.base = findtype; 844 textregion.length = strlen(findtype); 845 dns_result = dns_rdatatype_fromtext(&rdatatype, &textregion); 846 if (dns_result != ISC_R_SUCCESS) { 847 t_info("dns_rdatatype_fromtext %s failed %s\n", 848 findtype, 849 dns_result_totext(dns_result)); 850 dns_db_detach(&db); 851 isc_hash_destroy(); 852 isc_entropy_detach(&ectx); 853 isc_mem_destroy(&mctx); 854 return(T_UNRESOLVED); 855 } 856 857 /* 858 * find a name we know is there 859 */ 860 861 cversionp = NULL; 862 dns_fixedname_init(&dns_foundname); 863 dns_rdataset_init(&rdataset); 864 dns_db_currentversion(db, &cversionp); 865 nodep = NULL; 866 867 dns_result = dns_db_find(db, 868 dns_fixedname_name(&dns_findname), 869 cversionp, 870 rdatatype, 871 0, 872 0, 873 &nodep, 874 dns_fixedname_name(&dns_foundname), 875 &rdataset, NULL); 876 877 if (dns_result != ISC_R_SUCCESS) { 878 t_info("unable to find %s using current version\n", findname); 879 dns_db_closeversion(db, &cversionp, ISC_FALSE); 880 dns_db_detach(&db); 881 isc_hash_destroy(); 882 isc_entropy_detach(&ectx); 883 isc_mem_destroy(&mctx); 884 return(T_UNRESOLVED); 885 } 886 887 /* 888 * create a new version 889 * delete the found rdataset in the new version 890 * attempt to find the rdataset again and expect the find to fail 891 * close/commit the new version 892 * attempt to find the rdataset in the current version and 893 * expect the find to succeed 894 */ 895 896 nversionp = NULL; 897 dns_result = dns_db_newversion(db, &nversionp); 898 if (dns_result != ISC_R_SUCCESS) { 899 t_info("dns_db_newversion failed %s\n", 900 dns_result_totext(dns_result)); 901 dns_db_detachnode(db, &nodep); 902 dns_rdataset_disassociate(&rdataset); 903 dns_db_closeversion(db, &cversionp, ISC_FALSE); 904 dns_db_detach(&db); 905 isc_hash_destroy(); 906 isc_entropy_detach(&ectx); 907 isc_mem_destroy(&mctx); 908 return(T_UNRESOLVED); 909 } 910 911 /* 912 * Delete the found rdataset in the new version. 913 */ 914 dns_result = dns_db_deleterdataset(db, nodep, nversionp, rdatatype, 0); 915 if (dns_result != ISC_R_SUCCESS) { 916 t_info("dns_db_deleterdataset failed %s\n", 917 dns_result_totext(dns_result)); 918 dns_rdataset_disassociate(&rdataset); 919 dns_db_detachnode(db, &nodep); 920 dns_db_closeversion(db, &nversionp, ISC_FALSE); 921 dns_db_closeversion(db, &cversionp, ISC_FALSE); 922 dns_db_detach(&db); 923 isc_hash_destroy(); 924 isc_entropy_detach(&ectx); 925 isc_mem_destroy(&mctx); 926 return(T_UNRESOLVED); 927 } 928 929 /* 930 * Don't need these now. 931 */ 932 dns_rdataset_disassociate(&rdataset); 933 dns_db_detachnode(db, &nodep); 934 nodep = NULL; 935 936 /* 937 * Find the deleted rdataset and expect it to fail. 938 */ 939 dns_result = dns_db_find(db, 940 dns_fixedname_name(&dns_findname), 941 nversionp, 942 rdatatype, 943 0, 944 0, 945 &nodep, 946 dns_fixedname_name(&dns_foundname), 947 &rdataset, NULL); 948 949 if ((dns_result != ISC_R_NOTFOUND) && (dns_result != DNS_R_NXDOMAIN)) { 950 t_info("unexpectedly found %s using current version\n", 951 findname); 952 dns_db_closeversion(db, &cversionp, ISC_FALSE); 953 dns_db_closeversion(db, &nversionp, ISC_FALSE); 954 dns_db_detach(&db); 955 isc_hash_destroy(); 956 isc_entropy_detach(&ectx); 957 isc_mem_destroy(&mctx); 958 return(T_FAIL); 959 } 960 961 /* 962 * Close/commit the new version. 963 */ 964 dns_db_closeversion(db, &nversionp, ISC_TRUE); 965 966 /* 967 * Find the deleted rdata in the current version. 968 */ 969 dns_result = dns_db_find(db, dns_fixedname_name(&dns_findname), 970 cversionp, rdatatype, DNS_DBFIND_GLUEOK, 971 0, &nodep, dns_fixedname_name(&dns_foundname), 972 &rdataset, NULL); 973 974 /* 975 * And expect it to succeed. 976 */ 977 if (dns_result == ISC_R_SUCCESS) { 978 result = T_PASS; 979 } else { 980 t_info("cound not find %s using current version\n", findname); 981 dns_db_closeversion(db, &cversionp, ISC_FALSE); 982 dns_db_detach(&db); 983 isc_hash_destroy(); 984 isc_entropy_detach(&ectx); 985 isc_mem_destroy(&mctx); 986 result = T_FAIL; 987 } 988 989 dns_db_detachnode(db, &nodep); 990 dns_rdataset_disassociate(&rdataset); 991 992 dns_db_closeversion(db, &cversionp, ISC_FALSE); 993 dns_db_detach(&db); 994 isc_hash_destroy(); 995 isc_entropy_detach(&ectx); 996 isc_mem_destroy(&mctx); 997 998 return(result); 999 } 1000 1001 static void 1002 t8(void) { 1003 int result; 1004 1005 t_assert("dns_db_currentversion", 8, T_REQUIRED, "%s", a8); 1006 result = t_eval("dns_db_currentversion_data", 1007 t_dns_db_currentversion, 7); 1008 t_result(result); 1009 } 1010 1011 static const char *a9 = 1012 "A call to dns_db_newversion() opens a new version for " 1013 "reading and writing."; 1014 1015 static int 1016 t_dns_db_newversion(char **av) { 1017 1018 char *filename; 1019 char *db_type; 1020 char *origin; 1021 char *class; 1022 char *model; 1023 char *newname; 1024 char *newtype; 1025 1026 int result; 1027 int len; 1028 int rval; 1029 dns_db_t *db; 1030 isc_result_t dns_result; 1031 isc_result_t isc_result; 1032 isc_mem_t *mctx; 1033 isc_entropy_t *ectx; 1034 dns_dbnode_t *nodep; 1035 dns_dbnode_t *found_nodep; 1036 isc_textregion_t textregion; 1037 isc_buffer_t newname_buffer; 1038 dns_fixedname_t dns_newname; 1039 dns_fixedname_t dns_foundname; 1040 dns_rdata_t added_rdata = DNS_RDATA_INIT; 1041 const char * added_rdata_data; 1042 dns_rdataset_t added_rdataset; 1043 dns_rdata_t found_rdata = DNS_RDATA_INIT; 1044 dns_rdataset_t found_rdataset; 1045 dns_rdatatype_t rdatatype; 1046 dns_rdataclass_t rdataclass; 1047 dns_dbversion_t *nversionp; 1048 dns_rdatalist_t rdatalist; 1049 1050 filename = T_ARG(0); 1051 db_type = T_ARG(1); 1052 origin = T_ARG(2); 1053 class = T_ARG(3); 1054 model = T_ARG(4); 1055 newname = T_ARG(5); 1056 newtype = T_ARG(6); 1057 db = NULL; 1058 mctx = NULL; 1059 ectx = NULL; 1060 1061 /* 1062 * Open a new version, add some data, commit it, 1063 * close it, open a new version, and check that changes 1064 * are present. 1065 */ 1066 1067 t_info("testing using file %s and name %s\n", filename, newname); 1068 1069 isc_result = isc_mem_create(0, 0, &mctx); 1070 if (isc_result != ISC_R_SUCCESS) { 1071 t_info("isc_mem_create failed %s\n", 1072 isc_result_totext(isc_result)); 1073 return(T_UNRESOLVED); 1074 } 1075 1076 isc_result = isc_entropy_create(mctx, &ectx); 1077 if (isc_result != ISC_R_SUCCESS) { 1078 t_info("isc_entropy_create failed %s\n", 1079 isc_result_totext(isc_result)); 1080 isc_mem_destroy(&mctx); 1081 return(T_UNRESOLVED); 1082 } 1083 1084 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 1085 if (isc_result != ISC_R_SUCCESS) { 1086 t_info("isc_hash_create failed %s\n", 1087 isc_result_totext(isc_result)); 1088 isc_entropy_detach(&ectx); 1089 isc_mem_destroy(&mctx); 1090 return(T_UNRESOLVED); 1091 } 1092 1093 dns_result = t_create(db_type, origin, class, model, mctx, &db); 1094 if (dns_result != ISC_R_SUCCESS) { 1095 isc_hash_destroy(); 1096 isc_entropy_detach(&ectx); 1097 isc_mem_destroy(&mctx); 1098 return(T_UNRESOLVED); 1099 } 1100 1101 dns_result = dns_db_load(db, filename); 1102 if (dns_result != ISC_R_SUCCESS) { 1103 t_info("dns_db_load returned %s\n", 1104 dns_result_totext(dns_result)); 1105 dns_db_detach(&db); 1106 isc_hash_destroy(); 1107 isc_entropy_detach(&ectx); 1108 isc_mem_destroy(&mctx); 1109 return(T_UNRESOLVED); 1110 } 1111 1112 /* 1113 * Add a new name. 1114 */ 1115 1116 dns_fixedname_init(&dns_newname); 1117 len = strlen(newname); 1118 isc_buffer_init(&newname_buffer, newname, len); 1119 isc_buffer_add(&newname_buffer, len); 1120 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_newname), 1121 &newname_buffer, NULL, 0, NULL); 1122 if (dns_result != ISC_R_SUCCESS) { 1123 t_info("dns_name_fromtext failed %s\n", 1124 dns_result_totext(dns_result)); 1125 dns_db_detach(&db); 1126 isc_hash_destroy(); 1127 isc_entropy_detach(&ectx); 1128 isc_mem_destroy(&mctx); 1129 return(T_UNRESOLVED); 1130 } 1131 1132 nodep = NULL; 1133 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_newname), 1134 ISC_TRUE, &nodep); 1135 if (dns_result != ISC_R_SUCCESS) { 1136 t_info("dns_db_findnode failed %s\n", 1137 dns_result_totext(dns_result)); 1138 dns_db_detach(&db); 1139 isc_hash_destroy(); 1140 isc_entropy_detach(&ectx); 1141 isc_mem_destroy(&mctx); 1142 return(T_UNRESOLVED); 1143 } 1144 1145 /* 1146 * Open a new version and associate some rdata with the new name. 1147 */ 1148 1149 textregion.base = newtype; 1150 textregion.length = strlen(newtype); 1151 dns_result = dns_rdatatype_fromtext(&rdatatype, &textregion); 1152 1153 if (dns_result != ISC_R_SUCCESS) { 1154 t_info("dns_rdatatype_fromtext %s failed %s\n", 1155 newtype, 1156 dns_result_totext(dns_result)); 1157 dns_db_detachnode(db, &nodep); 1158 dns_db_detach(&db); 1159 isc_hash_destroy(); 1160 isc_entropy_detach(&ectx); 1161 isc_mem_destroy(&mctx); 1162 return(T_UNRESOLVED); 1163 } 1164 1165 textregion.base = class; 1166 textregion.length = strlen(class); 1167 dns_result = dns_rdataclass_fromtext(&rdataclass, &textregion); 1168 if (dns_result != ISC_R_SUCCESS) { 1169 t_info("dns_rdataclass_fromtext failed %s\n", 1170 dns_result_totext(dns_result)); 1171 dns_db_detachnode(db, &nodep); 1172 dns_db_detach(&db); 1173 isc_hash_destroy(); 1174 isc_entropy_detach(&ectx); 1175 isc_mem_destroy(&mctx); 1176 return(T_UNRESOLVED); 1177 } 1178 1179 dns_rdata_init(&added_rdata); 1180 added_rdata_data = "\x10\x00\x00\x01"; 1181 DE_CONST(added_rdata_data, added_rdata.data); 1182 added_rdata.length = 4; 1183 added_rdata.rdclass = rdataclass; 1184 added_rdata.type = rdatatype; 1185 1186 dns_rdataset_init(&added_rdataset); 1187 rdatalist.type = rdatatype; 1188 rdatalist.covers = 0; 1189 rdatalist.rdclass = rdataclass; 1190 rdatalist.ttl = 0; 1191 ISC_LIST_INIT(rdatalist.rdata); 1192 ISC_LIST_APPEND(rdatalist.rdata, &added_rdata, link); 1193 1194 dns_result = dns_rdatalist_tordataset(&rdatalist, &added_rdataset); 1195 if (dns_result != ISC_R_SUCCESS) { 1196 t_info("dns_rdatalist_tordataset failed %s\n", 1197 dns_result_totext(dns_result)); 1198 dns_db_detachnode(db, &nodep); 1199 dns_db_detach(&db); 1200 isc_hash_destroy(); 1201 isc_entropy_detach(&ectx); 1202 isc_mem_destroy(&mctx); 1203 return(T_UNRESOLVED); 1204 } 1205 1206 nversionp = NULL; 1207 dns_result = dns_db_newversion(db, &nversionp); 1208 if (dns_result != ISC_R_SUCCESS) { 1209 t_info("dns_db_newversion failed %s\n", 1210 dns_result_totext(dns_result)); 1211 dns_db_detachnode(db, &nodep); 1212 dns_db_detach(&db); 1213 isc_hash_destroy(); 1214 isc_entropy_detach(&ectx); 1215 isc_mem_destroy(&mctx); 1216 return(T_UNRESOLVED); 1217 } 1218 1219 dns_result = dns_db_addrdataset(db, nodep, nversionp, 0, 1220 &added_rdataset, 0, NULL); 1221 if (dns_result != ISC_R_SUCCESS) { 1222 t_info("dns_db_addrdataset failed %s\n", 1223 dns_result_totext(dns_result)); 1224 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1225 dns_db_detachnode(db, &nodep); 1226 dns_db_detach(&db); 1227 isc_hash_destroy(); 1228 isc_entropy_detach(&ectx); 1229 isc_mem_destroy(&mctx); 1230 return(T_UNRESOLVED); 1231 } 1232 1233 /* 1234 * Close and commit the version. 1235 */ 1236 dns_db_closeversion(db, &nversionp, ISC_TRUE); 1237 dns_db_detachnode(db, &nodep); 1238 if (dns_rdataset_isassociated(&added_rdataset)) 1239 dns_rdataset_disassociate(&added_rdataset); 1240 nodep = NULL; 1241 1242 /* 1243 * Open a new version and find the data we added. 1244 */ 1245 dns_fixedname_init(&dns_foundname); 1246 dns_rdataset_init(&found_rdataset); 1247 nversionp = NULL; 1248 found_nodep = NULL; 1249 dns_db_newversion(db, &nversionp); 1250 1251 /* 1252 * Find the recently added name and rdata. 1253 */ 1254 dns_result = dns_db_find(db, dns_fixedname_name(&dns_newname), 1255 nversionp, rdatatype, 0, 0, &found_nodep, 1256 dns_fixedname_name(&dns_foundname), 1257 &found_rdataset, NULL); 1258 1259 if (dns_result != ISC_R_SUCCESS) { 1260 /* XXXWPK - NXRRSET ??? reference counts ??? */ 1261 t_info("dns_db_find failed %s\n", 1262 dns_result_totext(dns_result)); 1263 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1264 dns_db_detachnode(db, &found_nodep); 1265 if (dns_rdataset_isassociated(&found_rdataset)) 1266 dns_rdataset_disassociate(&found_rdataset); 1267 dns_db_detach(&db); 1268 isc_hash_destroy(); 1269 isc_entropy_detach(&ectx); 1270 isc_mem_destroy(&mctx); 1271 return(T_FAIL); 1272 } 1273 1274 dns_result = dns_rdataset_first(&found_rdataset); 1275 if (dns_result != ISC_R_SUCCESS) { 1276 t_info("dns_rdataset_first failed %s\n", 1277 dns_result_totext(dns_result)); 1278 dns_db_detachnode(db, &nodep); 1279 if (dns_rdataset_isassociated(&found_rdataset)) 1280 dns_rdataset_disassociate(&found_rdataset); 1281 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1282 dns_db_detach(&db); 1283 isc_hash_destroy(); 1284 isc_entropy_detach(&ectx); 1285 isc_mem_destroy(&mctx); 1286 return(T_FAIL); 1287 } 1288 1289 /* 1290 * Now make sure its what we expect. 1291 */ 1292 dns_rdata_init(&found_rdata); 1293 dns_rdataset_current(&found_rdataset, &found_rdata); 1294 rval = dns_rdata_compare(&added_rdata, &found_rdata); 1295 if (rval == 0) { 1296 result = T_PASS; 1297 } else { 1298 t_info("dns_rdata_compare returned %d\n", rval); 1299 result = T_FAIL; 1300 } 1301 1302 /* 1303 * Don't need these now. 1304 */ 1305 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1306 if (dns_rdataset_isassociated(&found_rdataset)) 1307 dns_rdataset_disassociate(&found_rdataset); 1308 dns_db_detachnode(db, &found_nodep); 1309 dns_db_detach(&db); 1310 isc_hash_destroy(); 1311 isc_entropy_detach(&ectx); 1312 isc_mem_destroy(&mctx); 1313 1314 return(result); 1315 } 1316 1317 static void 1318 t9(void) { 1319 int result; 1320 1321 t_assert("dns_db_newversion", 9, T_REQUIRED, "%s", a9); 1322 result = t_eval("dns_db_newversion_data", t_dns_db_newversion, 7); 1323 t_result(result); 1324 } 1325 1326 static const char *a10 = 1327 "When versionp points to a read-write version and commit is " 1328 "ISC_TRUE, a call to dns_db_closeversion(db, versionp, commit) " 1329 "causes all changes made in the version to take effect, " 1330 "and returns ISC_R_SUCCESS."; 1331 1332 static int 1333 t_dns_db_closeversion_1(char **av) { 1334 char *filename; 1335 char *db_type; 1336 char *origin; 1337 char *class; 1338 char *model; 1339 char *new_name; 1340 char *new_type; 1341 char *existing_name; 1342 char *existing_type; 1343 1344 int result; 1345 int len; 1346 int rval; 1347 int nfails; 1348 dns_db_t *db; 1349 isc_result_t dns_result; 1350 isc_result_t isc_result; 1351 isc_mem_t *mctx; 1352 isc_entropy_t *ectx; 1353 dns_dbnode_t *nodep; 1354 isc_textregion_t textregion; 1355 isc_buffer_t name_buffer; 1356 dns_fixedname_t dns_newname; 1357 dns_fixedname_t dns_foundname; 1358 dns_fixedname_t dns_existingname; 1359 dns_rdata_t added_rdata = DNS_RDATA_INIT; 1360 const char * added_rdata_data; 1361 dns_rdataset_t added_rdataset; 1362 dns_rdata_t found_rdata = DNS_RDATA_INIT; 1363 dns_rdataset_t found_rdataset; 1364 dns_rdatatype_t new_rdatatype; 1365 dns_rdatatype_t existing_rdatatype; 1366 dns_rdataclass_t rdataclass; 1367 dns_dbversion_t *nversionp; 1368 dns_dbversion_t *cversionp; 1369 dns_rdatalist_t rdatalist; 1370 1371 filename = T_ARG(0); 1372 db_type = T_ARG(1); 1373 origin = T_ARG(2); 1374 class = T_ARG(3); 1375 model = T_ARG(4); 1376 new_name = T_ARG(5); 1377 new_type = T_ARG(6); 1378 existing_name = T_ARG(7); 1379 existing_type = T_ARG(8); 1380 1381 nfails = 0; 1382 db = NULL; 1383 mctx = NULL; 1384 ectx = NULL; 1385 1386 /* 1387 * Open a new version, add some data, 1388 * remove some data, close with commit, open the current 1389 * version and check that changes are present. 1390 */ 1391 1392 t_info("testing using file %s and name %s\n", filename, new_name); 1393 1394 isc_result = isc_mem_create(0, 0, &mctx); 1395 if (isc_result != ISC_R_SUCCESS) { 1396 t_info("isc_mem_create failed %s\n", 1397 isc_result_totext(isc_result)); 1398 return(T_UNRESOLVED); 1399 } 1400 1401 isc_result = isc_entropy_create(mctx, &ectx); 1402 if (isc_result != ISC_R_SUCCESS) { 1403 t_info("isc_entropy_create failed %s\n", 1404 isc_result_totext(isc_result)); 1405 isc_mem_destroy(&mctx); 1406 return(T_UNRESOLVED); 1407 } 1408 1409 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 1410 if (isc_result != ISC_R_SUCCESS) { 1411 t_info("isc_hash_create failed %s\n", 1412 isc_result_totext(isc_result)); 1413 isc_entropy_detach(&ectx); 1414 isc_mem_destroy(&mctx); 1415 return(T_UNRESOLVED); 1416 } 1417 1418 dns_result = t_create(db_type, origin, class, model, mctx, &db); 1419 if (dns_result != ISC_R_SUCCESS) { 1420 isc_hash_destroy(); 1421 isc_entropy_detach(&ectx); 1422 isc_mem_destroy(&mctx); 1423 return(T_UNRESOLVED); 1424 } 1425 1426 dns_result = dns_db_load(db, filename); 1427 if (dns_result != ISC_R_SUCCESS) { 1428 t_info("dns_db_load returned %s\n", 1429 dns_result_totext(dns_result)); 1430 dns_db_detach(&db); 1431 isc_hash_destroy(); 1432 isc_entropy_detach(&ectx); 1433 isc_mem_destroy(&mctx); 1434 return(T_UNRESOLVED); 1435 } 1436 1437 /* 1438 * Remove all rdata for an existing name. 1439 */ 1440 1441 dns_fixedname_init(&dns_existingname); 1442 len = strlen(existing_name); 1443 isc_buffer_init(&name_buffer, existing_name, len); 1444 isc_buffer_add(&name_buffer, len); 1445 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_existingname), 1446 &name_buffer, NULL, 0, NULL); 1447 if (dns_result != ISC_R_SUCCESS) { 1448 t_info("dns_name_fromtext failed %s\n", 1449 dns_result_totext(dns_result)); 1450 dns_db_detach(&db); 1451 isc_hash_destroy(); 1452 isc_entropy_detach(&ectx); 1453 isc_mem_destroy(&mctx); 1454 return(T_UNRESOLVED); 1455 } 1456 1457 textregion.base = existing_type; 1458 textregion.length = strlen(existing_type); 1459 dns_result = dns_rdatatype_fromtext(&existing_rdatatype, &textregion); 1460 if (dns_result != ISC_R_SUCCESS) { 1461 t_info("dns_rdatatype_fromtext %s failed %s\n", 1462 existing_type, 1463 dns_result_totext(dns_result)); 1464 dns_db_detachnode(db, &nodep); 1465 dns_db_detach(&db); 1466 isc_hash_destroy(); 1467 isc_entropy_detach(&ectx); 1468 isc_mem_destroy(&mctx); 1469 return(T_UNRESOLVED); 1470 } 1471 1472 nodep = NULL; 1473 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_existingname), 1474 ISC_FALSE, &nodep); 1475 if (dns_result != ISC_R_SUCCESS) { 1476 t_info("dns_db_findnode %s\n", 1477 dns_result_totext(dns_result)); 1478 dns_db_detach(&db); 1479 isc_hash_destroy(); 1480 isc_entropy_detach(&ectx); 1481 isc_mem_destroy(&mctx); 1482 return(T_UNRESOLVED); 1483 } 1484 1485 /* open a new version */ 1486 nversionp = NULL; 1487 dns_result = dns_db_newversion(db, &nversionp); 1488 if (dns_result != ISC_R_SUCCESS) { 1489 t_info("dns_db_newversion failed %s\n", 1490 dns_result_totext(dns_result)); 1491 dns_db_detachnode(db, &nodep); 1492 dns_db_detach(&db); 1493 isc_hash_destroy(); 1494 isc_entropy_detach(&ectx); 1495 isc_mem_destroy(&mctx); 1496 return(T_UNRESOLVED); 1497 } 1498 1499 dns_result = dns_db_deleterdataset(db, nodep, nversionp, 1500 existing_rdatatype, 0); 1501 if (dns_result != ISC_R_SUCCESS) { 1502 t_info("dns_db_deleterdataset failed %s\n", 1503 dns_result_totext(dns_result)); 1504 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1505 dns_db_detachnode(db, &nodep); 1506 dns_db_detach(&db); 1507 isc_hash_destroy(); 1508 isc_entropy_detach(&ectx); 1509 isc_mem_destroy(&mctx); 1510 return(T_UNRESOLVED); 1511 } 1512 1513 /* 1514 * add a new name and associate some rdata with it 1515 */ 1516 1517 dns_db_detachnode(db, &nodep); 1518 nodep = NULL; 1519 1520 dns_fixedname_init(&dns_newname); 1521 len = strlen(new_name); 1522 isc_buffer_init(&name_buffer, new_name, len); 1523 isc_buffer_add(&name_buffer, len); 1524 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_newname), 1525 &name_buffer, NULL, 0, NULL); 1526 if (dns_result != ISC_R_SUCCESS) { 1527 t_info("dns_name_fromtext failed %s\n", 1528 dns_result_totext(dns_result)); 1529 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1530 dns_db_detach(&db); 1531 isc_hash_destroy(); 1532 isc_entropy_detach(&ectx); 1533 isc_mem_destroy(&mctx); 1534 return(T_UNRESOLVED); 1535 } 1536 1537 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_newname), 1538 ISC_TRUE, &nodep); 1539 if (dns_result != ISC_R_SUCCESS) { 1540 t_info("dns_db_findnode failed %s\n", 1541 dns_result_totext(dns_result)); 1542 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1543 dns_db_detach(&db); 1544 isc_hash_destroy(); 1545 isc_entropy_detach(&ectx); 1546 isc_mem_destroy(&mctx); 1547 return(T_UNRESOLVED); 1548 } 1549 1550 /* 1551 * associate some rdata with the new name 1552 */ 1553 1554 textregion.base = new_type; 1555 textregion.length = strlen(new_type); 1556 dns_result = dns_rdatatype_fromtext(&new_rdatatype, &textregion); 1557 if (dns_result != ISC_R_SUCCESS) { 1558 t_info("dns_rdatatype_fromtext %s failed %s\n", 1559 new_type, 1560 dns_result_totext(dns_result)); 1561 dns_db_detachnode(db, &nodep); 1562 dns_db_detach(&db); 1563 isc_hash_destroy(); 1564 isc_entropy_detach(&ectx); 1565 isc_mem_destroy(&mctx); 1566 return(T_UNRESOLVED); 1567 } 1568 1569 textregion.base = class; 1570 textregion.length = strlen(class); 1571 dns_result = dns_rdataclass_fromtext(&rdataclass, &textregion); 1572 if (dns_result != ISC_R_SUCCESS) { 1573 t_info("dns_rdataclass_fromtext failed %s\n", 1574 dns_result_totext(dns_result)); 1575 dns_db_detachnode(db, &nodep); 1576 dns_db_detach(&db); 1577 isc_hash_destroy(); 1578 isc_entropy_detach(&ectx); 1579 isc_mem_destroy(&mctx); 1580 return(T_UNRESOLVED); 1581 } 1582 1583 dns_rdata_init(&added_rdata); 1584 added_rdata_data = "\x10\x00\x00\x01"; 1585 DE_CONST(added_rdata_data, added_rdata.data); 1586 added_rdata.length = 4; 1587 added_rdata.rdclass = rdataclass; 1588 added_rdata.type = new_rdatatype; 1589 1590 dns_rdataset_init(&added_rdataset); 1591 rdatalist.type = new_rdatatype; 1592 rdatalist.covers = 0; 1593 rdatalist.rdclass = rdataclass; 1594 rdatalist.ttl = 0; 1595 ISC_LIST_INIT(rdatalist.rdata); 1596 ISC_LIST_APPEND(rdatalist.rdata, &added_rdata, link); 1597 1598 dns_result = dns_rdatalist_tordataset(&rdatalist, &added_rdataset); 1599 if (dns_result != ISC_R_SUCCESS) { 1600 t_info("dns_rdatalist_tordataset failed %s\n", 1601 dns_result_totext(dns_result)); 1602 dns_db_detachnode(db, &nodep); 1603 dns_db_detach(&db); 1604 isc_hash_destroy(); 1605 isc_entropy_detach(&ectx); 1606 isc_mem_destroy(&mctx); 1607 return(T_UNRESOLVED); 1608 } 1609 1610 dns_result = dns_db_addrdataset(db, nodep, nversionp, 0, 1611 &added_rdataset, 0, NULL); 1612 if (dns_result != ISC_R_SUCCESS) { 1613 t_info("dns_db_addrdataset failed %s\n", 1614 dns_result_totext(dns_result)); 1615 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1616 dns_db_detachnode(db, &nodep); 1617 dns_db_detach(&db); 1618 isc_hash_destroy(); 1619 isc_entropy_detach(&ectx); 1620 isc_mem_destroy(&mctx); 1621 return(T_UNRESOLVED); 1622 } 1623 1624 /* close and commit the version */ 1625 dns_db_closeversion(db, &nversionp, ISC_TRUE); 1626 dns_db_detachnode(db, &nodep); 1627 nodep = NULL; 1628 1629 /* open the current version and check changes */ 1630 dns_fixedname_init(&dns_foundname); 1631 dns_rdataset_init(&found_rdataset); 1632 cversionp = NULL; 1633 dns_db_currentversion(db, &cversionp); 1634 1635 /* find the recently added name and rdata */ 1636 dns_result = dns_db_find(db, 1637 dns_fixedname_name(&dns_newname), 1638 cversionp, 1639 new_rdatatype, 1640 0, 1641 0, 1642 &nodep, 1643 dns_fixedname_name(&dns_foundname), 1644 &found_rdataset, NULL); 1645 1646 if (dns_result != ISC_R_SUCCESS) { 1647 /* XXXWPK NXRRSET ??? reference counting ??? */ 1648 t_info("dns_db_find failed %s\n", 1649 dns_result_totext(dns_result)); 1650 dns_db_closeversion(db, &cversionp, ISC_FALSE); 1651 dns_db_detachnode(db, &nodep); 1652 if (dns_rdataset_isassociated(&found_rdataset)) 1653 dns_rdataset_disassociate(&found_rdataset); 1654 dns_db_detach(&db); 1655 isc_hash_destroy(); 1656 isc_entropy_detach(&ectx); 1657 isc_mem_destroy(&mctx); 1658 return(T_FAIL); 1659 } 1660 1661 dns_result = dns_rdataset_first(&found_rdataset); 1662 if (dns_result != ISC_R_SUCCESS) { 1663 t_info("dns_rdataset_first failed %s\n", 1664 dns_result_totext(dns_result)); 1665 dns_db_detachnode(db, &nodep); 1666 if (dns_rdataset_isassociated(&found_rdataset)) 1667 dns_rdataset_disassociate(&found_rdataset); 1668 dns_db_closeversion(db, &cversionp, ISC_FALSE); 1669 dns_db_detach(&db); 1670 isc_hash_destroy(); 1671 isc_entropy_detach(&ectx); 1672 isc_mem_destroy(&mctx); 1673 return(T_FAIL); 1674 } 1675 1676 /* 1677 * Now make sure its what we expect. 1678 */ 1679 dns_rdata_init(&found_rdata); 1680 dns_rdataset_current(&found_rdataset, &found_rdata); 1681 rval = dns_rdata_compare(&added_rdata, &found_rdata); 1682 if (rval != 0) { 1683 t_info("dns_rdata_compare returned %d\n", rval); 1684 ++nfails; 1685 } 1686 1687 /* 1688 * Now check the rdata deletion. 1689 */ 1690 1691 if (dns_rdataset_isassociated(&found_rdataset)) 1692 dns_rdataset_disassociate(&found_rdataset); 1693 dns_rdataset_init(&found_rdataset); 1694 dns_db_detachnode(db, &nodep); 1695 nodep = NULL; 1696 dns_fixedname_init(&dns_foundname); 1697 1698 dns_result = dns_db_find(db, dns_fixedname_name(&dns_existingname), 1699 cversionp, existing_rdatatype, 1700 0, 0, &nodep, 1701 dns_fixedname_name(&dns_foundname), 1702 &found_rdataset, NULL); 1703 1704 1705 if ((dns_result != ISC_R_NOTFOUND) && (dns_result != DNS_R_NXDOMAIN)) { 1706 dns_rdataset_disassociate(&found_rdataset); 1707 dns_db_detachnode(db, &nodep); 1708 t_info("dns_db_find %s returned %s\n", existing_name, 1709 dns_result_totext(dns_result)); 1710 ++nfails; 1711 } 1712 1713 dns_db_closeversion(db, &cversionp, ISC_FALSE); 1714 dns_db_detach(&db); 1715 isc_hash_destroy(); 1716 isc_entropy_detach(&ectx); 1717 isc_mem_destroy(&mctx); 1718 1719 if (nfails == 0) 1720 result = T_PASS; 1721 else 1722 result = T_FAIL; 1723 1724 return(result); 1725 } 1726 1727 static void 1728 t10(void) { 1729 int result; 1730 1731 t_assert("dns_db_closeversion", 10, T_REQUIRED, "%s", a10); 1732 result = t_eval("dns_db_closeversion_1_data", 1733 t_dns_db_closeversion_1, 9); 1734 t_result(result); 1735 } 1736 1737 static const char *a11 = 1738 "When versionp points to a read-write version and commit is " 1739 "ISC_FALSE, a call to dns_db_closeversion(db, versionp, commit) " 1740 "causes all changes made in the version to to be rolled back, " 1741 "and returns ISC_R_SUCCESS."; 1742 1743 static int 1744 t_dns_db_closeversion_2(char **av) { 1745 char *filename; 1746 char *db_type; 1747 char *origin; 1748 char *class; 1749 char *model; 1750 char *new_name; 1751 char *new_type; 1752 char *existing_name; 1753 char *existing_type; 1754 1755 int result; 1756 int len; 1757 int rval; 1758 int nfails; 1759 dns_db_t *db; 1760 isc_result_t dns_result; 1761 isc_result_t isc_result; 1762 isc_mem_t *mctx; 1763 isc_entropy_t *ectx; 1764 dns_dbnode_t *nodep; 1765 isc_textregion_t textregion; 1766 isc_buffer_t name_buffer; 1767 dns_fixedname_t dns_newname; 1768 dns_fixedname_t dns_foundname; 1769 dns_fixedname_t dns_existingname; 1770 dns_rdata_t added_rdata = DNS_RDATA_INIT; 1771 const char * added_rdata_data; 1772 dns_rdataset_t added_rdataset; 1773 dns_rdata_t found_rdata = DNS_RDATA_INIT; 1774 dns_rdataset_t found_rdataset; 1775 dns_rdatatype_t new_rdatatype; 1776 dns_rdatatype_t existing_rdatatype; 1777 dns_rdataclass_t rdataclass; 1778 dns_dbversion_t *nversionp; 1779 dns_dbversion_t *cversionp; 1780 dns_rdatalist_t rdatalist; 1781 1782 filename = T_ARG(0); 1783 db_type = T_ARG(1); 1784 origin = T_ARG(2); 1785 class = T_ARG(3); 1786 model = T_ARG(4); 1787 new_name = T_ARG(5); 1788 new_type = T_ARG(6); 1789 existing_name = T_ARG(7); 1790 existing_type = T_ARG(8); 1791 1792 nfails = 0; 1793 db = NULL; 1794 mctx = NULL; 1795 ectx = NULL; 1796 1797 /* 1798 * Open a new version, add some data, 1799 * remove some data, close with commit, open the current 1800 * version and check that changes are present. 1801 */ 1802 1803 t_info("testing using file %s and name %s\n", filename, new_name); 1804 1805 isc_result = isc_mem_create(0, 0, &mctx); 1806 if (isc_result != ISC_R_SUCCESS) { 1807 t_info("isc_mem_create failed %s\n", 1808 isc_result_totext(isc_result)); 1809 return(T_UNRESOLVED); 1810 } 1811 1812 isc_result = isc_entropy_create(mctx, &ectx); 1813 if (isc_result != ISC_R_SUCCESS) { 1814 t_info("isc_entropy_create failed %s\n", 1815 isc_result_totext(isc_result)); 1816 isc_mem_destroy(&mctx); 1817 return(T_UNRESOLVED); 1818 } 1819 1820 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 1821 if (isc_result != ISC_R_SUCCESS) { 1822 t_info("isc_hash_create failed %s\n", 1823 isc_result_totext(isc_result)); 1824 isc_entropy_detach(&ectx); 1825 isc_mem_destroy(&mctx); 1826 return(T_UNRESOLVED); 1827 } 1828 1829 dns_result = t_create(db_type, origin, class, model, mctx, &db); 1830 if (dns_result != ISC_R_SUCCESS) { 1831 isc_hash_destroy(); 1832 isc_entropy_detach(&ectx); 1833 isc_mem_destroy(&mctx); 1834 return(T_UNRESOLVED); 1835 } 1836 1837 dns_result = dns_db_load(db, filename); 1838 if (dns_result != ISC_R_SUCCESS) { 1839 t_info("dns_db_load returned %s\n", 1840 dns_result_totext(dns_result)); 1841 dns_db_detach(&db); 1842 isc_hash_destroy(); 1843 isc_entropy_detach(&ectx); 1844 isc_mem_destroy(&mctx); 1845 return(T_UNRESOLVED); 1846 } 1847 1848 /* 1849 * Remove all rdata for an existing name. 1850 */ 1851 1852 dns_fixedname_init(&dns_existingname); 1853 len = strlen(existing_name); 1854 isc_buffer_init(&name_buffer, existing_name, len); 1855 isc_buffer_add(&name_buffer, len); 1856 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_existingname), 1857 &name_buffer, NULL, 0, NULL); 1858 if (dns_result != ISC_R_SUCCESS) { 1859 t_info("dns_name_fromtext failed %s\n", 1860 dns_result_totext(dns_result)); 1861 dns_db_detach(&db); 1862 isc_hash_destroy(); 1863 isc_entropy_detach(&ectx); 1864 isc_mem_destroy(&mctx); 1865 return(T_UNRESOLVED); 1866 } 1867 1868 textregion.base = existing_type; 1869 textregion.length = strlen(existing_type); 1870 dns_result = dns_rdatatype_fromtext(&existing_rdatatype, &textregion); 1871 if (dns_result != ISC_R_SUCCESS) { 1872 t_info("dns_rdatatype_fromtext %s failed %s\n", 1873 existing_type, 1874 dns_result_totext(dns_result)); 1875 dns_db_detachnode(db, &nodep); 1876 dns_db_detach(&db); 1877 isc_hash_destroy(); 1878 isc_entropy_detach(&ectx); 1879 isc_mem_destroy(&mctx); 1880 return(T_UNRESOLVED); 1881 } 1882 1883 nodep = NULL; 1884 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_existingname), 1885 ISC_FALSE, &nodep); 1886 if (dns_result != ISC_R_SUCCESS) { 1887 t_info("dns_db_findnode %s\n", 1888 dns_result_totext(dns_result)); 1889 dns_db_detach(&db); 1890 isc_hash_destroy(); 1891 isc_entropy_detach(&ectx); 1892 isc_mem_destroy(&mctx); 1893 return(T_UNRESOLVED); 1894 } 1895 1896 /* 1897 * Open a new version. 1898 */ 1899 nversionp = NULL; 1900 dns_result = dns_db_newversion(db, &nversionp); 1901 if (dns_result != ISC_R_SUCCESS) { 1902 t_info("dns_db_newversion failed %s\n", 1903 dns_result_totext(dns_result)); 1904 dns_db_detachnode(db, &nodep); 1905 dns_db_detach(&db); 1906 isc_hash_destroy(); 1907 isc_entropy_detach(&ectx); 1908 isc_mem_destroy(&mctx); 1909 return(T_UNRESOLVED); 1910 } 1911 1912 dns_result = dns_db_deleterdataset(db, nodep, nversionp, 1913 existing_rdatatype, 0); 1914 if (dns_result != ISC_R_SUCCESS) { 1915 t_info("dns_db_deleterdataset failed %s\n", 1916 dns_result_totext(dns_result)); 1917 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1918 dns_db_detachnode(db, &nodep); 1919 dns_db_detach(&db); 1920 isc_hash_destroy(); 1921 isc_entropy_detach(&ectx); 1922 isc_mem_destroy(&mctx); 1923 return(T_UNRESOLVED); 1924 } 1925 1926 /* 1927 * add a new name and associate some rdata with it 1928 */ 1929 1930 dns_db_detachnode(db, &nodep); 1931 nodep = NULL; 1932 1933 dns_fixedname_init(&dns_newname); 1934 len = strlen(new_name); 1935 isc_buffer_init(&name_buffer, new_name, len); 1936 isc_buffer_add(&name_buffer, len); 1937 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_newname), 1938 &name_buffer, NULL, 0, NULL); 1939 if (dns_result != ISC_R_SUCCESS) { 1940 t_info("dns_name_fromtext failed %s\n", 1941 dns_result_totext(dns_result)); 1942 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1943 dns_db_detach(&db); 1944 isc_hash_destroy(); 1945 isc_entropy_detach(&ectx); 1946 isc_mem_destroy(&mctx); 1947 return(T_UNRESOLVED); 1948 } 1949 1950 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_newname), 1951 ISC_TRUE, &nodep); 1952 if (dns_result != ISC_R_SUCCESS) { 1953 t_info("dns_db_findnode failed %s\n", 1954 dns_result_totext(dns_result)); 1955 dns_db_closeversion(db, &nversionp, ISC_FALSE); 1956 dns_db_detach(&db); 1957 isc_hash_destroy(); 1958 isc_entropy_detach(&ectx); 1959 isc_mem_destroy(&mctx); 1960 return(T_UNRESOLVED); 1961 } 1962 1963 textregion.base = new_type; 1964 textregion.length = strlen(new_type); 1965 dns_result = dns_rdatatype_fromtext(&new_rdatatype, &textregion); 1966 if (dns_result != ISC_R_SUCCESS) { 1967 t_info("dns_rdatatype_fromtext %s failed %s\n", 1968 new_type, dns_result_totext(dns_result)); 1969 dns_db_detachnode(db, &nodep); 1970 dns_db_detach(&db); 1971 isc_hash_destroy(); 1972 isc_entropy_detach(&ectx); 1973 isc_mem_destroy(&mctx); 1974 return(T_UNRESOLVED); 1975 } 1976 1977 textregion.base = class; 1978 textregion.length = strlen(class); 1979 dns_result = dns_rdataclass_fromtext(&rdataclass, &textregion); 1980 if (dns_result != ISC_R_SUCCESS) { 1981 t_info("dns_rdataclass_fromtext failed %s\n", 1982 dns_result_totext(dns_result)); 1983 dns_db_detachnode(db, &nodep); 1984 dns_db_detach(&db); 1985 isc_hash_destroy(); 1986 isc_entropy_detach(&ectx); 1987 isc_mem_destroy(&mctx); 1988 return(T_UNRESOLVED); 1989 } 1990 1991 dns_rdata_init(&added_rdata); 1992 added_rdata_data = "\x10\x00\x00\x01"; 1993 DE_CONST(added_rdata_data, added_rdata.data); 1994 added_rdata.length = 4; 1995 added_rdata.rdclass = rdataclass; 1996 added_rdata.type = new_rdatatype; 1997 1998 dns_rdataset_init(&added_rdataset); 1999 rdatalist.type = new_rdatatype; 2000 rdatalist.covers = 0; 2001 rdatalist.rdclass = rdataclass; 2002 rdatalist.ttl = 0; 2003 ISC_LIST_INIT(rdatalist.rdata); 2004 ISC_LIST_APPEND(rdatalist.rdata, &added_rdata, link); 2005 2006 dns_result = dns_rdatalist_tordataset(&rdatalist, &added_rdataset); 2007 if (dns_result != ISC_R_SUCCESS) { 2008 t_info("dns_rdatalist_tordataset failed %s\n", 2009 dns_result_totext(dns_result)); 2010 dns_db_detachnode(db, &nodep); 2011 dns_db_detach(&db); 2012 isc_hash_destroy(); 2013 isc_entropy_detach(&ectx); 2014 isc_mem_destroy(&mctx); 2015 return(T_UNRESOLVED); 2016 } 2017 2018 dns_result = dns_db_addrdataset(db, nodep, nversionp, 0, 2019 &added_rdataset, 0, NULL); 2020 if (dns_result != ISC_R_SUCCESS) { 2021 t_info("dns_db_addrdataset failed %s\n", 2022 dns_result_totext(dns_result)); 2023 dns_db_closeversion(db, &nversionp, ISC_FALSE); 2024 dns_db_detachnode(db, &nodep); 2025 dns_db_detach(&db); 2026 isc_hash_destroy(); 2027 isc_entropy_detach(&ectx); 2028 isc_mem_destroy(&mctx); 2029 return(T_UNRESOLVED); 2030 } 2031 2032 /* 2033 * Check that our changes took. 2034 */ 2035 dns_db_detachnode(db, &nodep); 2036 nodep = NULL; 2037 dns_fixedname_init(&dns_foundname); 2038 dns_rdataset_init(&found_rdataset); 2039 2040 /* 2041 * Find the recently added name and rdata. 2042 */ 2043 dns_result = dns_db_find(db, dns_fixedname_name(&dns_newname), 2044 nversionp, new_rdatatype, 0, 0, &nodep, 2045 dns_fixedname_name(&dns_foundname), 2046 &found_rdataset, NULL); 2047 2048 if ((dns_result == ISC_R_NOTFOUND) || 2049 (dns_result == DNS_R_NXDOMAIN) || 2050 (dns_result == DNS_R_NXRRSET)) { 2051 2052 t_info("dns_db_find failed %s\n", 2053 dns_result_totext(dns_result)); 2054 dns_db_closeversion(db, &nversionp, ISC_FALSE); 2055 dns_db_detachnode(db, &nodep); 2056 if (dns_rdataset_isassociated(&found_rdataset)) 2057 dns_rdataset_disassociate(&found_rdataset); 2058 dns_db_detach(&db); 2059 isc_hash_destroy(); 2060 isc_entropy_detach(&ectx); 2061 isc_mem_destroy(&mctx); 2062 return(T_FAIL); 2063 } 2064 2065 dns_result = dns_rdataset_first(&found_rdataset); 2066 if (dns_result != ISC_R_SUCCESS) { 2067 t_info("dns_rdataset_first failed %s\n", 2068 dns_result_totext(dns_result)); 2069 dns_db_detachnode(db, &nodep); 2070 if (dns_rdataset_isassociated(&found_rdataset)) 2071 dns_rdataset_disassociate(&found_rdataset); 2072 dns_db_closeversion(db, &nversionp, ISC_FALSE); 2073 dns_db_detach(&db); 2074 isc_hash_destroy(); 2075 isc_entropy_detach(&ectx); 2076 isc_mem_destroy(&mctx); 2077 return(T_FAIL); 2078 } 2079 2080 /* 2081 * Now make sure its what we expect. 2082 */ 2083 dns_rdata_init(&found_rdata); 2084 dns_rdataset_current(&found_rdataset, &found_rdata); 2085 rval = dns_rdata_compare(&added_rdata, &found_rdata); 2086 if (rval != 0) { 2087 t_info("dns_rdata_compare returned %d\n", rval); 2088 ++nfails; 2089 } 2090 2091 /* 2092 * Now check the rdata deletion. 2093 */ 2094 if (dns_rdataset_isassociated(&found_rdataset)) 2095 dns_rdataset_disassociate(&found_rdataset); 2096 dns_rdataset_init(&found_rdataset); 2097 dns_db_detachnode(db, &nodep); 2098 nodep = NULL; 2099 dns_fixedname_init(&dns_foundname); 2100 2101 dns_result = dns_db_find(db, 2102 dns_fixedname_name(&dns_existingname), 2103 nversionp, 2104 existing_rdatatype, 2105 0, 2106 0, 2107 &nodep, 2108 dns_fixedname_name(&dns_foundname), 2109 &found_rdataset, NULL); 2110 2111 2112 if ((dns_result != ISC_R_NOTFOUND) && (dns_result != DNS_R_NXDOMAIN)) { 2113 t_info("dns_db_find %s returned %s\n", existing_name, 2114 dns_result_totext(dns_result)); 2115 if (dns_rdataset_isassociated(&found_rdataset)) 2116 dns_rdataset_disassociate(&found_rdataset); 2117 dns_db_detachnode(db, &nodep); 2118 ++nfails; 2119 } 2120 2121 2122 /* 2123 * Close the version without a commit. 2124 */ 2125 dns_db_closeversion(db, &nversionp, ISC_FALSE); 2126 2127 /* 2128 * Open the current version and check changes. 2129 */ 2130 dns_fixedname_init(&dns_foundname); 2131 dns_rdataset_init(&found_rdataset); 2132 cversionp = NULL; 2133 dns_db_currentversion(db, &cversionp); 2134 2135 /* 2136 * Find the recently added name and rdata. 2137 */ 2138 dns_result = dns_db_find(db, 2139 dns_fixedname_name(&dns_newname), 2140 cversionp, 2141 new_rdatatype, 2142 0, 2143 0, 2144 &nodep, 2145 dns_fixedname_name(&dns_foundname), 2146 &found_rdataset, NULL); 2147 2148 if ((dns_result != ISC_R_NOTFOUND) && (dns_result != DNS_R_NXDOMAIN)) { 2149 t_info("dns_db_find %s returned %s\n", new_name, 2150 dns_result_totext(dns_result)); 2151 dns_rdataset_disassociate(&found_rdataset); 2152 dns_db_detachnode(db, &nodep); 2153 dns_db_closeversion(db, &cversionp, ISC_FALSE); 2154 dns_db_detach(&db); 2155 isc_hash_destroy(); 2156 isc_entropy_detach(&ectx); 2157 isc_mem_destroy(&mctx); 2158 return(T_FAIL); 2159 } 2160 2161 /* 2162 * Now check the rdata deletion. 2163 */ 2164 nodep = NULL; 2165 dns_rdataset_init(&found_rdataset); 2166 dns_fixedname_init(&dns_foundname); 2167 2168 dns_result = dns_db_find(db, dns_fixedname_name(&dns_existingname), 2169 cversionp, existing_rdatatype, 0, 0, 2170 &nodep, dns_fixedname_name(&dns_foundname), 2171 &found_rdataset, NULL); 2172 2173 2174 if ((dns_result == ISC_R_NOTFOUND) || 2175 (dns_result == DNS_R_NXDOMAIN) || 2176 (dns_result == DNS_R_NXRRSET)) { 2177 2178 t_info("dns_db_find %s returned %s\n", existing_name, 2179 dns_result_totext(dns_result)); 2180 dns_rdataset_disassociate(&found_rdataset); 2181 dns_db_detachnode(db, &nodep); 2182 ++nfails; 2183 } 2184 2185 dns_db_detachnode(db, &nodep); 2186 dns_rdataset_disassociate(&found_rdataset); 2187 dns_db_closeversion(db, &cversionp, ISC_FALSE); 2188 dns_db_detach(&db); 2189 isc_hash_destroy(); 2190 isc_entropy_detach(&ectx); 2191 isc_mem_destroy(&mctx); 2192 2193 if (nfails == 0) 2194 result = T_PASS; 2195 else 2196 result = T_FAIL; 2197 2198 return(result); 2199 } 2200 2201 static void 2202 t11(void) { 2203 int result; 2204 2205 t_assert("dns_db_closeversion", 11, T_REQUIRED, "%s", a11); 2206 result = t_eval("dns_db_closeversion_2_data", 2207 t_dns_db_closeversion_2, 9); 2208 t_result(result); 2209 } 2210 2211 static const char *a12 = 2212 "A call to dns_db_expirenode() marks as stale all records at node " 2213 "which expire at or before 'now'. If 'now' is zero, then the current " 2214 "time will be used."; 2215 2216 static int 2217 t_dns_db_expirenode(char **av) { 2218 char *filename; 2219 char *db_type; 2220 char *origin; 2221 char *class; 2222 char *existing_name; 2223 char *node_xtime; 2224 char *find_xtime; 2225 char *exp_find_result; 2226 2227 int result; 2228 int len; 2229 dns_db_t *db; 2230 isc_result_t dns_result; 2231 isc_result_t exp_result; 2232 isc_result_t isc_result; 2233 isc_mem_t *mctx; 2234 isc_entropy_t *ectx; 2235 dns_dbnode_t *nodep; 2236 isc_buffer_t name_buffer; 2237 dns_fixedname_t dns_foundname; 2238 dns_fixedname_t dns_existingname; 2239 isc_stdtime_t node_expire_time; 2240 isc_stdtime_t find_expire_time; 2241 isc_stdtime_t now; 2242 dns_rdataset_t rdataset; 2243 2244 filename = T_ARG(0); 2245 db_type = T_ARG(1); 2246 origin = T_ARG(2); 2247 class = T_ARG(3); 2248 existing_name = T_ARG(4); 2249 node_xtime = T_ARG(5); 2250 find_xtime = T_ARG(6); 2251 exp_find_result = T_ARG(7); 2252 mctx = NULL; 2253 ectx = NULL; 2254 2255 /* 2256 * Find a node, mark it as stale, do a dns_db_find on the name and 2257 * expect it to fail. 2258 */ 2259 2260 t_info("testing using file %s and name %s\n", filename, existing_name); 2261 2262 node_expire_time = (isc_stdtime_t) strtol(node_xtime, NULL, 10); 2263 find_expire_time = (isc_stdtime_t) strtol(find_xtime, NULL, 10); 2264 exp_result = t_dns_result_fromtext(exp_find_result); 2265 2266 isc_stdtime_get(&now); 2267 2268 dns_fixedname_init(&dns_existingname); 2269 len = strlen(existing_name); 2270 isc_buffer_init(&name_buffer, existing_name, len); 2271 isc_buffer_add(&name_buffer, len); 2272 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_existingname), 2273 &name_buffer, NULL, 0, NULL); 2274 if (dns_result != ISC_R_SUCCESS) { 2275 t_info("dns_name_fromtext failed %s\n", 2276 dns_result_totext(dns_result)); 2277 return(T_UNRESOLVED); 2278 } 2279 2280 isc_result = isc_mem_create(0, 0, &mctx); 2281 if (isc_result != ISC_R_SUCCESS) { 2282 t_info("isc_mem_create failed %s\n", 2283 isc_result_totext(isc_result)); 2284 return(T_UNRESOLVED); 2285 } 2286 2287 isc_result = isc_entropy_create(mctx, &ectx); 2288 if (isc_result != ISC_R_SUCCESS) { 2289 t_info("isc_entropy_create failed %s\n", 2290 isc_result_totext(isc_result)); 2291 isc_mem_destroy(&mctx); 2292 return(T_UNRESOLVED); 2293 } 2294 2295 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 2296 if (isc_result != ISC_R_SUCCESS) { 2297 t_info("isc_hash_create failed %s\n", 2298 isc_result_totext(isc_result)); 2299 isc_entropy_detach(&ectx); 2300 isc_mem_destroy(&mctx); 2301 return(T_UNRESOLVED); 2302 } 2303 2304 db = NULL; 2305 dns_result = t_create(db_type, origin, class, "cache", mctx, &db); 2306 if (dns_result != ISC_R_SUCCESS) { 2307 isc_hash_destroy(); 2308 isc_entropy_detach(&ectx); 2309 isc_mem_destroy(&mctx); 2310 return(T_UNRESOLVED); 2311 } 2312 2313 dns_result = dns_db_load(db, filename); 2314 if (dns_result != ISC_R_SUCCESS) { 2315 t_info("dns_db_load returned %s\n", 2316 dns_result_totext(dns_result)); 2317 dns_db_detach(&db); 2318 isc_hash_destroy(); 2319 isc_entropy_detach(&ectx); 2320 isc_mem_destroy(&mctx); 2321 return(T_UNRESOLVED); 2322 } 2323 2324 nodep = NULL; 2325 2326 /* 2327 * Check that the node is there. 2328 */ 2329 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_existingname), 2330 ISC_FALSE, &nodep); 2331 if (dns_result != ISC_R_SUCCESS) { 2332 t_info("unable to find %s\n", existing_name); 2333 dns_db_detach(&db); 2334 isc_hash_destroy(); 2335 isc_entropy_detach(&ectx); 2336 isc_mem_destroy(&mctx); 2337 return(T_UNRESOLVED); 2338 } 2339 2340 /* 2341 * Expire it. 2342 */ 2343 if (node_expire_time != 0) 2344 node_expire_time += now; 2345 2346 dns_result = dns_db_expirenode(db, nodep, node_expire_time); 2347 if (dns_result != ISC_R_SUCCESS) { 2348 t_info("dns_db_expirenode failed %s\n", 2349 dns_result_totext(dns_result)); 2350 dns_db_detachnode(db, &nodep); 2351 dns_db_detach(&db); 2352 isc_hash_destroy(); 2353 isc_entropy_detach(&ectx); 2354 isc_mem_destroy(&mctx); 2355 return(T_FAIL); 2356 } 2357 2358 dns_fixedname_init(&dns_foundname); 2359 dns_rdataset_init(&rdataset); 2360 dns_db_detachnode(db, &nodep); 2361 nodep = NULL; 2362 2363 if (find_expire_time != 0) 2364 find_expire_time += now; 2365 2366 dns_result = dns_db_find(db, 2367 dns_fixedname_name(&dns_existingname), 2368 NULL, 2369 dns_rdatatype_any, 2370 0, 2371 find_expire_time, 2372 &nodep, 2373 dns_fixedname_name(&dns_foundname), 2374 &rdataset, NULL); 2375 2376 if (dns_result == exp_result) { 2377 result = T_PASS; 2378 } else { 2379 t_info("dns_db_find %s returned %s\n", existing_name, 2380 dns_result_totext(dns_result)); 2381 result = T_FAIL; 2382 } 2383 2384 if ((dns_result != ISC_R_NOTFOUND) && 2385 (dns_result != DNS_R_NXDOMAIN) && 2386 (dns_result != DNS_R_NXRRSET)) { 2387 2388 /* 2389 * Don't need to disassociate the rdataset because 2390 * we're searching with dns_rdatatype_any. 2391 */ 2392 dns_db_detachnode(db, &nodep); 2393 } 2394 2395 2396 dns_db_detach(&db); 2397 isc_hash_destroy(); 2398 isc_entropy_detach(&ectx); 2399 isc_mem_destroy(&mctx); 2400 2401 return(result); 2402 } 2403 2404 static void 2405 t12(void) { 2406 int result; 2407 2408 t_assert("dns_db_expirenode", 12, T_REQUIRED, "%s", a12); 2409 result = t_eval("dns_db_expirenode_data", t_dns_db_expirenode, 8); 2410 t_result(result); 2411 } 2412 2413 static const char *a13 = 2414 "If the node name exists, then a call to " 2415 "dns_db_findnode(db, name, ISC_FALSE, nodep) initializes nodep " 2416 "to point to the node and returns ISC_R_SUCCESS, otherwise " 2417 "it returns ISC_R_NOTFOUND."; 2418 2419 static int 2420 t_dns_db_findnode_1(char **av) { 2421 char *filename; 2422 char *db_type; 2423 char *origin; 2424 char *class; 2425 char *model; 2426 char *find_name; 2427 char *find_type; 2428 char *expected_result; 2429 2430 int result; 2431 int len; 2432 dns_db_t *db; 2433 isc_result_t dns_result; 2434 isc_result_t isc_result; 2435 isc_mem_t *mctx; 2436 isc_entropy_t *ectx; 2437 dns_dbnode_t *nodep; 2438 isc_buffer_t name_buffer; 2439 dns_rdataset_t rdataset; 2440 dns_rdatatype_t rdatatype; 2441 isc_textregion_t textregion; 2442 dns_fixedname_t dns_name; 2443 dns_dbversion_t *cversionp; 2444 isc_result_t exp_result; 2445 2446 filename = T_ARG(0); 2447 db_type = T_ARG(1); 2448 origin = T_ARG(2); 2449 class = T_ARG(3); 2450 model = T_ARG(4); 2451 find_name = T_ARG(5); 2452 find_type = T_ARG(6); 2453 expected_result = T_ARG(7); 2454 2455 db = NULL; 2456 mctx = NULL; 2457 ectx = NULL; 2458 2459 t_info("testing using file %s and name %s\n", filename, find_name); 2460 2461 exp_result = t_dns_result_fromtext(expected_result); 2462 2463 textregion.base = find_type; 2464 textregion.length = strlen(find_type); 2465 dns_result = dns_rdatatype_fromtext(&rdatatype, &textregion); 2466 if (dns_result != ISC_R_SUCCESS) { 2467 t_info("dns_rdatatype_fromtext %s failed %s\n", 2468 find_type, 2469 dns_result_totext(dns_result)); 2470 return(T_UNRESOLVED); 2471 } 2472 2473 isc_result = isc_mem_create(0, 0, &mctx); 2474 if (isc_result != ISC_R_SUCCESS) { 2475 t_info("isc_mem_create failed %s\n", 2476 isc_result_totext(isc_result)); 2477 return(T_UNRESOLVED); 2478 } 2479 2480 isc_result = isc_entropy_create(mctx, &ectx); 2481 if (isc_result != ISC_R_SUCCESS) { 2482 t_info("isc_entropy_create failed %s\n", 2483 isc_result_totext(isc_result)); 2484 isc_mem_destroy(&mctx); 2485 return(T_UNRESOLVED); 2486 } 2487 2488 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 2489 if (isc_result != ISC_R_SUCCESS) { 2490 t_info("isc_hash_create failed %s\n", 2491 isc_result_totext(isc_result)); 2492 isc_mem_destroy(&mctx); 2493 return(T_UNRESOLVED); 2494 } 2495 2496 dns_result = t_create(db_type, origin, class, model, mctx, &db); 2497 if (dns_result != ISC_R_SUCCESS) { 2498 isc_mem_destroy(&mctx); 2499 return(T_UNRESOLVED); 2500 } 2501 2502 dns_result = dns_db_load(db, filename); 2503 if (dns_result != ISC_R_SUCCESS) { 2504 t_info("dns_db_load returned %s\n", 2505 dns_result_totext(dns_result)); 2506 dns_db_detach(&db); 2507 isc_mem_destroy(&mctx); 2508 return(T_UNRESOLVED); 2509 } 2510 2511 nodep = NULL; 2512 dns_fixedname_init(&dns_name); 2513 2514 len = strlen(find_name); 2515 isc_buffer_init(&name_buffer, find_name, len); 2516 isc_buffer_add(&name_buffer, len); 2517 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_name), 2518 &name_buffer, NULL, 0, NULL); 2519 if (dns_result != ISC_R_SUCCESS) { 2520 t_info("dns_name_fromtext failed %s\n", 2521 dns_result_totext(dns_result)); 2522 dns_db_detach(&db); 2523 isc_mem_destroy(&mctx); 2524 return(T_UNRESOLVED); 2525 } 2526 2527 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_name), 2528 ISC_FALSE, &nodep); 2529 if (dns_result != exp_result) { 2530 t_info("dns_db_findnode failed %s\n", 2531 dns_result_totext(dns_result)); 2532 if (dns_result == ISC_R_SUCCESS) 2533 dns_db_detachnode(db, &nodep); 2534 dns_db_detach(&db); 2535 isc_mem_destroy(&mctx); 2536 return(T_FAIL); 2537 } 2538 2539 /* 2540 * if we're expecting the find to succeed and it did, 2541 * check that the node has been initialized 2542 * by checking for the specified type of rdata 2543 * and expecting the search to succeed 2544 */ 2545 2546 if (dns_result == ISC_R_SUCCESS) { 2547 cversionp = NULL; 2548 dns_db_currentversion(db, &cversionp); 2549 dns_rdataset_init(&rdataset); 2550 2551 dns_result = dns_db_findrdataset(db, nodep, cversionp, 2552 rdatatype, 0, 2553 0, &rdataset, NULL); 2554 if (dns_result == ISC_R_SUCCESS) { 2555 dns_rdataset_disassociate(&rdataset); 2556 result = T_PASS; 2557 } else { 2558 t_info("dns_db_findrdataset failed %s\n", 2559 dns_result_totext(dns_result)); 2560 result = T_FAIL; 2561 } 2562 dns_db_closeversion(db, &cversionp, ISC_FALSE); 2563 dns_db_detachnode(db, &nodep); 2564 } else { 2565 result = T_PASS; 2566 } 2567 2568 dns_db_detach(&db); 2569 isc_hash_destroy(); 2570 isc_entropy_detach(&ectx); 2571 isc_mem_destroy(&mctx); 2572 2573 return(result); 2574 } 2575 2576 static void 2577 t13(void) { 2578 int result; 2579 2580 t_assert("dns_db_findnode", 13, T_REQUIRED, "%s", a13); 2581 result = t_eval("dns_db_findnode_1_data", t_dns_db_findnode_1, 8); 2582 t_result(result); 2583 } 2584 2585 static const char *a14 = 2586 "If the node name does not exist and create is ISC_TRUE, " 2587 "then a call to dns_db_findnode(db, name, create, nodep) " 2588 "creates the node, initializes nodep to point to the node, " 2589 "and returns ISC_R_SUCCESS."; 2590 2591 static int 2592 t_dns_db_findnode_2(char **av) { 2593 char *filename; 2594 char *db_type; 2595 char *origin; 2596 char *class; 2597 char *model; 2598 char *newname; 2599 2600 int nfails; 2601 int result; 2602 int len; 2603 dns_db_t *db; 2604 isc_result_t dns_result; 2605 isc_result_t isc_result; 2606 isc_mem_t *mctx; 2607 isc_entropy_t *ectx; 2608 dns_dbnode_t *nodep; 2609 dns_dbnode_t *newnodep; 2610 isc_buffer_t name_buffer; 2611 dns_rdataset_t rdataset; 2612 dns_fixedname_t dns_name; 2613 dns_fixedname_t dns_foundname; 2614 dns_dbversion_t *cversionp; 2615 2616 filename = T_ARG(0); 2617 db_type = T_ARG(1); 2618 origin = T_ARG(2); 2619 class = T_ARG(3); 2620 model = T_ARG(4); 2621 newname = T_ARG(5); 2622 2623 db = NULL; 2624 mctx = NULL; 2625 ectx = NULL; 2626 nfails = 0; 2627 2628 t_info("testing using file %s and name %s\n", filename, newname); 2629 2630 isc_result = isc_mem_create(0, 0, &mctx); 2631 if (isc_result != ISC_R_SUCCESS) { 2632 t_info("isc_mem_create failed %s\n", 2633 isc_result_totext(isc_result)); 2634 return(T_UNRESOLVED); 2635 } 2636 2637 isc_result = isc_entropy_create(mctx, &ectx); 2638 if (isc_result != ISC_R_SUCCESS) { 2639 t_info("isc_entropy_create failed %s\n", 2640 isc_result_totext(isc_result)); 2641 return(T_UNRESOLVED); 2642 } 2643 2644 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 2645 if (isc_result != ISC_R_SUCCESS) { 2646 t_info("isc_hash_create failed %s\n", 2647 isc_result_totext(isc_result)); 2648 return(T_UNRESOLVED); 2649 } 2650 2651 dns_result = t_create(db_type, origin, class, model, mctx, &db); 2652 if (dns_result != ISC_R_SUCCESS) { 2653 isc_hash_destroy(); 2654 isc_entropy_detach(&ectx); 2655 isc_mem_destroy(&mctx); 2656 return(T_UNRESOLVED); 2657 } 2658 2659 dns_result = dns_db_load(db, filename); 2660 if (dns_result != ISC_R_SUCCESS) { 2661 t_info("dns_db_load returned %s\n", 2662 dns_result_totext(dns_result)); 2663 dns_db_detach(&db); 2664 isc_hash_destroy(); 2665 isc_entropy_detach(&ectx); 2666 isc_mem_destroy(&mctx); 2667 return(T_UNRESOLVED); 2668 } 2669 2670 nodep = NULL; 2671 dns_fixedname_init(&dns_name); 2672 2673 /* 2674 * Make sure the name isn't there 2675 */ 2676 len = strlen(newname); 2677 isc_buffer_init(&name_buffer, newname, len); 2678 isc_buffer_add(&name_buffer, len); 2679 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_name), 2680 &name_buffer, NULL, 0, NULL); 2681 if (dns_result != ISC_R_SUCCESS) { 2682 t_info("dns_name_fromtext returned %s\n", 2683 dns_result_totext(dns_result)); 2684 dns_db_detach(&db); 2685 isc_hash_destroy(); 2686 isc_entropy_detach(&ectx); 2687 isc_mem_destroy(&mctx); 2688 return(T_UNRESOLVED); 2689 } 2690 2691 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_name), 2692 ISC_FALSE, &nodep); 2693 if ((dns_result != ISC_R_NOTFOUND) && 2694 (dns_result != DNS_R_NXDOMAIN) && 2695 (dns_result != DNS_R_NXRRSET)) { 2696 t_info("dns_db_findnode %s\n", 2697 dns_result_totext(dns_result)); 2698 dns_db_detachnode(db, &nodep); 2699 dns_db_detach(&db); 2700 isc_hash_destroy(); 2701 isc_entropy_detach(&ectx); 2702 isc_mem_destroy(&mctx); 2703 return(T_UNRESOLVED); 2704 } 2705 2706 /* 2707 * Add it. 2708 */ 2709 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_name), 2710 ISC_TRUE, &nodep); 2711 if (dns_result != ISC_R_SUCCESS) { 2712 t_info("dns_db_findnode %s\n", 2713 dns_result_totext(dns_result)); 2714 dns_db_detach(&db); 2715 isc_hash_destroy(); 2716 isc_entropy_detach(&ectx); 2717 isc_mem_destroy(&mctx); 2718 return(T_FAIL); 2719 } 2720 2721 /* 2722 * Check it. 2723 */ 2724 newnodep = NULL; 2725 dns_rdataset_init(&rdataset); 2726 dns_fixedname_init(&dns_foundname); 2727 cversionp = NULL; 2728 dns_db_currentversion(db, &cversionp); 2729 2730 /* 2731 * First try dns_db_find DNS_R_NXDOMAIN. 2732 */ 2733 dns_result = dns_db_find(db, 2734 dns_fixedname_name(&dns_name), 2735 cversionp, 2736 dns_rdatatype_any, 2737 0, 2738 0, 2739 &newnodep, 2740 dns_fixedname_name(&dns_foundname), 2741 &rdataset, NULL); 2742 if ((dns_result != ISC_R_NOTFOUND) && (dns_result != DNS_R_NXDOMAIN)) { 2743 dns_db_detachnode(db, &newnodep); 2744 } 2745 2746 if (dns_result != DNS_R_NXDOMAIN) { 2747 t_info("dns_db_find %s\n", 2748 dns_result_totext(dns_result)); 2749 ++nfails; 2750 } 2751 2752 /* 2753 * Then try dns_db_findnode ISC_R_SUCCESS. 2754 */ 2755 dns_result = dns_db_findnode(db, dns_fixedname_name(&dns_name), 2756 ISC_FALSE, &newnodep); 2757 t_info("dns_db_findnode %s\n", dns_result_totext(dns_result)); 2758 if (dns_result == ISC_R_SUCCESS) { 2759 dns_db_detachnode(db, &newnodep); 2760 } else { 2761 t_info("dns_db_findnode %s failed %s\n", newname, 2762 dns_result_totext(dns_result)); 2763 ++nfails; 2764 } 2765 2766 2767 dns_db_detachnode(db, &nodep); 2768 dns_db_closeversion(db, &cversionp, ISC_FALSE); 2769 dns_db_detach(&db); 2770 isc_hash_destroy(); 2771 isc_entropy_detach(&ectx); 2772 isc_mem_destroy(&mctx); 2773 2774 if (nfails == 0) 2775 result = T_PASS; 2776 else 2777 result = T_FAIL; 2778 2779 return(result); 2780 } 2781 2782 static void 2783 t14(void) { 2784 int result; 2785 2786 t_assert("dns_db_findnode", 14, T_REQUIRED, "%s", a14); 2787 result = t_eval("dns_db_findnode_2_data", t_dns_db_findnode_2, 6); 2788 t_result(result); 2789 } 2790 2791 static int 2792 t_dns_db_find_x(char **av) { 2793 char *dbfile; 2794 char *dbtype; 2795 char *dborigin; 2796 char *dbclass; 2797 char *dbmodel; 2798 char *findname; 2799 char *findtype; 2800 char *findopts; 2801 char *findtime; 2802 char *expected_result; 2803 2804 int result; 2805 int len; 2806 int opts; 2807 dns_db_t *db; 2808 isc_result_t dns_result; 2809 isc_result_t isc_result; 2810 isc_stdtime_t ftime; 2811 isc_stdtime_t now; 2812 isc_result_t exp_result; 2813 isc_mem_t *mctx; 2814 isc_entropy_t *ectx; 2815 dns_dbnode_t *nodep; 2816 isc_textregion_t textregion; 2817 isc_buffer_t findname_buffer; 2818 dns_fixedname_t dns_findname; 2819 dns_fixedname_t dns_foundname; 2820 dns_rdataset_t rdataset; 2821 dns_rdatatype_t rdatatype; 2822 dns_dbversion_t *cversionp; 2823 2824 dbfile = T_ARG(0); 2825 dbtype = T_ARG(1); 2826 dborigin = T_ARG(2); 2827 dbclass = T_ARG(3); 2828 dbmodel = T_ARG(4); 2829 findname = T_ARG(5); 2830 findtype = T_ARG(6); 2831 findopts = T_ARG(7); 2832 findtime = T_ARG(8); 2833 expected_result = T_ARG(9); 2834 db = NULL; 2835 mctx = NULL; 2836 ectx = NULL; 2837 opts = 0; 2838 2839 t_info("testing using %s, name %s, type %s\n", dbfile, findname, 2840 findtype); 2841 2842 isc_result = isc_mem_create(0, 0, &mctx); 2843 if (isc_result != ISC_R_SUCCESS) { 2844 t_info("isc_mem_create failed %s\n", 2845 isc_result_totext(isc_result)); 2846 return(T_UNRESOLVED); 2847 } 2848 2849 isc_result = isc_entropy_create(mctx, &ectx); 2850 if (isc_result != ISC_R_SUCCESS) { 2851 t_info("isc_entropy_create failed %s\n", 2852 isc_result_totext(isc_result)); 2853 isc_mem_destroy(&mctx); 2854 return(T_UNRESOLVED); 2855 } 2856 2857 isc_result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE); 2858 if (isc_result != ISC_R_SUCCESS) { 2859 t_info("isc_hash_create failed %s\n", 2860 isc_result_totext(isc_result)); 2861 isc_entropy_detach(&ectx); 2862 isc_mem_destroy(&mctx); 2863 return(T_UNRESOLVED); 2864 } 2865 2866 dns_result = t_create(dbtype, dborigin, dbclass, dbmodel, mctx, &db); 2867 if (dns_result != ISC_R_SUCCESS) { 2868 isc_hash_destroy(); 2869 isc_entropy_detach(&ectx); 2870 isc_mem_destroy(&mctx); 2871 return(T_UNRESOLVED); 2872 } 2873 2874 dns_result = dns_db_load(db, dbfile); 2875 if (dns_result != ISC_R_SUCCESS) { 2876 t_info("dns_db_load returned %s\n", 2877 dns_result_totext(dns_result)); 2878 dns_db_detach(&db); 2879 isc_hash_destroy(); 2880 isc_entropy_detach(&ectx); 2881 isc_mem_destroy(&mctx); 2882 return(T_UNRESOLVED); 2883 } 2884 2885 exp_result = t_dns_result_fromtext(expected_result); 2886 2887 dns_fixedname_init(&dns_findname); 2888 len = strlen(findname); 2889 isc_buffer_init(&findname_buffer, findname, len); 2890 isc_buffer_add(&findname_buffer, len); 2891 dns_result = dns_name_fromtext(dns_fixedname_name(&dns_findname), 2892 &findname_buffer, NULL, 0, NULL); 2893 if (dns_result != ISC_R_SUCCESS) { 2894 t_info("dns_name_fromtext failed %s\n", 2895 dns_result_totext(dns_result)); 2896 dns_db_detach(&db); 2897 isc_hash_destroy(); 2898 isc_entropy_detach(&ectx); 2899 isc_mem_destroy(&mctx); 2900 return(T_UNRESOLVED); 2901 } 2902 2903 textregion.base = findtype; 2904 textregion.length = strlen(findtype); 2905 dns_result = dns_rdatatype_fromtext(&rdatatype, &textregion); 2906 if (dns_result != ISC_R_SUCCESS) { 2907 t_info("dns_rdatatype_fromtext %s failed %s\n", 2908 findtype, 2909 dns_result_totext(dns_result)); 2910 dns_db_detach(&db); 2911 isc_hash_destroy(); 2912 isc_entropy_detach(&ectx); 2913 isc_mem_destroy(&mctx); 2914 return(T_UNRESOLVED); 2915 } 2916 2917 if (strstr(findopts, "DNS_DBFIND_GLUEOK")) 2918 opts |= DNS_DBFIND_GLUEOK; 2919 if (strstr(findopts, "DNS_DBFIND_VALIDATEGLUE")) 2920 opts |= DNS_DBFIND_VALIDATEGLUE; 2921 2922 isc_stdtime_get(&now); 2923 2924 ftime = strtol(findtime, NULL, 10); 2925 if (ftime != 0) 2926 ftime += now; 2927 2928 cversionp = NULL; 2929 dns_fixedname_init(&dns_foundname); 2930 dns_rdataset_init(&rdataset); 2931 if (dns_db_iszone(db)) 2932 dns_db_currentversion(db, &cversionp); 2933 nodep = NULL; 2934 2935 dns_result = dns_db_find(db, 2936 dns_fixedname_name(&dns_findname), 2937 cversionp, 2938 rdatatype, 2939 opts, 2940 ftime, 2941 &nodep, 2942 dns_fixedname_name(&dns_foundname), 2943 &rdataset, NULL); 2944 2945 if (dns_result != exp_result) { 2946 t_info("dns_db_find %s %s unexpectedly returned %s, " 2947 "expected %s\n", 2948 findname, findtype, dns_result_totext(dns_result), 2949 dns_result_totext(exp_result)); 2950 result = T_FAIL; 2951 } else { 2952 result = T_PASS; 2953 } 2954 2955 if ((dns_result != ISC_R_NOTFOUND) && (dns_result != DNS_R_NXDOMAIN)) { 2956 2957 if ((dns_result != DNS_R_NXRRSET) && 2958 (dns_result != DNS_R_ZONECUT)) 2959 if (dns_rdataset_isassociated(&rdataset)) 2960 dns_rdataset_disassociate(&rdataset); 2961 dns_db_detachnode(db, &nodep); 2962 } 2963 2964 if (dns_db_iszone(db)) 2965 dns_db_closeversion(db, &cversionp, ISC_FALSE); 2966 dns_db_detach(&db); 2967 isc_hash_destroy(); 2968 isc_entropy_detach(&ectx); 2969 isc_mem_destroy(&mctx); 2970 2971 return(result); 2972 } 2973 2974 static const char *a15 = 2975 "A call to dns_db_find(db, name, version, type, options, now, ...) " 2976 "finds the best match for 'name' and 'type' in version 'version' " 2977 "of 'db'."; 2978 2979 static void 2980 t15(void) { 2981 int result; 2982 2983 t_assert("dns_db_find", 15, T_REQUIRED, "%s", a15); 2984 result = t_eval("dns_db_find_1_data", t_dns_db_find_x, 10); 2985 t_result(result); 2986 } 2987 2988 2989 static const char *a16 = 2990 "When the desired node and type were found, but are glue, " 2991 "and the DNS_DBFIND_GLUEOK option is set, a call to " 2992 "dns_db_find(db, name, version, type, options, now, ...) " 2993 "returns DNS_R_GLUE."; 2994 2995 static void 2996 t16(void) { 2997 int result; 2998 2999 t_assert("dns_db_find", 16, T_REQUIRED, "%s", a16); 3000 result = t_eval("dns_db_find_2_data", t_dns_db_find_x, 10); 3001 t_result(result); 3002 } 3003 3004 static const char *a17 = 3005 "A call to dns_db_find() returns DNS_R_DELEGATION when the data " 3006 "requested is beneath a zone cut."; 3007 3008 static void 3009 t17(void) { 3010 int result; 3011 3012 t_assert("dns_db_find", 17, T_REQUIRED, "%s", a17); 3013 result = t_eval("dns_db_find_3_data", t_dns_db_find_x, 10); 3014 t_result(result); 3015 } 3016 3017 static const char *a18 = 3018 "A call to dns_db_find() returns DNS_R_DELEGATION when type is " 3019 "dns_rdatatype_any and the desired node is a zone cut."; 3020 3021 static void 3022 t18(void) { 3023 int result; 3024 3025 t_assert("dns_db_find", 18, T_REQUIRED, "%s", a18); 3026 result = t_eval("dns_db_find_4_data", t_dns_db_find_x, 10); 3027 t_result(result); 3028 } 3029 3030 static const char *a19 = 3031 "A call to dns_db_find() returns DNS_R_DNAME when the data " 3032 "requested is beneath a DNAME."; 3033 3034 static void 3035 t19(void) { 3036 int result; 3037 3038 t_assert("dns_db_find", 19, T_REQUIRED, "%s", a19); 3039 result = t_eval("dns_db_find_5_data", t_dns_db_find_x, 10); 3040 t_result(result); 3041 } 3042 3043 static const char *a20 = 3044 "A call to dns_db_find() returns DNS_R_CNAME when the requested " 3045 "rdataset was not found but there is a CNAME at the desired name."; 3046 3047 static void 3048 t20(void) { 3049 int result; 3050 3051 t_assert("dns_db_find", 20, T_REQUIRED, "%s", a20); 3052 result = t_eval("dns_db_find_6_data", t_dns_db_find_x, 10); 3053 t_result(result); 3054 } 3055 3056 static const char *a21 = 3057 "A call to dns_db_find() returns DNS_R_NXDOMAIN when name " 3058 "does not exist."; 3059 3060 static void 3061 t21(void) { 3062 int result; 3063 3064 t_assert("dns_db_find", 21, T_REQUIRED, "%s", a21); 3065 result = t_eval("dns_db_find_7_data", t_dns_db_find_x, 10); 3066 t_result(result); 3067 } 3068 3069 static const char *a22 = 3070 "A call to dns_db_find() returns DNS_R_NXRRSET when " 3071 "the desired name exists, but the desired type does not."; 3072 3073 static void 3074 t22(void) { 3075 int result; 3076 3077 t_assert("dns_db_find", 22, T_REQUIRED, "%s", a22); 3078 result = t_eval("dns_db_find_8_data", t_dns_db_find_x, 10); 3079 t_result(result); 3080 } 3081 3082 static const char *a23 = 3083 "When db is a cache database, a call to dns_db_find() " 3084 "returns ISC_R_NOTFOUND when the desired name does not exist, " 3085 "and no delegation could be found."; 3086 3087 static void 3088 t23(void) { 3089 int result; 3090 3091 t_assert("dns_db_find", 23, T_REQUIRED, "%s", a23); 3092 result = t_eval("dns_db_find_9_data", t_dns_db_find_x, 10); 3093 t_result(result); 3094 } 3095 3096 static const char *a24 = 3097 "When db is a cache database, an rdataset will be found only " 3098 "if at least one rdataset at the found node expires after 'now'."; 3099 3100 static void 3101 t24(void) { 3102 int result; 3103 3104 t_assert("dns_db_find", 24, T_REQUIRED, "%s", a24); 3105 result = t_eval("dns_db_find_10_data", t_dns_db_find_x, 10); 3106 t_result(result); 3107 } 3108 3109 static const char *a25 = 3110 "A call to dns_db_load(db, filename) returns DNS_R_NOTZONETOP " 3111 "when the zone data contains a SOA not at the zone apex."; 3112 3113 static void 3114 t25(void) { 3115 int result; 3116 3117 t_assert("dns_db_load", 25, T_REQUIRED, "%s", a25); 3118 result = t_eval("dns_db_load_soa_not_top", t_dns_db_load, 9); 3119 t_result(result); 3120 } 3121 3122 testspec_t T_testlist[] = { 3123 { (PFV) t1, "dns_db_load" }, 3124 { (PFV) t2, "dns_db_iscache" }, 3125 { (PFV) t3, "dns_db_iscache" }, 3126 { (PFV) t4, "dns_db_iszone" }, 3127 { (PFV) t5, "dns_db_iszone" }, 3128 { (PFV) t6, "dns_db_origin" }, 3129 { (PFV) t7, "dns_db_class" }, 3130 { (PFV) t8, "dns_db_currentversion" }, 3131 { (PFV) t9, "dns_db_newversion" }, 3132 { (PFV) t10, "dns_db_closeversion" }, 3133 { (PFV) t11, "dns_db_closeversion" }, 3134 { (PFV) t12, "dns_db_expirenode" }, 3135 { (PFV) t13, "dns_db_findnode" }, 3136 { (PFV) t14, "dns_db_findnode" }, 3137 { (PFV) t15, "dns_db_find" }, 3138 { (PFV) t16, "dns_db_find" }, 3139 { (PFV) t17, "dns_db_find" }, 3140 { (PFV) t18, "dns_db_find" }, 3141 { (PFV) t19, "dns_db_find" }, 3142 { (PFV) t20, "dns_db_find" }, 3143 { (PFV) t21, "dns_db_find" }, 3144 { (PFV) t22, "dns_db_find" }, 3145 { (PFV) t23, "dns_db_find" }, 3146 { (PFV) t24, "dns_db_find" }, 3147 { (PFV) t25, "dns_db_load" }, 3148 { (PFV) 0, NULL } 3149 }; 3150 3151 #ifdef WIN32 3152 int 3153 main(int argc, char **argv) { 3154 t_settests(T_testlist); 3155 return (t_main(argc, argv)); 3156 } 3157 #endif 3158