xref: /minix/external/bsd/bind/dist/bin/tests/db/t_db.c (revision 00b67f09)
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
t_create(const char * db_type,const char * origin,const char * class,const char * model,isc_mem_t * mctx,dns_db_t ** db)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, &region);
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
t_dns_db_load(char ** av)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
t1(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
t_dns_db_zc_x(char * filename,char * db_type,char * origin,char * class,dns_dbtype_t dbtype,isc_boolean_t (* cf)(dns_db_t *),isc_boolean_t exp_result)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
test_dns_db_zc_x(const char * filename,dns_dbtype_t dbtype,isc_boolean_t (* cf)(dns_db_t *),isc_boolean_t exp_result)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
t2(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
t3(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
t4(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
t5(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
t_dns_db_origin(char ** av)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
t6(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
t_dns_db_class(char ** av)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
t7(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
t_dns_db_currentversion(char ** av)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
t8(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
t_dns_db_newversion(char ** av)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
t9(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
t_dns_db_closeversion_1(char ** av)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
t10(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
t_dns_db_closeversion_2(char ** av)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
t11(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
t_dns_db_expirenode(char ** av)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
t12(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
t_dns_db_findnode_1(char ** av)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
t13(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
t_dns_db_findnode_2(char ** av)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
t14(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
t_dns_db_find_x(char ** av)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
t15(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
t16(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
t17(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
t18(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
t19(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
t20(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
t21(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
t22(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
t23(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
t24(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
t25(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
main(int argc,char ** argv)3153 main(int argc, char **argv) {
3154 	t_settests(T_testlist);
3155 	return (t_main(argc, argv));
3156 }
3157 #endif
3158