?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add BIND 9.2.4rc7.
[dragonfly.git] / contrib / bind-9.2.4rc7 / lib / dns / sdb.c
blobc810cd4236b428b63af4fbddde9533810fc6a608
1 /*
2 * Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000, 2001, 2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /* $Id: sdb.c,v 1.35.2.6 2004/07/22 04:04:41 marka Exp $ */
19
20 #include <config.h>
21
22 #include <string.h>
23
24 #include <isc/buffer.h>
25 #include <isc/lex.h>
26 #include <isc/log.h>
27 #include <isc/magic.h>
28 #include <isc/mem.h>
29 #include <isc/once.h>
30 #include <isc/print.h>
31 #include <isc/region.h>
32 #include <isc/util.h>
33
34 #include <dns/callbacks.h>
35 #include <dns/db.h>
36 #include <dns/dbiterator.h>
37 #include <dns/fixedname.h>
38 #include <dns/log.h>
39 #include <dns/rdata.h>
40 #include <dns/rdatalist.h>
41 #include <dns/rdataset.h>
42 #include <dns/rdatasetiter.h>
43 #include <dns/rdatatype.h>
44 #include <dns/result.h>
45 #include <dns/sdb.h>
46 #include <dns/types.h>
47
48 #include "rdatalist_p.h"
49
50 struct dns_sdbimplementation {
51 const dns_sdbmethods_t *methods;
52 void *driverdata;
53 unsigned int flags;
54 isc_mem_t *mctx;
55 isc_mutex_t driverlock;
56 dns_dbimplementation_t *dbimp;
57 };
58
59 struct dns_sdb {
60 /* Unlocked */
61 dns_db_t common;
62 char *zone;
63 dns_sdbimplementation_t *implementation;
64 void *dbdata;
65 isc_mutex_t lock;
66 /* Locked */
67 unsigned int references;
68 };
69
70 struct dns_sdblookup {
71 /* Unlocked */
72 unsigned int magic;
73 dns_sdb_t *sdb;
74 ISC_LIST(dns_rdatalist_t) lists;
75 ISC_LIST(isc_buffer_t) buffers;
76 dns_name_t *name;
77 ISC_LINK(dns_sdblookup_t) link;
78 isc_mutex_t lock;
79 dns_rdatacallbacks_t callbacks;
80 /* Locked */
81 unsigned int references;
82 };
83
84 typedef struct dns_sdblookup dns_sdbnode_t;
85
86 struct dns_sdballnodes {
87 dns_dbiterator_t common;
88 ISC_LIST(dns_sdbnode_t) nodelist;
89 dns_sdbnode_t *current;
90 dns_sdbnode_t *origin;
91 };
92
93 typedef dns_sdballnodes_t sdb_dbiterator_t;
94
95 typedef struct sdb_rdatasetiter {
96 dns_rdatasetiter_t common;
97 dns_rdatalist_t *current;
98 } sdb_rdatasetiter_t;
99
100 #define SDB_MAGIC ISC_MAGIC('S', 'D', 'B', '-')
101
102 /*
103 * Note that "impmagic" is not the first four bytes of the struct, so
104 * ISC_MAGIC_VALID cannot be used.
105 */
106 #define VALID_SDB(sdb) ((sdb) != NULL && \
107 (sdb)->common.impmagic == SDB_MAGIC)
108
109 #define SDBLOOKUP_MAGIC ISC_MAGIC('S','D','B','L')
110 #define VALID_SDBLOOKUP(sdbl) ISC_MAGIC_VALID(sdbl, SDBLOOKUP_MAGIC)
111 #define VALID_SDBNODE(sdbn) VALID_SDBLOOKUP(sdbn)
112
113 /* These values are taken from RFC 1537 */
114 #define SDB_DEFAULT_REFRESH (60 * 60 * 8)
115 #define SDB_DEFAULT_RETRY (60 * 60 * 2)
116 #define SDB_DEFAULT_EXPIRE (60 * 60 * 24 * 7)
117 #define SDB_DEFAULT_MINIMUM (60 * 60 * 24)
118
119 /* This is a reasonable value */
120 #define SDB_DEFAULT_TTL (60 * 60 * 24)
121
122 #define MAYBE_LOCK(sdb) \
123 do { \
124 unsigned int flags = sdb->implementation->flags; \
125 if ((flags & DNS_SDBFLAG_THREADSAFE) == 0) \
126 LOCK(&sdb->implementation->driverlock); \
127 } while (0)
128
129 #define MAYBE_UNLOCK(sdb) \
130 do { \
131 unsigned int flags = sdb->implementation->flags; \
132 if ((flags & DNS_SDBFLAG_THREADSAFE) == 0) \
133 UNLOCK(&sdb->implementation->driverlock); \
134 } while (0)
135
136 static int dummy;
137
138 static isc_result_t dns_sdb_create(isc_mem_t *mctx, dns_name_t *origin,
139 dns_dbtype_t type, dns_rdataclass_t rdclass,
140 unsigned int argc, char *argv[],
141 void *driverarg, dns_db_t **dbp);
142
143 static isc_result_t findrdataset(dns_db_t *db, dns_dbnode_t *node,
144 dns_dbversion_t *version,
145 dns_rdatatype_t type, dns_rdatatype_t covers,
146 isc_stdtime_t now, dns_rdataset_t *rdataset,
147 dns_rdataset_t *sigrdataset);
148
149 static isc_result_t createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep);
150
151 static void destroynode(dns_sdbnode_t *node);
152
153 static void detachnode(dns_db_t *db, dns_dbnode_t **targetp);
154
155
156 static void list_tordataset(dns_rdatalist_t *rdatalist,
157 dns_db_t *db, dns_dbnode_t *node,
158 dns_rdataset_t *rdataset);
159
160 static void dbiterator_destroy(dns_dbiterator_t **iteratorp);
161 static isc_result_t dbiterator_first(dns_dbiterator_t *iterator);
162 static isc_result_t dbiterator_last(dns_dbiterator_t *iterator);
163 static isc_result_t dbiterator_seek(dns_dbiterator_t *iterator,
164 dns_name_t *name);
165 static isc_result_t dbiterator_prev(dns_dbiterator_t *iterator);
166 static isc_result_t dbiterator_next(dns_dbiterator_t *iterator);
167 static isc_result_t dbiterator_current(dns_dbiterator_t *iterator,
168 dns_dbnode_t **nodep,
169 dns_name_t *name);
170 static isc_result_t dbiterator_pause(dns_dbiterator_t *iterator);
171 static isc_result_t dbiterator_origin(dns_dbiterator_t *iterator,
172 dns_name_t *name);
173
174 static dns_dbiteratormethods_t dbiterator_methods = {
175 dbiterator_destroy,
176 dbiterator_first,
177 dbiterator_last,
178 dbiterator_seek,
179 dbiterator_prev,
180 dbiterator_next,
181 dbiterator_current,
182 dbiterator_pause,
183 dbiterator_origin
184 };
185
186 static void rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp);
187 static isc_result_t rdatasetiter_first(dns_rdatasetiter_t *iterator);
188 static isc_result_t rdatasetiter_next(dns_rdatasetiter_t *iterator);
189 static void rdatasetiter_current(dns_rdatasetiter_t *iterator,
190 dns_rdataset_t *rdataset);
191
192 static dns_rdatasetitermethods_t rdatasetiter_methods = {
193 rdatasetiter_destroy,
194 rdatasetiter_first,
195 rdatasetiter_next,
196 rdatasetiter_current
197 };
198
199 /*
200 * Functions used by implementors of simple databases
201 */
202 isc_result_t
203 dns_sdb_register(const char *drivername, const dns_sdbmethods_t *methods,
204 void *driverdata, unsigned int flags, isc_mem_t *mctx,
205 dns_sdbimplementation_t **sdbimp)
206 {
207 dns_sdbimplementation_t *imp;
208 isc_result_t result;
209
210 REQUIRE(drivername != NULL);
211 REQUIRE(methods != NULL);
212 REQUIRE(methods->lookup != NULL);
213 REQUIRE(mctx != NULL);
214 REQUIRE(sdbimp != NULL && *sdbimp == NULL);
215 REQUIRE((flags & ~(DNS_SDBFLAG_RELATIVEOWNER |
216 DNS_SDBFLAG_RELATIVERDATA |
217 DNS_SDBFLAG_THREADSAFE)) == 0);
218
219 imp = isc_mem_get(mctx, sizeof(dns_sdbimplementation_t));
220 if (imp == NULL)
221 return (ISC_R_NOMEMORY);
222 imp->methods = methods;
223 imp->driverdata = driverdata;
224 imp->flags = flags;
225 imp->mctx = NULL;
226 isc_mem_attach(mctx, &imp->mctx);
227 result = isc_mutex_init(&imp->driverlock);
228 if (result != ISC_R_SUCCESS) {
229 UNEXPECTED_ERROR(__FILE__, __LINE__,
230 "isc_mutex_init() failed: %s",
231 isc_result_totext(result));
232 goto cleanup_mctx;
233 }
234
235 imp->dbimp = NULL;
236 result = dns_db_register(drivername, dns_sdb_create, imp, mctx,
237 &imp->dbimp);
238 if (result != ISC_R_SUCCESS)
239 goto cleanup_mutex;
240 *sdbimp = imp;
241
242 return (ISC_R_SUCCESS);
243
244 cleanup_mutex:
245 DESTROYLOCK(&imp->driverlock);
246 cleanup_mctx:
247 isc_mem_put(mctx, imp, sizeof(dns_sdbimplementation_t));
248 return (result);
249 }
250
251 void
252 dns_sdb_unregister(dns_sdbimplementation_t **sdbimp) {
253 dns_sdbimplementation_t *imp;
254 isc_mem_t *mctx;
255
256 REQUIRE(sdbimp != NULL && *sdbimp != NULL);
257
258 imp = *sdbimp;
259 dns_db_unregister(&imp->dbimp);
260 DESTROYLOCK(&imp->driverlock);
261
262 mctx = imp->mctx;
263 isc_mem_put(mctx, imp, sizeof(dns_sdbimplementation_t));
264 isc_mem_detach(&mctx);
265
266 *sdbimp = NULL;
267 }
268
269 static inline unsigned int
270 initial_size(const char *data) {
271 unsigned int len = strlen(data);
272 unsigned int size;
273 for (size = 64; size < (64 * 1024); size *= 2)
274 if (len < size)
275 return (size);
276 return (64 * 1024);
277 }
278
279 isc_result_t
280 dns_sdb_putrr(dns_sdblookup_t *lookup, const char *type, dns_ttl_t ttl,
281 const char *data)
282 {
283 dns_rdatalist_t *rdatalist;
284 dns_rdata_t *rdata;
285 dns_rdatatype_t typeval;
286 isc_textregion_t r;
287 isc_buffer_t b;
288 isc_buffer_t *rdatabuf;
289 isc_lex_t *lex;
290 isc_result_t result;
291 unsigned int size;
292 isc_mem_t *mctx;
293 dns_sdbimplementation_t *imp;
294 dns_name_t *origin;
295
296 REQUIRE(VALID_SDBLOOKUP(lookup));
297 REQUIRE(type != NULL);
298 REQUIRE(data != NULL);
299
300 mctx = lookup->sdb->common.mctx;
301
302 DE_CONST(type, r.base);
303 r.length = strlen(type);
304 result = dns_rdatatype_fromtext(&typeval, &r);
305 if (result != ISC_R_SUCCESS)
306 return (result);
307
308 rdatalist = ISC_LIST_HEAD(lookup->lists);
309 while (rdatalist != NULL) {
310 if (rdatalist->type == typeval)
311 break;
312 rdatalist = ISC_LIST_NEXT(rdatalist, link);
313 }
314
315 if (rdatalist == NULL) {
316 rdatalist = isc_mem_get(mctx, sizeof(dns_rdatalist_t));
317 if (rdatalist == NULL)
318 return (ISC_R_NOMEMORY);
319 rdatalist->rdclass = lookup->sdb->common.rdclass;
320 rdatalist->type = typeval;
321 rdatalist->covers = 0;
322 rdatalist->ttl = ttl;
323 ISC_LIST_INIT(rdatalist->rdata);
324 ISC_LINK_INIT(rdatalist, link);
325 ISC_LIST_APPEND(lookup->lists, rdatalist, link);
326 } else
327 if (rdatalist->ttl != ttl)
328 return (DNS_R_BADTTL);
329
330 rdata = isc_mem_get(mctx, sizeof(dns_rdata_t));
331 if (rdata == NULL)
332 return (ISC_R_NOMEMORY);
333 dns_rdata_init(rdata);
334
335 imp = lookup->sdb->implementation;
336 if ((imp->flags & DNS_SDBFLAG_RELATIVERDATA) != 0)
337 origin = &lookup->sdb->common.origin;
338 else
339 origin = dns_rootname;
340
341 lex = NULL;
342 result = isc_lex_create(mctx, 64, &lex);
343 if (result != ISC_R_SUCCESS)
344 goto failure;
345
346 size = initial_size(data);
347 do {
348 isc_buffer_init(&b, data, strlen(data));
349 isc_buffer_add(&b, strlen(data));
350
351 result = isc_lex_openbuffer(lex, &b);
352 if (result != ISC_R_SUCCESS)
353 goto failure;
354
355 rdatabuf = NULL;
356 result = isc_buffer_allocate(mctx, &rdatabuf, size);
357 if (result != ISC_R_SUCCESS)
358 goto failure;
359
360 result = dns_rdata_fromtext(rdata, rdatalist->rdclass,
361 rdatalist->type, lex,
362 origin, ISC_FALSE,
363 mctx, rdatabuf,
364 &lookup->callbacks);
365 if (result != ISC_R_SUCCESS)
366 isc_buffer_free(&rdatabuf);
367 size *= 2;
368 } while (result == ISC_R_NOSPACE);
369
370 if (result != ISC_R_SUCCESS)
371 goto failure;
372
373 ISC_LIST_APPEND(rdatalist->rdata, rdata, link);
374 ISC_LIST_APPEND(lookup->buffers, rdatabuf, link);
375
376 if (lex != NULL)
377 isc_lex_destroy(&lex);
378
379 return (ISC_R_SUCCESS);
380
381 failure:
382
383 if (rdatabuf != NULL)
384 isc_buffer_free(&rdatabuf);
385 if (lex != NULL)
386 isc_lex_destroy(&lex);
387 isc_mem_put(mctx, rdata, sizeof(dns_rdata_t));
388
389 return (result);
390 }
391
392 isc_result_t
393 dns_sdb_putnamedrr(dns_sdballnodes_t *allnodes, const char *name,
394 const char *type, dns_ttl_t ttl, const char *data)
395 {
396 dns_name_t *newname, *origin;
397 dns_fixedname_t fnewname;
398 dns_sdb_t *sdb = (dns_sdb_t *)allnodes->common.db;
399 dns_sdbimplementation_t *imp = sdb->implementation;
400 dns_sdbnode_t *sdbnode;
401 isc_mem_t *mctx = sdb->common.mctx;
402 isc_buffer_t b;
403 isc_result_t result;
404
405 dns_fixedname_init(&fnewname);
406 newname = dns_fixedname_name(&fnewname);
407
408 if ((imp->flags & DNS_SDBFLAG_RELATIVERDATA) != 0)
409 origin = &sdb->common.origin;
410 else
411 origin = dns_rootname;
412 isc_buffer_init(&b, name, strlen(name));
413 isc_buffer_add(&b, strlen(name));
414
415 result = dns_name_fromtext(newname, &b, origin, ISC_FALSE, NULL);
416 if (result != ISC_R_SUCCESS)
417 return (result);
418
419 if (allnodes->common.relative_names) {
420 /* All names are relative to the root */
421 unsigned int nlabels = dns_name_countlabels(newname);
422 dns_name_getlabelsequence(newname, 0, nlabels - 1, newname);
423 }
424
425 sdbnode = ISC_LIST_HEAD(allnodes->nodelist);
426 if (sdbnode == NULL || !dns_name_equal(sdbnode->name, newname)) {
427 sdbnode = NULL;
428 result = createnode(sdb, &sdbnode);
429 if (result != ISC_R_SUCCESS)
430 return (result);
431 sdbnode->name = isc_mem_get(mctx, sizeof(dns_name_t));
432 if (sdbnode->name == NULL) {
433 destroynode(sdbnode);
434 return (ISC_R_NOMEMORY);
435 }
436 dns_name_init(sdbnode->name, NULL);
437 result = dns_name_dup(newname, mctx, sdbnode->name);
438 if (result != ISC_R_SUCCESS) {
439 isc_mem_put(mctx, sdbnode->name, sizeof(dns_name_t));
440 destroynode(sdbnode);
441 return (result);
442 }
443 ISC_LIST_PREPEND(allnodes->nodelist, sdbnode, link);
444 if (allnodes->origin == NULL &&
445 dns_name_equal(newname, &sdb->common.origin))
446 allnodes->origin = sdbnode;
447 }
448 return (dns_sdb_putrr(sdbnode, type, ttl, data));
449
450 }
451
452 isc_result_t
453 dns_sdb_putsoa(dns_sdblookup_t *lookup, const char *mname, const char *rname,
454 isc_uint32_t serial)
455 {
456 char str[2 * DNS_NAME_MAXTEXT + 5 * (sizeof("2147483647")) + 7];
457 int n;
458
459 REQUIRE(mname != NULL);
460 REQUIRE(rname != NULL);
461
462 n = snprintf(str, sizeof str, "%s %s %u %u %u %u %u",
463 mname, rname, serial,
464 SDB_DEFAULT_REFRESH, SDB_DEFAULT_RETRY,
465 SDB_DEFAULT_EXPIRE, SDB_DEFAULT_MINIMUM);
466 if (n >= (int)sizeof(str) || n < 0)
467 return (ISC_R_NOSPACE);
468 return (dns_sdb_putrr(lookup, "SOA", SDB_DEFAULT_TTL, str));
469 }
470
471 /*
472 * DB routines
473 */
474
475 static void
476 attach(dns_db_t *source, dns_db_t **targetp) {
477 dns_sdb_t *sdb = (dns_sdb_t *) source;
478
479 REQUIRE(VALID_SDB(sdb));
480
481 LOCK(&sdb->lock);
482 REQUIRE(sdb->references > 0);
483 sdb->references++;
484 UNLOCK(&sdb->lock);
485
486 *targetp = source;
487 }
488
489 static void
490 destroy(dns_sdb_t *sdb) {
491 isc_mem_t *mctx;
492 dns_sdbimplementation_t *imp = sdb->implementation;
493
494 mctx = sdb->common.mctx;
495
496 if (imp->methods->destroy != NULL) {
497 MAYBE_LOCK(sdb);
498 imp->methods->destroy(sdb->zone, imp->driverdata,
499 &sdb->dbdata);
500 MAYBE_UNLOCK(sdb);
501 }
502
503 isc_mem_free(mctx, sdb->zone);
504 DESTROYLOCK(&sdb->lock);
505
506 sdb->common.magic = 0;
507 sdb->common.impmagic = 0;
508
509 dns_name_free(&sdb->common.origin, mctx);
510
511 isc_mem_put(mctx, sdb, sizeof(dns_sdb_t));
512 isc_mem_detach(&mctx);
513 }
514
515 static void
516 detach(dns_db_t **dbp) {
517 dns_sdb_t *sdb = (dns_sdb_t *)(*dbp);
518 isc_boolean_t need_destroy = ISC_FALSE;
519
520 REQUIRE(VALID_SDB(sdb));
521 LOCK(&sdb->lock);
522 REQUIRE(sdb->references > 0);
523 sdb->references--;
524 if (sdb->references == 0)
525 need_destroy = ISC_TRUE;
526 UNLOCK(&sdb->lock);
527
528 if (need_destroy)
529 destroy(sdb);
530
531 *dbp = NULL;
532 }
533
534 static isc_result_t
535 beginload(dns_db_t *db, dns_addrdatasetfunc_t *addp, dns_dbload_t **dbloadp) {
536 UNUSED(db);
537 UNUSED(addp);
538 UNUSED(dbloadp);
539 return (ISC_R_NOTIMPLEMENTED);
540 }
541
542 static isc_result_t
543 endload(dns_db_t *db, dns_dbload_t **dbloadp) {
544 UNUSED(db);
545 UNUSED(dbloadp);
546 return (ISC_R_NOTIMPLEMENTED);
547 }
548
549 static isc_result_t
550 dump(dns_db_t *db, dns_dbversion_t *version, const char *filename) {
551 UNUSED(db);
552 UNUSED(version);
553 UNUSED(filename);
554 return (ISC_R_NOTIMPLEMENTED);
555 }
556
557 static void
558 currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
559 REQUIRE(versionp != NULL && *versionp == NULL);
560
561 UNUSED(db);
562
563 *versionp = (void *) &dummy;
564 return;
565 }
566
567 static isc_result_t
568 newversion(dns_db_t *db, dns_dbversion_t **versionp) {
569 UNUSED(db);
570 UNUSED(versionp);
571
572 return (ISC_R_NOTIMPLEMENTED);
573 }
574
575 static void
576 attachversion(dns_db_t *db, dns_dbversion_t *source,
577 dns_dbversion_t **targetp)
578 {
579 REQUIRE(source != NULL && source == (void *) &dummy);
580 REQUIRE(targetp != NULL && *targetp == NULL);
581
582 UNUSED(db);
583 *targetp = source;
584 return;
585 }
586
587 static void
588 closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {
589 REQUIRE(versionp != NULL && *versionp == (void *) &dummy);
590 REQUIRE(commit == ISC_FALSE);
591
592 UNUSED(db);
593 UNUSED(commit);
594
595 *versionp = NULL;
596 }
597
598 static isc_result_t
599 createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep) {
600 dns_sdbnode_t *node;
601 isc_result_t result;
602
603 node = isc_mem_get(sdb->common.mctx, sizeof(dns_sdbnode_t));
604 if (node == NULL)
605 return (ISC_R_NOMEMORY);
606
607 node->sdb = NULL;
608 attach((dns_db_t *)sdb, (dns_db_t **)&node->sdb);
609 ISC_LIST_INIT(node->lists);
610 ISC_LIST_INIT(node->buffers);
611 ISC_LINK_INIT(node, link);
612 node->name = NULL;
613 result = isc_mutex_init(&node->lock);
614 if (result != ISC_R_SUCCESS) {
615 UNEXPECTED_ERROR(__FILE__, __LINE__,
616 "isc_mutex_init() failed: %s",
617 isc_result_totext(result));
618 isc_mem_put(sdb->common.mctx, node, sizeof(dns_sdbnode_t));
619 return (ISC_R_UNEXPECTED);
620 }
621 dns_rdatacallbacks_init(&node->callbacks);
622 node->references = 1;
623 node->magic = SDBLOOKUP_MAGIC;
624
625 *nodep = node;
626 return (ISC_R_SUCCESS);
627 }
628
629 static void
630 destroynode(dns_sdbnode_t *node) {
631 dns_rdatalist_t *list;
632 dns_rdata_t *rdata;
633 isc_buffer_t *b;
634 dns_sdb_t *sdb;
635 isc_mem_t *mctx;
636
637 sdb = node->sdb;
638 mctx = sdb->common.mctx;
639
640 while (!ISC_LIST_EMPTY(node->lists)) {
641 list = ISC_LIST_HEAD(node->lists);
642 while (!ISC_LIST_EMPTY(list->rdata)) {
643 rdata = ISC_LIST_HEAD(list->rdata);
644 ISC_LIST_UNLINK(list->rdata, rdata, link);
645 isc_mem_put(mctx, rdata, sizeof(dns_rdata_t));
646 }
647 ISC_LIST_UNLINK(node->lists, list, link);
648 isc_mem_put(mctx, list, sizeof(dns_rdatalist_t));
649 }
650
651 while (!ISC_LIST_EMPTY(node->buffers)) {
652 b = ISC_LIST_HEAD(node->buffers);
653 ISC_LIST_UNLINK(node->buffers, b, link);
654 isc_buffer_free(&b);
655 }
656
657 if (node->name != NULL) {
658 dns_name_free(node->name, mctx);
659 isc_mem_put(mctx, node->name, sizeof(dns_name_t));
660 }
661 DESTROYLOCK(&node->lock);
662 node->magic = 0;
663 isc_mem_put(mctx, node, sizeof(dns_sdbnode_t));
664 detach((dns_db_t **) (void *)&sdb);
665 }
666
667 static isc_result_t
668 findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
669 dns_dbnode_t **nodep)
670 {
671 dns_sdb_t *sdb = (dns_sdb_t *)db;
672 dns_sdbnode_t *node = NULL;
673 isc_result_t result;
674 isc_buffer_t b;
675 char namestr[DNS_NAME_MAXTEXT + 1];
676 isc_boolean_t isorigin;
677 dns_sdbimplementation_t *imp;
678
679 REQUIRE(VALID_SDB(sdb));
680 REQUIRE(create == ISC_FALSE);
681 REQUIRE(nodep != NULL && *nodep == NULL);
682
683 UNUSED(name);
684 UNUSED(create);
685
686 imp = sdb->implementation;
687
688 isc_buffer_init(&b, namestr, sizeof(namestr));
689 if ((imp->flags & DNS_SDBFLAG_RELATIVEOWNER) != 0) {
690 dns_name_t relname;
691 unsigned int labels;
692
693 labels = dns_name_countlabels(name) -
694 dns_name_countlabels(&db->origin);
695 dns_name_init(&relname, NULL);
696 dns_name_getlabelsequence(name, 0, labels, &relname);
697 result = dns_name_totext(&relname, ISC_TRUE, &b);
698 if (result != ISC_R_SUCCESS)
699 return (result);
700 } else {
701 result = dns_name_totext(name, ISC_TRUE, &b);
702 if (result != ISC_R_SUCCESS)
703 return (result);
704 }
705 isc_buffer_putuint8(&b, 0);
706
707 result = createnode(sdb, &node);
708 if (result != ISC_R_SUCCESS)
709 return (result);
710
711 isorigin = dns_name_equal(name, &sdb->common.origin);
712
713 MAYBE_LOCK(sdb);
714 result = imp->methods->lookup(sdb->zone, namestr, sdb->dbdata, node);
715 MAYBE_UNLOCK(sdb);
716 if (result != ISC_R_SUCCESS && !isorigin) {
717 destroynode(node);
718 return (result);
719 }
720
721 if (isorigin && imp->methods->authority != NULL) {
722 MAYBE_LOCK(sdb);
723 result = imp->methods->authority(sdb->zone, sdb->dbdata, node);
724 MAYBE_UNLOCK(sdb);
725 if (result != ISC_R_SUCCESS) {
726 destroynode(node);
727 return (result);
728 }
729 }
730
731 *nodep = node;
732 return (ISC_R_SUCCESS);
733 }
734
735 static isc_result_t
736 find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
737 dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
738 dns_dbnode_t **nodep, dns_name_t *foundname,
739 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
740 {
741 dns_sdb_t *sdb = (dns_sdb_t *)db;
742 dns_dbnode_t *node = NULL;
743 dns_fixedname_t fname;
744 dns_rdataset_t xrdataset;
745 dns_name_t *xname;
746 unsigned int nlabels, olabels;
747 isc_result_t result;
748 unsigned int i;
749
750 REQUIRE(VALID_SDB(sdb));
751 REQUIRE(nodep == NULL || *nodep == NULL);
752 REQUIRE(version == NULL || version == (void *) &dummy);
753
754 UNUSED(options);
755 UNUSED(sdb);
756
757 if (!dns_name_issubdomain(name, &db->origin))
758 return (DNS_R_NXDOMAIN);
759
760 olabels = dns_name_countlabels(&db->origin);
761 nlabels = dns_name_countlabels(name);
762
763 dns_fixedname_init(&fname);
764 xname = dns_fixedname_name(&fname);
765
766 if (rdataset == NULL) {
767 dns_rdataset_init(&xrdataset);
768 rdataset = &xrdataset;
769 }
770
771 result = DNS_R_NXDOMAIN;
772
773 for (i = olabels; i <= nlabels; i++) {
774 /*
775 * Unless this is an explicit lookup at the origin, don't
776 * look at the origin.
777 */
778 if (i == olabels && i != nlabels)
779 continue;
780
781 /*
782 * Look up the next label.
783 */
784 dns_name_getlabelsequence(name, nlabels - i, i, xname);
785 result = findnode(db, xname, ISC_FALSE, &node);
786 if (result != ISC_R_SUCCESS) {
787 result = DNS_R_NXDOMAIN;
788 continue;
789 }
790
791 /*
792 * Look for a DNAME at the current label, unless this is
793 * the qname.
794 */
795 if (i < nlabels) {
796 result = findrdataset(db, node, version,
797 dns_rdatatype_dname,
798 0, now, rdataset, sigrdataset);
799 if (result == ISC_R_SUCCESS) {
800 result = DNS_R_DNAME;
801 break;
802 }
803 }
804
805 /*
806 * Look for an NS at the current label, unless this is the
807 * origin or glue is ok.
808 */
809 if (i != olabels && (options & DNS_DBFIND_GLUEOK) == 0) {
810 result = findrdataset(db, node, version,
811 dns_rdatatype_ns,
812 0, now, rdataset, sigrdataset);
813 if (result == ISC_R_SUCCESS) {
814 if (i == nlabels && type == dns_rdatatype_any)
815 {
816 result = DNS_R_ZONECUT;
817 dns_rdataset_disassociate(rdataset);
818 if (sigrdataset != NULL)
819 dns_rdataset_disassociate
820 (sigrdataset);
821 } else
822 result = DNS_R_DELEGATION;
823 break;
824 }
825 }
826
827 /*
828 * If the current name is not the qname, add another label
829 * and try again.
830 */
831 if (i < nlabels) {
832 destroynode(node);
833 node = NULL;
834 continue;
835 }
836
837 /*
838 * If we're looking for ANY, we're done.
839 */
840 if (type == dns_rdatatype_any) {
841 result = ISC_R_SUCCESS;
842 break;
843 }
844
845 /*
846 * Look for the qtype.
847 */
848 result = findrdataset(db, node, version, type,
849 0, now, rdataset, sigrdataset);
850 if (result == ISC_R_SUCCESS)
851 break;
852
853 /*
854 * Look for a CNAME
855 */
856 if (type != dns_rdatatype_cname) {
857 result = findrdataset(db, node, version,
858 dns_rdatatype_cname,
859 0, now, rdataset, sigrdataset);
860 if (result == ISC_R_SUCCESS) {
861 result = DNS_R_CNAME;
862 break;
863 }
864 }
865
866 result = DNS_R_NXRRSET;
867 break;
868 }
869
870 if (rdataset == &xrdataset && dns_rdataset_isassociated(rdataset))
871 dns_rdataset_disassociate(rdataset);
872
873 if (foundname != NULL) {
874 isc_result_t xresult;
875
876 xresult = dns_name_copy(xname, foundname, NULL);
877 if (xresult != ISC_R_SUCCESS) {
878 destroynode(node);
879 if (dns_rdataset_isassociated(rdataset))
880 dns_rdataset_disassociate(rdataset);
881 return (DNS_R_BADDB);
882 }
883 }
884
885 if (nodep != NULL)
886 *nodep = node;
887 else if (node != NULL)
888 detachnode(db, &node);
889
890 return (result);
891 }
892
893 static isc_result_t
894 findzonecut(dns_db_t *db, dns_name_t *name, unsigned int options,
895 isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
896 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
897 {
898 UNUSED(db);
899 UNUSED(name);
900 UNUSED(options);
901 UNUSED(now);
902 UNUSED(nodep);
903 UNUSED(foundname);
904 UNUSED(rdataset);
905 UNUSED(sigrdataset);
906
907 return (ISC_R_NOTIMPLEMENTED);
908 }
909
910 static void
911 attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) {
912 dns_sdb_t *sdb = (dns_sdb_t *)db;
913 dns_sdbnode_t *node = (dns_sdbnode_t *)source;
914
915 REQUIRE(VALID_SDB(sdb));
916
917 UNUSED(sdb);
918
919 LOCK(&node->lock);
920 INSIST(node->references > 0);
921 node->references++;
922 INSIST(node->references != 0); /* Catch overflow. */
923 UNLOCK(&node->lock);
924
925 *targetp = source;
926 }
927
928 static void
929 detachnode(dns_db_t *db, dns_dbnode_t **targetp) {
930 dns_sdb_t *sdb = (dns_sdb_t *)db;
931 dns_sdbnode_t *node;
932 isc_boolean_t need_destroy = ISC_FALSE;
933
934 REQUIRE(VALID_SDB(sdb));
935 REQUIRE(targetp != NULL && *targetp != NULL);
936
937 UNUSED(sdb);
938
939 node = (dns_sdbnode_t *)(*targetp);
940
941 LOCK(&node->lock);
942 INSIST(node->references > 0);
943 node->references--;
944 if (node->references == 0)
945 need_destroy = ISC_TRUE;
946 UNLOCK(&node->lock);
947
948 if (need_destroy)
949 destroynode(node);
950
951 *targetp = NULL;
952 }
953
954 static isc_result_t
955 expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now) {
956 UNUSED(db);
957 UNUSED(node);
958 UNUSED(now);
959 INSIST(0);
960 return (ISC_R_UNEXPECTED);
961 }
962
963 static void
964 printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
965 UNUSED(db);
966 UNUSED(node);
967 UNUSED(out);
968 return;
969 }
970
971 static isc_result_t
972 createiterator(dns_db_t *db, isc_boolean_t relative_names,
973 dns_dbiterator_t **iteratorp)
974 {
975 dns_sdb_t *sdb = (dns_sdb_t *)db;
976 sdb_dbiterator_t *sdbiter;
977 dns_sdbimplementation_t *imp = sdb->implementation;
978 isc_result_t result;
979
980 REQUIRE(VALID_SDB(sdb));
981
982 if (imp->methods->allnodes == NULL)
983 return (ISC_R_NOTIMPLEMENTED);
984
985 sdbiter = isc_mem_get(sdb->common.mctx, sizeof(sdb_dbiterator_t));
986 if (sdbiter == NULL)
987 return (ISC_R_NOMEMORY);
988
989 sdbiter->common.methods = &dbiterator_methods;
990 sdbiter->common.db = NULL;
991 dns_db_attach(db, &sdbiter->common.db);
992 sdbiter->common.relative_names = relative_names;
993 sdbiter->common.magic = DNS_DBITERATOR_MAGIC;
994 ISC_LIST_INIT(sdbiter->nodelist);
995 sdbiter->current = NULL;
996 sdbiter->origin = NULL;
997
998 MAYBE_LOCK(sdb);
999 result = imp->methods->allnodes(sdb->zone, sdb->dbdata, sdbiter);
1000 MAYBE_UNLOCK(sdb);
1001 if (result != ISC_R_SUCCESS) {
1002 dbiterator_destroy((dns_dbiterator_t **) (void *)&sdbiter);
1003 return (result);
1004 }
1005
1006 if (sdbiter->origin != NULL) {
1007 ISC_LIST_UNLINK(sdbiter->nodelist, sdbiter->origin, link);
1008 ISC_LIST_PREPEND(sdbiter->nodelist, sdbiter->origin, link);
1009 }
1010
1011 *iteratorp = (dns_dbiterator_t *)sdbiter;
1012
1013 return (ISC_R_SUCCESS);
1014 }
1015
1016 static isc_result_t
1017 findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
1018 dns_rdatatype_t type, dns_rdatatype_t covers,
1019 isc_stdtime_t now, dns_rdataset_t *rdataset,
1020 dns_rdataset_t *sigrdataset)
1021 {
1022 dns_rdatalist_t *list;
1023 dns_sdbnode_t *sdbnode = (dns_sdbnode_t *)node;
1024
1025 REQUIRE(VALID_SDBNODE(node));
1026
1027 UNUSED(db);
1028 UNUSED(version);
1029 UNUSED(covers);
1030 UNUSED(now);
1031 UNUSED(sigrdataset);
1032
1033 if (type == dns_rdatatype_sig)
1034 return (ISC_R_NOTIMPLEMENTED);
1035
1036 list = ISC_LIST_HEAD(sdbnode->lists);
1037 while (list != NULL) {
1038 if (list->type == type)
1039 break;
1040 list = ISC_LIST_NEXT(list, link);
1041 }
1042 if (list == NULL)
1043 return (ISC_R_NOTFOUND);
1044
1045 list_tordataset(list, db, node, rdataset);
1046
1047 return (ISC_R_SUCCESS);
1048 }
1049
1050 static isc_result_t
1051 allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
1052 isc_stdtime_t now, dns_rdatasetiter_t **iteratorp)
1053 {
1054 sdb_rdatasetiter_t *iterator;
1055
1056 REQUIRE(version == NULL || version == &dummy);
1057
1058 UNUSED(version);
1059 UNUSED(now);
1060
1061 iterator = isc_mem_get(db->mctx, sizeof(sdb_rdatasetiter_t));
1062 if (iterator == NULL)
1063 return (ISC_R_NOMEMORY);
1064
1065 iterator->common.magic = DNS_RDATASETITER_MAGIC;
1066 iterator->common.methods = &rdatasetiter_methods;
1067 iterator->common.db = db;
1068 iterator->common.node = NULL;
1069 attachnode(db, node, &iterator->common.node);
1070 iterator->common.version = version;
1071 iterator->common.now = now;
1072
1073 *iteratorp = (dns_rdatasetiter_t *)iterator;
1074
1075 return (ISC_R_SUCCESS);
1076 }
1077
1078 static isc_result_t
1079 addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
1080 isc_stdtime_t now, dns_rdataset_t *rdataset, unsigned int options,
1081 dns_rdataset_t *addedrdataset)
1082 {
1083 UNUSED(db);
1084 UNUSED(node);
1085 UNUSED(version);
1086 UNUSED(now);
1087 UNUSED(rdataset);
1088 UNUSED(options);
1089 UNUSED(addedrdataset);
1090
1091 return (ISC_R_NOTIMPLEMENTED);
1092 }
1093
1094 static isc_result_t
1095 subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
1096 dns_rdataset_t *rdataset, unsigned int options,
1097 dns_rdataset_t *newrdataset)
1098 {
1099 UNUSED(db);
1100 UNUSED(node);
1101 UNUSED(version);
1102 UNUSED(rdataset);
1103 UNUSED(options);
1104 UNUSED(newrdataset);
1105
1106 return (ISC_R_NOTIMPLEMENTED);
1107 }
1108
1109 static isc_result_t
1110 deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
1111 dns_rdatatype_t type, dns_rdatatype_t covers)
1112 {
1113 UNUSED(db);
1114 UNUSED(node);
1115 UNUSED(version);
1116 UNUSED(type);
1117 UNUSED(covers);
1118
1119 return (ISC_R_NOTIMPLEMENTED);
1120 }
1121
1122 static isc_boolean_t
1123 issecure(dns_db_t *db) {
1124 UNUSED(db);
1125
1126 return (ISC_FALSE);
1127 }
1128
1129 static unsigned int
1130 nodecount(dns_db_t *db) {
1131 UNUSED(db);
1132
1133 return (0);
1134 }
1135
1136 static isc_boolean_t
1137 ispersistent(dns_db_t *db) {
1138 UNUSED(db);
1139 return (ISC_TRUE);
1140 }
1141
1142 static void
1143 overmem(dns_db_t *db, isc_boolean_t overmem) {
1144 UNUSED(db);
1145 UNUSED(overmem);
1146 }
1147
1148 static void
1149 settask(dns_db_t *db, isc_task_t *task) {
1150 UNUSED(db);
1151 UNUSED(task);
1152 }
1153
1154
1155 static dns_dbmethods_t sdb_methods = {
1156 attach,
1157 detach,
1158 beginload,
1159 endload,
1160 dump,
1161 currentversion,
1162 newversion,
1163 attachversion,
1164 closeversion,
1165 findnode,
1166 find,
1167 findzonecut,
1168 attachnode,
1169 detachnode,
1170 expirenode,
1171 printnode,
1172 createiterator,
1173 findrdataset,
1174 allrdatasets,
1175 addrdataset,
1176 subtractrdataset,
1177 deleterdataset,
1178 issecure,
1179 nodecount,
1180 ispersistent,
1181 overmem,
1182 settask
1183 };
1184
1185 static isc_result_t
1186 dns_sdb_create(isc_mem_t *mctx, dns_name_t *origin, dns_dbtype_t type,
1187 dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
1188 void *driverarg, dns_db_t **dbp)
1189 {
1190 dns_sdb_t *sdb;
1191 isc_result_t result;
1192 char zonestr[DNS_NAME_MAXTEXT + 1];
1193 isc_buffer_t b;
1194 dns_sdbimplementation_t *imp;
1195
1196 REQUIRE(driverarg != NULL);
1197
1198 imp = driverarg;
1199
1200 if (type != dns_dbtype_zone)
1201 return (ISC_R_NOTIMPLEMENTED);
1202
1203 sdb = isc_mem_get(mctx, sizeof(dns_sdb_t));
1204 if (sdb == NULL)
1205 return (ISC_R_NOMEMORY);
1206 memset(sdb, 0, sizeof(dns_sdb_t));
1207
1208 dns_name_init(&sdb->common.origin, NULL);
1209 sdb->common.attributes = 0;
1210 sdb->common.methods = &sdb_methods;
1211 sdb->common.rdclass = rdclass;
1212 sdb->common.mctx = NULL;
1213 sdb->implementation = imp;
1214
1215 isc_mem_attach(mctx, &sdb->common.mctx);
1216
1217 result = isc_mutex_init(&sdb->lock);
1218 if (result != ISC_R_SUCCESS) {
1219 UNEXPECTED_ERROR(__FILE__, __LINE__,
1220 "isc_mutex_init() failed: %s",
1221 isc_result_totext(result));
1222 result = ISC_R_UNEXPECTED;
1223 goto cleanup_mctx;
1224 }
1225
1226 result = dns_name_dupwithoffsets(origin, mctx, &sdb->common.origin);
1227 if (result != ISC_R_SUCCESS)
1228 goto cleanup_lock;
1229
1230 isc_buffer_init(&b, zonestr, sizeof(zonestr));
1231 result = dns_name_totext(origin, ISC_TRUE, &b);
1232 if (result != ISC_R_SUCCESS)
1233 goto cleanup_origin;
1234 isc_buffer_putuint8(&b, 0);
1235
1236 sdb->zone = isc_mem_strdup(mctx, zonestr);
1237 if (sdb->zone == NULL) {
1238 result = ISC_R_NOMEMORY;
1239 goto cleanup_origin;
1240 }
1241
1242 sdb->dbdata = NULL;
1243 if (imp->methods->create != NULL) {
1244 MAYBE_LOCK(sdb);
1245 result = imp->methods->create(sdb->zone, argc, argv,
1246 imp->driverdata, &sdb->dbdata);
1247 MAYBE_UNLOCK(sdb);
1248 if (result != ISC_R_SUCCESS)
1249 goto cleanup_zonestr;
1250 }
1251
1252 sdb->references = 1;
1253
1254 sdb->common.magic = DNS_DB_MAGIC;
1255 sdb->common.impmagic = SDB_MAGIC;
1256
1257 *dbp = (dns_db_t *)sdb;
1258
1259 return (ISC_R_SUCCESS);
1260
1261 cleanup_zonestr:
1262 isc_mem_free(mctx, sdb->zone);
1263 cleanup_origin:
1264 dns_name_free(&sdb->common.origin, mctx);
1265 cleanup_lock:
1266 isc_mutex_destroy(&sdb->lock);
1267 cleanup_mctx:
1268 isc_mem_put(mctx, sdb, sizeof(dns_sdb_t));
1269 isc_mem_detach(&mctx);
1270
1271 return (result);
1272 }
1273
1274
1275 /*
1276 * Rdataset Methods
1277 */
1278
1279 static void
1280 disassociate(dns_rdataset_t *rdataset) {
1281 dns_dbnode_t *node = rdataset->private5;
1282 dns_sdbnode_t *sdbnode = (dns_sdbnode_t *) node;
1283 dns_db_t *db = (dns_db_t *) sdbnode->sdb;
1284
1285 detachnode(db, &node);
1286 isc__rdatalist_disassociate(rdataset);
1287 }
1288
1289 static void
1290 rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
1291 dns_dbnode_t *node = source->private5;
1292 dns_sdbnode_t *sdbnode = (dns_sdbnode_t *) node;
1293 dns_db_t *db = (dns_db_t *) sdbnode->sdb;
1294 dns_dbnode_t *tempdb = NULL;
1295
1296 isc__rdatalist_clone(source, target);
1297 attachnode(db, node, &tempdb);
1298 source->private5 = tempdb;
1299 }
1300
1301 static dns_rdatasetmethods_t methods = {
1302 disassociate,
1303 isc__rdatalist_first,
1304 isc__rdatalist_next,
1305 isc__rdatalist_current,
1306 rdataset_clone,
1307 isc__rdatalist_count
1308 };
1309
1310 static void
1311 list_tordataset(dns_rdatalist_t *rdatalist,
1312 dns_db_t *db, dns_dbnode_t *node,
1313 dns_rdataset_t *rdataset)
1314 {
1315 /*
1316 * The sdb rdataset is an rdatalist with some additions.
1317 * - private1 & private2 are used by the rdatalist.
1318 * - private3 & private 4 are unused.
1319 * - private5 is the node.
1320 */
1321
1322 /* This should never fail. */
1323 RUNTIME_CHECK(dns_rdatalist_tordataset(rdatalist, rdataset) ==
1324 ISC_R_SUCCESS);
1325
1326 rdataset->methods = &methods;
1327 dns_db_attachnode(db, node, &rdataset->private5);
1328 }
1329
1330 /*
1331 * Database Iterator Methods
1332 */
1333 static void
1334 dbiterator_destroy(dns_dbiterator_t **iteratorp) {
1335 sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)(*iteratorp);
1336 dns_sdb_t *sdb = (dns_sdb_t *)sdbiter->common.db;
1337
1338 while (!ISC_LIST_EMPTY(sdbiter->nodelist)) {
1339 dns_sdbnode_t *node;
1340 node = ISC_LIST_HEAD(sdbiter->nodelist);
1341 ISC_LIST_UNLINK(sdbiter->nodelist, node, link);
1342 destroynode(node);
1343 }
1344
1345 dns_db_detach(&sdbiter->common.db);
1346 isc_mem_put(sdb->common.mctx, sdbiter, sizeof(sdb_dbiterator_t));
1347
1348 *iteratorp = NULL;
1349 }
1350
1351 static isc_result_t
1352 dbiterator_first(dns_dbiterator_t *iterator) {
1353 sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)iterator;
1354
1355 sdbiter->current = ISC_LIST_HEAD(sdbiter->nodelist);
1356 if (sdbiter->current == NULL)
1357 return (ISC_R_NOMORE);
1358 else
1359 return (ISC_R_SUCCESS);
1360 }
1361
1362 static isc_result_t
1363 dbiterator_last(dns_dbiterator_t *iterator) {
1364 sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)iterator;
1365
1366 sdbiter->current = ISC_LIST_TAIL(sdbiter->nodelist);
1367 if (sdbiter->current == NULL)
1368 return (ISC_R_NOMORE);
1369 else
1370 return (ISC_R_SUCCESS);
1371 }
1372
1373 static isc_result_t
1374 dbiterator_seek(dns_dbiterator_t *iterator, dns_name_t *name) {
1375 sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)iterator;
1376
1377 sdbiter->current = ISC_LIST_HEAD(sdbiter->nodelist);
1378 while (sdbiter->current != NULL)
1379 if (dns_name_equal(sdbiter->current->name, name))
1380 return (ISC_R_SUCCESS);
1381 return (ISC_R_NOTFOUND);
1382 }
1383
1384 static isc_result_t
1385 dbiterator_prev(dns_dbiterator_t *iterator) {
1386 sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)iterator;
1387
1388 sdbiter->current = ISC_LIST_PREV(sdbiter->current, link);
1389 if (sdbiter->current == NULL)
1390 return (ISC_R_NOMORE);
1391 else
1392 return (ISC_R_SUCCESS);
1393 }
1394
1395 static isc_result_t
1396 dbiterator_next(dns_dbiterator_t *iterator) {
1397 sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)iterator;
1398
1399 sdbiter->current = ISC_LIST_NEXT(sdbiter->current, link);
1400 if (sdbiter->current == NULL)
1401 return (ISC_R_NOMORE);
1402 else
1403 return (ISC_R_SUCCESS);
1404 }
1405
1406 static isc_result_t
1407 dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
1408 dns_name_t *name)
1409 {
1410 sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)iterator;
1411
1412 attachnode(iterator->db, sdbiter->current, nodep);
1413 if (name != NULL)
1414 return (dns_name_copy(sdbiter->current->name, name, NULL));
1415 return (ISC_R_SUCCESS);
1416 }
1417
1418 static isc_result_t
1419 dbiterator_pause(dns_dbiterator_t *iterator) {
1420 UNUSED(iterator);
1421 return (ISC_R_SUCCESS);
1422 }
1423
1424 static isc_result_t
1425 dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) {
1426 UNUSED(iterator);
1427 return (dns_name_copy(dns_rootname, name, NULL));
1428 }
1429
1430 /*
1431 * Rdataset Iterator Methods
1432 */
1433
1434 static void
1435 rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) {
1436 sdb_rdatasetiter_t *sdbiterator = (sdb_rdatasetiter_t *)(*iteratorp);
1437 detachnode(sdbiterator->common.db, &sdbiterator->common.node);
1438 isc_mem_put(sdbiterator->common.db->mctx, sdbiterator,
1439 sizeof(sdb_rdatasetiter_t));
1440 *iteratorp = NULL;
1441 }
1442
1443 static isc_result_t
1444 rdatasetiter_first(dns_rdatasetiter_t *iterator) {
1445 sdb_rdatasetiter_t *sdbiterator = (sdb_rdatasetiter_t *)iterator;
1446 dns_sdbnode_t *sdbnode = (dns_sdbnode_t *)iterator->node;
1447
1448 if (ISC_LIST_EMPTY(sdbnode->lists))
1449 return (ISC_R_NOMORE);
1450 sdbiterator->current = ISC_LIST_HEAD(sdbnode->lists);
1451 return (ISC_R_SUCCESS);
1452 }
1453
1454 static isc_result_t
1455 rdatasetiter_next(dns_rdatasetiter_t *iterator) {
1456 sdb_rdatasetiter_t *sdbiterator = (sdb_rdatasetiter_t *)iterator;
1457
1458 sdbiterator->current = ISC_LIST_NEXT(sdbiterator->current, link);
1459 if (sdbiterator->current == NULL)
1460 return (ISC_R_NOMORE);
1461 else
1462 return (ISC_R_SUCCESS);
1463 }
1464
1465 static void
1466 rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset) {
1467 sdb_rdatasetiter_t *sdbiterator = (sdb_rdatasetiter_t *)iterator;
1468
1469 list_tordataset(sdbiterator->current, iterator->db, iterator->node,
1470 rdataset);
1471 }
DragonFly BSD