?  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 / zone.c
blob10d4a0253a53fc6f5aa34dd72664ef8eff99f59b
1 /*
2 * Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-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: zone.c,v 1.333.2.33 2004/06/04 02:41:39 marka Exp $ */
19
20 #include <config.h>
21
22 #include <isc/file.h>
23 #include <isc/mutex.h>
24 #include <isc/print.h>
25 #include <isc/random.h>
26 #include <isc/ratelimiter.h>
27 #include <isc/refcount.h>
28 #include <isc/serial.h>
29 #include <isc/string.h>
30 #include <isc/taskpool.h>
31 #include <isc/timer.h>
32 #include <isc/util.h>
33
34 #include <dns/acl.h>
35 #include <dns/adb.h>
36 #include <dns/callbacks.h>
37 #include <dns/db.h>
38 #include <dns/events.h>
39 #include <dns/journal.h>
40 #include <dns/log.h>
41 #include <dns/master.h>
42 #include <dns/masterdump.h>
43 #include <dns/message.h>
44 #include <dns/name.h>
45 #include <dns/peer.h>
46 #include <dns/rcode.h>
47 #include <dns/rdataclass.h>
48 #include <dns/rdatalist.h>
49 #include <dns/rdataset.h>
50 #include <dns/rdatastruct.h>
51 #include <dns/request.h>
52 #include <dns/resolver.h>
53 #include <dns/result.h>
54 #include <dns/stats.h>
55 #include <dns/ssu.h>
56 #include <dns/tsig.h>
57 #include <dns/xfrin.h>
58 #include <dns/zone.h>
59
60 #define ZONE_MAGIC ISC_MAGIC('Z', 'O', 'N', 'E')
61 #define DNS_ZONE_VALID(zone) ISC_MAGIC_VALID(zone, ZONE_MAGIC)
62
63 #define NOTIFY_MAGIC ISC_MAGIC('N', 't', 'f', 'y')
64 #define DNS_NOTIFY_VALID(notify) ISC_MAGIC_VALID(notify, NOTIFY_MAGIC)
65
66 #define STUB_MAGIC ISC_MAGIC('S', 't', 'u', 'b')
67 #define DNS_STUB_VALID(stub) ISC_MAGIC_VALID(stub, STUB_MAGIC)
68
69 #define ZONEMGR_MAGIC ISC_MAGIC('Z', 'm', 'g', 'r')
70 #define DNS_ZONEMGR_VALID(stub) ISC_MAGIC_VALID(stub, ZONEMGR_MAGIC)
71
72 #define LOAD_MAGIC ISC_MAGIC('L', 'o', 'a', 'd')
73 #define DNS_LOAD_VALID(load) ISC_MAGIC_VALID(load, LOAD_MAGIC)
74
75 #define FORWARD_MAGIC ISC_MAGIC('F', 'o', 'r', 'w')
76 #define DNS_FORWARD_VALID(load) ISC_MAGIC_VALID(load, FORWARD_MAGIC)
77
78 #define IO_MAGIC ISC_MAGIC('Z', 'm', 'I', 'O')
79 #define DNS_IO_VALID(load) ISC_MAGIC_VALID(load, IO_MAGIC)
80
81 /*
82 * Ensure 'a' is at least 'min' but not more than 'max'.
83 */
84 #define RANGE(a, min, max) \
85 (((a) < (min)) ? (min) : ((a) < (max) ? (a) : (max)))
86
87 /*
88 * Default values.
89 */
90 #define DNS_DEFAULT_IDLEIN 3600 /* 1 hour */
91 #define DNS_DEFAULT_IDLEOUT 3600 /* 1 hour */
92 #define MAX_XFER_TIME (2*3600) /* Documented default is 2 hours */
93
94 #ifndef DNS_MAX_EXPIRE
95 #define DNS_MAX_EXPIRE 14515200 /* 24 weeks */
96 #endif
97
98 #ifndef DNS_DUMP_DELAY
99 #define DNS_DUMP_DELAY 900 /* 15 minutes */
100 #endif
101
102 typedef struct dns_notify dns_notify_t;
103 typedef struct dns_stub dns_stub_t;
104 typedef struct dns_load dns_load_t;
105 typedef struct dns_forward dns_forward_t;
106 typedef struct dns_io dns_io_t;
107 typedef ISC_LIST(dns_io_t) dns_iolist_t;
108
109 #define DNS_ZONE_CHECKLOCK
110 #ifdef DNS_ZONE_CHECKLOCK
111 #define LOCK_ZONE(z) \
112 do { LOCK(&(z)->lock); \
113 INSIST((z)->locked == ISC_FALSE); \
114 (z)->locked = ISC_TRUE; \
115 } while (0)
116 #define UNLOCK_ZONE(z) \
117 do { (z)->locked = ISC_FALSE; UNLOCK(&(z)->lock); } while (0)
118 #define LOCKED_ZONE(z) ((z)->locked)
119 #else
120 #define LOCK_ZONE(z) LOCK(&(z)->lock)
121 #define UNLOCK_ZONE(z) UNLOCK(&(z)->lock)
122 #define LOCKED_ZONE(z) ISC_TRUE
123 #endif
124
125 struct dns_zone {
126 /* Unlocked */
127 unsigned int magic;
128 isc_mutex_t lock;
129 #ifdef DNS_ZONE_CHECKLOCK
130 isc_boolean_t locked;
131 #endif
132 isc_mem_t *mctx;
133 isc_refcount_t erefs;
134
135 /* Locked */
136 dns_db_t *db;
137 dns_zonemgr_t *zmgr;
138 ISC_LINK(dns_zone_t) link; /* Used by zmgr. */
139 isc_timer_t *timer;
140 unsigned int irefs;
141 dns_name_t origin;
142 char *masterfile;
143 char *journal;
144 isc_int32_t journalsize;
145 dns_rdataclass_t rdclass;
146 dns_zonetype_t type;
147 unsigned int flags;
148 unsigned int options;
149 unsigned int db_argc;
150 char **db_argv;
151 isc_time_t expiretime;
152 isc_time_t refreshtime;
153 isc_time_t dumptime;
154 isc_time_t loadtime;
155 isc_uint32_t serial;
156 isc_uint32_t refresh;
157 isc_uint32_t retry;
158 isc_uint32_t expire;
159 isc_uint32_t minimum;
160
161 isc_uint32_t maxrefresh;
162 isc_uint32_t minrefresh;
163 isc_uint32_t maxretry;
164 isc_uint32_t minretry;
165
166 isc_sockaddr_t *masters;
167 dns_name_t **masterkeynames;
168 unsigned int masterscnt;
169 unsigned int curmaster;
170 unsigned int refreshcnt;
171 isc_sockaddr_t masteraddr;
172 dns_notifytype_t notifytype;
173 isc_sockaddr_t *notify;
174 unsigned int notifycnt;
175 isc_sockaddr_t notifyfrom;
176 isc_task_t *task;
177 isc_sockaddr_t notifysrc4;
178 isc_sockaddr_t notifysrc6;
179 isc_sockaddr_t xfrsource4;
180 isc_sockaddr_t xfrsource6;
181 dns_xfrin_ctx_t *xfr; /* task locked */
182 /* Access Control Lists */
183 dns_acl_t *update_acl;
184 dns_acl_t *forward_acl;
185 dns_acl_t *notify_acl;
186 dns_acl_t *query_acl;
187 dns_acl_t *xfr_acl;
188 dns_severity_t check_names;
189 ISC_LIST(dns_notify_t) notifies;
190 dns_request_t *request;
191 dns_loadctx_t *lctx;
192 dns_io_t *readio;
193 isc_uint32_t maxxfrin;
194 isc_uint32_t maxxfrout;
195 isc_uint32_t idlein;
196 isc_uint32_t idleout;
197 isc_boolean_t diff_on_reload;
198 isc_event_t ctlevent;
199 dns_ssutable_t *ssutable;
200 isc_uint32_t sigvalidityinterval;
201 dns_view_t *view;
202 /*
203 * Zones in certain states such as "waiting for zone transfer"
204 * or "zone transfer in progress" are kept on per-state linked lists
205 * in the zone manager using the 'statelink' field. The 'statelist'
206 * field points at the list the zone is currently on. It the zone
207 * is not on any such list, statelist is NULL.
208 */
209 ISC_LINK(dns_zone_t) statelink;
210 dns_zonelist_t *statelist;
211 /*
212 * Optional per-zone statistics counters (NULL if not present).
213 */
214 isc_uint64_t *counters;
215 };
216
217 #define DNS_ZONE_FLAG(z,f) (ISC_TF(((z)->flags & (f)) != 0))
218 #define DNS_ZONE_SETFLAG(z,f) do { \
219 INSIST(LOCKED_ZONE(z)); \
220 (z)->flags |= (f); \
221 } while (0)
222 #define DNS_ZONE_CLRFLAG(z,f) do { \
223 INSIST(LOCKED_ZONE(z)); \
224 (z)->flags &= ~(f); \
225 } while (0)
226 /* XXX MPA these may need to go back into zone.h */
227 #define DNS_ZONEFLG_REFRESH 0x00000001U /* refresh check in progress */
228 #define DNS_ZONEFLG_NEEDDUMP 0x00000002U /* zone need consolidation */
229 #define DNS_ZONEFLG_USEVC 0x00000004U /* use tcp for refresh query */
230 #define DNS_ZONEFLG_DUMPING 0x00000008U /* a dump is in progress */
231 #define DNS_ZONEFLG_HASINCLUDE 0x00000010U /* $INCLUDE in zone file */
232 #define DNS_ZONEFLG_LOADED 0x00000020U /* database has loaded */
233 #define DNS_ZONEFLG_EXITING 0x00000040U /* zone is being destroyed */
234 #define DNS_ZONEFLG_EXPIRED 0x00000080U /* zone has expired */
235 #define DNS_ZONEFLG_NEEDREFRESH 0x00000100U /* refresh check needed */
236 #define DNS_ZONEFLG_UPTODATE 0x00000200U /* zone contents are
237 * uptodate */
238 #define DNS_ZONEFLG_NEEDNOTIFY 0x00000400U /* need to send out notify
239 * messages */
240 #define DNS_ZONEFLG_DIFFONRELOAD 0x00000800U /* generate a journal diff on
241 * reload */
242 #define DNS_ZONEFLG_NOMASTERS 0x00001000U /* an attempt to refresh a
243 * zone with no masters
244 * occured */
245 #define DNS_ZONEFLG_LOADING 0x00002000U /* load from disk in progress*/
246 #define DNS_ZONEFLG_HAVETIMERS 0x00004000U /* timer values have been set
247 * from SOA (if not set, we
248 * are still using
249 * default timer values) */
250 #define DNS_ZONEFLG_FORCEXFER 0x00008000U /* Force a zone xfer */
251 #define DNS_ZONEFLG_NOREFRESH 0x00010000U
252 #define DNS_ZONEFLG_DIALNOTIFY 0x00020000U
253 #define DNS_ZONEFLG_DIALREFRESH 0x00040000U
254 #define DNS_ZONEFLG_SHUTDOWN 0x00080000U
255 #define DNS_ZONEFLAG_NOIXFR 0x00100000U /* IXFR failed, force AXFR */
256 #define DNS_ZONEFLG_FLUSH 0x00200000U
257
258 #define DNS_ZONE_OPTION(z,o) (((z)->options & (o)) != 0)
259
260 /* Flags for zone_load() */
261 #define DNS_ZONELOADFLAG_NOSTAT 0x00000001U /* Do not stat() master files */
262
263 struct dns_zonemgr {
264 unsigned int magic;
265 isc_mem_t * mctx;
266 int refs; /* Locked by rwlock */
267 isc_taskmgr_t * taskmgr;
268 isc_timermgr_t * timermgr;
269 isc_socketmgr_t * socketmgr;
270 isc_taskpool_t * zonetasks;
271 isc_task_t * task;
272 isc_ratelimiter_t * rl;
273 isc_rwlock_t rwlock;
274 isc_mutex_t iolock;
275
276 /* Locked by rwlock. */
277 dns_zonelist_t zones;
278 dns_zonelist_t waiting_for_xfrin;
279 dns_zonelist_t xfrin_in_progress;
280
281 /* Configuration data. */
282 isc_uint32_t transfersin;
283 isc_uint32_t transfersperns;
284 unsigned int serialqueryrate;
285
286 /* Locked by iolock */
287 isc_uint32_t iolimit;
288 isc_uint32_t ioactive;
289 dns_iolist_t high;
290 dns_iolist_t low;
291 };
292
293 /*
294 * Hold notify state.
295 */
296 struct dns_notify {
297 unsigned int magic;
298 unsigned int flags;
299 isc_mem_t *mctx;
300 dns_zone_t *zone;
301 dns_adbfind_t *find;
302 dns_request_t *request;
303 dns_name_t ns;
304 isc_sockaddr_t dst;
305 unsigned int attempt;
306 ISC_LINK(dns_notify_t) link;
307 };
308
309 #define DNS_NOTIFY_NOSOA 0x0001U
310
311 /*
312 * dns_stub holds state while performing a 'stub' transfer.
313 * 'db' is the zone's 'db' or a new one if this is the initial
314 * transfer.
315 */
316
317 struct dns_stub {
318 unsigned int magic;
319 isc_mem_t *mctx;
320 dns_zone_t *zone;
321 dns_db_t *db;
322 dns_dbversion_t *version;
323 };
324
325 /*
326 * Hold load state.
327 */
328 struct dns_load {
329 unsigned int magic;
330 isc_mem_t *mctx;
331 dns_zone_t *zone;
332 dns_db_t *db;
333 isc_time_t loadtime;
334 dns_rdatacallbacks_t callbacks;
335 };
336
337 /*
338 * Hold forward state.
339 */
340 struct dns_forward {
341 unsigned int magic;
342 isc_mem_t *mctx;
343 dns_zone_t *zone;
344 isc_buffer_t *msgbuf;
345 dns_request_t *request;
346 isc_uint32_t which;
347 isc_sockaddr_t addr;
348 dns_updatecallback_t callback;
349 void *callback_arg;
350 };
351
352 /*
353 * Hold IO request state.
354 */
355 struct dns_io {
356 unsigned int magic;
357 dns_zonemgr_t *zmgr;
358 isc_boolean_t high;
359 isc_task_t *task;
360 ISC_LINK(dns_io_t) link;
361 isc_event_t *event;
362 };
363
364 static void zone_settimer(dns_zone_t *, isc_time_t *);
365 static void cancel_refresh(dns_zone_t *);
366 static void zone_debuglog(dns_zone_t *zone, const char *, int debuglevel,
367 const char *msg, ...) ISC_FORMAT_PRINTF(4, 5);
368 static void notify_log(dns_zone_t *zone, int level, const char *fmt, ...)
369 ISC_FORMAT_PRINTF(3, 4);
370 static void queue_xfrin(dns_zone_t *zone);
371 static void zone_unload(dns_zone_t *zone);
372 static void zone_expire(dns_zone_t *zone);
373 static void zone_iattach(dns_zone_t *source, dns_zone_t **target);
374 static void zone_idetach(dns_zone_t **zonep);
375 static isc_result_t zone_replacedb(dns_zone_t *zone, dns_db_t *db,
376 isc_boolean_t dump);
377 static isc_result_t default_journal(dns_zone_t *zone);
378 static void zone_xfrdone(dns_zone_t *zone, isc_result_t result);
379 static isc_result_t zone_postload(dns_zone_t *zone, dns_db_t *db,
380 isc_time_t loadtime, isc_result_t result);
381 static void zone_needdump(dns_zone_t *zone, unsigned int delay);
382 static void zone_shutdown(isc_task_t *, isc_event_t *);
383 static void zone_loaddone(void *arg, isc_result_t result);
384 static isc_result_t zone_startload(dns_db_t *db, dns_zone_t *zone,
385 isc_time_t loadtime);
386
387 #if 0
388 /* ondestroy example */
389 static void dns_zonemgr_dbdestroyed(isc_task_t *task, isc_event_t *event);
390 #endif
391
392 static void refresh_callback(isc_task_t *, isc_event_t *);
393 static void stub_callback(isc_task_t *, isc_event_t *);
394 static void queue_soa_query(dns_zone_t *zone);
395 static void soa_query(isc_task_t *, isc_event_t *);
396 static void ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset,
397 dns_stub_t *stub);
398 static int message_count(dns_message_t *msg, dns_section_t section,
399 dns_rdatatype_t type);
400 static void notify_cancel(dns_zone_t *zone);
401 static void notify_find_address(dns_notify_t *notify);
402 static void notify_send(dns_notify_t *notify);
403 static isc_result_t notify_createmessage(dns_zone_t *zone,
404 unsigned int flags,
405 dns_message_t **messagep);
406 static void notify_done(isc_task_t *task, isc_event_t *event);
407 static void notify_send_toaddr(isc_task_t *task, isc_event_t *event);
408 static isc_result_t zone_dump(dns_zone_t *);
409 static void got_transfer_quota(isc_task_t *task, isc_event_t *event);
410 static isc_result_t zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr,
411 dns_zone_t *zone);
412 static void zmgr_resume_xfrs(dns_zonemgr_t *zmgr, isc_boolean_t multi);
413 static void zonemgr_free(dns_zonemgr_t *zmgr);
414 static isc_result_t zonemgr_getio(dns_zonemgr_t *zmgr, isc_boolean_t high,
415 isc_task_t *task, isc_taskaction_t action,
416 void *arg, dns_io_t **iop);
417 static void zonemgr_putio(dns_io_t **iop);
418 static void zonemgr_cancelio(dns_io_t *io);
419
420 static isc_result_t
421 zone_get_from_db(dns_db_t *db, dns_name_t *origin, unsigned int *nscount,
422 unsigned int *soacount, isc_uint32_t *serial,
423 isc_uint32_t *refresh, isc_uint32_t *retry,
424 isc_uint32_t *expire, isc_uint32_t *minimum);
425
426 static void zone_freedbargs(dns_zone_t *zone);
427 static void forward_callback(isc_task_t *task, isc_event_t *event);
428 static void zone_saveunique(dns_zone_t *zone, const char *path,
429 const char *templat);
430 static void zone_maintenance(dns_zone_t *zone);
431 static void zone_notify(dns_zone_t *zone);
432
433 #define ENTER zone_debuglog(zone, me, 1, "enter")
434
435 static const unsigned int dbargc_default = 1;
436 static const char *dbargv_default[] = { "rbt" };
437
438 /***
439 *** Public functions.
440 ***/
441
442 isc_result_t
443 dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) {
444 isc_result_t result;
445 dns_zone_t *zone;
446
447 REQUIRE(zonep != NULL && *zonep == NULL);
448 REQUIRE(mctx != NULL);
449
450 zone = isc_mem_get(mctx, sizeof *zone);
451 if (zone == NULL)
452 return (ISC_R_NOMEMORY);
453
454 result = isc_mutex_init(&zone->lock);
455 if (result != ISC_R_SUCCESS) {
456 isc_mem_put(mctx, zone, sizeof *zone);
457 UNEXPECTED_ERROR(__FILE__, __LINE__,
458 "isc_mutex_init() failed: %s",
459 isc_result_totext(result));
460 return (ISC_R_UNEXPECTED);
461 }
462
463 /* XXX MPA check that all elements are initialised */
464 zone->mctx = NULL;
465 #ifdef DNS_ZONE_CHECKLOCK
466 zone->locked = ISC_FALSE;
467 #endif
468 isc_mem_attach(mctx, &zone->mctx);
469 zone->db = NULL;
470 zone->zmgr = NULL;
471 ISC_LINK_INIT(zone, link);
472 isc_refcount_init(&zone->erefs, 1); /* Implicit attach. */
473 zone->irefs = 0;
474 dns_name_init(&zone->origin, NULL);
475 zone->masterfile = NULL;
476 zone->journalsize = -1;
477 zone->journal = NULL;
478 zone->rdclass = dns_rdataclass_none;
479 zone->type = dns_zone_none;
480 zone->flags = 0;
481 zone->options = 0;
482 zone->db_argc = 0;
483 zone->db_argv = NULL;
484 isc_time_settoepoch(&zone->expiretime);
485 isc_time_settoepoch(&zone->refreshtime);
486 isc_time_settoepoch(&zone->dumptime);
487 isc_time_settoepoch(&zone->loadtime);
488 zone->serial = 0;
489 zone->refresh = DNS_ZONE_DEFAULTREFRESH;
490 zone->retry = DNS_ZONE_DEFAULTRETRY;
491 zone->expire = 0;
492 zone->minimum = 0;
493 zone->maxrefresh = DNS_ZONE_MAXREFRESH;
494 zone->minrefresh = DNS_ZONE_MINREFRESH;
495 zone->maxretry = DNS_ZONE_MAXRETRY;
496 zone->minretry = DNS_ZONE_MINRETRY;
497 zone->masters = NULL;
498 zone->masterkeynames = NULL;
499 zone->masterscnt = 0;
500 zone->curmaster = 0;
501 zone->refreshcnt = 0;
502 zone->notify = NULL;
503 zone->notifytype = dns_notifytype_yes;
504 zone->notifycnt = 0;
505 zone->task = NULL;
506 zone->update_acl = NULL;
507 zone->forward_acl = NULL;
508 zone->notify_acl = NULL;
509 zone->query_acl = NULL;
510 zone->xfr_acl = NULL;
511 zone->check_names = dns_severity_ignore;
512 zone->request = NULL;
513 zone->lctx = NULL;
514 zone->readio = NULL;
515 zone->timer = NULL;
516 zone->idlein = DNS_DEFAULT_IDLEIN;
517 zone->idleout = DNS_DEFAULT_IDLEOUT;
518 ISC_LIST_INIT(zone->notifies);
519 isc_sockaddr_any(&zone->notifysrc4);
520 isc_sockaddr_any6(&zone->notifysrc6);
521 isc_sockaddr_any(&zone->xfrsource4);
522 isc_sockaddr_any6(&zone->xfrsource6);
523 zone->xfr = NULL;
524 zone->maxxfrin = MAX_XFER_TIME;
525 zone->maxxfrout = MAX_XFER_TIME;
526 zone->diff_on_reload = ISC_FALSE;
527 zone->ssutable = NULL;
528 zone->sigvalidityinterval = 30 * 24 * 3600;
529 zone->view = NULL;
530 ISC_LINK_INIT(zone, statelink);
531 zone->statelist = NULL;
532 zone->counters = NULL;
533
534 zone->magic = ZONE_MAGIC;
535
536 /* Must be after magic is set. */
537 result = dns_zone_setdbtype(zone, dbargc_default, dbargv_default);
538 if (result != ISC_R_SUCCESS)
539 goto free_mutex;
540
541 ISC_EVENT_INIT(&zone->ctlevent, sizeof(zone->ctlevent), 0, NULL,
542 DNS_EVENT_ZONECONTROL, zone_shutdown, zone, zone,
543 NULL, NULL);
544 *zonep = zone;
545 return (ISC_R_SUCCESS);
546
547 free_mutex:
548 DESTROYLOCK(&zone->lock);
549 return (ISC_R_NOMEMORY);
550 }
551
552 /*
553 * Free a zone. Because we require that there be no more
554 * outstanding events or references, no locking is necessary.
555 */
556 static void
557 zone_free(dns_zone_t *zone) {
558 isc_mem_t *mctx = NULL;
559
560 REQUIRE(DNS_ZONE_VALID(zone));
561 REQUIRE(isc_refcount_current(&zone->erefs) == 0);
562 REQUIRE(zone->irefs == 0);
563 REQUIRE(!LOCKED_ZONE(zone));
564 REQUIRE(zone->timer == NULL);
565
566 /*
567 * Managed objects. Order is important.
568 */
569 if (zone->request != NULL)
570 dns_request_destroy(&zone->request); /* XXXMPA */
571 INSIST(zone->readio == NULL);
572 INSIST(zone->statelist == NULL);
573
574 if (zone->task != NULL)
575 isc_task_detach(&zone->task);
576 if (zone->zmgr)
577 dns_zonemgr_releasezone(zone->zmgr, zone);
578
579 /* Unmanaged objects */
580 if (zone->masterfile != NULL)
581 isc_mem_free(zone->mctx, zone->masterfile);
582 zone->masterfile = NULL;
583 zone->journalsize = -1;
584 if (zone->journal != NULL)
585 isc_mem_free(zone->mctx, zone->journal);
586 zone->journal = NULL;
587 if (zone->counters != NULL)
588 dns_stats_freecounters(zone->mctx, &zone->counters);
589 if (zone->db != NULL)
590 dns_db_detach(&zone->db);
591 zone_freedbargs(zone);
592 dns_zone_setmasterswithkeys(zone, NULL, NULL, 0);
593 dns_zone_setalsonotify(zone, NULL, 0);
594 zone->check_names = dns_severity_ignore;
595 if (zone->update_acl != NULL)
596 dns_acl_detach(&zone->update_acl);
597 if (zone->forward_acl != NULL)
598 dns_acl_detach(&zone->forward_acl);
599 if (zone->notify_acl != NULL)
600 dns_acl_detach(&zone->notify_acl);
601 if (zone->query_acl != NULL)
602 dns_acl_detach(&zone->query_acl);
603 if (zone->xfr_acl != NULL)
604 dns_acl_detach(&zone->xfr_acl);
605 if (dns_name_dynamic(&zone->origin))
606 dns_name_free(&zone->origin, zone->mctx);
607 if (zone->ssutable != NULL)
608 dns_ssutable_detach(&zone->ssutable);
609
610 /* last stuff */
611 DESTROYLOCK(&zone->lock);
612 isc_refcount_destroy(&zone->erefs);
613 zone->magic = 0;
614 mctx = zone->mctx;
615 isc_mem_put(mctx, zone, sizeof *zone);
616 isc_mem_detach(&mctx);
617 }
618
619 /*
620 * Single shot.
621 */
622 void
623 dns_zone_setclass(dns_zone_t *zone, dns_rdataclass_t rdclass) {
624
625 REQUIRE(DNS_ZONE_VALID(zone));
626 REQUIRE(rdclass != dns_rdataclass_none);
627
628 /*
629 * Test and set.
630 */
631 LOCK_ZONE(zone);
632 REQUIRE(zone->rdclass == dns_rdataclass_none ||
633 zone->rdclass == rdclass);
634 zone->rdclass = rdclass;
635 UNLOCK_ZONE(zone);
636 }
637
638 dns_rdataclass_t
639 dns_zone_getclass(dns_zone_t *zone){
640 REQUIRE(DNS_ZONE_VALID(zone));
641
642 return (zone->rdclass);
643 }
644
645 void
646 dns_zone_setnotifytype(dns_zone_t *zone, dns_notifytype_t notifytype) {
647 REQUIRE(DNS_ZONE_VALID(zone));
648
649 LOCK_ZONE(zone);
650 zone->notifytype = notifytype;
651 UNLOCK_ZONE(zone);
652 }
653
654 /*
655 * Single shot.
656 */
657 void
658 dns_zone_settype(dns_zone_t *zone, dns_zonetype_t type) {
659
660 REQUIRE(DNS_ZONE_VALID(zone));
661 REQUIRE(type != dns_zone_none);
662
663 /*
664 * Test and set.
665 */
666 LOCK_ZONE(zone);
667 REQUIRE(zone->type == dns_zone_none || zone->type == type);
668 zone->type = type;
669 UNLOCK_ZONE(zone);
670 }
671
672 static void
673 zone_freedbargs(dns_zone_t *zone) {
674 unsigned int i;
675
676 /* Free the old database argument list. */
677 if (zone->db_argv != NULL) {
678 for (i = 0; i < zone->db_argc; i++)
679 isc_mem_free(zone->mctx, zone->db_argv[i]);
680 isc_mem_put(zone->mctx, zone->db_argv,
681 zone->db_argc * sizeof *zone->db_argv);
682 }
683 zone->db_argc = 0;
684 zone->db_argv = NULL;
685 }
686
687 isc_result_t
688 dns_zone_setdbtype(dns_zone_t *zone,
689 unsigned int dbargc, const char * const *dbargv) {
690 isc_result_t result = ISC_R_SUCCESS;
691 char **new = NULL;
692 unsigned int i;
693
694 REQUIRE(DNS_ZONE_VALID(zone));
695 REQUIRE(dbargc >= 1);
696 REQUIRE(dbargv != NULL);
697
698 LOCK_ZONE(zone);
699
700 /* Set up a new database argument list. */
701 new = isc_mem_get(zone->mctx, dbargc * sizeof *new);
702 if (new == NULL)
703 goto nomem;
704 for (i = 0; i < dbargc; i++)
705 new[i] = NULL;
706 for (i = 0; i < dbargc; i++) {
707 new[i] = isc_mem_strdup(zone->mctx, dbargv[i]);
708 if (new[i] == NULL)
709 goto nomem;
710 }
711
712 /* Free the old list. */
713 zone_freedbargs(zone);
714
715 zone->db_argc = dbargc;
716 zone->db_argv = new;
717 result = ISC_R_SUCCESS;
718 goto unlock;
719
720 nomem:
721 if (new != NULL) {
722 for (i = 0; i < dbargc; i++) {
723 if (zone->db_argv[i] != NULL)
724 isc_mem_free(zone->mctx, new[i]);
725 isc_mem_put(zone->mctx, new,
726 dbargc * sizeof *new);
727 }
728 }
729 result = ISC_R_NOMEMORY;
730
731 unlock:
732 UNLOCK_ZONE(zone);
733 return (result);
734 }
735
736 void
737 dns_zone_setview(dns_zone_t *zone, dns_view_t *view) {
738 REQUIRE(DNS_ZONE_VALID(zone));
739
740 LOCK_ZONE(zone);
741 if (zone->view != NULL)
742 dns_view_weakdetach(&zone->view);
743 dns_view_weakattach(view, &zone->view);
744 UNLOCK_ZONE(zone);
745 }
746
747
748 dns_view_t *
749 dns_zone_getview(dns_zone_t *zone) {
750 REQUIRE(DNS_ZONE_VALID(zone));
751
752 return (zone->view);
753 }
754
755
756 isc_result_t
757 dns_zone_setorigin(dns_zone_t *zone, dns_name_t *origin) {
758 isc_result_t result;
759
760 REQUIRE(DNS_ZONE_VALID(zone));
761 REQUIRE(origin != NULL);
762
763 LOCK_ZONE(zone);
764 if (dns_name_dynamic(&zone->origin)) {
765 dns_name_free(&zone->origin, zone->mctx);
766 dns_name_init(&zone->origin, NULL);
767 }
768 result = dns_name_dup(origin, zone->mctx, &zone->origin);
769 UNLOCK_ZONE(zone);
770 return (result);
771 }
772
773
774 static isc_result_t
775 dns_zone_setstring(dns_zone_t *zone, char **field, const char *value) {
776 char *copy;
777
778 if (value != NULL) {
779 copy = isc_mem_strdup(zone->mctx, value);
780 if (copy == NULL)
781 return (ISC_R_NOMEMORY);
782 } else {
783 copy = NULL;
784 }
785
786 if (*field != NULL)
787 isc_mem_free(zone->mctx, *field);
788
789 *field = copy;
790 return (ISC_R_SUCCESS);
791 }
792
793 isc_result_t
794 dns_zone_setfile(dns_zone_t *zone, const char *file) {
795 isc_result_t result = ISC_R_SUCCESS;
796
797 REQUIRE(DNS_ZONE_VALID(zone));
798
799 LOCK_ZONE(zone);
800 result = dns_zone_setstring(zone, &zone->masterfile, file);
801 if (result == ISC_R_SUCCESS)
802 result = default_journal(zone);
803 UNLOCK_ZONE(zone);
804
805 return (result);
806 }
807
808 const char *
809 dns_zone_getfile(dns_zone_t *zone) {
810 REQUIRE(DNS_ZONE_VALID(zone));
811
812 return (zone->masterfile);
813 }
814
815 static isc_result_t
816 default_journal(dns_zone_t *zone) {
817 isc_result_t result;
818 char *journal;
819
820 REQUIRE(DNS_ZONE_VALID(zone));
821 REQUIRE(LOCKED_ZONE(zone));
822
823 if (zone->masterfile != NULL) {
824 /* Calculate string length including '\0'. */
825 int len = strlen(zone->masterfile) + sizeof ".jnl";
826 journal = isc_mem_allocate(zone->mctx, len);
827 if (journal == NULL)
828 return (ISC_R_NOMEMORY);
829 strcpy(journal, zone->masterfile);
830 strcat(journal, ".jnl");
831 } else {
832 journal = NULL;
833 }
834 result = dns_zone_setstring(zone, &zone->journal, journal);
835 if (journal != NULL)
836 isc_mem_free(zone->mctx, journal);
837 return (result);
838 }
839
840 isc_result_t
841 dns_zone_setjournal(dns_zone_t *zone, const char *journal) {
842 isc_result_t result = ISC_R_SUCCESS;
843
844 REQUIRE(DNS_ZONE_VALID(zone));
845
846 LOCK_ZONE(zone);
847 result = dns_zone_setstring(zone, &zone->journal, journal);
848 UNLOCK_ZONE(zone);
849
850 return (result);
851 }
852
853 char *
854 dns_zone_getjournal(dns_zone_t *zone) {
855 REQUIRE(DNS_ZONE_VALID(zone));
856
857 return (zone->journal);
858 }
859
860 /*
861 * Return true iff the zone is "dynamic", in the sense that the zone's
862 * master file (if any) is written by the server, rather than being
863 * updated manually and read by the server.
864 *
865 * This is true for slave zones, stub zones, and zones that allow
866 * dynamic updates either by having an update policy ("ssutable")
867 * or an "allow-update" ACL with a value other than exactly "{ none; }".
868 */
869 static isc_boolean_t
870 zone_isdynamic(dns_zone_t *zone) {
871 REQUIRE(DNS_ZONE_VALID(zone));
872
873 return (ISC_TF(zone->type == dns_zone_slave ||
874 zone->type == dns_zone_stub ||
875 zone->ssutable != NULL ||
876 (zone->update_acl != NULL &&
877 ! (zone->update_acl->length == 1 &&
878 zone->update_acl->elements[0].negative == ISC_TRUE
879 &&
880 zone->update_acl->elements[0].type ==
881 dns_aclelementtype_any))));
882 }
883
884
885 static isc_result_t
886 zone_load(dns_zone_t *zone, unsigned int flags) {
887 isc_result_t result;
888 isc_time_t now;
889 isc_time_t loadtime, filetime;
890 dns_db_t *db = NULL;
891
892 REQUIRE(DNS_ZONE_VALID(zone));
893
894 LOCK_ZONE(zone);
895 isc_time_now(&now);
896
897 INSIST(zone->type != dns_zone_none);
898
899 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADING)) {
900 result = ISC_R_SUCCESS;
901 goto cleanup;
902 }
903
904 if (zone->db != NULL && zone->masterfile == NULL) {
905 /*
906 * The zone has no master file configured, but it already
907 * has a database. It could be the built-in
908 * version.bind. CH zone, a zone with a persistent
909 * database being reloaded, or maybe a zone that
910 * used to have a master file but whose configuration
911 * was changed so that it no longer has one. Do nothing.
912 */
913 result = ISC_R_SUCCESS;
914 goto cleanup;
915 }
916
917 if (zone->db != NULL && zone_isdynamic(zone)) {
918 /*
919 * This is a slave, stub, or dynamically updated
920 * zone being reloaded. Do nothing - the database
921 * we already have is guaranteed to be up-to-date.
922 */
923 if (zone->type == dns_zone_master)
924 result = DNS_R_DYNAMIC;
925 else
926 result = ISC_R_SUCCESS;
927 goto cleanup;
928 }
929
930 /*
931 * Don't do the load if the file that stores the zone is older
932 * than the last time the zone was loaded. If the zone has not
933 * been loaded yet, zone->loadtime will be the epoch.
934 */
935 if (zone->masterfile != NULL && ! isc_time_isepoch(&zone->loadtime)) {
936 /*
937 * The file is already loaded. If we are just doing a
938 * "rndc reconfig", we are done.
939 */
940 if ((flags & DNS_ZONELOADFLAG_NOSTAT) != 0) {
941 result = ISC_R_SUCCESS;
942 goto cleanup;
943 }
944 if (! DNS_ZONE_FLAG(zone, DNS_ZONEFLG_HASINCLUDE)) {
945 result = isc_file_getmodtime(zone->masterfile,
946 &filetime);
947 if (result == ISC_R_SUCCESS &&
948 isc_time_compare(&filetime, &zone->loadtime) < 0) {
949 dns_zone_log(zone, ISC_LOG_DEBUG(1),
950 "skipping load: master file older "
951 "than last load");
952 result = ISC_R_SUCCESS;
953 goto cleanup;
954 }
955 }
956 }
957
958 INSIST(zone->db_argc >= 1);
959
960 if ((zone->type == dns_zone_slave || zone->type == dns_zone_stub) &&
961 (strcmp(zone->db_argv[0], "rbt") == 0 ||
962 strcmp(zone->db_argv[0], "rbt64") == 0)) {
963 if (zone->masterfile == NULL ||
964 !isc_file_exists(zone->masterfile)) {
965 if (zone->masterfile != NULL)
966 dns_zone_log(zone, ISC_LOG_DEBUG(1),
967 "no master file");
968 zone->refreshtime = now;
969 if (zone->task != NULL)
970 zone_settimer(zone, &now);
971 result = ISC_R_SUCCESS;
972 goto cleanup;
973 }
974 }
975
976 dns_zone_log(zone, ISC_LOG_DEBUG(1), "starting load");
977
978 /*
979 * Store the current time before the zone is loaded, so that if the
980 * file changes between the time of the load and the time that
981 * zone->loadtime is set, then the file will still be reloaded
982 * the next time dns_zone_load is called.
983 */
984 result = isc_time_now(&loadtime);
985 if (result != ISC_R_SUCCESS)
986 goto cleanup;
987
988 result = dns_db_create(zone->mctx, zone->db_argv[0],
989 &zone->origin, (zone->type == dns_zone_stub) ?
990 dns_dbtype_stub : dns_dbtype_zone,
991 zone->rdclass,
992 zone->db_argc - 1, zone->db_argv + 1,
993 &db);
994
995 if (result != ISC_R_SUCCESS) {
996 dns_zone_log(zone, ISC_LOG_ERROR,
997 "loading zone: creating database: %s",
998 isc_result_totext(result));
999 goto cleanup;
1000 }
1001 dns_db_settask(db, zone->task);
1002
1003 if (! dns_db_ispersistent(db)) {
1004 if (zone->masterfile != NULL) {
1005 result = zone_startload(db, zone, loadtime);
1006 } else {
1007 result = DNS_R_NOMASTERFILE;
1008 if (zone->type == dns_zone_master) {
1009 dns_zone_log(zone, ISC_LOG_ERROR,
1010 "loading zone: "
1011 "no master file configured");
1012 goto cleanup;
1013 }
1014 dns_zone_log(zone, ISC_LOG_INFO, "loading zone: "
1015 "no master file configured: continuing");
1016 }
1017 }
1018
1019 if (result == DNS_R_CONTINUE) {
1020 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADING);
1021 result = ISC_R_SUCCESS;
1022 goto cleanup;
1023 }
1024
1025 result = zone_postload(zone, db, loadtime, result);
1026
1027 cleanup:
1028 UNLOCK_ZONE(zone);
1029 if (db != NULL)
1030 dns_db_detach(&db);
1031 return (result);
1032 }
1033
1034 isc_result_t
1035 dns_zone_load(dns_zone_t *zone) {
1036 return (zone_load(zone, 0));
1037 }
1038
1039 isc_result_t
1040 dns_zone_loadnew(dns_zone_t *zone) {
1041 return (zone_load(zone, DNS_ZONELOADFLAG_NOSTAT));
1042 }
1043
1044 static void
1045 zone_gotreadhandle(isc_task_t *task, isc_event_t *event) {
1046 dns_load_t *load = event->ev_arg;
1047 isc_result_t result = ISC_R_SUCCESS;
1048 unsigned int options;
1049
1050 REQUIRE(DNS_LOAD_VALID(load));
1051
1052 if ((event->ev_attributes & ISC_EVENTATTR_CANCELED) != 0)
1053 result = ISC_R_CANCELED;
1054 isc_event_free(&event);
1055 if (result == ISC_R_CANCELED)
1056 goto fail;
1057
1058 options = DNS_MASTER_ZONE;
1059 if (load->zone->type == dns_zone_slave)
1060 options |= DNS_MASTER_SLAVE;
1061 result = dns_master_loadfileinc(load->zone->masterfile,
1062 dns_db_origin(load->db),
1063 dns_db_origin(load->db),
1064 load->zone->rdclass,
1065 options,
1066 &load->callbacks, task,
1067 zone_loaddone, load,
1068 &load->zone->lctx, load->zone->mctx);
1069 if (result != ISC_R_SUCCESS && result != DNS_R_CONTINUE &&
1070 result != DNS_R_SEENINCLUDE)
1071 goto fail;
1072 return;
1073
1074 fail:
1075 zone_loaddone(load, result);
1076 }
1077
1078 static isc_result_t
1079 zone_startload(dns_db_t *db, dns_zone_t *zone, isc_time_t loadtime) {
1080 dns_load_t *load;
1081 isc_result_t result;
1082 isc_result_t tresult;
1083 unsigned int options;
1084
1085 options = DNS_MASTER_ZONE;
1086 if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_MANYERRORS))
1087 options |= DNS_MASTER_MANYERRORS;
1088 if (zone->type == dns_zone_slave)
1089 options |= DNS_MASTER_SLAVE;
1090 if (zone->zmgr != NULL && zone->db != NULL && zone->task != NULL) {
1091 load = isc_mem_get(zone->mctx, sizeof(*load));
1092 if (load == NULL)
1093 return (ISC_R_NOMEMORY);
1094
1095 load->mctx = NULL;
1096 load->zone = NULL;
1097 load->db = NULL;
1098 load->loadtime = loadtime;
1099 load->magic = LOAD_MAGIC;
1100
1101 isc_mem_attach(zone->mctx, &load->mctx);
1102 zone_iattach(zone, &load->zone);
1103 dns_db_attach(db, &load->db);
1104 dns_rdatacallbacks_init(&load->callbacks);
1105 result = dns_db_beginload(db, &load->callbacks.add,
1106 &load->callbacks.add_private);
1107 if (result != ISC_R_SUCCESS)
1108 goto cleanup;
1109 result = zonemgr_getio(zone->zmgr, ISC_TRUE, zone->task,
1110 zone_gotreadhandle, load,
1111 &zone->readio);
1112 if (result != ISC_R_SUCCESS) {
1113 tresult = dns_db_endload(load->db,
1114 &load->callbacks.add_private);
1115 if (result == ISC_R_SUCCESS)
1116 result = tresult;
1117 goto cleanup;
1118 } else
1119 result = DNS_R_CONTINUE;
1120 } else if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_MANYERRORS)) {
1121 dns_rdatacallbacks_t callbacks;
1122
1123 dns_rdatacallbacks_init(&callbacks);
1124 result = dns_db_beginload(db, &callbacks.add,
1125 &callbacks.add_private);
1126 if (result != ISC_R_SUCCESS)
1127 return (result);
1128 result = dns_master_loadfile(zone->masterfile, &zone->origin,
1129 &zone->origin, zone->rdclass,
1130 options, &callbacks, zone->mctx);
1131 tresult = dns_db_endload(db, &callbacks.add_private);
1132 if (result == ISC_R_SUCCESS)
1133 result = tresult;
1134 } else {
1135 result = dns_db_load(db, zone->masterfile);
1136 }
1137
1138 return (result);
1139
1140 cleanup:
1141 load->magic = 0;
1142 dns_db_detach(&load->db);
1143 zone_idetach(&load->zone);
1144 isc_mem_detach(&load->mctx);
1145 isc_mem_put(zone->mctx, load, sizeof(*load));
1146 return (result);
1147 }
1148
1149 static isc_result_t
1150 zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime,
1151 isc_result_t result)
1152 {
1153 unsigned int soacount = 0;
1154 unsigned int nscount = 0;
1155 isc_uint32_t serial, refresh, retry, expire, minimum;
1156 isc_time_t now;
1157 isc_boolean_t needdump = ISC_FALSE;
1158
1159 isc_time_now(&now);
1160
1161 /*
1162 * Initiate zone transfer? We may need a error code that
1163 * indicates that the "permanent" form does not exist.
1164 * XXX better error feedback to log.
1165 */
1166 if (result != ISC_R_SUCCESS && result != DNS_R_SEENINCLUDE) {
1167 if (zone->type == dns_zone_slave ||
1168 zone->type == dns_zone_stub) {
1169 if (result == ISC_R_FILENOTFOUND)
1170 dns_zone_log(zone, ISC_LOG_DEBUG(1),
1171 "no master file");
1172 else if (result != DNS_R_NOMASTERFILE)
1173 dns_zone_log(zone, ISC_LOG_ERROR,
1174 "loading master file %s: %s",
1175 zone->masterfile,
1176 dns_result_totext(result));
1177 } else
1178 dns_zone_log(zone, ISC_LOG_ERROR,
1179 "loading master file %s: %s",
1180 zone->masterfile,
1181 dns_result_totext(result));
1182 goto cleanup;
1183 }
1184
1185 dns_zone_log(zone, ISC_LOG_DEBUG(2),
1186 "number of nodes in database: %u",
1187 dns_db_nodecount(db));
1188 zone->loadtime = loadtime;
1189
1190 dns_zone_log(zone, ISC_LOG_DEBUG(1), "loaded");
1191
1192 if (result == DNS_R_SEENINCLUDE)
1193 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HASINCLUDE);
1194 else
1195 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_HASINCLUDE);
1196 /*
1197 * Apply update log, if any.
1198 */
1199 if (zone->journal != NULL &&
1200 ! DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NOMERGE)) {
1201 result = dns_journal_rollforward(zone->mctx, db,
1202 zone->journal);
1203 if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND &&
1204 result != DNS_R_UPTODATE && result != DNS_R_NOJOURNAL &&
1205 result != ISC_R_RANGE) {
1206 dns_zone_log(zone, ISC_LOG_ERROR,
1207 "journal rollforward failed: %s",
1208 dns_result_totext(result));
1209 goto cleanup;
1210 }
1211 if (result == ISC_R_NOTFOUND || result == ISC_R_RANGE) {
1212 dns_zone_log(zone, ISC_LOG_ERROR,
1213 "journal rollforward failed: "
1214 "journal out of sync with zone");
1215 goto cleanup;
1216 }
1217 dns_zone_log(zone, ISC_LOG_DEBUG(1),
1218 "journal rollforward completed "
1219 "successfully: %s",
1220 dns_result_totext(result));
1221 if (result == ISC_R_SUCCESS)
1222 needdump = ISC_TRUE;
1223 }
1224
1225 /*
1226 * Obtain ns and soa counts for top of zone.
1227 */
1228 nscount = 0;
1229 soacount = 0;
1230 INSIST(db != NULL);
1231 result = zone_get_from_db(db, &zone->origin, &nscount,
1232 &soacount, &serial, &refresh, &retry,
1233 &expire, &minimum);
1234 if (result != ISC_R_SUCCESS) {
1235 dns_zone_log(zone, ISC_LOG_ERROR,
1236 "could not find NS and/or SOA records");
1237 }
1238
1239 /*
1240 * Master / Slave / Stub zones require both NS and SOA records at
1241 * the top of the zone.
1242 */
1243
1244 switch (zone->type) {
1245 case dns_zone_master:
1246 case dns_zone_slave:
1247 case dns_zone_stub:
1248 if (soacount != 1) {
1249 dns_zone_log(zone, ISC_LOG_ERROR,
1250 "has %d SOA records", soacount);
1251 result = DNS_R_BADZONE;
1252 }
1253 if (nscount == 0) {
1254 dns_zone_log(zone, ISC_LOG_ERROR,
1255 "has no NS records");
1256 result = DNS_R_BADZONE;
1257 }
1258 if (result != ISC_R_SUCCESS)
1259 goto cleanup;
1260 if (zone->db != NULL) {
1261 if (!isc_serial_ge(serial, zone->serial)) {
1262 dns_zone_log(zone, ISC_LOG_ERROR,
1263 "zone serial has gone backwards");
1264 }
1265 }
1266 zone->serial = serial;
1267 zone->refresh = RANGE(refresh,
1268 zone->minrefresh, zone->maxrefresh);
1269 zone->retry = RANGE(retry,
1270 zone->minretry, zone->maxretry);
1271 zone->expire = RANGE(expire, zone->refresh + zone->retry,
1272 DNS_MAX_EXPIRE);
1273 zone->minimum = minimum;
1274 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HAVETIMERS);
1275
1276 if (zone->type == dns_zone_slave ||
1277 zone->type == dns_zone_stub) {
1278 isc_time_t t;
1279 isc_interval_t i;
1280 unsigned int delay;
1281
1282 result = isc_file_getmodtime(zone->journal, &t);
1283 if (result != ISC_R_SUCCESS)
1284 result = isc_file_getmodtime(zone->masterfile,
1285 &t);
1286
1287 if (result == ISC_R_SUCCESS) {
1288 isc_interval_set(&i, zone->expire, 0);
1289 isc_time_add(&t, &i, &zone->expiretime);
1290 } else {
1291 isc_interval_set(&i, zone->retry, 0);
1292 isc_time_add(&now, &i, &zone->expiretime);
1293 }
1294 delay = isc_random_jitter(zone->retry,
1295 (zone->retry * 3) / 4);
1296 isc_interval_set(&i, delay, 0);
1297 isc_time_add(&now, &i, &zone->refreshtime);
1298 if (isc_time_compare(&zone->refreshtime,
1299 &zone->expiretime) >= 0)
1300 zone->refreshtime = now;
1301 }
1302 break;
1303 default:
1304 UNEXPECTED_ERROR(__FILE__, __LINE__,
1305 "unexpected zone type %d", zone->type);
1306 result = ISC_R_UNEXPECTED;
1307 goto cleanup;
1308 }
1309
1310
1311 #if 0
1312 /* destroy notification example. */
1313 {
1314 isc_event_t *e = isc_event_allocate(zone->mctx, NULL,
1315 DNS_EVENT_DBDESTROYED,
1316 dns_zonemgr_dbdestroyed,
1317 zone,
1318 sizeof(isc_event_t));
1319 dns_db_ondestroy(db, zone->task, &e);
1320 }
1321 #endif
1322
1323 if (zone->db != NULL) {
1324 result = zone_replacedb(zone, db, ISC_FALSE);
1325 if (result != ISC_R_SUCCESS)
1326 goto cleanup;
1327 } else {
1328 dns_db_attach(db, &zone->db);
1329 DNS_ZONE_SETFLAG(zone,
1330 DNS_ZONEFLG_LOADED|DNS_ZONEFLG_NEEDNOTIFY);
1331 }
1332 result = ISC_R_SUCCESS;
1333 if (needdump)
1334 zone_needdump(zone, DNS_DUMP_DELAY);
1335 if (zone->task != NULL)
1336 zone_settimer(zone, &now);
1337 dns_zone_log(zone, ISC_LOG_INFO, "loaded serial %u", zone->serial);
1338 return (result);
1339
1340 cleanup:
1341 if (zone->type == dns_zone_slave ||
1342 zone->type == dns_zone_stub) {
1343 if (zone->journal != NULL)
1344 zone_saveunique(zone, zone->journal, "jn-XXXXXXXX");
1345 if (zone->masterfile != NULL)
1346 zone_saveunique(zone, zone->masterfile, "db-XXXXXXXX");
1347
1348 /* Mark the zone for immediate refresh. */
1349 zone->refreshtime = now;
1350 if (zone->task != NULL)
1351 zone_settimer(zone, &now);
1352 result = ISC_R_SUCCESS;
1353 }
1354 return (result);
1355 }
1356
1357 static isc_boolean_t
1358 exit_check(dns_zone_t *zone) {
1359
1360 REQUIRE(LOCKED_ZONE(zone));
1361
1362 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_SHUTDOWN) &&
1363 zone->irefs == 0)
1364 {
1365 /*
1366 * DNS_ZONEFLG_SHUTDOWN can only be set if erefs == 0.
1367 */
1368 INSIST(isc_refcount_current(&zone->erefs) == 0);
1369 return (ISC_TRUE);
1370 }
1371 return (ISC_FALSE);
1372 }
1373
1374 static isc_result_t
1375 zone_count_ns_rr(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
1376 unsigned int *nscount)
1377 {
1378 isc_result_t result;
1379 unsigned int count;
1380 dns_rdataset_t rdataset;
1381
1382 REQUIRE(nscount != NULL);
1383
1384 dns_rdataset_init(&rdataset);
1385 result = dns_db_findrdataset(db, node, version, dns_rdatatype_ns,
1386 dns_rdatatype_none, 0, &rdataset, NULL);
1387 if (result == ISC_R_NOTFOUND) {
1388 *nscount = 0;
1389 result = ISC_R_SUCCESS;
1390 goto invalidate_rdataset;
1391 }
1392 else if (result != ISC_R_SUCCESS)
1393 goto invalidate_rdataset;
1394
1395 count = 0;
1396 result = dns_rdataset_first(&rdataset);
1397 while (result == ISC_R_SUCCESS) {
1398 count++;
1399 result = dns_rdataset_next(&rdataset);
1400 }
1401 dns_rdataset_disassociate(&rdataset);
1402
1403 *nscount = count;
1404 result = ISC_R_SUCCESS;
1405
1406 invalidate_rdataset:
1407 dns_rdataset_invalidate(&rdataset);
1408
1409 return (result);
1410 }
1411
1412 static isc_result_t
1413 zone_load_soa_rr(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
1414 unsigned int *soacount,
1415 isc_uint32_t *serial, isc_uint32_t *refresh,
1416 isc_uint32_t *retry, isc_uint32_t *expire,
1417 isc_uint32_t *minimum)
1418 {
1419 isc_result_t result;
1420 unsigned int count;
1421 dns_rdataset_t rdataset;
1422 dns_rdata_t rdata = DNS_RDATA_INIT;
1423 dns_rdata_soa_t soa;
1424
1425 dns_rdataset_init(&rdataset);
1426 result = dns_db_findrdataset(db, node, version, dns_rdatatype_soa,
1427 dns_rdatatype_none, 0, &rdataset, NULL);
1428 if (result != ISC_R_SUCCESS)
1429 goto invalidate_rdataset;
1430
1431 count = 0;
1432 result = dns_rdataset_first(&rdataset);
1433 while (result == ISC_R_SUCCESS) {
1434 dns_rdata_init(&rdata);
1435 dns_rdataset_current(&rdataset, &rdata);
1436 count++;
1437 if (count == 1)
1438 dns_rdata_tostruct(&rdata, &soa, NULL);
1439
1440 result = dns_rdataset_next(&rdataset);
1441 dns_rdata_reset(&rdata);
1442 }
1443 dns_rdataset_disassociate(&rdataset);
1444
1445 if (soacount != NULL)
1446 *soacount = count;
1447
1448 if (count > 0) {
1449 if (serial != NULL)
1450 *serial = soa.serial;
1451 if (refresh != NULL)
1452 *refresh = soa.refresh;
1453 if (retry != NULL)
1454 *retry = soa.retry;
1455 if (expire != NULL)
1456 *expire = soa.expire;
1457 if (minimum != NULL)
1458 *minimum = soa.minimum;
1459 }
1460
1461 result = ISC_R_SUCCESS;
1462
1463 invalidate_rdataset:
1464 dns_rdataset_invalidate(&rdataset);
1465
1466 return (result);
1467 }
1468
1469 /*
1470 * zone must be locked.
1471 */
1472 static isc_result_t
1473 zone_get_from_db(dns_db_t *db, dns_name_t *origin, unsigned int *nscount,
1474 unsigned int *soacount, isc_uint32_t *serial,
1475 isc_uint32_t *refresh, isc_uint32_t *retry,
1476 isc_uint32_t *expire, isc_uint32_t *minimum)
1477 {
1478 dns_dbversion_t *version;
1479 isc_result_t result;
1480 isc_result_t answer = ISC_R_SUCCESS;
1481 dns_dbnode_t *node;
1482
1483 REQUIRE(db != NULL);
1484 REQUIRE(origin != NULL);
1485
1486 version = NULL;
1487 dns_db_currentversion(db, &version);
1488
1489 node = NULL;
1490 result = dns_db_findnode(db, origin, ISC_FALSE, &node);
1491 if (result != ISC_R_SUCCESS) {
1492 answer = result;
1493 goto closeversion;
1494 }
1495
1496 if (nscount != NULL) {
1497 result = zone_count_ns_rr(db, node, version, nscount);
1498 if (result != ISC_R_SUCCESS)
1499 answer = result;
1500 }
1501
1502 if (soacount != NULL || serial != NULL || refresh != NULL
1503 || retry != NULL || expire != NULL || minimum != NULL) {
1504 result = zone_load_soa_rr(db, node, version, soacount,
1505 serial, refresh, retry, expire,
1506 minimum);
1507 if (result != ISC_R_SUCCESS)
1508 answer = result;
1509 }
1510
1511 dns_db_detachnode(db, &node);
1512 closeversion:
1513 dns_db_closeversion(db, &version, ISC_FALSE);
1514
1515 return (answer);
1516 }
1517
1518 void
1519 dns_zone_attach(dns_zone_t *source, dns_zone_t **target) {
1520 REQUIRE(DNS_ZONE_VALID(source));
1521 REQUIRE(target != NULL && *target == NULL);
1522 isc_refcount_increment(&source->erefs, NULL);
1523 *target = source;
1524 }
1525
1526 void
1527 dns_zone_detach(dns_zone_t **zonep) {
1528 dns_zone_t *zone;
1529 unsigned int refs;
1530 isc_boolean_t free_now = ISC_FALSE;
1531
1532 REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep));
1533
1534 zone = *zonep;
1535
1536 isc_refcount_decrement(&zone->erefs, &refs);
1537
1538 if (refs == 0) {
1539 LOCK_ZONE(zone);
1540 /*
1541 * We just detached the last external reference.
1542 */
1543 if (zone->task != NULL) {
1544 /*
1545 * This zone is being managed. Post
1546 * its control event and let it clean
1547 * up synchronously in the context of
1548 * its task.
1549 */
1550 isc_event_t *ev = &zone->ctlevent;
1551 isc_task_send(zone->task, &ev);
1552 } else {
1553 /*
1554 * This zone is not being managed; it has
1555 * no task and can have no outstanding
1556 * events. Free it immediately.
1557 */
1558 /*
1559 * Unmanaged zones should not have non-null views;
1560 * we have no way of detaching from the view here
1561 * without causing deadlock because this code is called
1562 * with the view already locked.
1563 */
1564 INSIST(zone->view == NULL);
1565 free_now = ISC_TRUE;
1566 }
1567 UNLOCK_ZONE(zone);
1568 }
1569 *zonep = NULL;
1570 if (free_now)
1571 zone_free(zone);
1572 }
1573
1574 void
1575 dns_zone_iattach(dns_zone_t *source, dns_zone_t **target) {
1576 REQUIRE(DNS_ZONE_VALID(source));
1577 REQUIRE(target != NULL && *target == NULL);
1578 LOCK_ZONE(source);
1579 zone_iattach(source, target);
1580 UNLOCK_ZONE(source);
1581 }
1582
1583 static void
1584 zone_iattach(dns_zone_t *source, dns_zone_t **target) {
1585
1586 /*
1587 * 'source' locked by caller.
1588 */
1589 REQUIRE(LOCKED_ZONE(source));
1590 REQUIRE(DNS_ZONE_VALID(source));
1591 REQUIRE(target != NULL && *target == NULL);
1592 INSIST(source->irefs + isc_refcount_current(&source->erefs) > 0);
1593 source->irefs++;
1594 INSIST(source->irefs != 0);
1595 *target = source;
1596 }
1597
1598 static void
1599 zone_idetach(dns_zone_t **zonep) {
1600 dns_zone_t *zone;
1601
1602 /*
1603 * 'zone' locked by caller.
1604 */
1605 REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep));
1606 zone = *zonep;
1607 REQUIRE(LOCKED_ZONE(*zonep));
1608 *zonep = NULL;
1609
1610 INSIST(zone->irefs > 0);
1611 zone->irefs--;
1612 INSIST(zone->irefs + isc_refcount_current(&zone->erefs) > 0);
1613 }
1614
1615 void
1616 dns_zone_idetach(dns_zone_t **zonep) {
1617 dns_zone_t *zone;
1618 isc_boolean_t free_needed;
1619
1620 REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep));
1621 zone = *zonep;
1622 *zonep = NULL;
1623
1624 LOCK_ZONE(zone);
1625 INSIST(zone->irefs > 0);
1626 zone->irefs--;
1627 free_needed = exit_check(zone);
1628 UNLOCK_ZONE(zone);
1629 if (free_needed)
1630 zone_free(zone);
1631 }
1632
1633 isc_mem_t *
1634 dns_zone_getmctx(dns_zone_t *zone) {
1635 REQUIRE(DNS_ZONE_VALID(zone));
1636
1637 return (zone->mctx);
1638 }
1639
1640 dns_zonemgr_t *
1641 dns_zone_getmgr(dns_zone_t *zone) {
1642 REQUIRE(DNS_ZONE_VALID(zone));
1643
1644 return (zone->zmgr);
1645 }
1646
1647 void
1648 dns_zone_setflag(dns_zone_t *zone, unsigned int flags, isc_boolean_t value) {
1649 REQUIRE(DNS_ZONE_VALID(zone));
1650
1651 LOCK_ZONE(zone);
1652 if (value)
1653 DNS_ZONE_SETFLAG(zone, flags);
1654 else
1655 DNS_ZONE_CLRFLAG(zone, flags);
1656 UNLOCK_ZONE(zone);
1657 }
1658
1659 void
1660 dns_zone_setoption(dns_zone_t *zone, unsigned int option, isc_boolean_t value)
1661 {
1662 REQUIRE(DNS_ZONE_VALID(zone));
1663
1664 LOCK_ZONE(zone);
1665 if (value)
1666 zone->options |= option;
1667 else
1668 zone->options &= ~option;
1669 UNLOCK_ZONE(zone);
1670 }
1671
1672 unsigned int
1673 dns_zone_getoptions(dns_zone_t *zone) {
1674
1675 REQUIRE(DNS_ZONE_VALID(zone));
1676
1677 return (zone->options);
1678 }
1679
1680 isc_result_t
1681 dns_zone_setxfrsource4(dns_zone_t *zone, isc_sockaddr_t *xfrsource) {
1682 REQUIRE(DNS_ZONE_VALID(zone));
1683
1684 LOCK_ZONE(zone);
1685 zone->xfrsource4 = *xfrsource;
1686 UNLOCK_ZONE(zone);
1687
1688 return (ISC_R_SUCCESS);
1689 }
1690
1691 isc_sockaddr_t *
1692 dns_zone_getxfrsource4(dns_zone_t *zone) {
1693 REQUIRE(DNS_ZONE_VALID(zone));
1694 return (&zone->xfrsource4);
1695 }
1696
1697 isc_result_t
1698 dns_zone_setxfrsource6(dns_zone_t *zone, isc_sockaddr_t *xfrsource) {
1699 REQUIRE(DNS_ZONE_VALID(zone));
1700
1701 LOCK_ZONE(zone);
1702 zone->xfrsource6 = *xfrsource;
1703 UNLOCK_ZONE(zone);
1704
1705 return (ISC_R_SUCCESS);
1706 }
1707
1708 isc_sockaddr_t *
1709 dns_zone_getxfrsource6(dns_zone_t *zone) {
1710 REQUIRE(DNS_ZONE_VALID(zone));
1711 return (&zone->xfrsource6);
1712 }
1713
1714 isc_result_t
1715 dns_zone_setnotifysrc4(dns_zone_t *zone, isc_sockaddr_t *notifysrc) {
1716 REQUIRE(DNS_ZONE_VALID(zone));
1717
1718 LOCK_ZONE(zone);
1719 zone->notifysrc4 = *notifysrc;
1720 UNLOCK_ZONE(zone);
1721
1722 return (ISC_R_SUCCESS);
1723 }
1724
1725 isc_sockaddr_t *
1726 dns_zone_getnotifysrc4(dns_zone_t *zone) {
1727 REQUIRE(DNS_ZONE_VALID(zone));
1728 return (&zone->notifysrc4);
1729 }
1730
1731 isc_result_t
1732 dns_zone_setnotifysrc6(dns_zone_t *zone, isc_sockaddr_t *notifysrc) {
1733 REQUIRE(DNS_ZONE_VALID(zone));
1734
1735 LOCK_ZONE(zone);
1736 zone->notifysrc6 = *notifysrc;
1737 UNLOCK_ZONE(zone);
1738
1739 return (ISC_R_SUCCESS);
1740 }
1741
1742 isc_sockaddr_t *
1743 dns_zone_getnotifysrc6(dns_zone_t *zone) {
1744 REQUIRE(DNS_ZONE_VALID(zone));
1745 return (&zone->notifysrc6);
1746 }
1747
1748 isc_result_t
1749 dns_zone_setalsonotify(dns_zone_t *zone, isc_sockaddr_t *notify,
1750 isc_uint32_t count)
1751 {
1752 isc_sockaddr_t *new;
1753
1754 REQUIRE(DNS_ZONE_VALID(zone));
1755 REQUIRE(count == 0 || notify != NULL);
1756
1757 LOCK_ZONE(zone);
1758 if (zone->notify != NULL) {
1759 isc_mem_put(zone->mctx, zone->notify,
1760 zone->notifycnt * sizeof *new);
1761 zone->notify = NULL;
1762 zone->notifycnt = 0;
1763 }
1764 if (count != 0) {
1765 new = isc_mem_get(zone->mctx, count * sizeof *new);
1766 if (new == NULL) {
1767 UNLOCK_ZONE(zone);
1768 return (ISC_R_NOMEMORY);
1769 }
1770 memcpy(new, notify, count * sizeof *new);
1771 zone->notify = new;
1772 zone->notifycnt = count;
1773 }
1774 UNLOCK_ZONE(zone);
1775 return (ISC_R_SUCCESS);
1776 }
1777
1778 isc_result_t
1779 dns_zone_setmasters(dns_zone_t *zone, isc_sockaddr_t *masters,
1780 isc_uint32_t count)
1781 {
1782 isc_result_t result;
1783
1784 result = dns_zone_setmasterswithkeys(zone, masters, NULL, count);
1785 return (result);
1786 }
1787
1788 isc_result_t
1789 dns_zone_setmasterswithkeys(dns_zone_t *zone, isc_sockaddr_t *masters,
1790 dns_name_t **keynames, isc_uint32_t count)
1791 {
1792 isc_sockaddr_t *new;
1793 isc_result_t result = ISC_R_SUCCESS;
1794 dns_name_t **newname;
1795 unsigned int i;
1796
1797 REQUIRE(DNS_ZONE_VALID(zone));
1798 REQUIRE(count == 0 || masters != NULL);
1799 if (keynames != NULL) {
1800 REQUIRE(count != 0);
1801 }
1802
1803 LOCK_ZONE(zone);
1804 if (zone->masters != NULL) {
1805 isc_mem_put(zone->mctx, zone->masters,
1806 zone->masterscnt * sizeof *new);
1807 zone->masters = NULL;
1808 }
1809 if (zone->masterkeynames != NULL) {
1810 for (i = 0; i < zone->masterscnt; i++) {
1811 if (zone->masterkeynames[i] != NULL) {
1812 dns_name_free(zone->masterkeynames[i],
1813 zone->mctx);
1814 isc_mem_put(zone->mctx,
1815 zone->masterkeynames[i],
1816 sizeof(dns_name_t));
1817 zone->masterkeynames[i] = NULL;
1818 }
1819 }
1820 isc_mem_put(zone->mctx, zone->masterkeynames,
1821 zone->masterscnt * sizeof(dns_name_t *));
1822 zone->masterkeynames = NULL;
1823 }
1824 zone->masterscnt = 0;
1825 /*
1826 * If count == 0, don't allocate any space for masters or keynames
1827 * so internally, those pointers are NULL if count == 0
1828 */
1829 if (count == 0)
1830 goto unlock;
1831
1832 /*
1833 * masters must countain count elements!
1834 */
1835 new = isc_mem_get(zone->mctx,
1836 count * sizeof(isc_sockaddr_t));
1837 if (new == NULL) {
1838 result = ISC_R_NOMEMORY;
1839 goto unlock;
1840 }
1841 memcpy(new, masters, count * sizeof *new);
1842 zone->masters = new;
1843 zone->masterscnt = count;
1844 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NOMASTERS);
1845
1846 /*
1847 * if keynames is non-NULL, it must contain count elements!
1848 */
1849 if (keynames != NULL) {
1850 newname = isc_mem_get(zone->mctx,
1851 count * sizeof(dns_name_t *));
1852 if (newname == NULL) {
1853 result = ISC_R_NOMEMORY;
1854 isc_mem_put(zone->mctx, zone->masters,
1855 count * sizeof *new);
1856 goto unlock;
1857 }
1858 for (i = 0; i < count; i++)
1859 newname[i] = NULL;
1860 for (i = 0; i < count; i++) {
1861 if (keynames[i] != NULL) {
1862 newname[i] = isc_mem_get(zone->mctx,
1863 sizeof(dns_name_t));
1864 if (newname[i] == NULL)
1865 goto allocfail;
1866 dns_name_init(newname[i], NULL);
1867 result = dns_name_dup(keynames[i], zone->mctx,
1868 newname[i]);
1869 if (result != ISC_R_SUCCESS) {
1870 allocfail:
1871 for (i = 0; i < count; i++)
1872 if (newname[i] != NULL)
1873 dns_name_free(
1874 newname[i],
1875 zone->mctx);
1876 isc_mem_put(zone->mctx, zone->masters,
1877 count * sizeof *new);
1878 isc_mem_put(zone->mctx, newname,
1879 count * sizeof *newname);
1880 goto unlock;
1881 }
1882 }
1883 }
1884 zone->masterkeynames = newname;
1885 }
1886 unlock:
1887 UNLOCK_ZONE(zone);
1888 return (result);
1889 }
1890
1891 isc_result_t
1892 dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) {
1893 isc_result_t result = ISC_R_SUCCESS;
1894
1895 REQUIRE(DNS_ZONE_VALID(zone));
1896
1897 LOCK_ZONE(zone);
1898 if (zone->db == NULL)
1899 result = DNS_R_NOTLOADED;
1900 else
1901 dns_db_attach(zone->db, dpb);
1902 UNLOCK_ZONE(zone);
1903
1904 return (result);
1905 }
1906
1907 /*
1908 * Co-ordinates the starting of routine jobs.
1909 */
1910
1911 void
1912 dns_zone_maintenance(dns_zone_t *zone) {
1913 const char me[] = "dns_zone_maintenance";
1914 isc_time_t now;
1915
1916 REQUIRE(DNS_ZONE_VALID(zone));
1917 ENTER;
1918
1919 LOCK_ZONE(zone);
1920 isc_time_now(&now);
1921 zone_settimer(zone, &now);
1922 UNLOCK_ZONE(zone);
1923 }
1924
1925 static inline isc_boolean_t
1926 was_dumping(dns_zone_t *zone) {
1927 isc_boolean_t dumping;
1928
1929 REQUIRE(LOCKED_ZONE(zone));
1930
1931 dumping = DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DUMPING);
1932 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_DUMPING);
1933 if (!dumping) {
1934 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDDUMP);
1935 isc_time_settoepoch(&zone->dumptime);
1936 }
1937 return (dumping);
1938 }
1939
1940 static void
1941 zone_maintenance(dns_zone_t *zone) {
1942 const char me[] = "zone_maintenance";
1943 isc_time_t now;
1944 isc_result_t result;
1945 isc_boolean_t dumping;
1946
1947 REQUIRE(DNS_ZONE_VALID(zone));
1948 ENTER;
1949
1950 /*
1951 * Configuring the view of this zone may have
1952 * failed, for example because the config file
1953 * had a syntax error. In that case, the view
1954 * adb or resolver, and we had better not try
1955 * to do maintenance on it.
1956 */
1957 if (zone->view == NULL || zone->view->adb == NULL)
1958 return;
1959
1960 isc_time_now(&now);
1961
1962 /*
1963 * Expire check.
1964 */
1965 switch (zone->type) {
1966 case dns_zone_slave:
1967 case dns_zone_stub:
1968 LOCK_ZONE(zone);
1969 if (isc_time_compare(&now, &zone->expiretime) >= 0 &&
1970 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) {
1971 zone_expire(zone);
1972 zone->refreshtime = now;
1973 }
1974 UNLOCK_ZONE(zone);
1975 break;
1976 default:
1977 break;
1978 }
1979
1980 /*
1981 * Up to date check.
1982 */
1983 switch (zone->type) {
1984 case dns_zone_slave:
1985 case dns_zone_stub:
1986 if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALREFRESH) &&
1987 isc_time_compare(&now, &zone->refreshtime) >= 0)
1988 dns_zone_refresh(zone);
1989 break;
1990 default:
1991 break;
1992 }
1993
1994 /*
1995 * Do we need to consolidate the backing store?
1996 */
1997 switch (zone->type) {
1998 case dns_zone_master:
1999 case dns_zone_slave:
2000 LOCK_ZONE(zone);
2001 if (zone->masterfile != NULL &&
2002 isc_time_compare(&now, &zone->dumptime) >= 0 &&
2003 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) &&
2004 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP)) {
2005 dumping = was_dumping(zone);
2006 } else
2007 dumping = ISC_TRUE;
2008 UNLOCK_ZONE(zone);
2009 if (!dumping) {
2010 result = zone_dump(zone);
2011 if (result != ISC_R_SUCCESS)
2012 dns_zone_log(zone, ISC_LOG_WARNING,
2013 "dump failed: %s",
2014 dns_result_totext(result));
2015 }
2016 break;
2017 default:
2018 break;
2019 }
2020
2021 /*
2022 * Do we need to send out notify messages?
2023 */
2024 switch (zone->type) {
2025 case dns_zone_master:
2026 case dns_zone_slave:
2027 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDNOTIFY))
2028 zone_notify(zone);
2029 break;
2030 default:
2031 break;
2032 }
2033 zone_settimer(zone, &now);
2034 }
2035
2036 void
2037 dns_zone_markdirty(dns_zone_t *zone) {
2038
2039 LOCK_ZONE(zone);
2040 zone_needdump(zone, DNS_DUMP_DELAY);
2041 UNLOCK_ZONE(zone);
2042 }
2043
2044 void
2045 dns_zone_expire(dns_zone_t *zone) {
2046 REQUIRE(DNS_ZONE_VALID(zone));
2047
2048 LOCK_ZONE(zone);
2049 zone_expire(zone);
2050 UNLOCK_ZONE(zone);
2051 }
2052
2053 static void
2054 zone_expire(dns_zone_t *zone) {
2055 /*
2056 * 'zone' locked by caller.
2057 */
2058
2059 REQUIRE(LOCKED_ZONE(zone));
2060
2061 dns_zone_log(zone, ISC_LOG_WARNING, "expired");
2062
2063 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_EXPIRED);
2064 zone->refresh = DNS_ZONE_DEFAULTREFRESH;
2065 zone->retry = DNS_ZONE_DEFAULTRETRY;
2066 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_HAVETIMERS);
2067 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDDUMP);
2068 zone_unload(zone);
2069 }
2070
2071 void
2072 dns_zone_refresh(dns_zone_t *zone) {
2073 isc_interval_t i;
2074 isc_uint32_t oldflags;
2075
2076 REQUIRE(DNS_ZONE_VALID(zone));
2077
2078 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING))
2079 return;
2080
2081 /*
2082 * Set DNS_ZONEFLG_REFRESH so that there is only one refresh operation
2083 * in progress at a time.
2084 */
2085
2086 LOCK_ZONE(zone);
2087 oldflags = zone->flags;
2088 if (zone->masterscnt == 0) {
2089 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOMASTERS);
2090 if ((oldflags & DNS_ZONEFLG_NOMASTERS) == 0)
2091 dns_zone_log(zone, ISC_LOG_ERROR,
2092 "cannot refresh: no masters");
2093 goto unlock;
2094 }
2095 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_REFRESH);
2096 if ((oldflags & (DNS_ZONEFLG_REFRESH|DNS_ZONEFLG_LOADING)) != 0)
2097 goto unlock;
2098
2099 /*
2100 * Set the next refresh time as if refresh check has failed.
2101 * Setting this to the retry time will do that. XXXMLG
2102 * If we are successful it will be reset using zone->refresh.
2103 */
2104 isc_interval_set(&i, isc_random_jitter(zone->retry, zone->retry / 4),
2105 0);
2106 isc_time_nowplusinterval(&zone->refreshtime, &i);
2107
2108 /*
2109 * When lacking user-specified timer values from the SOA,
2110 * do exponential backoff of the retry time up to a
2111 * maximum of six hours.
2112 */
2113 if (! DNS_ZONE_FLAG(zone, DNS_ZONEFLG_HAVETIMERS))
2114 zone->retry = ISC_MIN(zone->retry * 2, 6 * 3600);
2115
2116 zone->curmaster = 0;
2117 zone->refreshcnt = 0;
2118 /* initiate soa query */
2119 queue_soa_query(zone);
2120 unlock:
2121 UNLOCK_ZONE(zone);
2122 }
2123
2124 isc_result_t
2125 dns_zone_flush(dns_zone_t *zone) {
2126 isc_result_t result = ISC_R_ALREADYRUNNING;
2127 isc_boolean_t dumping;
2128
2129 REQUIRE(DNS_ZONE_VALID(zone));
2130
2131 LOCK_ZONE(zone);
2132 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FLUSH);
2133 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP) &&
2134 zone->masterfile != NULL)
2135 dumping = was_dumping(zone);
2136 else
2137 dumping = ISC_TRUE;
2138 UNLOCK_ZONE(zone);
2139 if (!dumping)
2140 result = zone_dump(zone);
2141 return (result);
2142 }
2143
2144 isc_result_t
2145 dns_zone_dump(dns_zone_t *zone) {
2146 isc_result_t result = ISC_R_ALREADYRUNNING;
2147 isc_boolean_t dumping;
2148
2149 REQUIRE(DNS_ZONE_VALID(zone));
2150
2151 LOCK_ZONE(zone);
2152 dumping = was_dumping(zone);
2153 UNLOCK_ZONE(zone);
2154 if (!dumping)
2155 result = zone_dump(zone);
2156 return (result);
2157 }
2158
2159 static void
2160 zone_needdump(dns_zone_t *zone, unsigned int delay) {
2161 isc_time_t dumptime;
2162 isc_time_t now;
2163 isc_interval_t i;
2164
2165 /*
2166 * 'zone' locked by caller
2167 */
2168
2169 REQUIRE(DNS_ZONE_VALID(zone));
2170 REQUIRE(LOCKED_ZONE(zone));
2171
2172 /*
2173 * Do we have a place to dump to and are we loaded?
2174 */
2175 if (zone->masterfile == NULL ||
2176 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) == 0)
2177 return;
2178
2179 isc_interval_set(&i, delay, 0);
2180 isc_time_now(&now);
2181 isc_time_add(&now, &i, &dumptime);
2182
2183 /* add some noise */
2184 delay = isc_random_jitter(delay, delay/4);
2185
2186 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NEEDDUMP);
2187 if (isc_time_isepoch(&zone->dumptime) ||
2188 isc_time_compare(&zone->dumptime, &dumptime) > 0)
2189 zone->dumptime = dumptime;
2190 if (zone->task != NULL)
2191 zone_settimer(zone, &now);
2192 }
2193
2194 static isc_result_t
2195 zone_dump(dns_zone_t *zone) {
2196 isc_result_t result;
2197 dns_dbversion_t *version = NULL;
2198 isc_boolean_t again;
2199 dns_db_t *db = NULL;
2200 char *masterfile = NULL;
2201
2202 REQUIRE(DNS_ZONE_VALID(zone));
2203
2204 redo:
2205 LOCK_ZONE(zone);
2206 if (zone->db != NULL)
2207 dns_db_attach(zone->db, &db);
2208 if (zone->masterfile != NULL)
2209 masterfile = isc_mem_strdup(zone->mctx, zone->masterfile);
2210 UNLOCK_ZONE(zone);
2211 if (db == NULL) {
2212 result = DNS_R_NOTLOADED;
2213 goto fail;
2214 }
2215 if (masterfile == NULL) {
2216 result = DNS_R_NOMASTERFILE;
2217 goto fail;
2218 }
2219 dns_db_currentversion(db, &version);
2220
2221 result = dns_master_dump(zone->mctx, db, version,
2222 &dns_master_style_default, masterfile);
2223
2224 dns_db_closeversion(db, &version, ISC_FALSE);
2225 fail:
2226 if (db != NULL)
2227 dns_db_detach(&db);
2228 if (masterfile != NULL)
2229 isc_mem_free(zone->mctx, masterfile);
2230 masterfile = NULL;
2231
2232 again = ISC_FALSE;
2233 LOCK_ZONE(zone);
2234 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_DUMPING);
2235 if (result != ISC_R_SUCCESS) {
2236 /*
2237 * Try again in a short while.
2238 */
2239 zone_needdump(zone, DNS_DUMP_DELAY);
2240 } else if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FLUSH) &&
2241 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP) &&
2242 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) {
2243 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDDUMP);
2244 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_DUMPING);
2245 isc_time_settoepoch(&zone->dumptime);
2246 again = ISC_TRUE;
2247 }
2248 UNLOCK_ZONE(zone);
2249 if (again)
2250 goto redo;
2251
2252 return (result);
2253 }
2254
2255 isc_result_t
2256 dns_zone_dumptostream(dns_zone_t *zone, FILE *fd) {
2257 isc_result_t result;
2258 dns_dbversion_t *version = NULL;
2259 dns_db_t *db = NULL;
2260
2261 REQUIRE(DNS_ZONE_VALID(zone));
2262
2263 LOCK_ZONE(zone);
2264 if (zone->db != NULL)
2265 dns_db_attach(zone->db, &db);
2266 UNLOCK_ZONE(zone);
2267 if (db == NULL)
2268 return (DNS_R_NOTLOADED);
2269
2270 dns_db_currentversion(db, &version);
2271 result = dns_master_dumptostream(zone->mctx, db, version,
2272 &dns_master_style_default, fd);
2273 dns_db_closeversion(db, &version, ISC_FALSE);
2274 dns_db_detach(&db);
2275 return (result);
2276 }
2277
2278 void
2279 dns_zone_unload(dns_zone_t *zone) {
2280 REQUIRE(DNS_ZONE_VALID(zone));
2281
2282 LOCK_ZONE(zone);
2283 zone_unload(zone);
2284 UNLOCK_ZONE(zone);
2285 }
2286
2287 static void
2288 notify_cancel(dns_zone_t *zone) {
2289 dns_notify_t *notify;
2290
2291 /*
2292 * 'zone' locked by caller.
2293 */
2294
2295 REQUIRE(LOCKED_ZONE(zone));
2296
2297 for (notify = ISC_LIST_HEAD(zone->notifies);
2298 notify != NULL;
2299 notify = ISC_LIST_NEXT(notify, link)) {
2300 if (notify->find != NULL)
2301 dns_adb_cancelfind(notify->find);
2302 if (notify->request != NULL)
2303 dns_request_cancel(notify->request);
2304 }
2305 }
2306
2307 static void
2308 zone_unload(dns_zone_t *zone) {
2309
2310 /*
2311 * 'zone' locked by caller.
2312 */
2313
2314 REQUIRE(LOCKED_ZONE(zone));
2315
2316 dns_db_detach(&zone->db);
2317 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_LOADED);
2318 }
2319
2320 void
2321 dns_zone_setminrefreshtime(dns_zone_t *zone, isc_uint32_t val) {
2322 REQUIRE(DNS_ZONE_VALID(zone));
2323 REQUIRE(val > 0);
2324
2325 zone->minrefresh = val;
2326 }
2327
2328 void
2329 dns_zone_setmaxrefreshtime(dns_zone_t *zone, isc_uint32_t val) {
2330 REQUIRE(DNS_ZONE_VALID(zone));
2331 REQUIRE(val > 0);
2332
2333 zone->maxrefresh = val;
2334 }
2335
2336 void
2337 dns_zone_setminretrytime(dns_zone_t *zone, isc_uint32_t val) {
2338 REQUIRE(DNS_ZONE_VALID(zone));
2339 REQUIRE(val > 0);
2340
2341 zone->minretry = val;
2342 }
2343
2344 void
2345 dns_zone_setmaxretrytime(dns_zone_t *zone, isc_uint32_t val) {
2346 REQUIRE(DNS_ZONE_VALID(zone));
2347 REQUIRE(val > 0);
2348
2349 zone->maxretry = val;
2350 }
2351
2352 static isc_boolean_t
2353 notify_isqueued(dns_zone_t *zone, dns_name_t *name, isc_sockaddr_t *addr) {
2354 dns_notify_t *notify;
2355
2356 for (notify = ISC_LIST_HEAD(zone->notifies);
2357 notify != NULL;
2358 notify = ISC_LIST_NEXT(notify, link)) {
2359 if (notify->request != NULL)
2360 continue;
2361 if (name != NULL && dns_name_dynamic(&notify->ns) &&
2362 dns_name_equal(name, &notify->ns))
2363 return (ISC_TRUE);
2364 if (addr != NULL && isc_sockaddr_equal(addr, &notify->dst))
2365 return (ISC_TRUE);
2366 }
2367 return (ISC_FALSE);
2368 }
2369
2370 static void
2371 notify_destroy(dns_notify_t *notify, isc_boolean_t locked) {
2372 isc_mem_t *mctx;
2373
2374 /*
2375 * Caller holds zone lock.
2376 */
2377 REQUIRE(DNS_NOTIFY_VALID(notify));
2378
2379 if (notify->zone != NULL) {
2380 if (!locked)
2381 LOCK_ZONE(notify->zone);
2382 REQUIRE(LOCKED_ZONE(notify->zone));
2383 if (ISC_LINK_LINKED(notify, link))
2384 ISC_LIST_UNLINK(notify->zone->notifies, notify, link);
2385 if (!locked)
2386 UNLOCK_ZONE(notify->zone);
2387 if (locked)
2388 zone_idetach(&notify->zone);
2389 else
2390 dns_zone_idetach(&notify->zone);
2391 }
2392 if (notify->find != NULL)
2393 dns_adb_destroyfind(&notify->find);
2394 if (notify->request != NULL)
2395 dns_request_destroy(&notify->request);
2396 if (dns_name_dynamic(&notify->ns))
2397 dns_name_free(&notify->ns, notify->mctx);
2398 mctx = notify->mctx;
2399 isc_mem_put(notify->mctx, notify, sizeof *notify);
2400 isc_mem_detach(&mctx);
2401 }
2402
2403 static isc_result_t
2404 notify_create(isc_mem_t *mctx, unsigned int flags, dns_notify_t **notifyp) {
2405 dns_notify_t *notify;
2406
2407 REQUIRE(notifyp != NULL && *notifyp == NULL);
2408
2409 notify = isc_mem_get(mctx, sizeof *notify);
2410 if (notify == NULL)
2411 return (ISC_R_NOMEMORY);
2412
2413 notify->mctx = NULL;
2414 isc_mem_attach(mctx, &notify->mctx);
2415 notify->flags = flags;
2416 notify->zone = NULL;
2417 notify->find = NULL;
2418 notify->request = NULL;
2419 isc_sockaddr_any(&notify->dst);
2420 dns_name_init(&notify->ns, NULL);
2421 notify->attempt = 0;
2422 ISC_LINK_INIT(notify, link);
2423 notify->magic = NOTIFY_MAGIC;
2424 *notifyp = notify;
2425 return (ISC_R_SUCCESS);
2426 }
2427
2428 /*
2429 * XXXAG should check for DNS_ZONEFLG_EXITING
2430 */
2431 static void
2432 process_adb_event(isc_task_t *task, isc_event_t *ev) {
2433 dns_notify_t *notify;
2434 isc_eventtype_t result;
2435
2436 UNUSED(task);
2437
2438 notify = ev->ev_arg;
2439 REQUIRE(DNS_NOTIFY_VALID(notify));
2440 INSIST(task == notify->zone->task);
2441 result = ev->ev_type;
2442 isc_event_free(&ev);
2443 if (result == DNS_EVENT_ADBMOREADDRESSES) {
2444 dns_adb_destroyfind(&notify->find);
2445 notify_find_address(notify);
2446 return;
2447 }
2448 if (result == DNS_EVENT_ADBNOMOREADDRESSES) {
2449 LOCK_ZONE(notify->zone);
2450 notify_send(notify);
2451 UNLOCK_ZONE(notify->zone);
2452 }
2453 notify_destroy(notify, ISC_FALSE);
2454 }
2455
2456 static void
2457 notify_find_address(dns_notify_t *notify) {
2458 isc_result_t result;
2459 unsigned int options;
2460
2461 REQUIRE(DNS_NOTIFY_VALID(notify));
2462 options = DNS_ADBFIND_WANTEVENT | DNS_ADBFIND_INET |
2463 DNS_ADBFIND_INET6 | DNS_ADBFIND_RETURNLAME;
2464
2465 if (notify->zone->view->adb == NULL)
2466 goto destroy;
2467
2468 result = dns_adb_createfind(notify->zone->view->adb,
2469 notify->zone->task,
2470 process_adb_event, notify,
2471 &notify->ns, dns_rootname,
2472 options, 0, NULL,
2473 notify->zone->view->dstport,
2474 &notify->find);
2475
2476 /* Something failed? */
2477 if (result != ISC_R_SUCCESS)
2478 goto destroy;
2479
2480 /* More addresses pending? */
2481 if ((notify->find->options & DNS_ADBFIND_WANTEVENT) != 0)
2482 return;
2483
2484 /* We have as many addresses as we can get. */
2485 LOCK_ZONE(notify->zone);
2486 notify_send(notify);
2487 UNLOCK_ZONE(notify->zone);
2488
2489 destroy:
2490 notify_destroy(notify, ISC_FALSE);
2491 }
2492
2493
2494 static isc_result_t
2495 notify_send_queue(dns_notify_t *notify) {
2496 isc_event_t *e;
2497 isc_result_t result;
2498
2499 e = isc_event_allocate(notify->mctx, NULL,
2500 DNS_EVENT_NOTIFYSENDTOADDR,
2501 notify_send_toaddr,
2502 notify, sizeof(isc_event_t));
2503 if (e == NULL)
2504 return (ISC_R_NOMEMORY);
2505 e->ev_arg = notify;
2506 e->ev_sender = NULL;
2507 result = isc_ratelimiter_enqueue(notify->zone->zmgr->rl,
2508 notify->zone->task, &e);
2509 if (result != ISC_R_SUCCESS)
2510 isc_event_free(&e);
2511 return (result);
2512 }
2513
2514 static void
2515 notify_send_toaddr(isc_task_t *task, isc_event_t *event) {
2516 dns_notify_t *notify;
2517 isc_result_t result;
2518 dns_message_t *message = NULL;
2519 isc_netaddr_t dstip;
2520 dns_tsigkey_t *key = NULL;
2521 char addrbuf[ISC_SOCKADDR_FORMATSIZE];
2522 isc_sockaddr_t src;
2523 int timeout;
2524
2525 notify = event->ev_arg;
2526 REQUIRE(DNS_NOTIFY_VALID(notify));
2527
2528 UNUSED(task);
2529
2530 LOCK_ZONE(notify->zone);
2531
2532 if (DNS_ZONE_FLAG(notify->zone, DNS_ZONEFLG_LOADED) == 0) {
2533 result = ISC_R_CANCELED;
2534 goto cleanup;
2535 }
2536
2537 if ((event->ev_attributes & ISC_EVENTATTR_CANCELED) != 0 ||
2538 DNS_ZONE_FLAG(notify->zone, DNS_ZONEFLG_EXITING) ||
2539 notify->zone->view->requestmgr == NULL ||
2540 notify->zone->db == NULL) {
2541 result = ISC_R_CANCELED;
2542 goto cleanup;
2543 }
2544
2545 result = notify_createmessage(notify->zone, notify->flags, &message);
2546 if (result != ISC_R_SUCCESS)
2547 goto cleanup;
2548
2549 isc_netaddr_fromsockaddr(&dstip, &notify->dst);
2550 (void)dns_view_getpeertsig(notify->zone->view, &dstip, &key);
2551
2552 isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf));
2553 notify_log(notify->zone, ISC_LOG_DEBUG(3), "sending notify to %s",
2554 addrbuf);
2555 switch (isc_sockaddr_pf(&notify->dst)) {
2556 case PF_INET:
2557 src = notify->zone->notifysrc4;
2558 break;
2559 case PF_INET6:
2560 src = notify->zone->notifysrc6;
2561 break;
2562 default:
2563 result = ISC_R_NOTIMPLEMENTED;
2564 goto cleanup_key;
2565 }
2566 timeout = 15;
2567 if (DNS_ZONE_FLAG(notify->zone, DNS_ZONEFLG_DIALNOTIFY))
2568 timeout = 30;
2569 result = dns_request_createvia(notify->zone->view->requestmgr, message,
2570 &src, &notify->dst, 0, key, timeout,
2571 notify->zone->task,
2572 notify_done, notify,
2573 &notify->request);
2574 cleanup_key:
2575 if (key != NULL)
2576 dns_tsigkey_detach(&key);
2577 dns_message_destroy(&message);
2578 cleanup:
2579 UNLOCK_ZONE(notify->zone);
2580 if (result != ISC_R_SUCCESS)
2581 notify_destroy(notify, ISC_FALSE);
2582 isc_event_free(&event);
2583 }
2584
2585 static void
2586 notify_send(dns_notify_t *notify) {
2587 dns_adbaddrinfo_t *ai;
2588 isc_sockaddr_t dst;
2589 isc_result_t result;
2590 dns_notify_t *new = NULL;
2591
2592 /*
2593 * Zone lock held by caller.
2594 */
2595 REQUIRE(DNS_NOTIFY_VALID(notify));
2596 REQUIRE(LOCKED_ZONE(notify->zone));
2597
2598 for (ai = ISC_LIST_HEAD(notify->find->list);
2599 ai != NULL;
2600 ai = ISC_LIST_NEXT(ai, publink)) {
2601 dst = ai->sockaddr;
2602 if (notify_isqueued(notify->zone, NULL, &dst))
2603 continue;
2604 new = NULL;
2605 result = notify_create(notify->mctx,
2606 (notify->flags & DNS_NOTIFY_NOSOA),
2607 &new);
2608 if (result != ISC_R_SUCCESS)
2609 goto cleanup;
2610 zone_iattach(notify->zone, &new->zone);
2611 ISC_LIST_APPEND(new->zone->notifies, new, link);
2612 new->dst = dst;
2613 result = notify_send_queue(new);
2614 if (result != ISC_R_SUCCESS)
2615 goto cleanup;
2616 new = NULL;
2617 }
2618
2619 cleanup:
2620 if (new != NULL)
2621 notify_destroy(new, ISC_TRUE);
2622 }
2623
2624 void
2625 dns_zone_notify(dns_zone_t *zone) {
2626 isc_time_t now;
2627
2628 REQUIRE(DNS_ZONE_VALID(zone));
2629
2630 LOCK_ZONE(zone);
2631 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NEEDNOTIFY);
2632
2633 isc_time_now(&now);
2634 zone_settimer(zone, &now);
2635 UNLOCK_ZONE(zone);
2636 }
2637
2638 static void
2639 zone_notify(dns_zone_t *zone) {
2640 dns_dbnode_t *node = NULL;
2641 dns_dbversion_t *version = NULL;
2642 dns_name_t *origin = NULL;
2643 dns_name_t master;
2644 dns_rdata_ns_t ns;
2645 dns_rdata_soa_t soa;
2646 isc_uint32_t serial;
2647 dns_rdata_t rdata = DNS_RDATA_INIT;
2648 dns_rdataset_t nsrdset;
2649 dns_rdataset_t soardset;
2650 isc_result_t result;
2651 dns_notify_t *notify = NULL;
2652 unsigned int i;
2653 isc_sockaddr_t dst;
2654 isc_boolean_t isqueued;
2655 dns_notifytype_t notifytype;
2656 unsigned int flags = 0;
2657 isc_boolean_t loggednotify = ISC_FALSE;
2658
2659 REQUIRE(DNS_ZONE_VALID(zone));
2660
2661 LOCK_ZONE(zone);
2662 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDNOTIFY);
2663 notifytype = zone->notifytype;
2664 UNLOCK_ZONE(zone);
2665
2666 if (! DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED))
2667 return;
2668
2669 if (notifytype == dns_notifytype_no)
2670 return;
2671
2672 origin = &zone->origin;
2673
2674 /*
2675 * If the zone is dialup we are done as we don't want to send
2676 * the current soa so as to force a refresh query.
2677 */
2678 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALNOTIFY))
2679 flags |= DNS_NOTIFY_NOSOA;
2680
2681 /*
2682 * Get SOA RRset.
2683 */
2684 dns_db_currentversion(zone->db, &version);
2685 result = dns_db_findnode(zone->db, origin, ISC_FALSE, &node);
2686 if (result != ISC_R_SUCCESS)
2687 goto cleanup1;
2688
2689 dns_rdataset_init(&soardset);
2690 result = dns_db_findrdataset(zone->db, node, version,
2691 dns_rdatatype_soa,
2692 dns_rdatatype_none, 0, &soardset, NULL);
2693 if (result != ISC_R_SUCCESS)
2694 goto cleanup2;
2695
2696 /*
2697 * Find serial and master server's name.
2698 */
2699 dns_name_init(&master, NULL);
2700 result = dns_rdataset_first(&soardset);
2701 if (result != ISC_R_SUCCESS)
2702 goto cleanup3;
2703 dns_rdataset_current(&soardset, &rdata);
2704 result = dns_rdata_tostruct(&rdata, &soa, NULL);
2705 RUNTIME_CHECK(result == ISC_R_SUCCESS);
2706 dns_rdata_reset(&rdata);
2707 result = dns_name_dup(&soa.origin, zone->mctx, &master);
2708 serial = soa.serial;
2709 dns_rdataset_disassociate(&soardset);
2710 if (result != ISC_R_SUCCESS)
2711 goto cleanup3;
2712
2713 /*
2714 * Enqueue notify requests for 'also-notify' servers.
2715 */
2716 LOCK_ZONE(zone);
2717 for (i = 0; i < zone->notifycnt; i++) {
2718 dst = zone->notify[i];
2719 if (notify_isqueued(zone, NULL, &dst))
2720 continue;
2721 result = notify_create(zone->mctx, flags, &notify);
2722 if (result != ISC_R_SUCCESS)
2723 continue;
2724 zone_iattach(zone, &notify->zone);
2725 notify->dst = dst;
2726 ISC_LIST_APPEND(zone->notifies, notify, link);
2727 result = notify_send_queue(notify);
2728 if (result != ISC_R_SUCCESS)
2729 notify_destroy(notify, ISC_TRUE);
2730 if (!loggednotify) {
2731 notify_log(zone, ISC_LOG_INFO,
2732 "sending notifies (serial %u)",
2733 serial);
2734 loggednotify = ISC_TRUE;
2735 }
2736 notify = NULL;
2737 }
2738 UNLOCK_ZONE(zone);
2739
2740 if (notifytype == dns_notifytype_explicit)
2741 goto cleanup3;
2742
2743 /*
2744 * Process NS RRset to generate notifies.
2745 */
2746
2747 dns_rdataset_init(&nsrdset);
2748 result = dns_db_findrdataset(zone->db, node, version,
2749 dns_rdatatype_ns,
2750 dns_rdatatype_none, 0, &nsrdset, NULL);
2751 if (result != ISC_R_SUCCESS)
2752 goto cleanup3;
2753
2754 result = dns_rdataset_first(&nsrdset);
2755 while (result == ISC_R_SUCCESS) {
2756 dns_rdataset_current(&nsrdset, &rdata);
2757 result = dns_rdata_tostruct(&rdata, &ns, NULL);
2758 dns_rdata_reset(&rdata);
2759 if (result != ISC_R_SUCCESS)
2760 continue;
2761 /*
2762 * don't notify the master server.
2763 */
2764 if (dns_name_compare(&master, &ns.name) == 0) {
2765 result = dns_rdataset_next(&nsrdset);
2766 continue;
2767 }
2768
2769 if (!loggednotify) {
2770 notify_log(zone, ISC_LOG_INFO,
2771 "sending notifies (serial %u)",
2772 serial);
2773 loggednotify = ISC_TRUE;
2774 }
2775
2776 LOCK_ZONE(zone);
2777 isqueued = notify_isqueued(zone, &ns.name, NULL);
2778 UNLOCK_ZONE(zone);
2779 if (isqueued) {
2780 result = dns_rdataset_next(&nsrdset);
2781 continue;
2782 }
2783 result = notify_create(zone->mctx, flags, &notify);
2784 if (result != ISC_R_SUCCESS)
2785 continue;
2786 dns_zone_iattach(zone, &notify->zone);
2787 result = dns_name_dup(&ns.name, zone->mctx, &notify->ns);
2788 if (result != ISC_R_SUCCESS) {
2789 LOCK_ZONE(zone);
2790 notify_destroy(notify, ISC_TRUE);
2791 UNLOCK_ZONE(zone);
2792 continue;
2793 }
2794 LOCK_ZONE(zone);
2795 ISC_LIST_APPEND(zone->notifies, notify, link);
2796 UNLOCK_ZONE(zone);
2797 notify_find_address(notify);
2798 notify = NULL;
2799 result = dns_rdataset_next(&nsrdset);
2800 }
2801 dns_rdataset_disassociate(&nsrdset);
2802
2803 cleanup3:
2804 if (dns_name_dynamic(&master))
2805 dns_name_free(&master, zone->mctx);
2806 cleanup2:
2807 dns_db_detachnode(zone->db, &node);
2808 cleanup1:
2809 dns_db_closeversion(zone->db, &version, ISC_FALSE);
2810 }
2811
2812 /***
2813 *** Private
2814 ***/
2815
2816 static inline isc_result_t
2817 save_nsrrset(dns_message_t *message, dns_name_t *name,
2818 dns_db_t *db, dns_dbversion_t *version)
2819 {
2820 dns_rdataset_t *nsrdataset = NULL;
2821 dns_rdataset_t *rdataset = NULL;
2822 dns_dbnode_t *node = NULL;
2823 dns_rdata_ns_t ns;
2824 isc_result_t result;
2825 dns_rdata_t rdata = DNS_RDATA_INIT;
2826
2827 /*
2828 * Extract NS RRset from message.
2829 */
2830 result = dns_message_findname(message, DNS_SECTION_ANSWER, name,
2831 dns_rdatatype_ns, dns_rdatatype_none,
2832 NULL, &nsrdataset);
2833 if (result != ISC_R_SUCCESS)
2834 goto fail;
2835
2836 /*
2837 * Add NS rdataset.
2838 */
2839 result = dns_db_findnode(db, name, ISC_TRUE, &node);
2840 if (result != ISC_R_SUCCESS)
2841 goto fail;
2842 result = dns_db_addrdataset(db, node, version, 0,
2843 nsrdataset, 0, NULL);
2844 dns_db_detachnode(db, &node);
2845 if (result != ISC_R_SUCCESS)
2846 goto fail;
2847 /*
2848 * Add glue rdatasets.
2849 */
2850 for (result = dns_rdataset_first(nsrdataset);
2851 result == ISC_R_SUCCESS;
2852 result = dns_rdataset_next(nsrdataset)) {
2853 dns_rdataset_current(nsrdataset, &rdata);
2854 result = dns_rdata_tostruct(&rdata, &ns, NULL);
2855 dns_rdata_reset(&rdata);
2856 RUNTIME_CHECK(result == ISC_R_SUCCESS);
2857 if (!dns_name_issubdomain(&ns.name, name))
2858 continue;
2859 rdataset = NULL;
2860 result = dns_message_findname(message, DNS_SECTION_ADDITIONAL,
2861 &ns.name, dns_rdatatype_a6,
2862 dns_rdatatype_none, NULL,
2863 &rdataset);
2864 if (result == ISC_R_SUCCESS) {
2865 result = dns_db_findnode(db, &ns.name,
2866 ISC_TRUE, &node);
2867 if (result != ISC_R_SUCCESS)
2868 goto fail;
2869 result = dns_db_addrdataset(db, node, version, 0,
2870 rdataset, 0, NULL);
2871 dns_db_detachnode(db, &node);
2872 if (result != ISC_R_SUCCESS)
2873 goto fail;
2874 }
2875 rdataset = NULL;
2876 result = dns_message_findname(message, DNS_SECTION_ADDITIONAL,
2877 &ns.name, dns_rdatatype_aaaa,
2878 dns_rdatatype_none, NULL,
2879 &rdataset);
2880 if (result == ISC_R_SUCCESS) {
2881 result = dns_db_findnode(db, &ns.name,
2882 ISC_TRUE, &node);
2883 if (result != ISC_R_SUCCESS)
2884 goto fail;
2885 result = dns_db_addrdataset(db, node, version, 0,
2886 rdataset, 0, NULL);
2887 dns_db_detachnode(db, &node);
2888 if (result != ISC_R_SUCCESS)
2889 goto fail;
2890 }
2891 rdataset = NULL;
2892 result = dns_message_findname(message, DNS_SECTION_ADDITIONAL,
2893 &ns.name, dns_rdatatype_a,
2894 dns_rdatatype_none, NULL,
2895 &rdataset);
2896 if (result == ISC_R_SUCCESS) {
2897 result = dns_db_findnode(db, &ns.name,
2898 ISC_TRUE, &node);
2899 if (result != ISC_R_SUCCESS)
2900 goto fail;
2901 result = dns_db_addrdataset(db, node, version, 0,
2902 rdataset, 0, NULL);
2903 dns_db_detachnode(db, &node);
2904 if (result != ISC_R_SUCCESS)
2905 goto fail;
2906 }
2907 }
2908 if (result != ISC_R_NOMORE)
2909 goto fail;
2910
2911 return (ISC_R_SUCCESS);
2912
2913 fail:
2914 return (result);
2915 }
2916
2917 static void
2918 stub_callback(isc_task_t *task, isc_event_t *event) {
2919 const char me[] = "stub_callback";
2920 dns_requestevent_t *revent = (dns_requestevent_t *)event;
2921 dns_stub_t *stub = NULL;
2922 dns_message_t *msg = NULL;
2923 dns_zone_t *zone = NULL;
2924 char master[ISC_SOCKADDR_FORMATSIZE];
2925 isc_uint32_t nscnt, cnamecnt;
2926 isc_result_t result;
2927 isc_time_t now;
2928 isc_boolean_t exiting = ISC_FALSE;
2929 isc_interval_t i;
2930
2931 stub = revent->ev_arg;
2932 INSIST(DNS_STUB_VALID(stub));
2933
2934 UNUSED(task);
2935
2936 zone = stub->zone;
2937
2938 ENTER;
2939
2940 isc_time_now(&now);
2941
2942 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING)) {
2943 zone_debuglog(zone, me, 1, "exiting");
2944 exiting = ISC_TRUE;
2945 goto next_master;
2946 }
2947
2948 isc_sockaddr_format(&zone->masteraddr, master, sizeof(master));
2949
2950 if (revent->result != ISC_R_SUCCESS) {
2951 dns_zone_log(zone, ISC_LOG_INFO,
2952 "could not refresh stub from master %s: %s",
2953 master, dns_result_totext(revent->result));
2954 goto next_master;
2955 }
2956
2957 result = dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
2958 if (result != ISC_R_SUCCESS)
2959 goto next_master;
2960
2961 result = dns_request_getresponse(revent->request, msg, 0);
2962 if (result != ISC_R_SUCCESS)
2963 goto next_master;
2964
2965 /*
2966 * Unexpected rcode.
2967 */
2968 if (msg->rcode != dns_rcode_noerror) {
2969 char rcode[128];
2970 isc_buffer_t rb;
2971
2972 isc_buffer_init(&rb, rcode, sizeof(rcode));
2973 dns_rcode_totext(msg->rcode, &rb);
2974
2975 dns_zone_log(zone, ISC_LOG_INFO,
2976 "refreshing stub: "
2977 "unexpected rcode (%.*s) from %s",
2978 (int)rb.used, rcode, master);
2979 goto next_master;
2980 }
2981
2982 /*
2983 * We need complete messages.
2984 */
2985 if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) {
2986 if (dns_request_usedtcp(revent->request)) {
2987 dns_zone_log(zone, ISC_LOG_INFO,
2988 "refreshing stub: "
2989 "truncated TCP response from master %s",
2990 master);
2991 goto next_master;
2992 }
2993 LOCK_ZONE(zone);
2994 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_USEVC);
2995 UNLOCK_ZONE(zone);
2996 goto same_master;
2997 }
2998
2999 /*
3000 * If non-auth log and next master.
3001 */
3002 if ((msg->flags & DNS_MESSAGEFLAG_AA) == 0) {
3003 dns_zone_log(zone, ISC_LOG_INFO, "refreshing stub: "
3004 "non-authoritative answer from master %s",
3005 master);
3006 goto next_master;
3007 }
3008
3009 /*
3010 * Sanity checks.
3011 */
3012 cnamecnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_cname);
3013 nscnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_ns);
3014
3015 if (cnamecnt != 0) {
3016 dns_zone_log(zone, ISC_LOG_INFO,
3017 "refreshing stub: unexpected CNAME response "
3018 "from master %s", master);
3019 goto next_master;
3020 }
3021
3022 if (nscnt == 0) {
3023 dns_zone_log(zone, ISC_LOG_INFO,
3024 "refreshing stub: no NS records in response "
3025 "from master %s", master);
3026 goto next_master;
3027 }
3028
3029 /*
3030 * Save answer.
3031 */
3032 result = save_nsrrset(msg, &zone->origin, stub->db, stub->version);
3033 if (result != ISC_R_SUCCESS) {
3034 dns_zone_log(zone, ISC_LOG_INFO,
3035 "refreshing stub: unable to save NS records "
3036 "from master %s", master);
3037 goto next_master;
3038 }
3039
3040 /*
3041 * Tidy up.
3042 */
3043 dns_db_closeversion(stub->db, &stub->version, ISC_TRUE);
3044 LOCK_ZONE(zone);
3045 if (zone->db == NULL)
3046 dns_db_attach(stub->db, &zone->db);
3047 UNLOCK_ZONE(zone);
3048 dns_db_detach(&stub->db);
3049
3050 if (zone->masterfile != NULL) {
3051 dns_zone_dump(zone);
3052 (void)isc_time_now(&zone->loadtime);
3053 }
3054
3055 dns_message_destroy(&msg);
3056 isc_event_free(&event);
3057 LOCK_ZONE(zone);
3058 dns_request_destroy(&zone->request);
3059 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH);
3060 isc_interval_set(&i, isc_random_jitter(zone->refresh,
3061 zone->refresh / 4), 0);
3062 isc_time_add(&now, &i, &zone->refreshtime);
3063 isc_interval_set(&i, zone->expire, 0);
3064 isc_time_add(&now, &i, &zone->expiretime);
3065 zone_settimer(zone, &now);
3066 UNLOCK_ZONE(zone);
3067 goto free_stub;
3068
3069 next_master:
3070 if (stub->version != NULL)
3071 dns_db_closeversion(stub->db, &stub->version, ISC_FALSE);
3072 if (stub->db != NULL)
3073 dns_db_detach(&stub->db);
3074 if (msg != NULL)
3075 dns_message_destroy(&msg);
3076 isc_event_free(&event);
3077 LOCK_ZONE(zone);
3078 dns_request_destroy(&zone->request);
3079 zone->curmaster++;
3080 zone->refreshcnt = 0;
3081 if (exiting || zone->curmaster >= zone->masterscnt) {
3082 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH);
3083
3084 zone_settimer(zone, &now);
3085 UNLOCK_ZONE(zone);
3086 goto free_stub;
3087 }
3088 queue_soa_query(zone);
3089 UNLOCK_ZONE(zone);
3090 goto free_stub;
3091
3092 same_master:
3093 if (msg != NULL)
3094 dns_message_destroy(&msg);
3095 isc_event_free(&event);
3096 LOCK_ZONE(zone);
3097 dns_request_destroy(&zone->request);
3098 UNLOCK_ZONE(zone);
3099 ns_query(zone, NULL, stub);
3100 goto done;
3101
3102 free_stub:
3103 stub->magic = 0;
3104 dns_zone_idetach(&stub->zone);
3105 INSIST(stub->db == NULL);
3106 INSIST(stub->version == NULL);
3107 isc_mem_put(stub->mctx, stub, sizeof(*stub));
3108
3109 done:
3110 INSIST(event == NULL);
3111 return;
3112 }
3113
3114 /*
3115 * An SOA query has finished (successfully or not).
3116 */
3117 static void
3118 refresh_callback(isc_task_t *task, isc_event_t *event) {
3119 const char me[] = "refresh_callback";
3120 dns_requestevent_t *revent = (dns_requestevent_t *)event;
3121 dns_zone_t *zone;
3122 dns_message_t *msg = NULL;
3123 isc_uint32_t soacnt, cnamecnt, soacount, nscount;
3124 isc_time_t now;
3125 char master[ISC_SOCKADDR_FORMATSIZE];
3126 dns_rdataset_t *rdataset;
3127 dns_rdata_t rdata = DNS_RDATA_INIT;
3128 dns_rdata_soa_t soa;
3129 isc_result_t result;
3130 isc_uint32_t serial;
3131 isc_interval_t i;
3132
3133 zone = revent->ev_arg;
3134 INSIST(DNS_ZONE_VALID(zone));
3135
3136 UNUSED(task);
3137
3138 ENTER;
3139
3140 /*
3141 * if timeout log and next master;
3142 */
3143
3144 isc_sockaddr_format(&zone->masteraddr, master, sizeof(master));
3145
3146 isc_time_now(&now);
3147
3148 if (revent->result != ISC_R_SUCCESS) {
3149 dns_zone_log(zone, ISC_LOG_INFO,
3150 "refresh: failure trying master %s: %s",
3151 master, dns_result_totext(revent->result));
3152 if (revent->result == ISC_R_TIMEDOUT &&
3153 !dns_request_usedtcp(revent->request)) {
3154 if (zone->refreshcnt < 3)
3155 goto same_master;
3156 dns_zone_log(zone, ISC_LOG_INFO,
3157 "refresh: retry limit for "
3158 "master %s exceeded",
3159 master);
3160 }
3161 goto next_master;
3162 }
3163
3164 result = dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
3165 if (result != ISC_R_SUCCESS)
3166 goto next_master;
3167 result = dns_request_getresponse(revent->request, msg, 0);
3168 if (result != ISC_R_SUCCESS) {
3169 dns_zone_log(zone, ISC_LOG_INFO,
3170 "refresh: failure trying master %s: %s",
3171 master, dns_result_totext(result));
3172 goto next_master;
3173 }
3174
3175 /*
3176 * Unexpected rcode.
3177 */
3178 if (msg->rcode != dns_rcode_noerror) {
3179 char rcode[128];
3180 isc_buffer_t rb;
3181
3182 isc_buffer_init(&rb, rcode, sizeof(rcode));
3183 dns_rcode_totext(msg->rcode, &rb);
3184
3185 dns_zone_log(zone, ISC_LOG_INFO,
3186 "refresh: unexpected rcode (%.*s) from master %s",
3187 (int)rb.used, rcode, master);
3188 goto next_master;
3189 }
3190
3191 /*
3192 * If truncated punt to zone transfer which will query again.
3193 */
3194 if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) {
3195 if (zone->type == dns_zone_slave) {
3196 dns_zone_log(zone, ISC_LOG_INFO,
3197 "refresh: truncated UDP answer, "
3198 "initiating TCP zone xfer "
3199 "for master %s",
3200 master);
3201 goto tcp_transfer;
3202 } else {
3203 INSIST(zone->type == dns_zone_stub);
3204 if (dns_request_usedtcp(revent->request)) {
3205 dns_zone_log(zone, ISC_LOG_INFO,
3206 "refresh: truncated TCP response "
3207 "from master %s",
3208 master);
3209 goto next_master;
3210 }
3211 LOCK_ZONE(zone);
3212 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_USEVC);
3213 UNLOCK_ZONE(zone);
3214 goto same_master;
3215 }
3216 }
3217
3218 /*
3219 * if non-auth log and next master;
3220 */
3221 if ((msg->flags & DNS_MESSAGEFLAG_AA) == 0) {
3222 dns_zone_log(zone, ISC_LOG_INFO,
3223 "refresh: non-authoritative answer from "
3224 "master %s", master);
3225 goto next_master;
3226 }
3227
3228 cnamecnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_cname);
3229 soacnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_soa);
3230 nscount = message_count(msg, DNS_SECTION_AUTHORITY, dns_rdatatype_ns);
3231 soacount = message_count(msg, DNS_SECTION_AUTHORITY,
3232 dns_rdatatype_soa);
3233
3234 /*
3235 * There should not be a CNAME record at top of zone.
3236 */
3237 if (cnamecnt != 0) {
3238 dns_zone_log(zone, ISC_LOG_INFO,
3239 "refresh: CNAME at top of zone "
3240 "in master %s", master);
3241 goto next_master;
3242 }
3243
3244 /*
3245 * if referral log and next master;
3246 */
3247 if (soacnt == 0 && soacount == 0 && nscount != 0) {
3248 dns_zone_log(zone, ISC_LOG_INFO,
3249 "refresh: referral response "
3250 "from master %s", master);
3251 goto next_master;
3252 }
3253
3254 /*
3255 * if nodata log and next master;
3256 */
3257 if (soacnt == 0 && (nscount == 0 || soacount != 0)) {
3258 dns_zone_log(zone, ISC_LOG_INFO,
3259 "refresh: NODATA response "
3260 "from master %s", master);
3261 goto next_master;
3262 }
3263
3264 /*
3265 * Only one soa at top of zone.
3266 */
3267 if (soacnt != 1) {
3268 dns_zone_log(zone, ISC_LOG_INFO,
3269 "refresh: answer SOA count (%d) != 1 "
3270 "from master %s",
3271 soacnt, master);
3272 goto next_master;
3273 }
3274 /*
3275 * Extract serial
3276 */
3277 rdataset = NULL;
3278 result = dns_message_findname(msg, DNS_SECTION_ANSWER, &zone->origin,
3279 dns_rdatatype_soa, dns_rdatatype_none,
3280 NULL, &rdataset);
3281 if (result != ISC_R_SUCCESS) {
3282 dns_zone_log(zone, ISC_LOG_INFO,
3283 "refresh: unable to get SOA record "
3284 "from master %s", master);
3285 goto next_master;
3286 }
3287
3288 result = dns_rdataset_first(rdataset);
3289 if (result != ISC_R_SUCCESS) {
3290 dns_zone_log(zone, ISC_LOG_INFO,
3291 "refresh: dns_rdataset_first() failed");
3292 goto next_master;
3293 }
3294
3295 dns_rdataset_current(rdataset, &rdata);
3296 result = dns_rdata_tostruct(&rdata, &soa, NULL);
3297 if (result != ISC_R_SUCCESS) {
3298 dns_zone_log(zone, ISC_LOG_INFO,
3299 "refresh: dns_rdata_tostruct() failed");
3300 goto next_master;
3301 }
3302
3303 serial = soa.serial;
3304
3305 zone_debuglog(zone, me, 1, "serial: new %u, old %u",
3306 serial, zone->serial);
3307 if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) ||
3308 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FORCEXFER) ||
3309 isc_serial_gt(serial, zone->serial)) {
3310 tcp_transfer:
3311 isc_event_free(&event);
3312 LOCK_ZONE(zone);
3313 dns_request_destroy(&zone->request);
3314 UNLOCK_ZONE(zone);
3315 if (zone->type == dns_zone_slave) {
3316 queue_xfrin(zone);
3317 } else {
3318 INSIST(zone->type == dns_zone_stub);
3319 ns_query(zone, rdataset, NULL);
3320 }
3321 if (msg != NULL)
3322 dns_message_destroy(&msg);
3323 } else if (isc_serial_eq(soa.serial, zone->serial)) {
3324 if (zone->masterfile != NULL) {
3325 result = ISC_R_FAILURE;
3326 if (zone->journal != NULL)
3327 result = isc_file_settime(zone->journal, &now);
3328 if (result != ISC_R_SUCCESS)
3329 result = isc_file_settime(zone->masterfile,
3330 &now);
3331 if (result != ISC_R_SUCCESS)
3332 dns_zone_log(zone, ISC_LOG_ERROR,
3333 "refresh: could not set file "
3334 "modification time of '%s': %s",
3335 zone->masterfile,
3336 dns_result_totext(result));
3337 }
3338 isc_interval_set(&i, isc_random_jitter(zone->refresh,
3339 zone->refresh / 4), 0);
3340 isc_time_add(&now, &i, &zone->refreshtime);
3341 isc_interval_set(&i, zone->expire, 0);
3342 isc_time_add(&now, &i, &zone->expiretime);
3343 goto next_master;
3344 } else {
3345 zone_debuglog(zone, me, 1, "ahead");
3346 goto next_master;
3347 }
3348 if (msg != NULL)
3349 dns_message_destroy(&msg);
3350 goto detach;
3351
3352 next_master:
3353 if (msg != NULL)
3354 dns_message_destroy(&msg);
3355 isc_event_free(&event);
3356 LOCK_ZONE(zone);
3357 dns_request_destroy(&zone->request);
3358 zone->curmaster++;
3359 zone->refreshcnt = 0;
3360 if (zone->curmaster >= zone->masterscnt) {
3361 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH);
3362 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDREFRESH)) {
3363 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDREFRESH);
3364 zone->refreshtime = now;
3365 }
3366 zone_settimer(zone, &now);
3367 UNLOCK_ZONE(zone);
3368 goto detach;
3369 }
3370 queue_soa_query(zone);
3371 UNLOCK_ZONE(zone);
3372 goto detach;
3373
3374 same_master:
3375 zone->refreshcnt++;
3376 if (msg != NULL)
3377 dns_message_destroy(&msg);
3378 isc_event_free(&event);
3379 LOCK_ZONE(zone);
3380 dns_request_destroy(&zone->request);
3381 queue_soa_query(zone);
3382 UNLOCK_ZONE(zone);
3383 detach:
3384 dns_zone_idetach(&zone);
3385 return;
3386 }
3387
3388 static void
3389 queue_soa_query(dns_zone_t *zone) {
3390 const char me[] = "queue_soa_query";
3391 isc_event_t *e;
3392 dns_zone_t *dummy = NULL;
3393 isc_result_t result;
3394
3395 ENTER;
3396 /*
3397 * Locked by caller
3398 */
3399 REQUIRE(LOCKED_ZONE(zone));
3400
3401 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING)) {
3402 cancel_refresh(zone);
3403 return;
3404 }
3405
3406 e = isc_event_allocate(zone->mctx, NULL, DNS_EVENT_ZONE,
3407 soa_query, zone, sizeof(isc_event_t));
3408 if (e == NULL) {
3409 cancel_refresh(zone);
3410 return;
3411 }
3412
3413 /*
3414 * Attach so that we won't clean up
3415 * until the event is delivered.
3416 */
3417 zone_iattach(zone, &dummy);
3418
3419 e->ev_arg = zone;
3420 e->ev_sender = NULL;
3421 result = isc_ratelimiter_enqueue(zone->zmgr->rl, zone->task, &e);
3422 if (result != ISC_R_SUCCESS) {
3423 zone_idetach(&dummy);
3424 isc_event_free(&e);
3425 cancel_refresh(zone);
3426 }
3427 }
3428
3429 static inline isc_result_t
3430 create_query(dns_zone_t *zone, dns_rdatatype_t rdtype,
3431 dns_message_t **messagep)
3432 {
3433 dns_message_t *message = NULL;
3434 dns_name_t *qname = NULL;
3435 dns_rdataset_t *qrdataset = NULL;
3436 isc_result_t result;
3437
3438 result = dns_message_create(zone->mctx, DNS_MESSAGE_INTENTRENDER,
3439 &message);
3440 if (result != ISC_R_SUCCESS)
3441 goto cleanup;
3442
3443 message->opcode = dns_opcode_query;
3444 message->rdclass = zone->rdclass;
3445
3446 result = dns_message_gettempname(message, &qname);
3447 if (result != ISC_R_SUCCESS)
3448 goto cleanup;
3449
3450 result = dns_message_gettemprdataset(message, &qrdataset);
3451 if (result != ISC_R_SUCCESS)
3452 goto cleanup;
3453
3454 /*
3455 * Make question.
3456 */
3457 dns_name_init(qname, NULL);
3458 dns_name_clone(&zone->origin, qname);
3459 dns_rdataset_init(qrdataset);
3460 dns_rdataset_makequestion(qrdataset, zone->rdclass, rdtype);
3461 ISC_LIST_APPEND(qname->list, qrdataset, link);
3462 dns_message_addname(message, qname, DNS_SECTION_QUESTION);
3463
3464 *messagep = message;
3465 return (ISC_R_SUCCESS);
3466
3467 cleanup:
3468 if (qname != NULL)
3469 dns_message_puttempname(message, &qname);
3470 if (qrdataset != NULL)
3471 dns_message_puttemprdataset(message, &qrdataset);
3472 if (message != NULL)
3473 dns_message_destroy(&message);
3474 return (result);
3475 }
3476
3477 static void
3478 soa_query(isc_task_t *task, isc_event_t *event) {
3479 const char me[] = "soa_query";
3480 isc_result_t result;
3481 dns_message_t *message = NULL;
3482 dns_zone_t *zone = event->ev_arg;
3483 dns_zone_t *dummy = NULL;
3484 isc_netaddr_t masterip;
3485 dns_tsigkey_t *key = NULL;
3486 isc_uint32_t options;
3487 isc_sockaddr_t src;
3488 isc_boolean_t cancel = ISC_TRUE;
3489 int timeout;
3490
3491 REQUIRE(DNS_ZONE_VALID(zone));
3492
3493 UNUSED(task);
3494
3495 ENTER;
3496
3497 LOCK_ZONE(zone);
3498 if (((event->ev_attributes & ISC_EVENTATTR_CANCELED) != 0) ||
3499 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING) ||
3500 zone->view->requestmgr == NULL) {
3501 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING))
3502 cancel = ISC_FALSE;
3503 goto cleanup;
3504 }
3505
3506 /*
3507 * XXX Optimisation: Create message when zone is setup and reuse.
3508 */
3509 result = create_query(zone, dns_rdatatype_soa, &message);
3510 if (result != ISC_R_SUCCESS)
3511 goto cleanup;
3512
3513 INSIST(zone->masterscnt > 0);
3514 INSIST(zone->curmaster < zone->masterscnt);
3515 zone->masteraddr = zone->masters[zone->curmaster];
3516
3517 isc_netaddr_fromsockaddr(&masterip, &zone->masteraddr);
3518 /*
3519 * First, look for a tsig key in the master statement, then
3520 * try for a server key.
3521 */
3522 if ((zone->masterkeynames != NULL) &&
3523 (zone->masterkeynames[zone->curmaster] != NULL)) {
3524 dns_view_t *view = dns_zone_getview(zone);
3525 dns_name_t *keyname = zone->masterkeynames[zone->curmaster];
3526 result = dns_view_gettsig(view, keyname, &key);
3527 if (result != ISC_R_SUCCESS) {
3528 char namebuf[DNS_NAME_FORMATSIZE];
3529 dns_name_format(keyname, namebuf, sizeof(namebuf));
3530 dns_zone_log(zone, ISC_LOG_ERROR,
3531 "unable to find key: %s", namebuf);
3532 }
3533 }
3534 if (key == NULL)
3535 (void)dns_view_getpeertsig(zone->view, &masterip, &key);
3536
3537 options = DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEVC) ?
3538 DNS_REQUESTOPT_TCP : 0;
3539 switch (isc_sockaddr_pf(&zone->masteraddr)) {
3540 case PF_INET:
3541 src = zone->xfrsource4;
3542 break;
3543 case PF_INET6:
3544 src = zone->xfrsource6;
3545 break;
3546 default:
3547 result = ISC_R_NOTIMPLEMENTED;
3548 goto cleanup;
3549 }
3550 zone_iattach(zone, &dummy);
3551 timeout = 15;
3552 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALREFRESH))
3553 timeout = 30;
3554 result = dns_request_createvia(zone->view->requestmgr, message,
3555 &src, &zone->masteraddr, options, key,
3556 timeout, zone->task,
3557 refresh_callback, zone, &zone->request);
3558 if (result != ISC_R_SUCCESS) {
3559 zone_idetach(&dummy);
3560 zone_debuglog(zone, me, 1,
3561 "dns_request_createvia() failed: %s",
3562 dns_result_totext(result));
3563 goto cleanup;
3564 }
3565 cancel = ISC_FALSE;
3566
3567 cleanup:
3568 if (key != NULL)
3569 dns_tsigkey_detach(&key);
3570 if (message != NULL)
3571 dns_message_destroy(&message);
3572 if (cancel)
3573 cancel_refresh(zone);
3574 isc_event_free(&event);
3575 UNLOCK_ZONE(zone);
3576 dns_zone_idetach(&zone);
3577 return;
3578 }
3579
3580 static void
3581 ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset, dns_stub_t *stub) {
3582 const char me[] = "ns_query";
3583 isc_result_t result;
3584 dns_message_t *message = NULL;
3585 isc_netaddr_t masterip;
3586 dns_tsigkey_t *key = NULL;
3587 dns_dbnode_t *node = NULL;
3588 isc_sockaddr_t src;
3589 int timeout;
3590
3591 REQUIRE(DNS_ZONE_VALID(zone));
3592 REQUIRE((soardataset != NULL && stub == NULL) ||
3593 (soardataset == NULL && stub != NULL));
3594 REQUIRE(stub == NULL || DNS_STUB_VALID(stub));
3595
3596 ENTER;
3597
3598 LOCK_ZONE(zone);
3599 if (stub == NULL) {
3600 stub = isc_mem_get(zone->mctx, sizeof *stub);
3601 if (stub == NULL)
3602 goto cleanup;
3603 stub->magic = STUB_MAGIC;
3604 stub->mctx = zone->mctx;
3605 stub->zone = NULL;
3606 stub->db = NULL;
3607 stub->version = NULL;
3608
3609 /*
3610 * Attach so that the zone won't disappear from under us.
3611 */
3612 zone_iattach(zone, &stub->zone);
3613
3614 /*
3615 * If a db exists we will update it, otherwise we create a
3616 * new one and attach it to the zone once we have the NS
3617 * RRset and glue.
3618 */
3619 if (zone->db != NULL)
3620 dns_db_attach(zone->db, &stub->db);
3621 else {
3622 INSIST(zone->db_argc >= 1);
3623 result = dns_db_create(zone->mctx, zone->db_argv[0],
3624 &zone->origin, dns_dbtype_stub,
3625 zone->rdclass,
3626 zone->db_argc - 1,
3627 zone->db_argv + 1,
3628 &stub->db);
3629 if (result != ISC_R_SUCCESS) {
3630 dns_zone_log(zone, ISC_LOG_ERROR,
3631 "refreshing stub: "
3632 "could not create "
3633 "database: %s",
3634 dns_result_totext(result));
3635 goto cleanup;
3636 }
3637 dns_db_settask(stub->db, zone->task);
3638 }
3639
3640 dns_db_newversion(stub->db, &stub->version);
3641
3642 /*
3643 * Update SOA record.
3644 */
3645 result = dns_db_findnode(stub->db, &zone->origin, ISC_TRUE,
3646 &node);
3647 if (result != ISC_R_SUCCESS) {
3648 dns_zone_log(zone, ISC_LOG_INFO,
3649 "refreshing stub: "
3650 "dns_db_findnode() failed: %s",
3651 dns_result_totext(result));
3652 goto cleanup;
3653 }
3654
3655 result = dns_db_addrdataset(stub->db, node, stub->version, 0,
3656 soardataset, 0, NULL);
3657 dns_db_detachnode(stub->db, &node);
3658 if (result != ISC_R_SUCCESS) {
3659 dns_zone_log(zone, ISC_LOG_INFO,
3660 "refreshing stub: "
3661 "dns_db_addrdataset() failed: %s",
3662 dns_result_totext(result));
3663 goto cleanup;
3664 }
3665 }
3666
3667 /*
3668 * XXX Optimisation: Create message when zone is setup and reuse.
3669 */
3670 result = create_query(zone, dns_rdatatype_ns, &message);
3671
3672 INSIST(zone->masterscnt > 0);
3673 INSIST(zone->curmaster < zone->masterscnt);
3674 zone->masteraddr = zone->masters[zone->curmaster];
3675
3676 isc_netaddr_fromsockaddr(&masterip, &zone->masteraddr);
3677 /*
3678 * First, look for a tsig key in the master statement, then
3679 * try for a server key.
3680 */
3681 if ((zone->masterkeynames != NULL) &&
3682 (zone->masterkeynames[zone->curmaster] != NULL)) {
3683 dns_view_t *view = dns_zone_getview(zone);
3684 dns_name_t *keyname = zone->masterkeynames[zone->curmaster];
3685 result = dns_view_gettsig(view, keyname, &key);
3686 if (result != ISC_R_SUCCESS) {
3687 char namebuf[DNS_NAME_FORMATSIZE];
3688 dns_name_format(keyname, namebuf, sizeof(namebuf));
3689 dns_zone_log(zone, ISC_LOG_ERROR,
3690 "unable to find key: %s", namebuf);
3691 }
3692 }
3693 if (key == NULL)
3694 (void)dns_view_getpeertsig(zone->view, &masterip, &key);
3695
3696 /*
3697 * Always use TCP so that we shouldn't truncate in additional section.
3698 */
3699 switch (isc_sockaddr_pf(&zone->masteraddr)) {
3700 case PF_INET:
3701 src = zone->xfrsource4;
3702 break;
3703 case PF_INET6:
3704 src = zone->xfrsource6;
3705 break;
3706 default:
3707 result = ISC_R_NOTIMPLEMENTED;
3708 goto cleanup;
3709 }
3710 timeout = 15;
3711 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALREFRESH))
3712 timeout = 30;
3713 result = dns_request_createvia(zone->view->requestmgr, message,
3714 &src, &zone->masteraddr,
3715 DNS_REQUESTOPT_TCP, key, timeout,
3716 zone->task, stub_callback, stub,
3717 &zone->request);
3718 if (result != ISC_R_SUCCESS) {
3719 zone_debuglog(zone, me, 1,
3720 "dns_request_createvia() failed: %s",
3721 dns_result_totext(result));
3722 goto cleanup;
3723 }
3724 dns_message_destroy(&message);
3725 goto unlock;
3726
3727 cleanup:
3728 cancel_refresh(zone);
3729 if (stub != NULL) {
3730 stub->magic = 0;
3731 if (stub->version != NULL)
3732 dns_db_closeversion(stub->db, &stub->version,
3733 ISC_FALSE);
3734 if (stub->db != NULL)
3735 dns_db_detach(&stub->db);
3736 if (stub->zone != NULL)
3737 zone_idetach(&stub->zone);
3738 isc_mem_put(stub->mctx, stub, sizeof(*stub));
3739 }
3740 if (message != NULL)
3741 dns_message_destroy(&message);
3742 unlock:
3743 if (key != NULL)
3744 dns_tsigkey_detach(&key);
3745 UNLOCK_ZONE(zone);
3746 return;
3747 }
3748
3749 /*
3750 * Handle the control event. Note that although this event causes the zone
3751 * to shut down, it is not a shutdown event in the sense of the task library.
3752 */
3753 static void
3754 zone_shutdown(isc_task_t *task, isc_event_t *event) {
3755 dns_zone_t *zone = (dns_zone_t *) event->ev_arg;
3756 isc_boolean_t free_needed, linked = ISC_FALSE;
3757
3758 UNUSED(task);
3759 REQUIRE(DNS_ZONE_VALID(zone));
3760 INSIST(event->ev_type == DNS_EVENT_ZONECONTROL);
3761 INSIST(isc_refcount_current(&zone->erefs) == 0);
3762 zone_debuglog(zone, "zone_shutdown", 3, "shutting down");
3763
3764 /*
3765 * Stop things being restarted after we cancel them below.
3766 */
3767 LOCK_ZONE(zone);
3768 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_EXITING);
3769 UNLOCK_ZONE(zone);
3770
3771 /*
3772 * If we were waiting for xfrin quota, step out of
3773 * the queue.
3774 * If there's no zone manager, we can't be waiting for the
3775 * xfrin quota
3776 */
3777 if (zone->zmgr != NULL) {
3778 RWLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
3779 if (zone->statelist == &zone->zmgr->waiting_for_xfrin) {
3780 ISC_LIST_UNLINK(zone->zmgr->waiting_for_xfrin, zone,
3781 statelink);
3782 linked = ISC_TRUE;
3783 zone->statelist = NULL;
3784 }
3785 RWUNLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
3786 }
3787
3788 /*
3789 * In task context, no locking required. See zone_xfrdone().
3790 */
3791 if (zone->xfr != NULL)
3792 dns_xfrin_shutdown(zone->xfr);
3793
3794 LOCK_ZONE(zone);
3795 if (linked) {
3796 INSIST(zone->irefs > 0);
3797 zone->irefs--;
3798 }
3799 if (zone->request != NULL) {
3800 dns_request_cancel(zone->request);
3801 }
3802
3803 if (zone->readio != NULL)
3804 zonemgr_cancelio(zone->readio);
3805
3806 if (zone->lctx != NULL)
3807 dns_loadctx_cancel(zone->lctx);
3808
3809 notify_cancel(zone);
3810
3811 if (zone->timer != NULL) {
3812 isc_timer_detach(&zone->timer);
3813 INSIST(zone->irefs > 0);
3814 zone->irefs--;
3815 }
3816
3817 if (zone->view != NULL)
3818 dns_view_weakdetach(&zone->view);
3819
3820 /*
3821 * We have now canceled everything set the flag to allow exit_check()
3822 * to succeed. We must not unlock between setting this flag and
3823 * calling exit_check().
3824 */
3825 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_SHUTDOWN);
3826 free_needed = exit_check(zone);
3827 UNLOCK_ZONE(zone);
3828 if (free_needed)
3829 zone_free(zone);
3830 }
3831
3832 static void
3833 zone_timer(isc_task_t *task, isc_event_t *event) {
3834 const char me[] = "zone_timer";
3835 dns_zone_t *zone = (dns_zone_t *)event->ev_arg;
3836
3837 UNUSED(task);
3838 REQUIRE(DNS_ZONE_VALID(zone));
3839
3840 ENTER;
3841
3842 zone_maintenance(zone);
3843
3844 isc_event_free(&event);
3845 }
3846
3847 static void
3848 zone_settimer(dns_zone_t *zone, isc_time_t *now) {
3849 const char me[] = "zone_settimer";
3850 isc_time_t next;
3851 isc_result_t result;
3852
3853 REQUIRE(DNS_ZONE_VALID(zone));
3854 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING))
3855 return;
3856
3857 isc_time_settoepoch(&next);
3858
3859 switch (zone->type) {
3860 case dns_zone_master:
3861 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDNOTIFY))
3862 next = *now;
3863 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP) &&
3864 !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DUMPING)) {
3865 INSIST(!isc_time_isepoch(&zone->dumptime));
3866 if (isc_time_isepoch(&next) ||
3867 isc_time_compare(&zone->dumptime, &next) < 0)
3868 next = zone->dumptime;
3869 }
3870 break;
3871
3872 case dns_zone_slave:
3873 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDNOTIFY))
3874 next = *now;
3875 /*FALLTHROUGH*/
3876
3877 case dns_zone_stub:
3878 if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_REFRESH) &&
3879 !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOMASTERS) &&
3880 !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOREFRESH) &&
3881 !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADING)) {
3882 INSIST(!isc_time_isepoch(&zone->refreshtime));
3883 if (isc_time_isepoch(&next) ||
3884 isc_time_compare(&zone->refreshtime, &next) < 0)
3885 next = zone->refreshtime;
3886 }
3887 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) {
3888 INSIST(!isc_time_isepoch(&zone->expiretime));
3889 if (isc_time_isepoch(&next) ||
3890 isc_time_compare(&zone->expiretime, &next) < 0)
3891 next = zone->expiretime;
3892 }
3893 break;
3894
3895 default:
3896 break;
3897 }
3898
3899 if (isc_time_isepoch(&next)) {
3900 zone_debuglog(zone, me, 10, "settimer inactive");
3901 result = isc_timer_reset(zone->timer, isc_timertype_inactive,
3902 NULL, NULL, ISC_TRUE);
3903 if (result != ISC_R_SUCCESS)
3904 dns_zone_log(zone, ISC_LOG_ERROR,
3905 "could not deactivate zone timer: %s",
3906 isc_result_totext(result));
3907 } else {
3908 if (isc_time_compare(&next, now) <= 0)
3909 next = *now;
3910 result = isc_timer_reset(zone->timer, isc_timertype_once,
3911 &next, NULL, ISC_TRUE);
3912 if (result != ISC_R_SUCCESS)
3913 dns_zone_log(zone, ISC_LOG_ERROR,
3914 "could not reset zone timer: %s",
3915 isc_result_totext(result));
3916 }
3917 }
3918
3919 static void
3920 cancel_refresh(dns_zone_t *zone) {
3921 const char me[] = "cancel_refresh";
3922 isc_time_t now;
3923
3924 /*
3925 * 'zone' locked by caller.
3926 */
3927
3928 REQUIRE(DNS_ZONE_VALID(zone));
3929 REQUIRE(LOCKED_ZONE(zone));
3930
3931 ENTER;
3932
3933 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH);
3934 isc_time_now(&now);
3935 zone_settimer(zone, &now);
3936 }
3937
3938 static isc_result_t
3939 notify_createmessage(dns_zone_t *zone, unsigned int flags,
3940 dns_message_t **messagep)
3941 {
3942 dns_dbnode_t *node = NULL;
3943 dns_dbversion_t *version = NULL;
3944 dns_message_t *message = NULL;
3945 dns_rdataset_t rdataset;
3946 dns_rdata_t rdata = DNS_RDATA_INIT;
3947
3948 dns_name_t *tempname = NULL;
3949 dns_rdata_t *temprdata = NULL;
3950 dns_rdatalist_t *temprdatalist = NULL;
3951 dns_rdataset_t *temprdataset = NULL;
3952
3953 isc_result_t result;
3954 isc_region_t r;
3955 isc_buffer_t *b = NULL;
3956
3957 REQUIRE(DNS_ZONE_VALID(zone));
3958 REQUIRE(messagep != NULL && *messagep == NULL);
3959
3960 message = NULL;
3961 result = dns_message_create(zone->mctx, DNS_MESSAGE_INTENTRENDER,
3962 &message);
3963 if (result != ISC_R_SUCCESS)
3964 return (result);
3965
3966 message->opcode = dns_opcode_notify;
3967 message->flags |= DNS_MESSAGEFLAG_AA;
3968 message->rdclass = zone->rdclass;
3969
3970 result = dns_message_gettempname(message, &tempname);
3971 if (result != ISC_R_SUCCESS)
3972 goto cleanup;
3973
3974 result = dns_message_gettemprdataset(message, &temprdataset);
3975 if (result != ISC_R_SUCCESS)
3976 goto cleanup;
3977
3978 /*
3979 * Make question.
3980 */
3981 dns_name_init(tempname, NULL);
3982 dns_name_clone(&zone->origin, tempname);
3983 dns_rdataset_init(temprdataset);
3984 dns_rdataset_makequestion(temprdataset, zone->rdclass,
3985 dns_rdatatype_soa);
3986 ISC_LIST_APPEND(tempname->list, temprdataset, link);
3987 dns_message_addname(message, tempname, DNS_SECTION_QUESTION);
3988 tempname = NULL;
3989 temprdataset = NULL;
3990
3991 if ((flags & DNS_NOTIFY_NOSOA) != 0)
3992 goto done;
3993
3994 result = dns_message_gettempname(message, &tempname);
3995 if (result != ISC_R_SUCCESS)
3996 goto soa_cleanup;
3997 result = dns_message_gettemprdata(message, &temprdata);
3998 if (result != ISC_R_SUCCESS)
3999 goto soa_cleanup;
4000 result = dns_message_gettemprdataset(message, &temprdataset);
4001 if (result != ISC_R_SUCCESS)
4002 goto soa_cleanup;
4003 result = dns_message_gettemprdatalist(message, &temprdatalist);
4004 if (result != ISC_R_SUCCESS)
4005 goto soa_cleanup;
4006
4007 dns_name_init(tempname, NULL);
4008 dns_name_clone(&zone->origin, tempname);
4009 dns_db_currentversion(zone->db, &version);
4010 result = dns_db_findnode(zone->db, tempname, ISC_FALSE, &node);
4011 if (result != ISC_R_SUCCESS)
4012 goto soa_cleanup;
4013
4014 dns_rdataset_init(&rdataset);
4015 result = dns_db_findrdataset(zone->db, node, version,
4016 dns_rdatatype_soa,
4017 dns_rdatatype_none, 0, &rdataset,
4018 NULL);
4019 if (result != ISC_R_SUCCESS)
4020 goto soa_cleanup;
4021 result = dns_rdataset_first(&rdataset);
4022 if (result != ISC_R_SUCCESS)
4023 goto soa_cleanup;
4024 dns_rdataset_current(&rdataset, &rdata);
4025 dns_rdata_toregion(&rdata, &r);
4026 result = isc_buffer_allocate(zone->mctx, &b, r.length);
4027 if (result != ISC_R_SUCCESS)
4028 goto soa_cleanup;
4029 isc_buffer_putmem(b, r.base, r.length);
4030 isc_buffer_usedregion(b, &r);
4031 dns_rdata_init(temprdata);
4032 dns_rdata_fromregion(temprdata, rdata.rdclass, rdata.type, &r);
4033 dns_message_takebuffer(message, &b);
4034 result = dns_rdataset_next(&rdataset);
4035 dns_rdataset_disassociate(&rdataset);
4036 if (result != ISC_R_NOMORE)
4037 goto soa_cleanup;
4038 temprdatalist->rdclass = rdata.rdclass;
4039 temprdatalist->type = rdata.type;
4040 temprdatalist->covers = 0;
4041 temprdatalist->ttl = rdataset.ttl;
4042 ISC_LIST_INIT(temprdatalist->rdata);
4043 ISC_LIST_APPEND(temprdatalist->rdata, temprdata, link);
4044
4045 dns_rdataset_init(temprdataset);
4046 result = dns_rdatalist_tordataset(temprdatalist, temprdataset);
4047 if (result != ISC_R_SUCCESS)
4048 goto soa_cleanup;
4049
4050 ISC_LIST_APPEND(tempname->list, temprdataset, link);
4051 dns_message_addname(message, tempname, DNS_SECTION_ANSWER);
4052 temprdatalist = NULL;
4053 temprdataset = NULL;
4054 temprdata = NULL;
4055 tempname = NULL;
4056
4057 soa_cleanup:
4058 if (node != NULL)
4059 dns_db_detachnode(zone->db, &node);
4060 if (version != NULL)
4061 dns_db_closeversion(zone->db, &version, ISC_FALSE);
4062 if (tempname != NULL)
4063 dns_message_puttempname(message, &tempname);
4064 if (temprdata != NULL)
4065 dns_message_puttemprdata(message, &temprdata);
4066 if (temprdataset != NULL)
4067 dns_message_puttemprdataset(message, &temprdataset);
4068 if (temprdatalist != NULL)
4069 dns_message_puttemprdatalist(message, &temprdatalist);
4070
4071 done:
4072 *messagep = message;
4073 return (ISC_R_SUCCESS);
4074
4075 cleanup:
4076 if (tempname != NULL)
4077 dns_message_puttempname(message, &tempname);
4078 if (temprdataset != NULL)
4079 dns_message_puttemprdataset(message, &temprdataset);
4080 if (message != NULL)
4081 dns_message_destroy(&message);
4082 return (result);
4083 }
4084
4085 isc_result_t
4086 dns_zone_notifyreceive(dns_zone_t *zone, isc_sockaddr_t *from,
4087 dns_message_t *msg)
4088 {
4089 unsigned int i;
4090 dns_rdata_soa_t soa;
4091 dns_rdataset_t *rdataset = NULL;
4092 dns_rdata_t rdata = DNS_RDATA_INIT;
4093 isc_result_t result;
4094 char fromtext[ISC_SOCKADDR_FORMATSIZE];
4095 int match = 0;
4096 isc_netaddr_t netaddr;
4097
4098 REQUIRE(DNS_ZONE_VALID(zone));
4099
4100 /*
4101 * If type != T_SOA return DNS_R_REFUSED. We don't yet support
4102 * ROLLOVER.
4103 *
4104 * SOA: RFC 1996
4105 * Check that 'from' is a valid notify source, (zone->masters).
4106 * Return DNS_R_REFUSED if not.
4107 *
4108 * If the notify message contains a serial number check it
4109 * against the zones serial and return if <= current serial
4110 *
4111 * If a refresh check is progress, if so just record the
4112 * fact we received a NOTIFY and from where and return.
4113 * We will perform a new refresh check when the current one
4114 * completes. Return ISC_R_SUCCESS.
4115 *
4116 * Otherwise initiate a refresh check using 'from' as the
4117 * first address to check. Return ISC_R_SUCCESS.
4118 */
4119
4120 isc_sockaddr_format(from, fromtext, sizeof(fromtext));
4121
4122 /*
4123 * We only handle NOTIFY (SOA) at the present.
4124 */
4125 LOCK_ZONE(zone);
4126 if (msg->counts[DNS_SECTION_QUESTION] == 0 ||
4127 dns_message_findname(msg, DNS_SECTION_QUESTION, &zone->origin,
4128 dns_rdatatype_soa, dns_rdatatype_none,
4129 NULL, NULL) != ISC_R_SUCCESS) {
4130 UNLOCK_ZONE(zone);
4131 if (msg->counts[DNS_SECTION_QUESTION] == 0) {
4132 dns_zone_log(zone, ISC_LOG_NOTICE,
4133 "NOTIFY with no "
4134 "question section from: %s", fromtext);
4135 return (DNS_R_FORMERR);
4136 }
4137 dns_zone_log(zone, ISC_LOG_NOTICE,
4138 "NOTIFY zone does not match");
4139 return (DNS_R_NOTIMP);
4140 }
4141
4142 /*
4143 * If we are a master zone just succeed.
4144 */
4145 if (zone->type == dns_zone_master) {
4146 UNLOCK_ZONE(zone);
4147 return (ISC_R_SUCCESS);
4148 }
4149
4150 isc_netaddr_fromsockaddr(&netaddr, from);
4151 for (i = 0; i < zone->masterscnt; i++) {
4152 if (isc_sockaddr_eqaddr(from, &zone->masters[i]))
4153 break;
4154 if (zone->view->aclenv.match_mapped &&
4155 IN6_IS_ADDR_V4MAPPED(&from->type.sin6.sin6_addr) &&
4156 isc_sockaddr_pf(&zone->masters[i]) == AF_INET) {
4157 isc_netaddr_t na1, na2;
4158 isc_netaddr_fromv4mapped(&na1, &netaddr);
4159 isc_netaddr_fromsockaddr(&na2, &zone->masters[i]);
4160 if (isc_netaddr_equal(&na1, &na2))
4161 break;
4162 }
4163 }
4164
4165 /*
4166 * Accept notify requests from non masters if they are on
4167 * 'zone->notify_acl'.
4168 */
4169 if (i >= zone->masterscnt && zone->notify_acl != NULL &&
4170 dns_acl_match(&netaddr, NULL, zone->notify_acl,
4171 &zone->view->aclenv,
4172 &match, NULL) == ISC_R_SUCCESS &&
4173 match > 0)
4174 {
4175 /* Accept notify. */
4176 } else if (i >= zone->masterscnt) {
4177 UNLOCK_ZONE(zone);
4178 dns_zone_log(zone, ISC_LOG_DEBUG(3),
4179 "refused notify from non-master: %s", fromtext);
4180 return (DNS_R_REFUSED);
4181 }
4182
4183 /*
4184 * If the zone is loaded and there are answers check the serial
4185 * to see if we need to do a refresh. Do not worry about this
4186 * check if we are a dialup zone as we use the notify request
4187 * to trigger a refresh check.
4188 */
4189 if (msg->counts[DNS_SECTION_ANSWER] > 0 &&
4190 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) &&
4191 !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOREFRESH)) {
4192 result = dns_message_findname(msg, DNS_SECTION_ANSWER,
4193 &zone->origin,
4194 dns_rdatatype_soa,
4195 dns_rdatatype_none, NULL,
4196 &rdataset);
4197 if (result == ISC_R_SUCCESS)
4198 result = dns_rdataset_first(rdataset);
4199 if (result == ISC_R_SUCCESS) {
4200 isc_uint32_t serial = 0;
4201
4202 dns_rdataset_current(rdataset, &rdata);
4203 result = dns_rdata_tostruct(&rdata, &soa, NULL);
4204 if (result == ISC_R_SUCCESS) {
4205 serial = soa.serial;
4206 if (isc_serial_le(serial, zone->serial)) {
4207 dns_zone_log(zone, ISC_LOG_DEBUG(3),
4208 "notify from %s: "
4209 "zone is up to date",
4210 fromtext);
4211 UNLOCK_ZONE(zone);
4212 return (ISC_R_SUCCESS);
4213 }
4214 }
4215 }
4216 }
4217
4218 /*
4219 * If we got this far and there was a refresh in progress just
4220 * let it complete. Record where we got the notify from so we
4221 * can perform a refresh check when the current one completes
4222 */
4223 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_REFRESH)) {
4224 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NEEDREFRESH);
4225 zone->notifyfrom = *from;
4226 UNLOCK_ZONE(zone);
4227 dns_zone_log(zone, ISC_LOG_DEBUG(3),
4228 "notify from %s: refresh in progress, "
4229 "refresh check queued",
4230 fromtext);
4231 return (ISC_R_SUCCESS);
4232 }
4233 zone->notifyfrom = *from;
4234 UNLOCK_ZONE(zone);
4235 dns_zone_refresh(zone);
4236 return (ISC_R_SUCCESS);
4237 }
4238
4239 void
4240 dns_zone_setnotifyacl(dns_zone_t *zone, dns_acl_t *acl) {
4241
4242 REQUIRE(DNS_ZONE_VALID(zone));
4243
4244 LOCK_ZONE(zone);
4245 if (zone->notify_acl != NULL)
4246 dns_acl_detach(&zone->notify_acl);
4247 dns_acl_attach(acl, &zone->notify_acl);
4248 UNLOCK_ZONE(zone);
4249 }
4250
4251 void
4252 dns_zone_setqueryacl(dns_zone_t *zone, dns_acl_t *acl) {
4253
4254 REQUIRE(DNS_ZONE_VALID(zone));
4255
4256 LOCK_ZONE(zone);
4257 if (zone->query_acl != NULL)
4258 dns_acl_detach(&zone->query_acl);
4259 dns_acl_attach(acl, &zone->query_acl);
4260 UNLOCK_ZONE(zone);
4261 }
4262
4263 void
4264 dns_zone_setupdateacl(dns_zone_t *zone, dns_acl_t *acl) {
4265
4266 REQUIRE(DNS_ZONE_VALID(zone));
4267
4268 LOCK_ZONE(zone);
4269 if (zone->update_acl != NULL)
4270 dns_acl_detach(&zone->update_acl);
4271 dns_acl_attach(acl, &zone->update_acl);
4272 UNLOCK_ZONE(zone);
4273 }
4274
4275 void
4276 dns_zone_setforwardacl(dns_zone_t *zone, dns_acl_t *acl) {
4277
4278 REQUIRE(DNS_ZONE_VALID(zone));
4279
4280 LOCK_ZONE(zone);
4281 if (zone->forward_acl != NULL)
4282 dns_acl_detach(&zone->forward_acl);
4283 dns_acl_attach(acl, &zone->forward_acl);
4284 UNLOCK_ZONE(zone);
4285 }
4286
4287 void
4288 dns_zone_setxfracl(dns_zone_t *zone, dns_acl_t *acl) {
4289
4290 REQUIRE(DNS_ZONE_VALID(zone));
4291
4292 LOCK_ZONE(zone);
4293 if (zone->xfr_acl != NULL)
4294 dns_acl_detach(&zone->xfr_acl);
4295 dns_acl_attach(acl, &zone->xfr_acl);
4296 UNLOCK_ZONE(zone);
4297 }
4298
4299 dns_acl_t *
4300 dns_zone_getnotifyacl(dns_zone_t *zone) {
4301
4302 REQUIRE(DNS_ZONE_VALID(zone));
4303
4304 return (zone->notify_acl);
4305 }
4306
4307 dns_acl_t *
4308 dns_zone_getqueryacl(dns_zone_t *zone) {
4309
4310 REQUIRE(DNS_ZONE_VALID(zone));
4311
4312 return (zone->query_acl);
4313 }
4314
4315 dns_acl_t *
4316 dns_zone_getupdateacl(dns_zone_t *zone) {
4317
4318 REQUIRE(DNS_ZONE_VALID(zone));
4319
4320 return (zone->update_acl);
4321 }
4322
4323 dns_acl_t *
4324 dns_zone_getforwardacl(dns_zone_t *zone) {
4325
4326 REQUIRE(DNS_ZONE_VALID(zone));
4327
4328 return (zone->forward_acl);
4329 }
4330
4331 dns_acl_t *
4332 dns_zone_getxfracl(dns_zone_t *zone) {
4333
4334 REQUIRE(DNS_ZONE_VALID(zone));
4335
4336 return (zone->xfr_acl);
4337 }
4338
4339 void
4340 dns_zone_clearupdateacl(dns_zone_t *zone) {
4341
4342 REQUIRE(DNS_ZONE_VALID(zone));
4343
4344 LOCK_ZONE(zone);
4345 if (zone->update_acl != NULL)
4346 dns_acl_detach(&zone->update_acl);
4347 UNLOCK_ZONE(zone);
4348 }
4349
4350 void
4351 dns_zone_clearforwardacl(dns_zone_t *zone) {
4352
4353 REQUIRE(DNS_ZONE_VALID(zone));
4354
4355 LOCK_ZONE(zone);
4356 if (zone->forward_acl != NULL)
4357 dns_acl_detach(&zone->forward_acl);
4358 UNLOCK_ZONE(zone);
4359 }
4360
4361 void
4362 dns_zone_clearnotifyacl(dns_zone_t *zone) {
4363
4364 REQUIRE(DNS_ZONE_VALID(zone));
4365
4366 LOCK_ZONE(zone);
4367 if (zone->notify_acl != NULL)
4368 dns_acl_detach(&zone->notify_acl);
4369 UNLOCK_ZONE(zone);
4370 }
4371
4372 void
4373 dns_zone_clearqueryacl(dns_zone_t *zone) {
4374
4375 REQUIRE(DNS_ZONE_VALID(zone));
4376
4377 LOCK_ZONE(zone);
4378 if (zone->query_acl != NULL)
4379 dns_acl_detach(&zone->query_acl);
4380 UNLOCK_ZONE(zone);
4381 }
4382
4383 void
4384 dns_zone_clearxfracl(dns_zone_t *zone) {
4385
4386 REQUIRE(DNS_ZONE_VALID(zone));
4387
4388 LOCK_ZONE(zone);
4389 if (zone->xfr_acl != NULL)
4390 dns_acl_detach(&zone->xfr_acl);
4391 UNLOCK_ZONE(zone);
4392 }
4393
4394 void
4395 dns_zone_setchecknames(dns_zone_t *zone, dns_severity_t severity) {
4396
4397 REQUIRE(DNS_ZONE_VALID(zone));
4398
4399 zone->check_names = severity;
4400 }
4401
4402 dns_severity_t
4403 dns_zone_getchecknames(dns_zone_t *zone) {
4404
4405 REQUIRE(DNS_ZONE_VALID(zone));
4406
4407 return (zone->check_names);
4408 }
4409
4410 void
4411 dns_zone_setjournalsize(dns_zone_t *zone, isc_int32_t size) {
4412
4413 REQUIRE(DNS_ZONE_VALID(zone));
4414
4415 zone->journalsize = size;
4416 }
4417
4418 isc_int32_t
4419 dns_zone_getjournalsize(dns_zone_t *zone) {
4420
4421 REQUIRE(DNS_ZONE_VALID(zone));
4422
4423 return (zone->journalsize);
4424 }
4425
4426 static void
4427 zone_tostr(dns_zone_t *zone, char *buf, size_t length) {
4428 isc_result_t result = ISC_R_FAILURE;
4429 isc_buffer_t buffer;
4430
4431 REQUIRE(buf != NULL);
4432 REQUIRE(length > 1U);
4433
4434 /*
4435 * Leave space for terminating '\0'.
4436 */
4437 isc_buffer_init(&buffer, buf, length - 1);
4438 if (dns_name_dynamic(&zone->origin))
4439 result = dns_name_totext(&zone->origin, ISC_TRUE, &buffer);
4440 if (result != ISC_R_SUCCESS)
4441 isc_buffer_putstr(&buffer, "<UNKNOWN>");
4442
4443 isc_buffer_putstr(&buffer, "/");
4444 (void)dns_rdataclass_totext(zone->rdclass, &buffer);
4445 buf[isc_buffer_usedlength(&buffer)] = '\0';
4446 }
4447
4448 static void
4449 notify_log(dns_zone_t *zone, int level, const char *fmt, ...) {
4450 va_list ap;
4451 char message[4096];
4452 char namebuf[1024+32];
4453
4454 if (isc_log_wouldlog(dns_lctx, level) == ISC_FALSE)
4455 return;
4456
4457 zone_tostr(zone, namebuf, sizeof(namebuf));
4458
4459 va_start(ap, fmt);
4460 vsnprintf(message, sizeof message, fmt, ap);
4461 va_end(ap);
4462 isc_log_write(dns_lctx, DNS_LOGCATEGORY_NOTIFY, DNS_LOGMODULE_ZONE,
4463 level, "zone %s: %s", namebuf, message);
4464 }
4465
4466 void
4467 dns_zone_log(dns_zone_t *zone, int level, const char *fmt, ...) {
4468 va_list ap;
4469 char message[4096];
4470 char namebuf[1024+32];
4471
4472 if (isc_log_wouldlog(dns_lctx, level) == ISC_FALSE)
4473 return;
4474
4475 zone_tostr(zone, namebuf, sizeof(namebuf));
4476
4477 va_start(ap, fmt);
4478 vsnprintf(message, sizeof message, fmt, ap);
4479 va_end(ap);
4480 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_ZONE,
4481 level, "zone %s: %s", namebuf, message);
4482 }
4483
4484 static void
4485 zone_debuglog(dns_zone_t *zone, const char *me, int debuglevel,
4486 const char *fmt, ...)
4487 {
4488 va_list ap;
4489 char message[4096];
4490 char namebuf[1024+32];
4491 int level = ISC_LOG_DEBUG(debuglevel);
4492
4493 if (isc_log_wouldlog(dns_lctx, level) == ISC_FALSE)
4494 return;
4495
4496 zone_tostr(zone, namebuf, sizeof(namebuf));
4497
4498 va_start(ap, fmt);
4499 vsnprintf(message, sizeof message, fmt, ap);
4500 va_end(ap);
4501 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_ZONE,
4502 level, "%s: zone %s: %s", me, namebuf, message);
4503 }
4504
4505 static int
4506 message_count(dns_message_t *msg, dns_section_t section, dns_rdatatype_t type)
4507 {
4508 isc_result_t result;
4509 dns_name_t *name;
4510 dns_rdataset_t *curr;
4511 int count = 0;
4512
4513 result = dns_message_firstname(msg, section);
4514 while (result == ISC_R_SUCCESS) {
4515 name = NULL;
4516 dns_message_currentname(msg, section, &name);
4517
4518 for (curr = ISC_LIST_TAIL(name->list); curr != NULL;
4519 curr = ISC_LIST_PREV(curr, link)) {
4520 if (curr->type == type)
4521 count++;
4522 }
4523 result = dns_message_nextname(msg, section);
4524 }
4525
4526 return (count);
4527 }
4528
4529 void
4530 dns_zone_setmaxxfrin(dns_zone_t *zone, isc_uint32_t maxxfrin) {
4531 REQUIRE(DNS_ZONE_VALID(zone));
4532
4533 zone->maxxfrin = maxxfrin;
4534 }
4535
4536 isc_uint32_t
4537 dns_zone_getmaxxfrin(dns_zone_t *zone) {
4538 REQUIRE(DNS_ZONE_VALID(zone));
4539
4540 return (zone->maxxfrin);
4541 }
4542
4543 void
4544 dns_zone_setmaxxfrout(dns_zone_t *zone, isc_uint32_t maxxfrout) {
4545 REQUIRE(DNS_ZONE_VALID(zone));
4546 zone->maxxfrout = maxxfrout;
4547 }
4548
4549 isc_uint32_t
4550 dns_zone_getmaxxfrout(dns_zone_t *zone) {
4551 REQUIRE(DNS_ZONE_VALID(zone));
4552
4553 return (zone->maxxfrout);
4554 }
4555
4556 dns_zonetype_t dns_zone_gettype(dns_zone_t *zone) {
4557 REQUIRE(DNS_ZONE_VALID(zone));
4558
4559 return (zone->type);
4560 }
4561
4562 dns_name_t *
4563 dns_zone_getorigin(dns_zone_t *zone) {
4564 REQUIRE(DNS_ZONE_VALID(zone));
4565
4566 return (&zone->origin);
4567 }
4568
4569 void
4570 dns_zone_settask(dns_zone_t *zone, isc_task_t *task) {
4571 REQUIRE(DNS_ZONE_VALID(zone));
4572
4573 LOCK_ZONE(zone);
4574 if (zone->task != NULL)
4575 isc_task_detach(&zone->task);
4576 isc_task_attach(task, &zone->task);
4577 if (zone->db != NULL)
4578 dns_db_settask(zone->db, zone->task);
4579 UNLOCK_ZONE(zone);
4580 }
4581
4582 void
4583 dns_zone_gettask(dns_zone_t *zone, isc_task_t **target) {
4584 REQUIRE(DNS_ZONE_VALID(zone));
4585 isc_task_attach(zone->task, target);
4586 }
4587
4588 void
4589 dns_zone_setidlein(dns_zone_t *zone, isc_uint32_t idlein) {
4590 REQUIRE(DNS_ZONE_VALID(zone));
4591
4592 if (idlein == 0)
4593 idlein = DNS_DEFAULT_IDLEIN;
4594 zone->idlein = idlein;
4595 }
4596
4597 isc_uint32_t
4598 dns_zone_getidlein(dns_zone_t *zone) {
4599 REQUIRE(DNS_ZONE_VALID(zone));
4600
4601 return (zone->idlein);
4602 }
4603
4604 void
4605 dns_zone_setidleout(dns_zone_t *zone, isc_uint32_t idleout) {
4606 REQUIRE(DNS_ZONE_VALID(zone));
4607
4608 zone->idleout = idleout;
4609 }
4610
4611 isc_uint32_t
4612 dns_zone_getidleout(dns_zone_t *zone) {
4613 REQUIRE(DNS_ZONE_VALID(zone));
4614
4615 return (zone->idleout);
4616 }
4617
4618 static void
4619 notify_done(isc_task_t *task, isc_event_t *event) {
4620 dns_requestevent_t *revent = (dns_requestevent_t *)event;
4621 dns_notify_t *notify;
4622 isc_result_t result;
4623 dns_message_t *message = NULL;
4624 isc_buffer_t buf;
4625 char rcode[128];
4626 char addrbuf[ISC_SOCKADDR_FORMATSIZE];
4627
4628 UNUSED(task);
4629
4630 notify = event->ev_arg;
4631 REQUIRE(DNS_NOTIFY_VALID(notify));
4632 INSIST(task == notify->zone->task);
4633
4634 isc_buffer_init(&buf, rcode, sizeof(rcode));
4635 isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf));
4636
4637 result = revent->result;
4638 if (result == ISC_R_SUCCESS)
4639 result = dns_message_create(notify->zone->mctx,
4640 DNS_MESSAGE_INTENTPARSE, &message);
4641 if (result == ISC_R_SUCCESS)
4642 result = dns_request_getresponse(revent->request, message,
4643 DNS_MESSAGEPARSE_PRESERVEORDER);
4644 if (result == ISC_R_SUCCESS)
4645 result = dns_rcode_totext(message->rcode, &buf);
4646 if (result == ISC_R_SUCCESS)
4647 notify_log(notify->zone, ISC_LOG_DEBUG(3),
4648 "notify response from %s: %.*s",
4649 addrbuf, (int)buf.used, rcode);
4650 else
4651 notify_log(notify->zone, ISC_LOG_DEBUG(1),
4652 "notify to %s failed: %s", addrbuf,
4653 dns_result_totext(result));
4654
4655 /*
4656 * Old bind's return formerr if they see a soa record. Retry w/o
4657 * the soa if we see a formerr and had sent a SOA.
4658 */
4659 isc_event_free(&event);
4660 if ((result == ISC_R_TIMEDOUT ||
4661 (message != NULL && message->rcode == dns_rcode_formerr &&
4662 (notify->flags & DNS_NOTIFY_NOSOA) == 0)) &&
4663 notify->attempt < 3) {
4664 notify->flags |= DNS_NOTIFY_NOSOA;
4665 notify->attempt++;
4666 dns_request_destroy(&notify->request);
4667 result = notify_send_queue(notify);
4668 if (result != ISC_R_SUCCESS)
4669 notify_destroy(notify, ISC_FALSE);
4670 } else {
4671 if (result == ISC_R_TIMEDOUT)
4672 notify_log(notify->zone, ISC_LOG_DEBUG(1),
4673 "notify to %s: retries exceeded", addrbuf);
4674 notify_destroy(notify, ISC_FALSE);
4675 }
4676 if (message != NULL)
4677 dns_message_destroy(&message);
4678 }
4679
4680 isc_result_t
4681 dns_zone_replacedb(dns_zone_t *zone, dns_db_t *db, isc_boolean_t dump) {
4682 isc_result_t result;
4683
4684 REQUIRE(DNS_ZONE_VALID(zone));
4685 LOCK_ZONE(zone);
4686 result = zone_replacedb(zone, db, dump);
4687 UNLOCK_ZONE(zone);
4688 return (result);
4689 }
4690
4691 static isc_result_t
4692 zone_replacedb(dns_zone_t *zone, dns_db_t *db, isc_boolean_t dump) {
4693 dns_dbversion_t *ver;
4694 isc_result_t result;
4695
4696 /*
4697 * 'zone' locked by caller.
4698 */
4699 REQUIRE(DNS_ZONE_VALID(zone));
4700 REQUIRE(LOCKED_ZONE(zone));
4701
4702 ver = NULL;
4703 dns_db_currentversion(db, &ver);
4704
4705 /*
4706 * The initial version of a slave zone is always dumped;
4707 * subsequent versions may be journalled instead if this
4708 * is enabled in the configuration.
4709 */
4710 if (zone->db != NULL && zone->journal != NULL &&
4711 zone->diff_on_reload) {
4712 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
4713 DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
4714 "generating diffs");
4715 result = dns_db_diff(zone->mctx, db, ver,
4716 zone->db, NULL /* XXX */,
4717 zone->journal);
4718 if (result != ISC_R_SUCCESS)
4719 goto fail;
4720 } else {
4721 if (dump && zone->masterfile != NULL) {
4722 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
4723 DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
4724 "dumping new zone version");
4725 result = dns_db_dump(db, ver, zone->masterfile);
4726 if (result != ISC_R_SUCCESS)
4727 goto fail;
4728
4729 /*
4730 * Update the time the zone was updated, so
4731 * dns_zone_load can avoid loading it when
4732 * the server is reloaded. If isc_time_now
4733 * fails for some reason, all that happens is
4734 * the timestamp is not updated.
4735 */
4736 (void)isc_time_now(&zone->loadtime);
4737 }
4738
4739 if (dump && zone->journal != NULL) {
4740 /*
4741 * The in-memory database just changed, and
4742 * because 'dump' is set, it didn't change by
4743 * being loaded from disk. Also, we have not
4744 * journalled diffs for this change.
4745 * Therefore, the on-disk journal is missing
4746 * the deltas for this change. Since it can
4747 * no longer be used to bring the zone
4748 * up-to-date, it is useless and should be
4749 * removed.
4750 */
4751 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
4752 DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
4753 "removing journal file");
4754 (void)remove(zone->journal);
4755 }
4756 }
4757
4758 dns_db_closeversion(db, &ver, ISC_FALSE);
4759
4760 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
4761 DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
4762 "replacing zone database");
4763
4764 if (zone->db != NULL)
4765 dns_db_detach(&zone->db);
4766 dns_db_attach(db, &zone->db);
4767 dns_db_settask(zone->db, zone->task);
4768 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADED|DNS_ZONEFLG_NEEDNOTIFY);
4769 return (ISC_R_SUCCESS);
4770
4771 fail:
4772 dns_db_closeversion(db, &ver, ISC_FALSE);
4773 return (result);
4774 }
4775
4776 static void
4777 zone_xfrdone(dns_zone_t *zone, isc_result_t result) {
4778 isc_time_t now;
4779 isc_interval_t i;
4780 isc_boolean_t again = ISC_FALSE;
4781 unsigned int soacount;
4782 unsigned int nscount;
4783 isc_uint32_t serial, refresh, retry, expire, minimum;
4784 isc_result_t xfrresult = result;
4785 isc_boolean_t free_needed;
4786
4787 REQUIRE(DNS_ZONE_VALID(zone));
4788
4789 dns_zone_log(zone, ISC_LOG_DEBUG(1),
4790 "zone transfer finished: %s", dns_result_totext(result));
4791
4792 LOCK_ZONE(zone);
4793 INSIST((zone->flags & DNS_ZONEFLG_REFRESH) != 0);
4794 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH);
4795
4796 isc_time_now(&now);
4797 switch (result) {
4798 case ISC_R_SUCCESS:
4799 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NEEDNOTIFY);
4800 /*FALLTHROUGH*/
4801 case DNS_R_UPTODATE:
4802 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_FORCEXFER);
4803 /*
4804 * Has the zone expired underneath us?
4805 */
4806 if (zone->db == NULL)
4807 goto same_master;
4808
4809 /*
4810 * Update the zone structure's data from the actual
4811 * SOA received.
4812 */
4813 nscount = 0;
4814 soacount = 0;
4815 INSIST(zone->db != NULL);
4816 result = zone_get_from_db(zone->db, &zone->origin, &nscount,
4817 &soacount, &serial, &refresh,
4818 &retry, &expire, &minimum);
4819 if (result == ISC_R_SUCCESS) {
4820 if (soacount != 1)
4821 dns_zone_log(zone, ISC_LOG_ERROR,
4822 "transferred zone "
4823 "has %d SOA record%s", soacount,
4824 (soacount != 0) ? "s" : "");
4825 if (nscount == 0)
4826 dns_zone_log(zone, ISC_LOG_ERROR,
4827 "transferred zone "
4828 "has no NS records");
4829 zone->serial = serial;
4830 zone->refresh = RANGE(refresh, zone->minrefresh,
4831 zone->maxrefresh);
4832 zone->retry = RANGE(retry, zone->minretry,
4833 zone->maxretry);
4834 zone->expire = RANGE(expire,
4835 zone->refresh + zone->retry,
4836 DNS_MAX_EXPIRE);
4837 zone->minimum = minimum;
4838 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HAVETIMERS);
4839 }
4840
4841 /*
4842 * Set our next update/expire times.
4843 */
4844 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDREFRESH)) {
4845 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDREFRESH);
4846 zone->refreshtime = now;
4847 isc_interval_set(&i, zone->expire, 0);
4848 isc_time_add(&now, &i, &zone->expiretime);
4849 } else {
4850 isc_interval_set(&i, isc_random_jitter(zone->refresh,
4851 zone->refresh / 4), 0);
4852 isc_time_add(&now, &i, &zone->refreshtime);
4853 isc_interval_set(&i, zone->expire, 0);
4854 isc_time_add(&now, &i, &zone->expiretime);
4855 }
4856 if (result == ISC_R_SUCCESS && xfrresult == ISC_R_SUCCESS)
4857 dns_zone_log(zone, ISC_LOG_INFO,
4858 "transferred serial %u", zone->serial);
4859
4860 /*
4861 * This is not neccessary if we just performed a AXFR
4862 * however it is necessary for an IXFR / UPTODATE and
4863 * won't hurt with an AXFR.
4864 */
4865 if (zone->masterfile != NULL || zone->journal != NULL) {
4866 result = ISC_R_FAILURE;
4867 if (zone->journal != NULL)
4868 result = isc_file_settime(zone->journal, &now);
4869 if (result != ISC_R_SUCCESS &&
4870 zone->masterfile != NULL)
4871 result = isc_file_settime(zone->masterfile,
4872 &now);
4873 /* Someone removed the file from underneath us! */
4874 if (result == ISC_R_FILENOTFOUND &&
4875 zone->masterfile != NULL)
4876 zone_needdump(zone, DNS_DUMP_DELAY);
4877 else if (result != ISC_R_SUCCESS)
4878 dns_zone_log(zone, ISC_LOG_ERROR,
4879 "transfer: could not set file "
4880 "modification time of '%s': %s",
4881 zone->masterfile,
4882 dns_result_totext(result));
4883 }
4884
4885 break;
4886
4887 case DNS_R_BADIXFR:
4888 /* Force retry with AXFR. */
4889 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLAG_NOIXFR);
4890 goto same_master;
4891
4892 default:
4893 zone->curmaster++;
4894 same_master:
4895 if (zone->curmaster >= zone->masterscnt)
4896 zone->curmaster = 0;
4897 else {
4898 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_REFRESH);
4899 again = ISC_TRUE;
4900 }
4901 break;
4902 }
4903 zone_settimer(zone, &now);
4904
4905 /*
4906 * If creating the transfer object failed, zone->xfr is NULL.
4907 * Otherwise, we are called as the done callback of a zone
4908 * transfer object that just entered its shutting-down
4909 * state. Since we are no longer responsible for shutting
4910 * it down, we can detach our reference.
4911 */
4912 if (zone->xfr != NULL)
4913 dns_xfrin_detach(&zone->xfr);
4914
4915 /*
4916 * This transfer finishing freed up a transfer quota slot.
4917 * Let any other zones waiting for quota have it.
4918 */
4919 RWLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
4920 ISC_LIST_UNLINK(zone->zmgr->xfrin_in_progress, zone, statelink);
4921 zone->statelist = NULL;
4922 zmgr_resume_xfrs(zone->zmgr, ISC_FALSE);
4923 RWUNLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
4924
4925 /*
4926 * Retry with a different server if necessary.
4927 */
4928 if (again && !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING))
4929 queue_soa_query(zone);
4930
4931 INSIST(zone->irefs > 0);
4932 zone->irefs--;
4933 free_needed = exit_check(zone);
4934 UNLOCK_ZONE(zone);
4935 if (free_needed)
4936 zone_free(zone);
4937 }
4938
4939 static void
4940 zone_loaddone(void *arg, isc_result_t result) {
4941 static char me[] = "zone_loaddone";
4942 dns_load_t *load = arg;
4943 dns_zone_t *zone;
4944 isc_result_t tresult;
4945
4946 REQUIRE(DNS_LOAD_VALID(load));
4947 zone = load->zone;
4948
4949 ENTER;
4950
4951 tresult = dns_db_endload(load->db, &load->callbacks.add_private);
4952 if (tresult != ISC_R_SUCCESS &&
4953 (result == ISC_R_SUCCESS || result == DNS_R_SEENINCLUDE))
4954 result = tresult;
4955
4956 LOCK_ZONE(load->zone);
4957 (void)zone_postload(load->zone, load->db, load->loadtime, result);
4958 zonemgr_putio(&load->zone->readio);
4959 DNS_ZONE_CLRFLAG(load->zone, DNS_ZONEFLG_LOADING);
4960 UNLOCK_ZONE(load->zone);
4961
4962 load->magic = 0;
4963 dns_db_detach(&load->db);
4964 if (load->zone->lctx != NULL)
4965 dns_loadctx_detach(&load->zone->lctx);
4966 dns_zone_idetach(&load->zone);
4967 isc_mem_putanddetach(&load->mctx, load, sizeof (*load));
4968 }
4969
4970 void
4971 dns_zone_getssutable(dns_zone_t *zone, dns_ssutable_t **table) {
4972 REQUIRE(DNS_ZONE_VALID(zone));
4973 REQUIRE(table != NULL);
4974 REQUIRE(*table == NULL);
4975
4976 LOCK_ZONE(zone);
4977 if (zone->ssutable != NULL)
4978 dns_ssutable_attach(zone->ssutable, table);
4979 UNLOCK_ZONE(zone);
4980 }
4981
4982 void
4983 dns_zone_setssutable(dns_zone_t *zone, dns_ssutable_t *table) {
4984 REQUIRE(DNS_ZONE_VALID(zone));
4985
4986 LOCK_ZONE(zone);
4987 if (zone->ssutable != NULL)
4988 dns_ssutable_detach(&zone->ssutable);
4989 if (table != NULL)
4990 dns_ssutable_attach(table, &zone->ssutable);
4991 UNLOCK_ZONE(zone);
4992 }
4993
4994 void
4995 dns_zone_setsigvalidityinterval(dns_zone_t *zone, isc_uint32_t interval) {
4996 REQUIRE(DNS_ZONE_VALID(zone));
4997
4998 zone->sigvalidityinterval = interval;
4999 }
5000
5001 isc_uint32_t
5002 dns_zone_getsigvalidityinterval(dns_zone_t *zone) {
5003 REQUIRE(DNS_ZONE_VALID(zone));
5004
5005 return (zone->sigvalidityinterval);
5006 }
5007
5008 static void
5009 queue_xfrin(dns_zone_t *zone) {
5010 const char me[] = "queue_xfrin";
5011 isc_result_t result;
5012 dns_zonemgr_t *zmgr = zone->zmgr;
5013
5014 ENTER;
5015
5016 INSIST(zone->statelist == NULL);
5017
5018 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5019 ISC_LIST_APPEND(zmgr->waiting_for_xfrin, zone, statelink);
5020 LOCK_ZONE(zone);
5021 zone->irefs++;
5022 UNLOCK_ZONE(zone);
5023 zone->statelist = &zmgr->waiting_for_xfrin;
5024 result = zmgr_start_xfrin_ifquota(zmgr, zone);
5025 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5026
5027 if (result == ISC_R_QUOTA) {
5028 dns_zone_log(zone, ISC_LOG_DEBUG(1),
5029 "zone transfer deferred due to quota");
5030 } else if (result != ISC_R_SUCCESS) {
5031 dns_zone_log(zone, ISC_LOG_ERROR,
5032 "starting zone transfer: %s",
5033 isc_result_totext(result));
5034 }
5035 }
5036
5037 /*
5038 * This event callback is called when a zone has received
5039 * any necessary zone transfer quota. This is the time
5040 * to go ahead and start the transfer.
5041 */
5042 static void
5043 got_transfer_quota(isc_task_t *task, isc_event_t *event) {
5044 isc_result_t result;
5045 dns_peer_t *peer = NULL;
5046 dns_tsigkey_t *tsigkey = NULL;
5047 char mastertext[256];
5048 dns_rdatatype_t xfrtype;
5049 dns_zone_t *zone = event->ev_arg;
5050 isc_netaddr_t masterip;
5051
5052 UNUSED(task);
5053
5054 INSIST(task == zone->task);
5055
5056 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING)) {
5057 result = ISC_R_CANCELED;
5058 goto cleanup;
5059 }
5060
5061 isc_sockaddr_format(&zone->masteraddr, mastertext, sizeof(mastertext));
5062
5063 isc_netaddr_fromsockaddr(&masterip, &zone->masteraddr);
5064 (void)dns_peerlist_peerbyaddr(zone->view->peers,
5065 &masterip, &peer);
5066
5067 /*
5068 * Decide whether we should request IXFR or AXFR.
5069 */
5070 if (zone->db == NULL) {
5071 dns_zone_log(zone, ISC_LOG_DEBUG(3),
5072 "no database exists yet, "
5073 "requesting AXFR of "
5074 "initial version from %s", mastertext);
5075 xfrtype = dns_rdatatype_axfr;
5076 } else if (dns_zone_isforced(zone)) {
5077 dns_zone_log(zone, ISC_LOG_DEBUG(3),
5078 "forced reload, requesting AXFR of "
5079 "initial version from %s", mastertext);
5080 xfrtype = dns_rdatatype_axfr;
5081 } else if (DNS_ZONE_FLAG(zone, DNS_ZONEFLAG_NOIXFR)) {
5082 dns_zone_log(zone, ISC_LOG_DEBUG(3),
5083 "retrying with AXFR from %s due to "
5084 "previous IXFR failure", mastertext);
5085 xfrtype = dns_rdatatype_axfr;
5086 LOCK_ZONE(zone);
5087 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLAG_NOIXFR);
5088 UNLOCK_ZONE(zone);
5089 } else {
5090 isc_boolean_t use_ixfr = ISC_TRUE;
5091 if (peer != NULL &&
5092 dns_peer_getrequestixfr(peer, &use_ixfr) ==
5093 ISC_R_SUCCESS) {
5094 ; /* Using peer setting */
5095 } else {
5096 use_ixfr = zone->view->requestixfr;
5097 }
5098 if (use_ixfr == ISC_FALSE) {
5099 dns_zone_log(zone, ISC_LOG_DEBUG(3),
5100 "IXFR disabled, "
5101 "requesting AXFR from %s",
5102 mastertext);
5103 xfrtype = dns_rdatatype_axfr;
5104 } else {
5105 dns_zone_log(zone, ISC_LOG_DEBUG(3),
5106 "requesting IXFR from %s",
5107 mastertext);
5108 xfrtype = dns_rdatatype_ixfr;
5109 }
5110 }
5111
5112 /*
5113 * Determine if we should attempt to sign the request with TSIG.
5114 */
5115 result = ISC_R_NOTFOUND;
5116 /*
5117 * First, look for a tsig key in the master statement, then
5118 * try for a server key.
5119 */
5120 if ((zone->masterkeynames != NULL) &&
5121 (zone->masterkeynames[zone->curmaster] != NULL)) {
5122 dns_view_t *view = dns_zone_getview(zone);
5123 dns_name_t *keyname = zone->masterkeynames[zone->curmaster];
5124 result = dns_view_gettsig(view, keyname, &tsigkey);
5125 }
5126 if (tsigkey == NULL)
5127 result = dns_view_getpeertsig(zone->view, &masterip, &tsigkey);
5128
5129 if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
5130 dns_zone_log(zone, ISC_LOG_ERROR,
5131 "could not get TSIG key "
5132 "for zone transfer: %s",
5133 isc_result_totext(result));
5134 }
5135
5136 result = dns_xfrin_create(zone, xfrtype, &zone->masteraddr,
5137 tsigkey, zone->mctx,
5138 zone->zmgr->timermgr, zone->zmgr->socketmgr,
5139 zone->task, zone_xfrdone, &zone->xfr);
5140 cleanup:
5141 /*
5142 * Any failure in this function is handled like a failed
5143 * zone transfer. This ensures that we get removed from
5144 * zmgr->xfrin_in_progress.
5145 */
5146 if (result != ISC_R_SUCCESS)
5147 zone_xfrdone(zone, result);
5148
5149 if (tsigkey != NULL)
5150 dns_tsigkey_detach(&tsigkey);
5151
5152 isc_event_free(&event);
5153 }
5154
5155 /*
5156 * Update forwarding support.
5157 */
5158
5159 static void
5160 forward_destroy(dns_forward_t *forward) {
5161
5162 forward->magic = 0;
5163 if (forward->request != NULL)
5164 dns_request_destroy(&forward->request);
5165 if (forward->msgbuf != NULL)
5166 isc_buffer_free(&forward->msgbuf);
5167 if (forward->zone != NULL)
5168 dns_zone_idetach(&forward->zone);
5169 isc_mem_putanddetach(&forward->mctx, forward, sizeof (*forward));
5170 }
5171
5172 static isc_result_t
5173 sendtomaster(dns_forward_t *forward) {
5174 isc_result_t result;
5175 isc_sockaddr_t src;
5176
5177 LOCK_ZONE(forward->zone);
5178 if (forward->which >= forward->zone->masterscnt) {
5179 UNLOCK_ZONE(forward->zone);
5180 return (ISC_R_NOMORE);
5181 }
5182
5183 forward->addr = forward->zone->masters[forward->which];
5184 /*
5185 * Always use TCP regardless of whether the original update
5186 * used TCP.
5187 * XXX The timeout may but a bit small if we are far down a
5188 * transfer graph and the master has to try several masters.
5189 */
5190 switch (isc_sockaddr_pf(&forward->addr)) {
5191 case PF_INET:
5192 src = forward->zone->xfrsource4;
5193 break;
5194 case PF_INET6:
5195 src = forward->zone->xfrsource6;
5196 break;
5197 default:
5198 result = ISC_R_NOTIMPLEMENTED;
5199 goto unlock;
5200 }
5201 result = dns_request_createraw(forward->zone->view->requestmgr,
5202 forward->msgbuf,
5203 &src, &forward->addr,
5204 DNS_REQUESTOPT_TCP, 15 /* XXX */,
5205 forward->zone->task,
5206 forward_callback, forward,
5207 &forward->request);
5208 unlock:
5209 UNLOCK_ZONE(forward->zone);
5210 return (result);
5211 }
5212
5213 static void
5214 forward_callback(isc_task_t *task, isc_event_t *event) {
5215 const char me[] = "forward_callback";
5216 dns_requestevent_t *revent = (dns_requestevent_t *)event;
5217 dns_message_t *msg = NULL;
5218 char master[ISC_SOCKADDR_FORMATSIZE];
5219 isc_result_t result;
5220 dns_forward_t *forward;
5221 dns_zone_t *zone;
5222
5223 UNUSED(task);
5224
5225 forward = revent->ev_arg;
5226 INSIST(DNS_FORWARD_VALID(forward));
5227 zone = forward->zone;
5228 INSIST(DNS_ZONE_VALID(zone));
5229
5230 ENTER;
5231
5232 isc_sockaddr_format(&forward->addr, master, sizeof(master));
5233
5234 if (revent->result != ISC_R_SUCCESS) {
5235 dns_zone_log(zone, ISC_LOG_INFO,
5236 "could not forward dynamic update to %s: %s",
5237 master, dns_result_totext(revent->result));
5238 goto next_master;
5239 }
5240
5241 result = dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
5242 if (result != ISC_R_SUCCESS)
5243 goto next_master;
5244
5245 result = dns_request_getresponse(revent->request, msg,
5246 DNS_MESSAGEPARSE_PRESERVEORDER |
5247 DNS_MESSAGEPARSE_CLONEBUFFER);
5248 if (result != ISC_R_SUCCESS)
5249 goto next_master;
5250
5251 switch (msg->rcode) {
5252 /*
5253 * Pass these rcodes back to client.
5254 */
5255 case dns_rcode_noerror:
5256 case dns_rcode_yxdomain:
5257 case dns_rcode_yxrrset:
5258 case dns_rcode_nxrrset:
5259 case dns_rcode_refused:
5260 case dns_rcode_nxdomain:
5261 break;
5262
5263 /* These should not occur if the masters/zone are valid. */
5264 case dns_rcode_notzone:
5265 case dns_rcode_notauth: {
5266 char rcode[128];
5267 isc_buffer_t rb;
5268
5269 isc_buffer_init(&rb, rcode, sizeof(rcode));
5270 dns_rcode_totext(msg->rcode, &rb);
5271 dns_zone_log(zone, ISC_LOG_WARNING,
5272 "forwarding dynamic update: "
5273 "unexpected response: master %s returned: %.*s",
5274 master, (int)rb.used, rcode);
5275 goto next_master;
5276 }
5277
5278 /* Try another server for these rcodes. */
5279 case dns_rcode_formerr:
5280 case dns_rcode_servfail:
5281 case dns_rcode_notimp:
5282 case dns_rcode_badvers:
5283 default:
5284 goto next_master;
5285 }
5286
5287 /* call callback */
5288 (forward->callback)(forward->callback_arg, ISC_R_SUCCESS, msg);
5289 msg = NULL;
5290 dns_request_destroy(&forward->request);
5291 forward_destroy(forward);
5292 isc_event_free(&event);
5293 return;
5294
5295 next_master:
5296 if (msg != NULL)
5297 dns_message_destroy(&msg);
5298 isc_event_free(&event);
5299 forward->which++;
5300 dns_request_destroy(&forward->request);
5301 result = sendtomaster(forward);
5302 if (result != ISC_R_SUCCESS) {
5303 /* call callback */
5304 dns_zone_log(zone, ISC_LOG_DEBUG(3),
5305 "exhausted dynamic update forwarder list");
5306 (forward->callback)(forward->callback_arg, result, NULL);
5307 forward_destroy(forward);
5308 }
5309 }
5310
5311 isc_result_t
5312 dns_zone_forwardupdate(dns_zone_t *zone, dns_message_t *msg,
5313 dns_updatecallback_t callback, void *callback_arg)
5314 {
5315 dns_forward_t *forward;
5316 isc_result_t result;
5317 isc_region_t *mr;
5318
5319 REQUIRE(DNS_ZONE_VALID(zone));
5320 REQUIRE(msg != NULL);
5321 REQUIRE(callback != NULL);
5322
5323 forward = isc_mem_get(zone->mctx, sizeof(*forward));
5324 if (forward == NULL)
5325 return (ISC_R_NOMEMORY);
5326
5327 forward->request = NULL;
5328 forward->zone = NULL;
5329 forward->msgbuf = NULL;
5330 forward->which = 0;
5331 forward->mctx = 0;
5332 forward->callback = callback;
5333 forward->callback_arg = callback_arg;
5334 forward->magic = FORWARD_MAGIC;
5335
5336 mr = dns_message_getrawmessage(msg);
5337 if (mr == NULL) {
5338 result = ISC_R_UNEXPECTEDEND;
5339 goto cleanup;
5340 }
5341
5342 result = isc_buffer_allocate(zone->mctx, &forward->msgbuf, mr->length);
5343 if (result != ISC_R_SUCCESS)
5344 goto cleanup;
5345 result = isc_buffer_copyregion(forward->msgbuf, mr);
5346 if (result != ISC_R_SUCCESS)
5347 goto cleanup;
5348
5349 isc_mem_attach(zone->mctx, &forward->mctx);
5350 dns_zone_iattach(zone, &forward->zone);
5351 result = sendtomaster(forward);
5352
5353 cleanup:
5354 if (result != ISC_R_SUCCESS) {
5355 forward_destroy(forward);
5356 }
5357 return (result);
5358 }
5359
5360 isc_result_t
5361 dns_zone_next(dns_zone_t *zone, dns_zone_t **next) {
5362 REQUIRE(DNS_ZONE_VALID(zone));
5363 REQUIRE(next != NULL && *next == NULL);
5364
5365 *next = ISC_LIST_NEXT(zone, link);
5366 if (*next == NULL)
5367 return (ISC_R_NOMORE);
5368 else
5369 return (ISC_R_SUCCESS);
5370 }
5371
5372 isc_result_t
5373 dns_zone_first(dns_zonemgr_t *zmgr, dns_zone_t **first) {
5374 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5375 REQUIRE(first != NULL && *first == NULL);
5376
5377 *first = ISC_LIST_HEAD(zmgr->zones);
5378 if (*first == NULL)
5379 return (ISC_R_NOMORE);
5380 else
5381 return (ISC_R_SUCCESS);
5382 }
5383
5384 /***
5385 *** Zone manager.
5386 ***/
5387
5388 isc_result_t
5389 dns_zonemgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
5390 isc_timermgr_t *timermgr, isc_socketmgr_t *socketmgr,
5391 dns_zonemgr_t **zmgrp)
5392 {
5393 dns_zonemgr_t *zmgr;
5394 isc_result_t result;
5395 isc_interval_t interval;
5396
5397 zmgr = isc_mem_get(mctx, sizeof *zmgr);
5398 if (zmgr == NULL)
5399 return (ISC_R_NOMEMORY);
5400 zmgr->mctx = NULL;
5401 zmgr->refs = 1;
5402 isc_mem_attach(mctx, &zmgr->mctx);
5403 zmgr->taskmgr = taskmgr;
5404 zmgr->timermgr = timermgr;
5405 zmgr->socketmgr = socketmgr;
5406 zmgr->zonetasks = NULL;
5407 zmgr->task = NULL;
5408 zmgr->rl = NULL;
5409 ISC_LIST_INIT(zmgr->zones);
5410 ISC_LIST_INIT(zmgr->waiting_for_xfrin);
5411 ISC_LIST_INIT(zmgr->xfrin_in_progress);
5412 result = isc_rwlock_init(&zmgr->rwlock, 0, 0);
5413 if (result != ISC_R_SUCCESS) {
5414 UNEXPECTED_ERROR(__FILE__, __LINE__,
5415 "isc_rwlock_init() failed: %s",
5416 isc_result_totext(result));
5417 result = ISC_R_UNEXPECTED;
5418 goto free_mem;
5419 }
5420 zmgr->transfersin = 10;
5421 zmgr->transfersperns = 2;
5422
5423 /* Create the zone task pool. */
5424 result = isc_taskpool_create(taskmgr, mctx,
5425 8 /* XXX */, 2, &zmgr->zonetasks);
5426 if (result != ISC_R_SUCCESS)
5427 goto free_rwlock;
5428
5429 /* Create a single task for queueing of SOA queries. */
5430 result = isc_task_create(taskmgr, 1, &zmgr->task);
5431 if (result != ISC_R_SUCCESS)
5432 goto free_taskpool;
5433 isc_task_setname(zmgr->task, "zmgr", zmgr);
5434 result = isc_ratelimiter_create(mctx, timermgr, zmgr->task,
5435 &zmgr->rl);
5436 if (result != ISC_R_SUCCESS)
5437 goto free_task;
5438 /* default to 20 refresh queries / notifies per second. */
5439 isc_interval_set(&interval, 0, 1000000000/2);
5440 result = isc_ratelimiter_setinterval(zmgr->rl, &interval);
5441 RUNTIME_CHECK(result == ISC_R_SUCCESS);
5442 isc_ratelimiter_setpertic(zmgr->rl, 10);
5443
5444 zmgr->iolimit = 1;
5445 zmgr->ioactive = 0;
5446 ISC_LIST_INIT(zmgr->high);
5447 ISC_LIST_INIT(zmgr->low);
5448
5449 result = isc_mutex_init(&zmgr->iolock);
5450 if (result != ISC_R_SUCCESS) {
5451 UNEXPECTED_ERROR(__FILE__, __LINE__,
5452 "isc_mutex_init() failed: %s",
5453 isc_result_totext(result));
5454 goto free_rl;
5455 }
5456 zmgr->magic = ZONEMGR_MAGIC;
5457
5458 *zmgrp = zmgr;
5459 return (ISC_R_SUCCESS);
5460
5461 #if 0
5462 free_iolock:
5463 DESTROYLOCK(&zmgr->iolock);
5464 #endif
5465 free_rl:
5466 isc_ratelimiter_detach(&zmgr->rl);
5467 free_task:
5468 isc_task_detach(&zmgr->task);
5469 free_taskpool:
5470 isc_taskpool_destroy(&zmgr->zonetasks);
5471 free_rwlock:
5472 isc_rwlock_destroy(&zmgr->rwlock);
5473 free_mem:
5474 isc_mem_put(zmgr->mctx, zmgr, sizeof *zmgr);
5475 isc_mem_detach(&mctx);
5476 return (result);
5477 }
5478
5479 isc_result_t
5480 dns_zonemgr_managezone(dns_zonemgr_t *zmgr, dns_zone_t *zone) {
5481 isc_result_t result;
5482
5483 REQUIRE(DNS_ZONE_VALID(zone));
5484 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5485
5486 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5487 LOCK_ZONE(zone);
5488 REQUIRE(zone->task == NULL);
5489 REQUIRE(zone->timer == NULL);
5490 REQUIRE(zone->zmgr == NULL);
5491
5492 isc_taskpool_gettask(zmgr->zonetasks,
5493 dns_name_hash(dns_zone_getorigin(zone),
5494 ISC_FALSE),
5495 &zone->task);
5496
5497 /*
5498 * Set the task name. The tag will arbitrarily point to one
5499 * of the zones sharing the task (in practice, the one
5500 * to be managed last).
5501 */
5502 isc_task_setname(zone->task, "zone", zone);
5503
5504 result = isc_timer_create(zmgr->timermgr, isc_timertype_inactive,
5505 NULL, NULL,
5506 zone->task, zone_timer, zone,
5507 &zone->timer);
5508 if (result != ISC_R_SUCCESS)
5509 goto cleanup_task;
5510 /*
5511 * The timer "holds" a iref.
5512 */
5513 zone->irefs++;
5514 INSIST(zone->irefs != 0);
5515
5516 ISC_LIST_APPEND(zmgr->zones, zone, link);
5517 zone->zmgr = zmgr;
5518 zmgr->refs++;
5519
5520 goto unlock;
5521
5522 cleanup_task:
5523 isc_task_detach(&zone->task);
5524
5525 unlock:
5526 UNLOCK_ZONE(zone);
5527 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5528 return (result);
5529 }
5530
5531 void
5532 dns_zonemgr_releasezone(dns_zonemgr_t *zmgr, dns_zone_t *zone) {
5533 isc_boolean_t free_now = ISC_FALSE;
5534
5535 REQUIRE(DNS_ZONE_VALID(zone));
5536 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5537 REQUIRE(zone->zmgr == zmgr);
5538
5539 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5540 LOCK_ZONE(zone);
5541
5542 ISC_LIST_UNLINK(zmgr->zones, zone, link);
5543 zone->zmgr = NULL;
5544 zmgr->refs--;
5545 if (zmgr->refs == 0)
5546 free_now = ISC_TRUE;
5547
5548 UNLOCK_ZONE(zone);
5549 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5550
5551 if (free_now)
5552 zonemgr_free(zmgr);
5553 ENSURE(zone->zmgr == NULL);
5554 }
5555
5556 void
5557 dns_zonemgr_attach(dns_zonemgr_t *source, dns_zonemgr_t **target) {
5558 REQUIRE(DNS_ZONEMGR_VALID(source));
5559 REQUIRE(target != NULL && *target == NULL);
5560
5561 RWLOCK(&source->rwlock, isc_rwlocktype_write);
5562 REQUIRE(source->refs > 0);
5563 source->refs++;
5564 INSIST(source->refs > 0);
5565 RWUNLOCK(&source->rwlock, isc_rwlocktype_write);
5566 *target = source;
5567 }
5568
5569 void
5570 dns_zonemgr_detach(dns_zonemgr_t **zmgrp) {
5571 dns_zonemgr_t *zmgr;
5572 isc_boolean_t free_now = ISC_FALSE;
5573
5574 REQUIRE(zmgrp != NULL);
5575 zmgr = *zmgrp;
5576 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5577
5578 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5579 zmgr->refs--;
5580 if (zmgr->refs == 0)
5581 free_now = ISC_TRUE;
5582 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5583
5584 if (free_now)
5585 zonemgr_free(zmgr);
5586 }
5587
5588 isc_result_t
5589 dns_zonemgr_forcemaint(dns_zonemgr_t *zmgr) {
5590 dns_zone_t *p;
5591
5592 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5593
5594 RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
5595 for (p = ISC_LIST_HEAD(zmgr->zones);
5596 p != NULL;
5597 p = ISC_LIST_NEXT(p, link))
5598 {
5599 dns_zone_maintenance(p);
5600 }
5601 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_read);
5602
5603 /*
5604 * Recent configuration changes may have increased the
5605 * amount of available transfers quota. Make sure any
5606 * transfers currently blocked on quota get started if
5607 * possible.
5608 */
5609 RWLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5610 zmgr_resume_xfrs(zmgr, ISC_TRUE);
5611 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_write);
5612 return (ISC_R_SUCCESS);
5613 }
5614
5615 void
5616 dns_zonemgr_shutdown(dns_zonemgr_t *zmgr) {
5617 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5618
5619 isc_ratelimiter_shutdown(zmgr->rl);
5620
5621 if (zmgr->task != NULL)
5622 isc_task_destroy(&zmgr->task);
5623 if (zmgr->zonetasks != NULL)
5624 isc_taskpool_destroy(&zmgr->zonetasks);
5625 }
5626
5627 static void
5628 zonemgr_free(dns_zonemgr_t *zmgr) {
5629 isc_mem_t *mctx;
5630
5631 INSIST(zmgr->refs == 0);
5632 INSIST(ISC_LIST_EMPTY(zmgr->zones));
5633
5634 zmgr->magic = 0;
5635
5636 DESTROYLOCK(&zmgr->iolock);
5637 isc_ratelimiter_detach(&zmgr->rl);
5638
5639 isc_rwlock_destroy(&zmgr->rwlock);
5640 mctx = zmgr->mctx;
5641 isc_mem_put(zmgr->mctx, zmgr, sizeof *zmgr);
5642 isc_mem_detach(&mctx);
5643 }
5644
5645 void
5646 dns_zonemgr_settransfersin(dns_zonemgr_t *zmgr, isc_uint32_t value) {
5647 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5648
5649 zmgr->transfersin = value;
5650 }
5651
5652 isc_uint32_t
5653 dns_zonemgr_getttransfersin(dns_zonemgr_t *zmgr) {
5654 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5655
5656 return (zmgr->transfersin);
5657 }
5658
5659 void
5660 dns_zonemgr_settransfersperns(dns_zonemgr_t *zmgr, isc_uint32_t value) {
5661 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5662
5663 zmgr->transfersperns = value;
5664 }
5665
5666 isc_uint32_t
5667 dns_zonemgr_getttransfersperns(dns_zonemgr_t *zmgr) {
5668 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5669
5670 return (zmgr->transfersperns);
5671 }
5672
5673 /*
5674 * Try to start a new incoming zone transfer to fill a quota
5675 * slot that was just vacated.
5676 *
5677 * Requires:
5678 * The zone manager is locked by the caller.
5679 */
5680 static void
5681 zmgr_resume_xfrs(dns_zonemgr_t *zmgr, isc_boolean_t multi) {
5682 dns_zone_t *zone;
5683 dns_zone_t *next;
5684
5685 for (zone = ISC_LIST_HEAD(zmgr->waiting_for_xfrin);
5686 zone != NULL;
5687 zone = next)
5688 {
5689 isc_result_t result;
5690 next = ISC_LIST_NEXT(zone, statelink);
5691 result = zmgr_start_xfrin_ifquota(zmgr, zone);
5692 if (result == ISC_R_SUCCESS) {
5693 if (multi)
5694 continue;
5695 /*
5696 * We successfully filled the slot. We're done.
5697 */
5698 break;
5699 } else if (result == ISC_R_QUOTA) {
5700 /*
5701 * Not enough quota. This is probably the per-server
5702 * quota, because we usually get called when a unit of
5703 * global quota has just been freed. Try the next
5704 * zone, it may succeed if it uses another master.
5705 */
5706 continue;
5707 } else {
5708 dns_zone_log(zone, ISC_LOG_DEBUG(3),
5709 "starting zone transfer: %s",
5710 isc_result_totext(result));
5711 break;
5712 }
5713 }
5714 }
5715
5716 /*
5717 * Try to start an incoming zone transfer for 'zone', quota permitting.
5718 *
5719 * Requires:
5720 * The zone manager is locked by the caller.
5721 *
5722 * Returns:
5723 * ISC_R_SUCCESS There was enough quota and we attempted to
5724 * start a transfer. zone_xfrdone() has been or will
5725 * be called.
5726 * ISC_R_QUOTA Not enough quota.
5727 * Others Failure.
5728 */
5729 static isc_result_t
5730 zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr, dns_zone_t *zone) {
5731 dns_peer_t *peer = NULL;
5732 isc_netaddr_t masterip;
5733 isc_uint32_t nxfrsin, nxfrsperns;
5734 dns_zone_t *x;
5735 isc_uint32_t maxtransfersin, maxtransfersperns;
5736 isc_event_t *e;
5737
5738 /*
5739 * Find any configured information about the server we'd
5740 * like to transfer this zone from.
5741 */
5742 isc_netaddr_fromsockaddr(&masterip, &zone->masteraddr);
5743 (void)dns_peerlist_peerbyaddr(zone->view->peers,
5744 &masterip, &peer);
5745
5746 /*
5747 * Determine the total maximum number of simultaneous
5748 * transfers allowed, and the maximum for this specific
5749 * master.
5750 */
5751 maxtransfersin = zmgr->transfersin;
5752 maxtransfersperns = zmgr->transfersperns;
5753 if (peer != NULL)
5754 (void)dns_peer_gettransfers(peer, &maxtransfersperns);
5755
5756 /*
5757 * Count the total number of transfers that are in progress,
5758 * and the number of transfers in progress from this master.
5759 * We linearly scan a list of all transfers; if this turns
5760 * out to be too slow, we could hash on the master address.
5761 */
5762 nxfrsin = nxfrsperns = 0;
5763 for (x = ISC_LIST_HEAD(zmgr->xfrin_in_progress);
5764 x != NULL;
5765 x = ISC_LIST_NEXT(x, statelink))
5766 {
5767 isc_netaddr_t xip;
5768 isc_netaddr_fromsockaddr(&xip, &x->masteraddr);
5769 nxfrsin++;
5770 if (isc_netaddr_equal(&xip, &masterip))
5771 nxfrsperns++;
5772 }
5773
5774 /* Enforce quota. */
5775 if (nxfrsin >= maxtransfersin)
5776 return (ISC_R_QUOTA);
5777
5778 if (nxfrsperns >= maxtransfersperns)
5779 return (ISC_R_QUOTA);
5780
5781 /*
5782 * We have sufficient quota. Move the zone to the "xfrin_in_progress"
5783 * list and send it an event to let it start the actual transfer in the
5784 * context of its own task.
5785 */
5786 e = isc_event_allocate(zmgr->mctx, zmgr,
5787 DNS_EVENT_ZONESTARTXFRIN,
5788 got_transfer_quota, zone,
5789 sizeof(isc_event_t));
5790 if (e == NULL)
5791 return (ISC_R_NOMEMORY);
5792
5793 LOCK_ZONE(zone);
5794 INSIST(zone->statelist == &zmgr->waiting_for_xfrin);
5795 ISC_LIST_UNLINK(zmgr->waiting_for_xfrin, zone, statelink);
5796 ISC_LIST_APPEND(zmgr->xfrin_in_progress, zone, statelink);
5797 zone->statelist = &zmgr->xfrin_in_progress;
5798 isc_task_send(zone->task, &e);
5799 UNLOCK_ZONE(zone);
5800
5801 return (ISC_R_SUCCESS);
5802 }
5803
5804 void
5805 dns_zonemgr_setiolimit(dns_zonemgr_t *zmgr, isc_uint32_t iolimit) {
5806
5807 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5808 REQUIRE(iolimit > 0);
5809
5810 zmgr->iolimit = iolimit;
5811 }
5812
5813 isc_uint32_t
5814 dns_zonemgr_getiolimit(dns_zonemgr_t *zmgr) {
5815
5816 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5817
5818 return (zmgr->iolimit);
5819 }
5820
5821 /*
5822 * Get permission to request a file handle from the OS.
5823 * An event will be sent to action when one is available.
5824 * There are two queues available (high and low), the high
5825 * queue will be serviced before the low one.
5826 *
5827 * zonemgr_putio() must be called after the event is delivered to
5828 * 'action'.
5829 */
5830
5831 static isc_result_t
5832 zonemgr_getio(dns_zonemgr_t *zmgr, isc_boolean_t high,
5833 isc_task_t *task, isc_taskaction_t action, void *arg,
5834 dns_io_t **iop)
5835 {
5836 dns_io_t *io;
5837 isc_boolean_t queue;
5838
5839 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5840 REQUIRE(iop != NULL && *iop == NULL);
5841
5842 io = isc_mem_get(zmgr->mctx, sizeof(*io));
5843 if (io == NULL)
5844 return (ISC_R_NOMEMORY);
5845 io->event = isc_event_allocate(zmgr->mctx, task, DNS_EVENT_IOREADY,
5846 action, arg, sizeof(*io->event));
5847 if (io->event == NULL) {
5848 isc_mem_put(zmgr->mctx, io, sizeof(*io));
5849 return (ISC_R_NOMEMORY);
5850 }
5851 io->zmgr = zmgr;
5852 io->high = high;
5853 io->task = NULL;
5854 isc_task_attach(task, &io->task);
5855 ISC_LINK_INIT(io, link);
5856 io->magic = IO_MAGIC;
5857
5858 LOCK(&zmgr->iolock);
5859 zmgr->ioactive++;
5860 queue = ISC_TF(zmgr->ioactive > zmgr->iolimit);
5861 if (queue) {
5862 if (io->high)
5863 ISC_LIST_APPEND(zmgr->high, io, link);
5864 else
5865 ISC_LIST_APPEND(zmgr->low, io, link);
5866 }
5867 UNLOCK(&zmgr->iolock);
5868 *iop = io;
5869
5870 if (!queue) {
5871 isc_task_send(io->task, &io->event);
5872 }
5873 return (ISC_R_SUCCESS);
5874 }
5875
5876 static void
5877 zonemgr_putio(dns_io_t **iop) {
5878 dns_io_t *io;
5879 dns_io_t *next;
5880 dns_zonemgr_t *zmgr;
5881
5882 REQUIRE(iop != NULL);
5883 io = *iop;
5884 REQUIRE(DNS_IO_VALID(io));
5885
5886 *iop = NULL;
5887
5888 INSIST(!ISC_LINK_LINKED(io, link));
5889 INSIST(io->event == NULL);
5890
5891 zmgr = io->zmgr;
5892 isc_task_detach(&io->task);
5893 io->magic = 0;
5894 isc_mem_put(zmgr->mctx, io, sizeof(*io));
5895
5896 LOCK(&zmgr->iolock);
5897 INSIST(zmgr->ioactive > 0);
5898 zmgr->ioactive--;
5899 next = HEAD(zmgr->high);
5900 if (next == NULL)
5901 next = HEAD(zmgr->low);
5902 if (next != NULL) {
5903 if (next->high)
5904 ISC_LIST_UNLINK(zmgr->high, next, link);
5905 else
5906 ISC_LIST_UNLINK(zmgr->low, next, link);
5907 INSIST(next->event != NULL);
5908 }
5909 UNLOCK(&zmgr->iolock);
5910 if (next != NULL)
5911 isc_task_send(next->task, &next->event);
5912 }
5913
5914 static void
5915 zonemgr_cancelio(dns_io_t *io) {
5916 isc_boolean_t send_event = ISC_FALSE;
5917
5918 REQUIRE(DNS_IO_VALID(io));
5919
5920 /*
5921 * If we are queued to be run then dequeue.
5922 */
5923 LOCK(&io->zmgr->iolock);
5924 if (ISC_LINK_LINKED(io, link)) {
5925 if (io->high)
5926 ISC_LIST_UNLINK(io->zmgr->high, io, link);
5927 else
5928 ISC_LIST_UNLINK(io->zmgr->low, io, link);
5929
5930 send_event = ISC_TRUE;
5931 INSIST(io->event != NULL);
5932 }
5933 UNLOCK(&io->zmgr->iolock);
5934 if (send_event) {
5935 io->event->ev_attributes |= ISC_EVENTATTR_CANCELED;
5936 isc_task_send(io->task, &io->event);
5937 }
5938 }
5939
5940 static void
5941 zone_saveunique(dns_zone_t *zone, const char *path, const char *templat) {
5942 char *buf;
5943 int buflen;
5944 isc_result_t result;
5945
5946 buflen = strlen(path) + strlen(templat) + 2;
5947
5948 buf = isc_mem_get(zone->mctx, buflen);
5949 if (buf == NULL)
5950 return;
5951
5952 result = isc_file_template(path, templat, buf, buflen);
5953 if (result != ISC_R_SUCCESS)
5954 goto cleanup;
5955
5956 result = isc_file_renameunique(path, buf);
5957 if (result != ISC_R_SUCCESS)
5958 goto cleanup;
5959
5960 dns_zone_log(zone, ISC_LOG_INFO, "saved '%s' as '%s'",
5961 path, buf);
5962
5963 cleanup:
5964 isc_mem_put(zone->mctx, buf, buflen);
5965 }
5966
5967 #if 0
5968 /* Hook for ondestroy notifcation from a database. */
5969
5970 static void
5971 dns_zonemgr_dbdestroyed(isc_task_t *task, isc_event_t *event) {
5972 dns_db_t *db = event->sender;
5973 UNUSED(task);
5974
5975 isc_event_free(&event);
5976
5977 isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
5978 DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
5979 "database (%p) destroyed", (void*) db);
5980 }
5981 #endif
5982
5983 void
5984 dns_zonemgr_setserialqueryrate(dns_zonemgr_t *zmgr, unsigned int value) {
5985 isc_interval_t interval;
5986 isc_uint32_t s, ns;
5987 isc_uint32_t pertic;
5988 isc_result_t result;
5989
5990 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
5991
5992 if (value == 0)
5993 value = 1;
5994
5995 if (value == 1) {
5996 s = 1;
5997 ns = 0;
5998 pertic = 1;
5999 } else if (value <= 10) {
6000 s = 0;
6001 ns = 1000000000 / value;
6002 pertic = 1;
6003 } else {
6004 s = 0;
6005 ns = (1000000000 / value) * 10;
6006 pertic = 10;
6007 }
6008
6009 isc_interval_set(&interval, s, ns);
6010 result = isc_ratelimiter_setinterval(zmgr->rl, &interval);
6011 RUNTIME_CHECK(result == ISC_R_SUCCESS);
6012 isc_ratelimiter_setpertic(zmgr->rl, pertic);
6013
6014 zmgr->serialqueryrate = value;
6015 }
6016
6017 unsigned int
6018 dns_zonemgr_getserialqueryrate(dns_zonemgr_t *zmgr) {
6019 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
6020
6021 return (zmgr->serialqueryrate);
6022 }
6023
6024 void
6025 dns_zone_forcereload(dns_zone_t *zone) {
6026 REQUIRE(DNS_ZONE_VALID(zone));
6027
6028 LOCK_ZONE(zone);
6029 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FORCEXFER);
6030 UNLOCK_ZONE(zone);
6031 dns_zone_refresh(zone);
6032 }
6033
6034 isc_boolean_t
6035 dns_zone_isforced(dns_zone_t *zone) {
6036 REQUIRE(DNS_ZONE_VALID(zone));
6037
6038 return (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FORCEXFER));
6039 }
6040
6041 isc_result_t
6042 dns_zone_setstatistics(dns_zone_t *zone, isc_boolean_t on) {
6043 isc_result_t result = ISC_R_SUCCESS;
6044
6045 LOCK_ZONE(zone);
6046 if (on) {
6047 if (zone->counters != NULL)
6048 goto done;
6049 result = dns_stats_alloccounters(zone->mctx, &zone->counters);
6050 } else {
6051 if (zone->counters == NULL)
6052 goto done;
6053 dns_stats_freecounters(zone->mctx, &zone->counters);
6054 }
6055 done:
6056 UNLOCK_ZONE(zone);
6057 return (result);
6058 }
6059
6060 isc_uint64_t *
6061 dns_zone_getstatscounters(dns_zone_t *zone) {
6062 return (zone->counters);
6063 }
6064
6065 void
6066 dns_zone_dialup(dns_zone_t *zone) {
6067
6068 REQUIRE(DNS_ZONE_VALID(zone));
6069
6070 zone_debuglog(zone, "dns_zone_dialup", 3,
6071 "notify = %d, refresh = %d",
6072 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALNOTIFY),
6073 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALREFRESH));
6074
6075 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALNOTIFY))
6076 dns_zone_notify(zone);
6077 if (zone->type != dns_zone_master &&
6078 DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALREFRESH))
6079 dns_zone_refresh(zone);
6080 }
6081
6082 void
6083 dns_zone_setdialup(dns_zone_t *zone, dns_dialuptype_t dialup) {
6084 REQUIRE(DNS_ZONE_VALID(zone));
6085
6086 LOCK_ZONE(zone);
6087 DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_DIALNOTIFY |
6088 DNS_ZONEFLG_DIALREFRESH |
6089 DNS_ZONEFLG_NOREFRESH);
6090 switch (dialup) {
6091 case dns_dialuptype_no:
6092 break;
6093 case dns_dialuptype_yes:
6094 DNS_ZONE_SETFLAG(zone, (DNS_ZONEFLG_DIALNOTIFY |
6095 DNS_ZONEFLG_DIALREFRESH |
6096 DNS_ZONEFLG_NOREFRESH));
6097 break;
6098 case dns_dialuptype_notify:
6099 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_DIALNOTIFY);
6100 break;
6101 case dns_dialuptype_notifypassive:
6102 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_DIALNOTIFY);
6103 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOREFRESH);
6104 break;
6105 case dns_dialuptype_refresh:
6106 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_DIALREFRESH);
6107 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOREFRESH);
6108 break;
6109 case dns_dialuptype_passive:
6110 DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NOREFRESH);
6111 break;
6112 default:
6113 INSIST(0);
6114 }
6115 UNLOCK_ZONE(zone);
6116 }
6117
6118 unsigned int
6119 dns_zonemgr_getcount(dns_zonemgr_t *zmgr, int state) {
6120 dns_zone_t *zone;
6121 unsigned int count = 0;
6122
6123 REQUIRE(DNS_ZONEMGR_VALID(zmgr));
6124
6125 RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
6126 switch (state) {
6127 case DNS_ZONESTATE_XFERRUNNING:
6128 for (zone = ISC_LIST_HEAD(zmgr->xfrin_in_progress);
6129 zone != NULL;
6130 zone = ISC_LIST_NEXT(zone, statelink))
6131 count++;
6132 break;
6133 case DNS_ZONESTATE_XFERDEFERRED:
6134 for (zone = ISC_LIST_HEAD(zmgr->waiting_for_xfrin);
6135 zone != NULL;
6136 zone = ISC_LIST_NEXT(zone, statelink))
6137 count++;
6138 break;
6139 case DNS_ZONESTATE_SOAQUERY:
6140 for (zone = ISC_LIST_HEAD(zmgr->zones);
6141 zone != NULL;
6142 zone = ISC_LIST_NEXT(zone, link))
6143 if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_REFRESH))
6144 count++;
6145 break;
6146 case DNS_ZONESTATE_ANY:
6147 for (zone = ISC_LIST_HEAD(zmgr->zones);
6148 zone != NULL;
6149 zone = ISC_LIST_NEXT(zone, link))
6150 count++;
6151 break;
6152 default:
6153 INSIST(0);
6154 }
6155
6156 RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_read);
6157
6158 return (count);
6159 }
DragonFly BSD