?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import bind 9.5.2 vendor sources.
[dragonfly.git] / contrib / bind-9.5.2 / lib / dns / xfrin.c
blobab7af0be280f68d781c6723bc64a53862f86678d
1 /*
2 * Copyright (C) 2004-2008 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and/or 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: xfrin.c,v 1.157.12.7 2008/09/25 04:15:41 marka Exp $ */
19
20 /*! \file */
21
22 #include <config.h>
23
24 #include <isc/mem.h>
25 #include <isc/print.h>
26 #include <isc/random.h>
27 #include <isc/string.h> /* Required for HP/UX (and others?) */
28 #include <isc/task.h>
29 #include <isc/timer.h>
30 #include <isc/util.h>
31
32 #include <dns/db.h>
33 #include <dns/diff.h>
34 #include <dns/events.h>
35 #include <dns/journal.h>
36 #include <dns/log.h>
37 #include <dns/message.h>
38 #include <dns/rdataclass.h>
39 #include <dns/rdatalist.h>
40 #include <dns/rdataset.h>
41 #include <dns/result.h>
42 #include <dns/soa.h>
43 #include <dns/tcpmsg.h>
44 #include <dns/timer.h>
45 #include <dns/tsig.h>
46 #include <dns/view.h>
47 #include <dns/xfrin.h>
48 #include <dns/zone.h>
49
50 #include <dst/dst.h>
51
52 /*
53 * Incoming AXFR and IXFR.
54 */
55
56 /*%
57 * It would be non-sensical (or at least obtuse) to use FAIL() with an
58 * ISC_R_SUCCESS code, but the test is there to keep the Solaris compiler
59 * from complaining about "end-of-loop code not reached".
60 */
61 #define FAIL(code) \
62 do { result = (code); \
63 if (result != ISC_R_SUCCESS) goto failure; \
64 } while (0)
65
66 #define CHECK(op) \
67 do { result = (op); \
68 if (result != ISC_R_SUCCESS) goto failure; \
69 } while (0)
70
71 /*%
72 * The states of the *XFR state machine. We handle both IXFR and AXFR
73 * with a single integrated state machine because they cannot be distinguished
74 * immediately - an AXFR response to an IXFR request can only be detected
75 * when the first two (2) response RRs have already been received.
76 */
77 typedef enum {
78 XFRST_SOAQUERY,
79 XFRST_GOTSOA,
80 XFRST_INITIALSOA,
81 XFRST_FIRSTDATA,
82 XFRST_IXFR_DELSOA,
83 XFRST_IXFR_DEL,
84 XFRST_IXFR_ADDSOA,
85 XFRST_IXFR_ADD,
86 XFRST_AXFR,
87 XFRST_END
88 } xfrin_state_t;
89
90 /*%
91 * Incoming zone transfer context.
92 */
93
94 struct dns_xfrin_ctx {
95 unsigned int magic;
96 isc_mem_t *mctx;
97 dns_zone_t *zone;
98
99 int refcount;
100
101 isc_task_t *task;
102 isc_timer_t *timer;
103 isc_socketmgr_t *socketmgr;
104
105 int connects; /*%< Connect in progress */
106 int sends; /*%< Send in progress */
107 int recvs; /*%< Receive in progress */
108 isc_boolean_t shuttingdown;
109
110 dns_name_t name; /*%< Name of zone to transfer */
111 dns_rdataclass_t rdclass;
112
113 isc_boolean_t checkid;
114 dns_messageid_t id;
115
116 /*%
117 * Requested transfer type (dns_rdatatype_axfr or
118 * dns_rdatatype_ixfr). The actual transfer type
119 * may differ due to IXFR->AXFR fallback.
120 */
121 dns_rdatatype_t reqtype;
122
123 isc_sockaddr_t masteraddr;
124 isc_sockaddr_t sourceaddr;
125 isc_socket_t *socket;
126
127 /*% Buffer for IXFR/AXFR request message */
128 isc_buffer_t qbuffer;
129 unsigned char qbuffer_data[512];
130
131 /*% Incoming reply TCP message */
132 dns_tcpmsg_t tcpmsg;
133 isc_boolean_t tcpmsg_valid;
134
135 dns_db_t *db;
136 dns_dbversion_t *ver;
137 dns_diff_t diff; /*%< Pending database changes */
138 int difflen; /*%< Number of pending tuples */
139
140 xfrin_state_t state;
141 isc_uint32_t end_serial;
142 isc_boolean_t is_ixfr;
143
144 unsigned int nmsg; /*%< Number of messages recvd */
145 unsigned int nrecs; /*%< Number of records recvd */
146 isc_uint64_t nbytes; /*%< Number of bytes received */
147
148 isc_time_t start; /*%< Start time of the transfer */
149 isc_time_t end; /*%< End time of the transfer */
150
151 dns_tsigkey_t *tsigkey; /*%< Key used to create TSIG */
152 isc_buffer_t *lasttsig; /*%< The last TSIG */
153 dst_context_t *tsigctx; /*%< TSIG verification context */
154 unsigned int sincetsig; /*%< recvd since the last TSIG */
155 dns_xfrindone_t done;
156
157 /*%
158 * AXFR- and IXFR-specific data. Only one is used at a time
159 * according to the is_ixfr flag, so this could be a union,
160 * but keeping them separate makes it a bit simpler to clean
161 * things up when destroying the context.
162 */
163 struct {
164 dns_addrdatasetfunc_t add_func;
165 dns_dbload_t *add_private;
166 } axfr;
167
168 struct {
169 isc_uint32_t request_serial;
170 isc_uint32_t current_serial;
171 dns_journal_t *journal;
172
173 } ixfr;
174 };
175
176 #define XFRIN_MAGIC ISC_MAGIC('X', 'f', 'r', 'I')
177 #define VALID_XFRIN(x) ISC_MAGIC_VALID(x, XFRIN_MAGIC)
178
179 /**************************************************************************/
180 /*
181 * Forward declarations.
182 */
183
184 static isc_result_t
185 xfrin_create(isc_mem_t *mctx,
186 dns_zone_t *zone,
187 dns_db_t *db,
188 isc_task_t *task,
189 isc_timermgr_t *timermgr,
190 isc_socketmgr_t *socketmgr,
191 dns_name_t *zonename,
192 dns_rdataclass_t rdclass,
193 dns_rdatatype_t reqtype,
194 isc_sockaddr_t *masteraddr,
195 isc_sockaddr_t *sourceaddr,
196 dns_tsigkey_t *tsigkey,
197 dns_xfrin_ctx_t **xfrp);
198
199 static isc_result_t axfr_init(dns_xfrin_ctx_t *xfr);
200 static isc_result_t axfr_makedb(dns_xfrin_ctx_t *xfr, dns_db_t **dbp);
201 static isc_result_t axfr_putdata(dns_xfrin_ctx_t *xfr, dns_diffop_t op,
202 dns_name_t *name, dns_ttl_t ttl,
203 dns_rdata_t *rdata);
204 static isc_result_t axfr_apply(dns_xfrin_ctx_t *xfr);
205 static isc_result_t axfr_commit(dns_xfrin_ctx_t *xfr);
206
207 static isc_result_t ixfr_init(dns_xfrin_ctx_t *xfr);
208 static isc_result_t ixfr_apply(dns_xfrin_ctx_t *xfr);
209 static isc_result_t ixfr_putdata(dns_xfrin_ctx_t *xfr, dns_diffop_t op,
210 dns_name_t *name, dns_ttl_t ttl,
211 dns_rdata_t *rdata);
212 static isc_result_t ixfr_commit(dns_xfrin_ctx_t *xfr);
213
214 static isc_result_t xfr_rr(dns_xfrin_ctx_t *xfr, dns_name_t *name,
215 isc_uint32_t ttl, dns_rdata_t *rdata);
216
217 static isc_result_t xfrin_start(dns_xfrin_ctx_t *xfr);
218
219 static void xfrin_connect_done(isc_task_t *task, isc_event_t *event);
220 static isc_result_t xfrin_send_request(dns_xfrin_ctx_t *xfr);
221 static void xfrin_send_done(isc_task_t *task, isc_event_t *event);
222 static void xfrin_sendlen_done(isc_task_t *task, isc_event_t *event);
223 static void xfrin_recv_done(isc_task_t *task, isc_event_t *event);
224 static void xfrin_timeout(isc_task_t *task, isc_event_t *event);
225
226 static void maybe_free(dns_xfrin_ctx_t *xfr);
227
228 static void
229 xfrin_fail(dns_xfrin_ctx_t *xfr, isc_result_t result, const char *msg);
230 static isc_result_t
231 render(dns_message_t *msg, isc_mem_t *mctx, isc_buffer_t *buf);
232
233 static void
234 xfrin_logv(int level, const char *zonetext, isc_sockaddr_t *masteraddr,
235 const char *fmt, va_list ap)
236 ISC_FORMAT_PRINTF(4, 0);
237
238 static void
239 xfrin_log1(int level, const char *zonetext, isc_sockaddr_t *masteraddr,
240 const char *fmt, ...)
241 ISC_FORMAT_PRINTF(4, 5);
242
243 static void
244 xfrin_log(dns_xfrin_ctx_t *xfr, int level, const char *fmt, ...)
245 ISC_FORMAT_PRINTF(3, 4);
246
247 /**************************************************************************/
248 /*
249 * AXFR handling
250 */
251
252 static isc_result_t
253 axfr_init(dns_xfrin_ctx_t *xfr) {
254 isc_result_t result;
255
256 xfr->is_ixfr = ISC_FALSE;
257
258 if (xfr->db != NULL)
259 dns_db_detach(&xfr->db);
260
261 CHECK(axfr_makedb(xfr, &xfr->db));
262 CHECK(dns_db_beginload(xfr->db, &xfr->axfr.add_func,
263 &xfr->axfr.add_private));
264 result = ISC_R_SUCCESS;
265 failure:
266 return (result);
267 }
268
269 static isc_result_t
270 axfr_makedb(dns_xfrin_ctx_t *xfr, dns_db_t **dbp) {
271 return (dns_db_create(xfr->mctx, /* XXX */
272 "rbt", /* XXX guess */
273 &xfr->name,
274 dns_dbtype_zone,
275 xfr->rdclass,
276 0, NULL, /* XXX guess */
277 dbp));
278 }
279
280 static isc_result_t
281 axfr_putdata(dns_xfrin_ctx_t *xfr, dns_diffop_t op,
282 dns_name_t *name, dns_ttl_t ttl, dns_rdata_t *rdata)
283 {
284 isc_result_t result;
285
286 dns_difftuple_t *tuple = NULL;
287
288 CHECK(dns_zone_checknames(xfr->zone, name, rdata));
289 CHECK(dns_difftuple_create(xfr->diff.mctx, op,
290 name, ttl, rdata, &tuple));
291 dns_diff_append(&xfr->diff, &tuple);
292 if (++xfr->difflen > 100)
293 CHECK(axfr_apply(xfr));
294 result = ISC_R_SUCCESS;
295 failure:
296 return (result);
297 }
298
299 /*
300 * Store a set of AXFR RRs in the database.
301 */
302 static isc_result_t
303 axfr_apply(dns_xfrin_ctx_t *xfr) {
304 isc_result_t result;
305
306 CHECK(dns_diff_load(&xfr->diff,
307 xfr->axfr.add_func, xfr->axfr.add_private));
308 xfr->difflen = 0;
309 dns_diff_clear(&xfr->diff);
310 result = ISC_R_SUCCESS;
311 failure:
312 return (result);
313 }
314
315 static isc_result_t
316 axfr_commit(dns_xfrin_ctx_t *xfr) {
317 isc_result_t result;
318
319 CHECK(axfr_apply(xfr));
320 CHECK(dns_db_endload(xfr->db, &xfr->axfr.add_private));
321 CHECK(dns_zone_replacedb(xfr->zone, xfr->db, ISC_TRUE));
322
323 result = ISC_R_SUCCESS;
324 failure:
325 return (result);
326 }
327
328 /**************************************************************************/
329 /*
330 * IXFR handling
331 */
332
333 static isc_result_t
334 ixfr_init(dns_xfrin_ctx_t *xfr) {
335 isc_result_t result;
336 char *journalfile;
337
338 if (xfr->reqtype != dns_rdatatype_ixfr) {
339 xfrin_log(xfr, ISC_LOG_ERROR,
340 "got incremental response to AXFR request");
341 return (DNS_R_FORMERR);
342 }
343
344 xfr->is_ixfr = ISC_TRUE;
345 INSIST(xfr->db != NULL);
346 xfr->difflen = 0;
347
348 journalfile = dns_zone_getjournal(xfr->zone);
349 if (journalfile != NULL)
350 CHECK(dns_journal_open(xfr->mctx, journalfile,
351 ISC_TRUE, &xfr->ixfr.journal));
352
353 result = ISC_R_SUCCESS;
354 failure:
355 return (result);
356 }
357
358 static isc_result_t
359 ixfr_putdata(dns_xfrin_ctx_t *xfr, dns_diffop_t op,
360 dns_name_t *name, dns_ttl_t ttl, dns_rdata_t *rdata)
361 {
362 isc_result_t result;
363
364 dns_difftuple_t *tuple = NULL;
365 if (op == DNS_DIFFOP_ADD)
366 CHECK(dns_zone_checknames(xfr->zone, name, rdata));
367 CHECK(dns_difftuple_create(xfr->diff.mctx, op,
368 name, ttl, rdata, &tuple));
369 dns_diff_append(&xfr->diff, &tuple);
370 if (++xfr->difflen > 100)
371 CHECK(ixfr_apply(xfr));
372 result = ISC_R_SUCCESS;
373 failure:
374 return (result);
375 }
376
377 /*
378 * Apply a set of IXFR changes to the database.
379 */
380 static isc_result_t
381 ixfr_apply(dns_xfrin_ctx_t *xfr) {
382 isc_result_t result;
383
384 if (xfr->ver == NULL) {
385 CHECK(dns_db_newversion(xfr->db, &xfr->ver));
386 if (xfr->ixfr.journal != NULL)
387 CHECK(dns_journal_begin_transaction(xfr->ixfr.journal));
388 }
389 CHECK(dns_diff_apply(&xfr->diff, xfr->db, xfr->ver));
390 if (xfr->ixfr.journal != NULL) {
391 result = dns_journal_writediff(xfr->ixfr.journal, &xfr->diff);
392 if (result != ISC_R_SUCCESS)
393 goto failure;
394 }
395 dns_diff_clear(&xfr->diff);
396 xfr->difflen = 0;
397 result = ISC_R_SUCCESS;
398 failure:
399 return (result);
400 }
401
402 static isc_result_t
403 ixfr_commit(dns_xfrin_ctx_t *xfr) {
404 isc_result_t result;
405
406 CHECK(ixfr_apply(xfr));
407 if (xfr->ver != NULL) {
408 /* XXX enter ready-to-commit state here */
409 if (xfr->ixfr.journal != NULL)
410 CHECK(dns_journal_commit(xfr->ixfr.journal));
411 dns_db_closeversion(xfr->db, &xfr->ver, ISC_TRUE);
412 dns_zone_markdirty(xfr->zone);
413 }
414 result = ISC_R_SUCCESS;
415 failure:
416 return (result);
417 }
418
419 /**************************************************************************/
420 /*
421 * Common AXFR/IXFR protocol code
422 */
423
424 /*
425 * Handle a single incoming resource record according to the current
426 * state.
427 */
428 static isc_result_t
429 xfr_rr(dns_xfrin_ctx_t *xfr, dns_name_t *name, isc_uint32_t ttl,
430 dns_rdata_t *rdata)
431 {
432 isc_result_t result;
433
434 xfr->nrecs++;
435
436 if (rdata->type == dns_rdatatype_none ||
437 dns_rdatatype_ismeta(rdata->type))
438 FAIL(DNS_R_FORMERR);
439
440 redo:
441 switch (xfr->state) {
442 case XFRST_SOAQUERY:
443 if (rdata->type != dns_rdatatype_soa) {
444 xfrin_log(xfr, ISC_LOG_ERROR,
445 "non-SOA response to SOA query");
446 FAIL(DNS_R_FORMERR);
447 }
448 xfr->end_serial = dns_soa_getserial(rdata);
449 if (!DNS_SERIAL_GT(xfr->end_serial, xfr->ixfr.request_serial) &&
450 !dns_zone_isforced(xfr->zone)) {
451 xfrin_log(xfr, ISC_LOG_DEBUG(3),
452 "requested serial %u, "
453 "master has %u, not updating",
454 xfr->ixfr.request_serial, xfr->end_serial);
455 FAIL(DNS_R_UPTODATE);
456 }
457 xfr->state = XFRST_GOTSOA;
458 break;
459
460 case XFRST_GOTSOA:
461 /*
462 * Skip other records in the answer section.
463 */
464 break;
465
466 case XFRST_INITIALSOA:
467 if (rdata->type != dns_rdatatype_soa) {
468 xfrin_log(xfr, ISC_LOG_ERROR,
469 "first RR in zone transfer must be SOA");
470 FAIL(DNS_R_FORMERR);
471 }
472 /*
473 * Remember the serial number in the initial SOA.
474 * We need it to recognize the end of an IXFR.
475 */
476 xfr->end_serial = dns_soa_getserial(rdata);
477 if (xfr->reqtype == dns_rdatatype_ixfr &&
478 ! DNS_SERIAL_GT(xfr->end_serial, xfr->ixfr.request_serial)
479 && !dns_zone_isforced(xfr->zone))
480 {
481 /*
482 * This must be the single SOA record that is
483 * sent when the current version on the master
484 * is not newer than the version in the request.
485 */
486 xfrin_log(xfr, ISC_LOG_DEBUG(3),
487 "requested serial %u, "
488 "master has %u, not updating",
489 xfr->ixfr.request_serial, xfr->end_serial);
490 FAIL(DNS_R_UPTODATE);
491 }
492 if (xfr->reqtype == dns_rdatatype_axfr)
493 xfr->checkid = ISC_FALSE;
494 xfr->state = XFRST_FIRSTDATA;
495 break;
496
497 case XFRST_FIRSTDATA:
498 /*
499 * If the transfer begins with one SOA record, it is an AXFR,
500 * if it begins with two SOAs, it is an IXFR.
501 */
502 if (xfr->reqtype == dns_rdatatype_ixfr &&
503 rdata->type == dns_rdatatype_soa &&
504 xfr->ixfr.request_serial == dns_soa_getserial(rdata)) {
505 xfrin_log(xfr, ISC_LOG_DEBUG(3),
506 "got incremental response");
507 CHECK(ixfr_init(xfr));
508 xfr->state = XFRST_IXFR_DELSOA;
509 } else {
510 xfrin_log(xfr, ISC_LOG_DEBUG(3),
511 "got nonincremental response");
512 CHECK(axfr_init(xfr));
513 xfr->state = XFRST_AXFR;
514 }
515 goto redo;
516
517 case XFRST_IXFR_DELSOA:
518 INSIST(rdata->type == dns_rdatatype_soa);
519 CHECK(ixfr_putdata(xfr, DNS_DIFFOP_DEL, name, ttl, rdata));
520 xfr->state = XFRST_IXFR_DEL;
521 break;
522
523 case XFRST_IXFR_DEL:
524 if (rdata->type == dns_rdatatype_soa) {
525 isc_uint32_t soa_serial = dns_soa_getserial(rdata);
526 xfr->state = XFRST_IXFR_ADDSOA;
527 xfr->ixfr.current_serial = soa_serial;
528 goto redo;
529 }
530 CHECK(ixfr_putdata(xfr, DNS_DIFFOP_DEL, name, ttl, rdata));
531 break;
532
533 case XFRST_IXFR_ADDSOA:
534 INSIST(rdata->type == dns_rdatatype_soa);
535 CHECK(ixfr_putdata(xfr, DNS_DIFFOP_ADD, name, ttl, rdata));
536 xfr->state = XFRST_IXFR_ADD;
537 break;
538
539 case XFRST_IXFR_ADD:
540 if (rdata->type == dns_rdatatype_soa) {
541 isc_uint32_t soa_serial = dns_soa_getserial(rdata);
542 if (soa_serial == xfr->end_serial) {
543 CHECK(ixfr_commit(xfr));
544 xfr->state = XFRST_END;
545 break;
546 } else if (soa_serial != xfr->ixfr.current_serial) {
547 xfrin_log(xfr, ISC_LOG_ERROR,
548 "IXFR out of sync: "
549 "expected serial %u, got %u",
550 xfr->ixfr.current_serial, soa_serial);
551 FAIL(DNS_R_FORMERR);
552 } else {
553 CHECK(ixfr_commit(xfr));
554 xfr->state = XFRST_IXFR_DELSOA;
555 goto redo;
556 }
557 }
558 if (rdata->type == dns_rdatatype_ns &&
559 dns_name_iswildcard(name))
560 FAIL(DNS_R_INVALIDNS);
561 CHECK(ixfr_putdata(xfr, DNS_DIFFOP_ADD, name, ttl, rdata));
562 break;
563
564 case XFRST_AXFR:
565 /*
566 * Old BINDs sent cross class A records for non IN classes.
567 */
568 if (rdata->type == dns_rdatatype_a &&
569 rdata->rdclass != xfr->rdclass &&
570 xfr->rdclass != dns_rdataclass_in)
571 break;
572 CHECK(axfr_putdata(xfr, DNS_DIFFOP_ADD, name, ttl, rdata));
573 if (rdata->type == dns_rdatatype_soa) {
574 CHECK(axfr_commit(xfr));
575 xfr->state = XFRST_END;
576 break;
577 }
578 break;
579 case XFRST_END:
580 FAIL(DNS_R_EXTRADATA);
581 default:
582 INSIST(0);
583 break;
584 }
585 result = ISC_R_SUCCESS;
586 failure:
587 return (result);
588 }
589
590 isc_result_t
591 dns_xfrin_create(dns_zone_t *zone, dns_rdatatype_t xfrtype,
592 isc_sockaddr_t *masteraddr, dns_tsigkey_t *tsigkey,
593 isc_mem_t *mctx, isc_timermgr_t *timermgr,
594 isc_socketmgr_t *socketmgr, isc_task_t *task,
595 dns_xfrindone_t done, dns_xfrin_ctx_t **xfrp)
596 {
597 isc_sockaddr_t sourceaddr;
598
599 switch (isc_sockaddr_pf(masteraddr)) {
600 case PF_INET:
601 sourceaddr = *dns_zone_getxfrsource4(zone);
602 break;
603 case PF_INET6:
604 sourceaddr = *dns_zone_getxfrsource6(zone);
605 break;
606 default:
607 INSIST(0);
608 }
609
610 return(dns_xfrin_create2(zone, xfrtype, masteraddr, &sourceaddr,
611 tsigkey, mctx, timermgr, socketmgr,
612 task, done, xfrp));
613 }
614
615 isc_result_t
616 dns_xfrin_create2(dns_zone_t *zone, dns_rdatatype_t xfrtype,
617 isc_sockaddr_t *masteraddr, isc_sockaddr_t *sourceaddr,
618 dns_tsigkey_t *tsigkey, isc_mem_t *mctx,
619 isc_timermgr_t *timermgr, isc_socketmgr_t *socketmgr,
620 isc_task_t *task, dns_xfrindone_t done, dns_xfrin_ctx_t **xfrp)
621 {
622 dns_name_t *zonename = dns_zone_getorigin(zone);
623 dns_xfrin_ctx_t *xfr = NULL;
624 isc_result_t result;
625 dns_db_t *db = NULL;
626
627 REQUIRE(xfrp != NULL && *xfrp == NULL);
628
629 (void)dns_zone_getdb(zone, &db);
630
631 if (xfrtype == dns_rdatatype_soa || xfrtype == dns_rdatatype_ixfr)
632 REQUIRE(db != NULL);
633
634 CHECK(xfrin_create(mctx, zone, db, task, timermgr, socketmgr, zonename,
635 dns_zone_getclass(zone), xfrtype, masteraddr,
636 sourceaddr, tsigkey, &xfr));
637
638 CHECK(xfrin_start(xfr));
639
640 xfr->done = done;
641 xfr->refcount++;
642 *xfrp = xfr;
643
644 failure:
645 if (db != NULL)
646 dns_db_detach(&db);
647 if (result != ISC_R_SUCCESS) {
648 char zonetext[DNS_NAME_MAXTEXT+32];
649 dns_zone_name(zone, zonetext, sizeof(zonetext));
650 xfrin_log1(ISC_LOG_ERROR, zonetext, masteraddr,
651 "zone transfer setup failed");
652 }
653 return (result);
654 }
655
656 void
657 dns_xfrin_shutdown(dns_xfrin_ctx_t *xfr) {
658 if (! xfr->shuttingdown)
659 xfrin_fail(xfr, ISC_R_CANCELED, "shut down");
660 }
661
662 void
663 dns_xfrin_attach(dns_xfrin_ctx_t *source, dns_xfrin_ctx_t **target) {
664 REQUIRE(target != NULL && *target == NULL);
665 source->refcount++;
666 *target = source;
667 }
668
669 void
670 dns_xfrin_detach(dns_xfrin_ctx_t **xfrp) {
671 dns_xfrin_ctx_t *xfr = *xfrp;
672 INSIST(xfr->refcount > 0);
673 xfr->refcount--;
674 maybe_free(xfr);
675 *xfrp = NULL;
676 }
677
678 static void
679 xfrin_cancelio(dns_xfrin_ctx_t *xfr) {
680 if (xfr->connects > 0) {
681 isc_socket_cancel(xfr->socket, xfr->task,
682 ISC_SOCKCANCEL_CONNECT);
683 } else if (xfr->recvs > 0) {
684 dns_tcpmsg_cancelread(&xfr->tcpmsg);
685 } else if (xfr->sends > 0) {
686 isc_socket_cancel(xfr->socket, xfr->task,
687 ISC_SOCKCANCEL_SEND);
688 }
689 }
690
691 static void
692 xfrin_reset(dns_xfrin_ctx_t *xfr) {
693 REQUIRE(VALID_XFRIN(xfr));
694
695 xfrin_log(xfr, ISC_LOG_INFO, "resetting");
696
697 xfrin_cancelio(xfr);
698
699 if (xfr->socket != NULL)
700 isc_socket_detach(&xfr->socket);
701
702 if (xfr->lasttsig != NULL)
703 isc_buffer_free(&xfr->lasttsig);
704
705 dns_diff_clear(&xfr->diff);
706 xfr->difflen = 0;
707
708 if (xfr->ixfr.journal != NULL)
709 dns_journal_destroy(&xfr->ixfr.journal);
710
711 if (xfr->axfr.add_private != NULL) {
712 (void)dns_db_endload(xfr->db, &xfr->axfr.add_private);
713 xfr->axfr.add_func = NULL;
714 }
715
716 if (xfr->tcpmsg_valid) {
717 dns_tcpmsg_invalidate(&xfr->tcpmsg);
718 xfr->tcpmsg_valid = ISC_FALSE;
719 }
720
721 if (xfr->ver != NULL)
722 dns_db_closeversion(xfr->db, &xfr->ver, ISC_FALSE);
723 }
724
725
726 static void
727 xfrin_fail(dns_xfrin_ctx_t *xfr, isc_result_t result, const char *msg) {
728 if (result != DNS_R_UPTODATE) {
729 xfrin_log(xfr, ISC_LOG_ERROR, "%s: %s",
730 msg, isc_result_totext(result));
731 if (xfr->is_ixfr)
732 /* Pass special result code to force AXFR retry */
733 result = DNS_R_BADIXFR;
734 }
735 xfrin_cancelio(xfr);
736 /*
737 * Close the journal.
738 */
739 if (xfr->ixfr.journal != NULL)
740 dns_journal_destroy(&xfr->ixfr.journal);
741 if (xfr->done != NULL) {
742 (xfr->done)(xfr->zone, result);
743 xfr->done = NULL;
744 }
745 xfr->shuttingdown = ISC_TRUE;
746 maybe_free(xfr);
747 }
748
749 static isc_result_t
750 xfrin_create(isc_mem_t *mctx,
751 dns_zone_t *zone,
752 dns_db_t *db,
753 isc_task_t *task,
754 isc_timermgr_t *timermgr,
755 isc_socketmgr_t *socketmgr,
756 dns_name_t *zonename,
757 dns_rdataclass_t rdclass,
758 dns_rdatatype_t reqtype,
759 isc_sockaddr_t *masteraddr,
760 isc_sockaddr_t *sourceaddr,
761 dns_tsigkey_t *tsigkey,
762 dns_xfrin_ctx_t **xfrp)
763 {
764 dns_xfrin_ctx_t *xfr = NULL;
765 isc_result_t result;
766 isc_uint32_t tmp;
767
768 xfr = isc_mem_get(mctx, sizeof(*xfr));
769 if (xfr == NULL)
770 return (ISC_R_NOMEMORY);
771 xfr->mctx = mctx;
772 xfr->refcount = 0;
773 xfr->zone = NULL;
774 dns_zone_iattach(zone, &xfr->zone);
775 xfr->task = NULL;
776 isc_task_attach(task, &xfr->task);
777 xfr->timer = NULL;
778 xfr->socketmgr = socketmgr;
779 xfr->done = NULL;
780
781 xfr->connects = 0;
782 xfr->sends = 0;
783 xfr->recvs = 0;
784 xfr->shuttingdown = ISC_FALSE;
785
786 dns_name_init(&xfr->name, NULL);
787 xfr->rdclass = rdclass;
788 isc_random_get(&tmp);
789 xfr->checkid = ISC_TRUE;
790 xfr->id = (isc_uint16_t)(tmp & 0xffff);
791 xfr->reqtype = reqtype;
792
793 /* sockaddr */
794 xfr->socket = NULL;
795 /* qbuffer */
796 /* qbuffer_data */
797 /* tcpmsg */
798 xfr->tcpmsg_valid = ISC_FALSE;
799
800 xfr->db = NULL;
801 if (db != NULL)
802 dns_db_attach(db, &xfr->db);
803 xfr->ver = NULL;
804 dns_diff_init(xfr->mctx, &xfr->diff);
805 xfr->difflen = 0;
806
807 if (reqtype == dns_rdatatype_soa)
808 xfr->state = XFRST_SOAQUERY;
809 else
810 xfr->state = XFRST_INITIALSOA;
811 /* end_serial */
812
813 xfr->nmsg = 0;
814 xfr->nrecs = 0;
815 xfr->nbytes = 0;
816 isc_time_now(&xfr->start);
817
818 xfr->tsigkey = NULL;
819 if (tsigkey != NULL)
820 dns_tsigkey_attach(tsigkey, &xfr->tsigkey);
821 xfr->lasttsig = NULL;
822 xfr->tsigctx = NULL;
823 xfr->sincetsig = 0;
824 xfr->is_ixfr = ISC_FALSE;
825
826 /* ixfr.request_serial */
827 /* ixfr.current_serial */
828 xfr->ixfr.journal = NULL;
829
830 xfr->axfr.add_func = NULL;
831 xfr->axfr.add_private = NULL;
832
833 CHECK(dns_name_dup(zonename, mctx, &xfr->name));
834
835 CHECK(isc_timer_create(timermgr, isc_timertype_inactive, NULL, NULL,
836 task, xfrin_timeout, xfr, &xfr->timer));
837 CHECK(dns_timer_setidle(xfr->timer,
838 dns_zone_getmaxxfrin(xfr->zone),
839 dns_zone_getidlein(xfr->zone),
840 ISC_FALSE));
841
842 xfr->masteraddr = *masteraddr;
843
844 INSIST(isc_sockaddr_pf(masteraddr) == isc_sockaddr_pf(sourceaddr));
845 xfr->sourceaddr = *sourceaddr;
846 isc_sockaddr_setport(&xfr->sourceaddr, 0);
847
848 isc_buffer_init(&xfr->qbuffer, xfr->qbuffer_data,
849 sizeof(xfr->qbuffer_data));
850
851 xfr->magic = XFRIN_MAGIC;
852 *xfrp = xfr;
853 return (ISC_R_SUCCESS);
854
855 failure:
856 if (xfr->timer != NULL)
857 isc_timer_detach(&xfr->timer);
858 if (dns_name_dynamic(&xfr->name))
859 dns_name_free(&xfr->name, xfr->mctx);
860 if (xfr->tsigkey != NULL)
861 dns_tsigkey_detach(&xfr->tsigkey);
862 if (xfr->db != NULL)
863 dns_db_detach(&xfr->db);
864 isc_task_detach(&xfr->task);
865 dns_zone_idetach(&xfr->zone);
866 isc_mem_put(mctx, xfr, sizeof(*xfr));
867
868 return (result);
869 }
870
871 static isc_result_t
872 xfrin_start(dns_xfrin_ctx_t *xfr) {
873 isc_result_t result;
874 CHECK(isc_socket_create(xfr->socketmgr,
875 isc_sockaddr_pf(&xfr->sourceaddr),
876 isc_sockettype_tcp,
877 &xfr->socket));
878 isc_socket_setname(xfr->socket, "xfrin", NULL);
879 #ifndef BROKEN_TCP_BIND_BEFORE_CONNECT
880 CHECK(isc_socket_bind(xfr->socket, &xfr->sourceaddr,
881 ISC_SOCKET_REUSEADDRESS));
882 #endif
883 CHECK(isc_socket_connect(xfr->socket, &xfr->masteraddr, xfr->task,
884 xfrin_connect_done, xfr));
885 xfr->connects++;
886 return (ISC_R_SUCCESS);
887 failure:
888 xfrin_fail(xfr, result, "failed setting up socket");
889 return (result);
890 }
891
892 /* XXX the resolver could use this, too */
893
894 static isc_result_t
895 render(dns_message_t *msg, isc_mem_t *mctx, isc_buffer_t *buf) {
896 dns_compress_t cctx;
897 isc_boolean_t cleanup_cctx = ISC_FALSE;
898 isc_result_t result;
899
900 CHECK(dns_compress_init(&cctx, -1, mctx));
901 cleanup_cctx = ISC_TRUE;
902 CHECK(dns_message_renderbegin(msg, &cctx, buf));
903 CHECK(dns_message_rendersection(msg, DNS_SECTION_QUESTION, 0));
904 CHECK(dns_message_rendersection(msg, DNS_SECTION_ANSWER, 0));
905 CHECK(dns_message_rendersection(msg, DNS_SECTION_AUTHORITY, 0));
906 CHECK(dns_message_rendersection(msg, DNS_SECTION_ADDITIONAL, 0));
907 CHECK(dns_message_renderend(msg));
908 result = ISC_R_SUCCESS;
909 failure:
910 if (cleanup_cctx)
911 dns_compress_invalidate(&cctx);
912 return (result);
913 }
914
915 /*
916 * A connection has been established.
917 */
918 static void
919 xfrin_connect_done(isc_task_t *task, isc_event_t *event) {
920 isc_socket_connev_t *cev = (isc_socket_connev_t *) event;
921 dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->ev_arg;
922 isc_result_t result = cev->result;
923 char sourcetext[ISC_SOCKADDR_FORMATSIZE];
924 isc_sockaddr_t sockaddr;
925
926 REQUIRE(VALID_XFRIN(xfr));
927
928 UNUSED(task);
929
930 INSIST(event->ev_type == ISC_SOCKEVENT_CONNECT);
931 isc_event_free(&event);
932
933 xfr->connects--;
934 if (xfr->shuttingdown) {
935 maybe_free(xfr);
936 return;
937 }
938
939 if (result != ISC_R_SUCCESS) {
940 dns_zonemgr_t * zmgr = dns_zone_getmgr(xfr->zone);
941 isc_time_t now;
942
943 if (zmgr != NULL) {
944 TIME_NOW(&now);
945 dns_zonemgr_unreachableadd(zmgr, &xfr->masteraddr,
946 &xfr->sourceaddr, &now);
947 }
948 goto failure;
949 }
950
951 result = isc_socket_getsockname(xfr->socket, &sockaddr);
952 if (result == ISC_R_SUCCESS) {
953 isc_sockaddr_format(&sockaddr, sourcetext, sizeof(sourcetext));
954 } else
955 strcpy(sourcetext, "<UNKNOWN>");
956 xfrin_log(xfr, ISC_LOG_INFO, "connected using %s", sourcetext);
957
958 dns_tcpmsg_init(xfr->mctx, xfr->socket, &xfr->tcpmsg);
959 xfr->tcpmsg_valid = ISC_TRUE;
960
961 CHECK(xfrin_send_request(xfr));
962 failure:
963 if (result != ISC_R_SUCCESS)
964 xfrin_fail(xfr, result, "failed to connect");
965 }
966
967 /*
968 * Convert a tuple into a dns_name_t suitable for inserting
969 * into the given dns_message_t.
970 */
971 static isc_result_t
972 tuple2msgname(dns_difftuple_t *tuple, dns_message_t *msg, dns_name_t **target)
973 {
974 isc_result_t result;
975 dns_rdata_t *rdata = NULL;
976 dns_rdatalist_t *rdl = NULL;
977 dns_rdataset_t *rds = NULL;
978 dns_name_t *name = NULL;
979
980 REQUIRE(target != NULL && *target == NULL);
981
982 CHECK(dns_message_gettemprdata(msg, &rdata));
983 dns_rdata_init(rdata);
984 dns_rdata_clone(&tuple->rdata, rdata);
985
986 CHECK(dns_message_gettemprdatalist(msg, &rdl));
987 dns_rdatalist_init(rdl);
988 rdl->type = tuple->rdata.type;
989 rdl->rdclass = tuple->rdata.rdclass;
990 rdl->ttl = tuple->ttl;
991 ISC_LIST_APPEND(rdl->rdata, rdata, link);
992
993 CHECK(dns_message_gettemprdataset(msg, &rds));
994 dns_rdataset_init(rds);
995 CHECK(dns_rdatalist_tordataset(rdl, rds));
996
997 CHECK(dns_message_gettempname(msg, &name));
998 dns_name_init(name, NULL);
999 dns_name_clone(&tuple->name, name);
1000 ISC_LIST_APPEND(name->list, rds, link);
1001
1002 *target = name;
1003 return (ISC_R_SUCCESS);
1004
1005 failure:
1006
1007 if (rds != NULL) {
1008 dns_rdataset_disassociate(rds);
1009 dns_message_puttemprdataset(msg, &rds);
1010 }
1011 if (rdl != NULL) {
1012 ISC_LIST_UNLINK(rdl->rdata, rdata, link);
1013 dns_message_puttemprdatalist(msg, &rdl);
1014 }
1015 if (rdata != NULL)
1016 dns_message_puttemprdata(msg, &rdata);
1017
1018 return (result);
1019 }
1020
1021
1022 /*
1023 * Build an *XFR request and send its length prefix.
1024 */
1025 static isc_result_t
1026 xfrin_send_request(dns_xfrin_ctx_t *xfr) {
1027 isc_result_t result;
1028 isc_region_t region;
1029 isc_region_t lregion;
1030 dns_rdataset_t *qrdataset = NULL;
1031 dns_message_t *msg = NULL;
1032 unsigned char length[2];
1033 dns_difftuple_t *soatuple = NULL;
1034 dns_name_t *qname = NULL;
1035 dns_dbversion_t *ver = NULL;
1036 dns_name_t *msgsoaname = NULL;
1037
1038 /* Create the request message */
1039 CHECK(dns_message_create(xfr->mctx, DNS_MESSAGE_INTENTRENDER, &msg));
1040 CHECK(dns_message_settsigkey(msg, xfr->tsigkey));
1041
1042 /* Create a name for the question section. */
1043 CHECK(dns_message_gettempname(msg, &qname));
1044 dns_name_init(qname, NULL);
1045 dns_name_clone(&xfr->name, qname);
1046
1047 /* Formulate the question and attach it to the question name. */
1048 CHECK(dns_message_gettemprdataset(msg, &qrdataset));
1049 dns_rdataset_init(qrdataset);
1050 dns_rdataset_makequestion(qrdataset, xfr->rdclass, xfr->reqtype);
1051 ISC_LIST_APPEND(qname->list, qrdataset, link);
1052 qrdataset = NULL;
1053
1054 dns_message_addname(msg, qname, DNS_SECTION_QUESTION);
1055 qname = NULL;
1056
1057 if (xfr->reqtype == dns_rdatatype_ixfr) {
1058 /* Get the SOA and add it to the authority section. */
1059 /* XXX is using the current version the right thing? */
1060 dns_db_currentversion(xfr->db, &ver);
1061 CHECK(dns_db_createsoatuple(xfr->db, ver, xfr->mctx,
1062 DNS_DIFFOP_EXISTS, &soatuple));
1063 xfr->ixfr.request_serial = dns_soa_getserial(&soatuple->rdata);
1064 xfr->ixfr.current_serial = xfr->ixfr.request_serial;
1065 xfrin_log(xfr, ISC_LOG_DEBUG(3),
1066 "requesting IXFR for serial %u",
1067 xfr->ixfr.request_serial);
1068
1069 CHECK(tuple2msgname(soatuple, msg, &msgsoaname));
1070 dns_message_addname(msg, msgsoaname, DNS_SECTION_AUTHORITY);
1071 } else if (xfr->reqtype == dns_rdatatype_soa)
1072 CHECK(dns_db_getsoaserial(xfr->db, NULL,
1073 &xfr->ixfr.request_serial));
1074
1075 xfr->checkid = ISC_TRUE;
1076 xfr->id++;
1077 xfr->nmsg = 0;
1078 xfr->nrecs = 0;
1079 xfr->nbytes = 0;
1080 isc_time_now(&xfr->start);
1081 msg->id = xfr->id;
1082 if (xfr->tsigctx != NULL)
1083 dst_context_destroy(&xfr->tsigctx);
1084
1085 CHECK(render(msg, xfr->mctx, &xfr->qbuffer));
1086
1087 /*
1088 * Free the last tsig, if there is one.
1089 */
1090 if (xfr->lasttsig != NULL)
1091 isc_buffer_free(&xfr->lasttsig);
1092
1093 /*
1094 * Save the query TSIG and don't let message_destroy free it.
1095 */
1096 CHECK(dns_message_getquerytsig(msg, xfr->mctx, &xfr->lasttsig));
1097
1098 isc_buffer_usedregion(&xfr->qbuffer, &region);
1099 INSIST(region.length <= 65535);
1100
1101 length[0] = region.length >> 8;
1102 length[1] = region.length & 0xFF;
1103 lregion.base = length;
1104 lregion.length = 2;
1105 CHECK(isc_socket_send(xfr->socket, &lregion, xfr->task,
1106 xfrin_sendlen_done, xfr));
1107 xfr->sends++;
1108
1109 failure:
1110 if (qname != NULL)
1111 dns_message_puttempname(msg, &qname);
1112 if (qrdataset != NULL)
1113 dns_message_puttemprdataset(msg, &qrdataset);
1114 if (msg != NULL)
1115 dns_message_destroy(&msg);
1116 if (soatuple != NULL)
1117 dns_difftuple_free(&soatuple);
1118 if (ver != NULL)
1119 dns_db_closeversion(xfr->db, &ver, ISC_FALSE);
1120 return (result);
1121 }
1122
1123 /* XXX there should be library support for sending DNS TCP messages */
1124
1125 static void
1126 xfrin_sendlen_done(isc_task_t *task, isc_event_t *event) {
1127 isc_socketevent_t *sev = (isc_socketevent_t *) event;
1128 dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->ev_arg;
1129 isc_result_t evresult = sev->result;
1130 isc_result_t result;
1131 isc_region_t region;
1132
1133 REQUIRE(VALID_XFRIN(xfr));
1134
1135 UNUSED(task);
1136
1137 INSIST(event->ev_type == ISC_SOCKEVENT_SENDDONE);
1138 isc_event_free(&event);
1139
1140 xfr->sends--;
1141 if (xfr->shuttingdown) {
1142 maybe_free(xfr);
1143 return;
1144 }
1145
1146 xfrin_log(xfr, ISC_LOG_DEBUG(3), "sent request length prefix");
1147 CHECK(evresult);
1148
1149 isc_buffer_usedregion(&xfr->qbuffer, &region);
1150 CHECK(isc_socket_send(xfr->socket, &region, xfr->task,
1151 xfrin_send_done, xfr));
1152 xfr->sends++;
1153 failure:
1154 if (result != ISC_R_SUCCESS)
1155 xfrin_fail(xfr, result, "failed sending request length prefix");
1156 }
1157
1158
1159 static void
1160 xfrin_send_done(isc_task_t *task, isc_event_t *event) {
1161 isc_socketevent_t *sev = (isc_socketevent_t *) event;
1162 dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->ev_arg;
1163 isc_result_t result;
1164
1165 REQUIRE(VALID_XFRIN(xfr));
1166
1167 UNUSED(task);
1168
1169 INSIST(event->ev_type == ISC_SOCKEVENT_SENDDONE);
1170
1171 xfr->sends--;
1172 xfrin_log(xfr, ISC_LOG_DEBUG(3), "sent request data");
1173 CHECK(sev->result);
1174
1175 CHECK(dns_tcpmsg_readmessage(&xfr->tcpmsg, xfr->task,
1176 xfrin_recv_done, xfr));
1177 xfr->recvs++;
1178 failure:
1179 isc_event_free(&event);
1180 if (result != ISC_R_SUCCESS)
1181 xfrin_fail(xfr, result, "failed sending request data");
1182 }
1183
1184
1185 static void
1186 xfrin_recv_done(isc_task_t *task, isc_event_t *ev) {
1187 dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) ev->ev_arg;
1188 isc_result_t result;
1189 dns_message_t *msg = NULL;
1190 dns_name_t *name;
1191 dns_tcpmsg_t *tcpmsg;
1192 dns_name_t *tsigowner = NULL;
1193
1194 REQUIRE(VALID_XFRIN(xfr));
1195
1196 UNUSED(task);
1197
1198 INSIST(ev->ev_type == DNS_EVENT_TCPMSG);
1199 tcpmsg = ev->ev_sender;
1200 isc_event_free(&ev);
1201
1202 xfr->recvs--;
1203 if (xfr->shuttingdown) {
1204 maybe_free(xfr);
1205 return;
1206 }
1207
1208 CHECK(tcpmsg->result);
1209
1210 xfrin_log(xfr, ISC_LOG_DEBUG(7), "received %u bytes",
1211 tcpmsg->buffer.used);
1212
1213 CHECK(isc_timer_touch(xfr->timer));
1214
1215 CHECK(dns_message_create(xfr->mctx, DNS_MESSAGE_INTENTPARSE, &msg));
1216
1217 CHECK(dns_message_settsigkey(msg, xfr->tsigkey));
1218 CHECK(dns_message_setquerytsig(msg, xfr->lasttsig));
1219
1220 msg->tsigctx = xfr->tsigctx;
1221 xfr->tsigctx = NULL;
1222
1223 if (xfr->nmsg > 0)
1224 msg->tcp_continuation = 1;
1225
1226 result = dns_message_parse(msg, &tcpmsg->buffer,
1227 DNS_MESSAGEPARSE_PRESERVEORDER);
1228
1229 if (result != ISC_R_SUCCESS || msg->rcode != dns_rcode_noerror ||
1230 (xfr->checkid && msg->id != xfr->id)) {
1231 if (result == ISC_R_SUCCESS)
1232 result = ISC_RESULTCLASS_DNSRCODE + msg->rcode; /*XXX*/
1233 if (result == ISC_R_SUCCESS || result == DNS_R_NOERROR)
1234 result = DNS_R_UNEXPECTEDID;
1235 if (xfr->reqtype == dns_rdatatype_axfr ||
1236 xfr->reqtype == dns_rdatatype_soa)
1237 FAIL(result);
1238 xfrin_log(xfr, ISC_LOG_DEBUG(3), "got %s, retrying with AXFR",
1239 isc_result_totext(result));
1240 try_axfr:
1241 dns_message_destroy(&msg);
1242 xfrin_reset(xfr);
1243 xfr->reqtype = dns_rdatatype_soa;
1244 xfr->state = XFRST_SOAQUERY;
1245 (void)xfrin_start(xfr);
1246 return;
1247 }
1248
1249 /*
1250 * Does the server know about IXFR? If it doesn't we will get
1251 * a message with a empty answer section or a potentially a CNAME /
1252 * DNAME, the later is handled by xfr_rr() which will return FORMERR
1253 * if the first RR in the answer section is not a SOA record.
1254 */
1255 if (xfr->reqtype == dns_rdatatype_ixfr &&
1256 xfr->state == XFRST_INITIALSOA &&
1257 msg->counts[DNS_SECTION_ANSWER] == 0) {
1258 xfrin_log(xfr, ISC_LOG_DEBUG(3),
1259 "empty answer section, retrying with AXFR");
1260 goto try_axfr;
1261 }
1262
1263 if (xfr->reqtype == dns_rdatatype_soa &&
1264 (msg->flags & DNS_MESSAGEFLAG_AA) == 0) {
1265 FAIL(DNS_R_NOTAUTHORITATIVE);
1266 }
1267
1268
1269 result = dns_message_checksig(msg, dns_zone_getview(xfr->zone));
1270 if (result != ISC_R_SUCCESS) {
1271 xfrin_log(xfr, ISC_LOG_DEBUG(3), "TSIG check failed: %s",
1272 isc_result_totext(result));
1273 FAIL(result);
1274 }
1275
1276 for (result = dns_message_firstname(msg, DNS_SECTION_ANSWER);
1277 result == ISC_R_SUCCESS;
1278 result = dns_message_nextname(msg, DNS_SECTION_ANSWER))
1279 {
1280 dns_rdataset_t *rds;
1281
1282 name = NULL;
1283 dns_message_currentname(msg, DNS_SECTION_ANSWER, &name);
1284 for (rds = ISC_LIST_HEAD(name->list);
1285 rds != NULL;
1286 rds = ISC_LIST_NEXT(rds, link))
1287 {
1288 for (result = dns_rdataset_first(rds);
1289 result == ISC_R_SUCCESS;
1290 result = dns_rdataset_next(rds))
1291 {
1292 dns_rdata_t rdata = DNS_RDATA_INIT;
1293 dns_rdataset_current(rds, &rdata);
1294 CHECK(xfr_rr(xfr, name, rds->ttl, &rdata));
1295 }
1296 }
1297 }
1298 if (result != ISC_R_NOMORE)
1299 goto failure;
1300
1301 if (dns_message_gettsig(msg, &tsigowner) != NULL) {
1302 /*
1303 * Reset the counter.
1304 */
1305 xfr->sincetsig = 0;
1306
1307 /*
1308 * Free the last tsig, if there is one.
1309 */
1310 if (xfr->lasttsig != NULL)
1311 isc_buffer_free(&xfr->lasttsig);
1312
1313 /*
1314 * Update the last tsig pointer.
1315 */
1316 CHECK(dns_message_getquerytsig(msg, xfr->mctx,
1317 &xfr->lasttsig));
1318
1319 } else if (dns_message_gettsigkey(msg) != NULL) {
1320 xfr->sincetsig++;
1321 if (xfr->sincetsig > 100 ||
1322 xfr->nmsg == 0 || xfr->state == XFRST_END)
1323 {
1324 result = DNS_R_EXPECTEDTSIG;
1325 goto failure;
1326 }
1327 }
1328
1329 /*
1330 * Update the number of messages received.
1331 */
1332 xfr->nmsg++;
1333
1334 /*
1335 * Update the number of bytes received.
1336 */
1337 xfr->nbytes += tcpmsg->buffer.used;
1338
1339 /*
1340 * Take the context back.
1341 */
1342 INSIST(xfr->tsigctx == NULL);
1343 xfr->tsigctx = msg->tsigctx;
1344 msg->tsigctx = NULL;
1345
1346 dns_message_destroy(&msg);
1347
1348 if (xfr->state == XFRST_GOTSOA) {
1349 xfr->reqtype = dns_rdatatype_axfr;
1350 xfr->state = XFRST_INITIALSOA;
1351 CHECK(xfrin_send_request(xfr));
1352 } else if (xfr->state == XFRST_END) {
1353 /*
1354 * Close the journal.
1355 */
1356 if (xfr->ixfr.journal != NULL)
1357 dns_journal_destroy(&xfr->ixfr.journal);
1358 /*
1359 * Inform the caller we succeeded.
1360 */
1361 if (xfr->done != NULL) {
1362 (xfr->done)(xfr->zone, ISC_R_SUCCESS);
1363 xfr->done = NULL;
1364 }
1365 /*
1366 * We should have no outstanding events at this
1367 * point, thus maybe_free() should succeed.
1368 */
1369 xfr->shuttingdown = ISC_TRUE;
1370 maybe_free(xfr);
1371 } else {
1372 /*
1373 * Read the next message.
1374 */
1375 CHECK(dns_tcpmsg_readmessage(&xfr->tcpmsg, xfr->task,
1376 xfrin_recv_done, xfr));
1377 xfr->recvs++;
1378 }
1379 return;
1380
1381 failure:
1382 if (msg != NULL)
1383 dns_message_destroy(&msg);
1384 if (result != ISC_R_SUCCESS)
1385 xfrin_fail(xfr, result, "failed while receiving responses");
1386 }
1387
1388 static void
1389 xfrin_timeout(isc_task_t *task, isc_event_t *event) {
1390 dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->ev_arg;
1391
1392 REQUIRE(VALID_XFRIN(xfr));
1393
1394 UNUSED(task);
1395
1396 isc_event_free(&event);
1397 /*
1398 * This will log "giving up: timeout".
1399 */
1400 xfrin_fail(xfr, ISC_R_TIMEDOUT, "giving up");
1401 }
1402
1403 static void
1404 maybe_free(dns_xfrin_ctx_t *xfr) {
1405 isc_uint64_t msecs;
1406 isc_uint64_t persec;
1407
1408 REQUIRE(VALID_XFRIN(xfr));
1409
1410 if (! xfr->shuttingdown || xfr->refcount != 0 ||
1411 xfr->connects != 0 || xfr->sends != 0 ||
1412 xfr->recvs != 0)
1413 return;
1414
1415 /*
1416 * Calculate the length of time the transfer took,
1417 * and print a log message with the bytes and rate.
1418 */
1419 isc_time_now(&xfr->end);
1420 msecs = isc_time_microdiff(&xfr->end, &xfr->start) / 1000;
1421 if (msecs == 0)
1422 msecs = 1;
1423 persec = (xfr->nbytes * 1000) / msecs;
1424 xfrin_log(xfr, ISC_LOG_INFO,
1425 "Transfer completed: %d messages, %d records, "
1426 "%" ISC_PRINT_QUADFORMAT "u bytes, "
1427 "%u.%03u secs (%u bytes/sec)",
1428 xfr->nmsg, xfr->nrecs, xfr->nbytes,
1429 (unsigned int) (msecs / 1000), (unsigned int) (msecs % 1000),
1430 (unsigned int) persec);
1431
1432 if (xfr->socket != NULL)
1433 isc_socket_detach(&xfr->socket);
1434
1435 if (xfr->timer != NULL)
1436 isc_timer_detach(&xfr->timer);
1437
1438 if (xfr->task != NULL)
1439 isc_task_detach(&xfr->task);
1440
1441 if (xfr->tsigkey != NULL)
1442 dns_tsigkey_detach(&xfr->tsigkey);
1443
1444 if (xfr->lasttsig != NULL)
1445 isc_buffer_free(&xfr->lasttsig);
1446
1447 dns_diff_clear(&xfr->diff);
1448
1449 if (xfr->ixfr.journal != NULL)
1450 dns_journal_destroy(&xfr->ixfr.journal);
1451
1452 if (xfr->axfr.add_private != NULL)
1453 (void)dns_db_endload(xfr->db, &xfr->axfr.add_private);
1454
1455 if (xfr->tcpmsg_valid)
1456 dns_tcpmsg_invalidate(&xfr->tcpmsg);
1457
1458 if (xfr->tsigctx != NULL)
1459 dst_context_destroy(&xfr->tsigctx);
1460
1461 if ((xfr->name.attributes & DNS_NAMEATTR_DYNAMIC) != 0)
1462 dns_name_free(&xfr->name, xfr->mctx);
1463
1464 if (xfr->ver != NULL)
1465 dns_db_closeversion(xfr->db, &xfr->ver, ISC_FALSE);
1466
1467 if (xfr->db != NULL)
1468 dns_db_detach(&xfr->db);
1469
1470 if (xfr->zone != NULL)
1471 dns_zone_idetach(&xfr->zone);
1472
1473 isc_mem_put(xfr->mctx, xfr, sizeof(*xfr));
1474 }
1475
1476 /*
1477 * Log incoming zone transfer messages in a format like
1478 * transfer of <zone> from <address>: <message>
1479 */
1480 static void
1481 xfrin_logv(int level, const char *zonetext, isc_sockaddr_t *masteraddr,
1482 const char *fmt, va_list ap)
1483 {
1484 char mastertext[ISC_SOCKADDR_FORMATSIZE];
1485 char msgtext[2048];
1486
1487 isc_sockaddr_format(masteraddr, mastertext, sizeof(mastertext));
1488 vsnprintf(msgtext, sizeof(msgtext), fmt, ap);
1489
1490 isc_log_write(dns_lctx, DNS_LOGCATEGORY_XFER_IN,
1491 DNS_LOGMODULE_XFER_IN, level,
1492 "transfer of '%s' from %s: %s",
1493 zonetext, mastertext, msgtext);
1494 }
1495
1496 /*
1497 * Logging function for use when a xfrin_ctx_t has not yet been created.
1498 */
1499
1500 static void
1501 xfrin_log1(int level, const char *zonetext, isc_sockaddr_t *masteraddr,
1502 const char *fmt, ...)
1503 {
1504 va_list ap;
1505
1506 if (isc_log_wouldlog(dns_lctx, level) == ISC_FALSE)
1507 return;
1508
1509 va_start(ap, fmt);
1510 xfrin_logv(level, zonetext, masteraddr, fmt, ap);
1511 va_end(ap);
1512 }
1513
1514 /*
1515 * Logging function for use when there is a xfrin_ctx_t.
1516 */
1517
1518 static void
1519 xfrin_log(dns_xfrin_ctx_t *xfr, int level, const char *fmt, ...)
1520 {
1521 va_list ap;
1522 char zonetext[DNS_NAME_MAXTEXT+32];
1523
1524 if (isc_log_wouldlog(dns_lctx, level) == ISC_FALSE)
1525 return;
1526
1527 dns_zone_name(xfr->zone, zonetext, sizeof(zonetext));
1528
1529 va_start(ap, fmt);
1530 xfrin_logv(level, zonetext, &xfr->masteraddr, fmt, ap);
1531 va_end(ap);
1532 }
DragonFly BSD