OpenDNSSEC-signer  1.4.3
xfrd.c
Go to the documentation of this file.
1 /*
2  * $Id: xfrd.c 4958 2011-04-18 07:11:09Z matthijs $
3  *
4  * Copyright (c) 2011 NLNet Labs. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditions and the following disclaimer in the
13  * documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
19  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
21  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
23  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
25  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  *
27  */
28 
34 #include "config.h"
35 #include "daemon/engine.h"
36 #include "daemon/xfrhandler.h"
37 #include "shared/duration.h"
38 #include "shared/file.h"
39 #include "shared/log.h"
40 #include "shared/status.h"
41 #include "shared/util.h"
42 #include "signer/domain.h"
43 #include "signer/zone.h"
44 #include "wire/tcpset.h"
45 #include "wire/xfrd.h"
46 
47 #include <unistd.h>
48 #include <fcntl.h>
49 
50 #define XFRD_TSIG_MAX_UNSIGNED 100
51 
52 static const char* xfrd_str = "xfrd";
53 
54 static void xfrd_handle_zone(netio_type* netio,
55  netio_handler_type* handler, netio_events_type event_types);
56 static void xfrd_make_request(xfrd_type* xfrd);
57 
58 static socklen_t xfrd_acl_sockaddr(acl_type* acl, unsigned int port,
59  struct sockaddr_storage *sck);
60 
61 static void xfrd_write_soa(xfrd_type* xfrd, buffer_type* buffer);
62 static int xfrd_parse_soa(xfrd_type* xfrd, buffer_type* buffer,
63  unsigned rdata_only, unsigned update, uint32_t t,
64  uint32_t* serial);
65 static ods_status xfrd_parse_rrs(xfrd_type* xfrd, buffer_type* buffer,
66  uint16_t count, int* done);
67 static xfrd_pkt_status xfrd_parse_packet(xfrd_type* xfrd,
68  buffer_type* buffer);
69 static xfrd_pkt_status xfrd_handle_packet(xfrd_type* xfrd,
70  buffer_type* buffer);
71 
72 static void xfrd_tcp_obtain(xfrd_type* xfrd, tcp_set_type* set);
73 static void xfrd_tcp_read(xfrd_type* xfrd, tcp_set_type* set);
74 static void xfrd_tcp_release(xfrd_type* xfrd, tcp_set_type* set);
75 static void xfrd_tcp_write(xfrd_type* xfrd, tcp_set_type* set);
76 static void xfrd_tcp_xfr(xfrd_type* xfrd, tcp_set_type* set);
77 static int xfrd_tcp_open(xfrd_type* xfrd, tcp_set_type* set);
78 
79 static void xfrd_udp_obtain(xfrd_type* xfrd);
80 static void xfrd_udp_read(xfrd_type* xfrd);
81 static void xfrd_udp_release(xfrd_type* xfrd);
82 static int xfrd_udp_read_packet(xfrd_type* xfrd);
83 static int xfrd_udp_send(xfrd_type* xfrd, buffer_type* buffer);
84 static int xfrd_udp_send_request_ixfr(xfrd_type* xfrd);
85 
86 static time_t xfrd_time(xfrd_type* xfrd);
87 static void xfrd_set_timer(xfrd_type* xfrd, time_t t);
88 static void xfrd_set_timer_time(xfrd_type* xfrd, time_t t);
89 static void xfrd_unset_timer(xfrd_type* xfrd);
90 
91 
96 xfrd_type*
97 xfrd_create(void* xfrhandler, void* zone)
98 {
99  xfrd_type* xfrd = NULL;
100  allocator_type* allocator = NULL;
101  if (!xfrhandler || !zone) {
102  return NULL;
103  }
104  allocator = allocator_create(malloc, free);
105  if (!allocator) {
106  ods_log_error("[%s] unable to create zone xfr structure: "
107  "allocator_create() failed", xfrd_str);
108  return NULL;
109  }
110  xfrd = (xfrd_type*) allocator_alloc(allocator, sizeof(xfrd_type));
111  if (!xfrd) {
112  ods_log_error("[%s] unable to create zone xfr structure: "
113  " allocator_alloc() failed", xfrd_str);
114  allocator_cleanup(allocator);
115  return NULL;
116  }
118  lock_basic_init(&xfrd->rw_lock);
119 
120  xfrd->allocator = allocator;
121  xfrd->xfrhandler = xfrhandler;
122  xfrd->zone = zone;
123  xfrd->tcp_conn = -1;
124  xfrd->round_num = -1;
125  xfrd->master_num = 0;
126  xfrd->next_master = -1;
127  xfrd->master = NULL;
129  xfrd->serial_xfr = 0;
130  xfrd->serial_disk = 0;
131  xfrd->serial_notify = 0;
132  xfrd->serial_xfr_acquired = 0;
133  xfrd->serial_disk_acquired = 0;
134  xfrd->serial_notify_acquired = 0;
136  xfrd->query_id = 0;
137  xfrd->msg_seq_nr = 0;
138  xfrd->msg_rr_count = 0;
139  xfrd->msg_old_serial = 0;
140  xfrd->msg_new_serial = 0;
141  xfrd->msg_is_ixfr = 0;
142  xfrd->udp_waiting = 0;
143  xfrd->udp_waiting_next = NULL;
144  xfrd->tcp_waiting = 0;
145  xfrd->tcp_waiting_next = NULL;
146  xfrd->tsig_rr = tsig_rr_create(allocator);
147  if (!xfrd->tsig_rr) {
148  xfrd_cleanup(xfrd);
149  return NULL;
150  }
151  xfrd->soa.ttl = 0;
152  xfrd->soa.mname[0] = 1;
153  xfrd->soa.rname[0] = 1;
154  xfrd->soa.serial = 0;
155  xfrd->soa.refresh = 3600;
156  xfrd->soa.retry = 300;
157  xfrd->soa.expire = 604800;
158  xfrd->soa.minimum = 3600;
159  xfrd->handler.fd = -1;
160  xfrd->handler.user_data = (void*) xfrd;
161  xfrd->handler.timeout = 0;
162  xfrd->handler.event_types =
164  xfrd->handler.event_handler = xfrd_handle_zone;
165  xfrd_set_timer_time(xfrd, 0);
166  return xfrd;
167 }
168 
169 
174 static time_t
175 xfrd_time(xfrd_type* xfrd)
176 {
177  ods_log_assert(xfrd);
178  ods_log_assert(xfrd->xfrhandler);
179  return xfrhandler_time((xfrhandler_type*) xfrd->xfrhandler);
180 }
181 
182 
187 static void
188 xfrd_set_timer(xfrd_type* xfrd, time_t t)
189 {
190  if (!xfrd || !xfrd->xfrhandler) {
191  return;
192  }
197  if(t > xfrd_time(xfrd) + 10) {
198  time_t extra = t - xfrd_time(xfrd);
199  time_t base = extra*9/10;
200  t = xfrd_time(xfrd) + base +
201  random()%(extra-base);
202  }
203  xfrd->handler.timeout = &xfrd->timeout;
204  xfrd->timeout.tv_sec = t;
205  xfrd->timeout.tv_nsec = 0;
206  return;
207 }
208 
209 
214 static void
215 xfrd_unset_timer(xfrd_type* xfrd)
216 {
217  ods_log_assert(xfrd);
218  xfrd->handler.timeout = NULL;
219  return;
220 }
221 
222 
227 static void
228 xfrd_set_timer_time(xfrd_type* xfrd, time_t t)
229 {
230  ods_log_assert(xfrd);
231  xfrd_set_timer(xfrd, xfrd_time(xfrd) + t);
232  return;
233 }
234 
235 
240 void
242 {
243  zone_type* zone = NULL;
244  if (!xfrd || !xfrd->zone || !xfrd->xfrhandler) {
245  return;
246  }
247  zone = (zone_type*) xfrd->zone;
248  ods_log_debug("[%s] zone %s sets timer timeout now", xfrd_str,
249  zone->name);
250  xfrd_set_timer_time(xfrd, 0);
251  return;
252 }
253 
254 
259 void
261 {
262  zone_type* zone = NULL;
263  if (!xfrd || !xfrd->zone || !xfrd->xfrhandler) {
264  return;
265  }
266  zone = (zone_type*) xfrd->zone;
267  ods_log_debug("[%s] zone %s sets timer timeout retry %u", xfrd_str,
268  zone->name, (unsigned) xfrd->soa.retry);
269  xfrd_set_timer_time(xfrd, xfrd->soa.retry);
270  return;
271 }
272 
273 
278 void
280 {
281  zone_type* zone = NULL;
282  if (!xfrd || !xfrd->zone || !xfrd->xfrhandler) {
283  return;
284  }
285  zone = (zone_type*) xfrd->zone;
286  ods_log_debug("[%s] zone %s sets timer timeout refresh %u", xfrd_str,
287  zone->name, (unsigned) xfrd->soa.refresh);
288  xfrd_set_timer_time(xfrd, xfrd->soa.refresh);
289  return;
290 }
291 
292 
297 static socklen_t
298 xfrd_acl_sockaddr(acl_type* acl, unsigned int port,
299  struct sockaddr_storage *sck)
300 {
301  ods_log_assert(acl);
302  ods_log_assert(sck);
303  ods_log_assert(port);
304  memset(sck, 0, sizeof(struct sockaddr_storage));
305  if (acl->family == AF_INET6) {
306  struct sockaddr_in6* sa = (struct sockaddr_in6*)sck;
307  sa->sin6_family = AF_INET6;
308  sa->sin6_port = htons(port);
309  sa->sin6_addr = acl->addr.addr6;
310  return sizeof(struct sockaddr_in6);
311  } else {
312  struct sockaddr_in* sa = (struct sockaddr_in*)sck;
313  sa->sin_family = AF_INET;
314  sa->sin_port = htons(port);
315  sa->sin_addr = acl->addr.addr;
316  return sizeof(struct sockaddr_in);
317  }
318  return 0;
319 }
320 
321 
326 socklen_t
327 xfrd_acl_sockaddr_to(acl_type* acl, struct sockaddr_storage *to)
328 {
329  unsigned int port = 0;
330  if (!acl || !to) {
331  return 0;
332  }
333  port = acl->port ? acl->port : (unsigned) atoi(DNS_PORT_STRING);
334  return xfrd_acl_sockaddr(acl, port, to);
335 }
336 
337 
342 static void
343 xfrd_tsig_sign(xfrd_type* xfrd, buffer_type* buffer)
344 {
345  tsig_algo_type* algo = NULL;
346  if (!xfrd || !xfrd->tsig_rr || !xfrd->master || !xfrd->master->tsig ||
347  !xfrd->master->tsig->key || !buffer) {
348  return; /* no tsig configured */
349  }
350  algo = tsig_lookup_algo(xfrd->master->tsig->algorithm);
351  if (!algo) {
352  ods_log_error("[%s] unable to sign request: tsig unknown algorithm "
353  "%s", xfrd_str, xfrd->master->tsig->algorithm);
354  return;
355  }
356  ods_log_assert(algo);
357  tsig_rr_reset(xfrd->tsig_rr, algo, xfrd->master->tsig->key);
358  xfrd->tsig_rr->original_query_id = buffer_pkt_id(buffer);
359  xfrd->tsig_rr->algo_name = ldns_rdf_clone(xfrd->tsig_rr->algo->wf_name);
360  xfrd->tsig_rr->key_name = ldns_rdf_clone(xfrd->tsig_rr->key->dname);
361  log_dname(xfrd->tsig_rr->key_name, "tsig sign query with key", LOG_DEBUG);
362  log_dname(xfrd->tsig_rr->algo_name, "tsig sign query with algorithm",
363  LOG_DEBUG);
364  tsig_rr_prepare(xfrd->tsig_rr);
365  tsig_rr_update(xfrd->tsig_rr, buffer, buffer_position(buffer));
366  tsig_rr_sign(xfrd->tsig_rr);
367  ods_log_debug("[%s] tsig append rr to request id=%u", xfrd_str,
368  buffer_pkt_id(buffer));
369  tsig_rr_append(xfrd->tsig_rr, buffer);
370  buffer_pkt_set_arcount(buffer, buffer_pkt_arcount(buffer)+1);
371  tsig_rr_prepare(xfrd->tsig_rr);
372  return;
373 }
374 
375 
380 static int
381 xfrd_tsig_process(xfrd_type* xfrd, buffer_type* buffer)
382 {
383  zone_type* zone = NULL;
384  int have_tsig = 0;
385  if (!xfrd || !xfrd->tsig_rr || !xfrd->master || !xfrd->master->tsig ||
386  !xfrd->master->tsig->key || !buffer) {
387  return 1; /* no tsig configured */
388  }
389  zone = (zone_type*) xfrd->zone;
390  ods_log_assert(zone);
391  ods_log_assert(zone->name);
392  ods_log_assert(xfrd->master->address);
393  if (!tsig_rr_find(xfrd->tsig_rr, buffer)) {
394  ods_log_error("[%s] unable to process tsig: xfr zone %s from %s "
395  "has malformed tsig rr", xfrd_str, zone->name,
396  xfrd->master->address);
397  return 0;
398  }
399  if (xfrd->tsig_rr->status == TSIG_OK) {
400  have_tsig = 1;
401  if (xfrd->tsig_rr->error_code != LDNS_RCODE_NOERROR) {
402  ods_log_error("[%s] zone %s, from %s has tsig error (%s)",
403  xfrd_str, zone->name, xfrd->master->address,
405  }
406  /* strip the TSIG resource record off... */
407  buffer_set_limit(buffer, xfrd->tsig_rr->position);
408  buffer_pkt_set_arcount(buffer, buffer_pkt_arcount(buffer)-1);
409  }
410  /* keep running the TSIG hash */
411  tsig_rr_update(xfrd->tsig_rr, buffer, buffer_limit(buffer));
412  if (have_tsig) {
413  if (!tsig_rr_verify(xfrd->tsig_rr)) {
414  ods_log_error("[%s] unable to process tsig: xfr zone %s from %s "
415  "has bad tsig signature", xfrd_str, zone->name,
416  xfrd->master->address);
417  return 0;
418  }
419  /* prepare for next tsigs */
420  tsig_rr_prepare(xfrd->tsig_rr);
421  } else if (xfrd->tsig_rr->update_since_last_prepare >
423  /* we allow a number of non-tsig signed packets */
424  ods_log_error("[%s] unable to process tsig: xfr zone %s, from %s "
425  "has too many consecutive packets without tsig", xfrd_str,
426  zone->name, xfrd->master->address);
427  return 0;
428  }
429  if (!have_tsig && xfrd->msg_seq_nr == 0) {
430  ods_log_error("[%s] unable to process tsig: xfr zone %s from %s "
431  "has no tsig in first packet of reply", xfrd_str,
432  zone->name, xfrd->master->address);
433  return 0;
434  }
435  /* process TSIG ok */
436  return 1;
437 }
438 
439 
444 static void
445 xfrd_commit_packet(xfrd_type* xfrd)
446 {
447  zone_type* zone = NULL;
448  char* xfrfile = NULL;
449  FILE* fd = NULL;
450  ods_log_assert(xfrd);
451  zone = (zone_type*) xfrd->zone;
452  xfrfile = ods_build_path(zone->name, ".xfrd", 0, 1);
453  if (!xfrfile) {
454  ods_log_crit("[%s] unable to commit xfr zone %s: build path failed",
455  xfrd_str, zone->name);
456  return;
457  }
458  ods_log_assert(zone);
459  ods_log_assert(zone->name);
460  lock_basic_lock(&zone->zone_lock);
461  lock_basic_lock(&xfrd->rw_lock);
463  /* mark end packet */
464  fd = ods_fopen(xfrfile, NULL, "a");
465  free((void*)xfrfile);
466  if (fd) {
467  fprintf(fd, ";;ENDPACKET\n");
468  ods_fclose(fd);
469  } else {
471  lock_basic_unlock(&xfrd->rw_lock);
473  ods_log_crit("[%s] unable to commit xfr zone %s: ods_fopen() failed "
474  "(%s)", xfrd_str, zone->name, strerror(errno));
475  return;
476  }
477  /* update soa serial management */
478  xfrd->serial_disk = xfrd->msg_new_serial;
479  xfrd->serial_disk_acquired = xfrd_time(xfrd);
480  xfrd->soa.serial = xfrd->serial_disk;
481  if (util_serial_gt(xfrd->serial_disk, xfrd->serial_xfr) &&
483  /* reschedule task */
484  int ret = 0;
485  xfrhandler_type* xfrhandler = (xfrhandler_type*) xfrd->xfrhandler;
486  engine_type* engine = (engine_type*) xfrhandler->engine;
487  ods_log_assert(xfrhandler);
488  ods_log_assert(engine);
489  ods_log_debug("[%s] reschedule task for zone %s: disk serial=%u "
490  "acquired=%u, memory serial=%u acquired=%u", xfrd_str,
491  zone->name, xfrd->serial_disk,
492  xfrd->serial_disk_acquired, xfrd->serial_xfr,
493  xfrd->serial_xfr_acquired);
494  ret = zone_reschedule_task(zone, engine->taskq, TASK_READ);
495  if (ret != ODS_STATUS_OK) {
496  ods_log_crit("[%s] unable to reschedule task for zone %s: %s",
497  xfrd_str, zone->name, ods_status2str(ret));
498  } else {
499  engine_wakeup_workers(engine);
500  }
501  }
503  lock_basic_unlock(&xfrd->rw_lock);
505  return;
506 }
507 
508 
513 static void
514 xfrd_dump_packet(xfrd_type* xfrd, buffer_type* buffer)
515 {
516  zone_type* zone = NULL;
517  char* xfrfile = NULL;
518  FILE* fd = NULL;
519  ldns_pkt* pkt = NULL;
520  ldns_status status = LDNS_STATUS_OK;
521  ods_log_assert(buffer);
522  ods_log_assert(xfrd);
523  zone = (zone_type*) xfrd->zone;
524  ods_log_assert(zone);
525  ods_log_assert(zone->name);
526  status = ldns_wire2pkt(&pkt, buffer_begin(buffer), buffer_limit(buffer));
527  if (status != LDNS_STATUS_OK) {
528  ods_log_crit("[%s] unable to dump packet zone %s: ldns_wire2pkt() "
529  "failed (%s)", xfrd_str, zone->name,
530  ldns_get_errorstr_by_id(status));
531  return;
532  }
533  ods_log_assert(pkt);
534  xfrfile = ods_build_path(zone->name, ".xfrd", 0, 1);
535  if (!xfrfile) {
536  ods_log_crit("[%s] unable to dump packet zone %s: build path failed",
537  xfrd_str, zone->name);
538  return;
539  }
540  lock_basic_lock(&xfrd->rw_lock);
541 
542  fd = ods_fopen(xfrfile, NULL, "a");
543  free((void*) xfrfile);
544  if (!fd) {
545  ods_log_crit("[%s] unable to dump packet zone %s: ods_fopen() failed "
546  "(%s)", xfrd_str, zone->name, strerror(errno));
547  lock_basic_unlock(&xfrd->rw_lock);
548  return;
549  }
550  ods_log_assert(fd);
551  if (xfrd->msg_seq_nr == 0) {
552  fprintf(fd, ";;BEGINPACKET\n");
553  }
554  ldns_rr_list_print(fd, ldns_pkt_answer(pkt));
555  ods_fclose(fd);
556  lock_basic_unlock(&xfrd->rw_lock);
557  ldns_pkt_free(pkt);
558  return;
559 }
560 
561 
566 static void
567 xfrd_write_soa(xfrd_type* xfrd, buffer_type* buffer)
568 {
569  zone_type* zone = NULL;
570  size_t rdlength_pos = 0;
571  uint16_t rdlength = 0;
572  ods_log_assert(xfrd);
573  ods_log_assert(buffer);
574  zone = (zone_type*) xfrd->zone;
575  ods_log_assert(zone);
576  ods_log_assert(zone->apex);
577  buffer_write_rdf(buffer, zone->apex);
578  buffer_write_u16(buffer, (uint16_t) LDNS_RR_TYPE_SOA);
579  buffer_write_u16(buffer, (uint16_t) zone->klass);
580  buffer_write_u32(buffer, xfrd->soa.ttl);
581  rdlength_pos = buffer_position(buffer);
582  buffer_skip(buffer, sizeof(rdlength));
583  buffer_write(buffer, xfrd->soa.mname+1, xfrd->soa.mname[0]);
584  buffer_write(buffer, xfrd->soa.rname+1, xfrd->soa.rname[0]);
585  buffer_write_u32(buffer, xfrd->soa.serial);
586  buffer_write_u32(buffer, xfrd->soa.refresh);
587  buffer_write_u32(buffer, xfrd->soa.retry);
588  buffer_write_u32(buffer, xfrd->soa.expire);
589  buffer_write_u32(buffer, xfrd->soa.minimum);
590  rdlength = buffer_position(buffer) - rdlength_pos - sizeof(rdlength);
591  buffer_write_u16_at(buffer, rdlength_pos, rdlength);
592  return;
593 }
594 
595 
600 static void
601 xfrd_update_soa(xfrd_type* xfrd, buffer_type* buffer, uint32_t ttl,
602  uint16_t mname_pos, uint16_t rname_pos,
603  uint32_t refresh, uint32_t retry, uint32_t expire, uint32_t minimum)
604 {
605  zone_type* zone = NULL;
606  ods_log_assert(xfrd);
607  ods_log_assert(buffer);
608  zone = (zone_type*) xfrd->zone;
609  ods_log_assert(zone);
610  ods_log_assert(zone->apex);
611  xfrd->soa.ttl = ttl;
612  xfrd->soa.refresh = refresh;
613  xfrd->soa.retry = retry;
614  xfrd->soa.expire = expire;
615  xfrd->soa.minimum = minimum;
616  buffer_set_position(buffer, mname_pos);
617  if (!(xfrd->soa.mname[0] =
618  buffer_read_dname(buffer, xfrd->soa.mname+1, 1))) {
619  xfrd->soa.mname[0] = 1;
620  xfrd->soa.mname[1] = 0;
621  }
622  buffer_set_position(buffer, rname_pos);
623  if (!(xfrd->soa.rname[0] =
624  buffer_read_dname(buffer, xfrd->soa.rname+1, 1))) {
625  xfrd->soa.rname[0] = 1;
626  xfrd->soa.rname[1] = 0;
627  }
628  return;
629 }
630 
631 
636 static int
637 xfrd_parse_soa(xfrd_type* xfrd, buffer_type* buffer, unsigned rdata_only,
638  unsigned update, uint32_t t, uint32_t* soa_serial)
639 {
640  ldns_rr_type type = LDNS_RR_TYPE_SOA;
641  uint16_t mname_pos = 0;
642  uint16_t rname_pos = 0;
643  uint16_t pos = 0;
644  uint32_t serial = 0;
645  uint32_t refresh = 0;
646  uint32_t retry = 0;
647  uint32_t expire = 0;
648  uint32_t minimum = 0;
649  uint32_t ttl = t;
650  ods_log_assert(xfrd);
651  ods_log_assert(buffer);
652 
653  /* type class ttl */
654  if (!rdata_only) {
655  if (!buffer_available(buffer, 10)) {
656  ods_log_debug("[%s] unable to parse soa: rr too short",
657  xfrd_str);
658  return 0;
659  }
660  type = (ldns_rr_type) buffer_read_u16(buffer);
661  if (type != LDNS_RR_TYPE_SOA) {
662  ods_log_debug("[%s] unable to parse soa: rrtype %u != soa",
663  xfrd_str, (unsigned) type);
664  return 0;
665  }
666  (void)buffer_read_u16(buffer); /* class */
667  ttl = buffer_read_u32(buffer);
668  /* rdata length */
669  if (!buffer_available(buffer, buffer_read_u16(buffer))) {
670  ods_log_debug("[%s] unable to parse soa: rdata too short",
671  xfrd_str);
672  return 0;
673  }
674  }
675  /* MNAME */
676  mname_pos = buffer_position(buffer);
677  if (!buffer_skip_dname(buffer)) {
678  ods_log_debug("[%s] unable to parse soa: bad mname",
679  xfrd_str);
680  return 0;
681  }
682  /* RNAME */
683  rname_pos = buffer_position(buffer);
684  if (!buffer_skip_dname(buffer)) {
685  ods_log_debug("[%s] unable to parse soa: bad rname",
686  xfrd_str);
687  return 0;
688  }
689  serial = buffer_read_u32(buffer);
690  refresh = buffer_read_u32(buffer);
691  retry = buffer_read_u32(buffer);
692  expire = buffer_read_u32(buffer);
693  minimum = buffer_read_u32(buffer);
694  pos = buffer_position(buffer);
695  if (soa_serial) {
696  *soa_serial = serial;
697  }
698  if (update) {
699  xfrd_update_soa(xfrd, buffer, ttl, mname_pos, rname_pos,
700  refresh, retry, expire, minimum);
701  }
702  buffer_set_position(buffer, pos);
703  return 1;
704 }
705 
706 
711 static ods_status
712 xfrd_parse_rrs(xfrd_type* xfrd, buffer_type* buffer, uint16_t count,
713  int* done)
714 {
715  ldns_rr_type type = 0;
716  uint16_t rrlen = 0;
717  uint32_t ttl = 0;
718  uint32_t serial = 0;
719  uint32_t tmp_serial = 0;
720  size_t i = 0;
721  ods_log_assert(xfrd);
722  ods_log_assert(buffer);
723  ods_log_assert(done);
724  for (i=0; i < count; ++i, ++xfrd->msg_rr_count) {
725  if (*done) {
726  return ODS_STATUS_OK;
727  }
728  if (!buffer_skip_dname(buffer)) {
729  return ODS_STATUS_SKIPDNAME;
730  }
731  if (!buffer_available(buffer, 10)) {
732  return ODS_STATUS_BUFAVAIL;
733  }
734  (void)buffer_position(buffer);
735  type = (ldns_rr_type) buffer_read_u16(buffer);
736  (void)buffer_read_u16(buffer); /* class */
737  ttl = buffer_read_u32(buffer);
738  rrlen = buffer_read_u16(buffer);
739  if (!buffer_available(buffer, rrlen)) {
740  return ODS_STATUS_BUFAVAIL;
741  }
742  if (type == LDNS_RR_TYPE_SOA) {
743  if (!xfrd_parse_soa(xfrd, buffer, 1, 0, ttl, &serial)) {
744  return ODS_STATUS_PARSESOA;
745  }
746  if (xfrd->msg_rr_count == 1 && serial != xfrd->msg_new_serial) {
747  /* 2nd RR is SOA with different serial, this is an IXFR */
748  xfrd->msg_is_ixfr = 1;
750  if (!xfrd->serial_disk_acquired) {
752  /* got IXFR but need AXFR */
753  return ODS_STATUS_REQAXFR;
754  }
755  if (serial != xfrd->serial_disk) {
757  /* bad start serial in IXFR */
758  return ODS_STATUS_INSERIAL;
759  }
761  xfrd->msg_old_serial = serial;
762  tmp_serial = serial;
763  } else if (serial == xfrd->msg_new_serial) {
764  /* saw another SOA of new serial. */
765  if (xfrd->msg_is_ixfr == 1) {
766  xfrd->msg_is_ixfr = 2; /* seen middle SOA in ixfr */
767  } else {
768  *done = 1; /* final axfr/ixfr soa */
769  }
770  } else if (xfrd->msg_is_ixfr) {
771  /* some additional checks */
772  if (util_serial_gt(serial, xfrd->msg_new_serial)) {
773  /* bad middle serial in IXFR (too high) */
774  return ODS_STATUS_INSERIAL;
775  }
776  if (util_serial_gt(tmp_serial, serial)) {
777  /* middle serial decreases in IXFR */
778  return ODS_STATUS_INSERIAL;
779  }
780  /* serial ok, update tmp serial */
781  tmp_serial = serial;
782  }
783  } else {
784  buffer_skip(buffer, rrlen);
785  }
786  }
787  return ODS_STATUS_OK;
788 }
789 
790 
795 static xfrd_pkt_status
796 xfrd_parse_packet(xfrd_type* xfrd, buffer_type* buffer)
797 {
798  zone_type* zone = NULL;
799  uint16_t qdcount = 0;
800  uint16_t ancount = 0;
801  uint16_t ancount_todo = 0;
802  uint16_t rrcount = 0;
803  uint32_t serial = 0;
804  int done = 0;
805  ods_status status = ODS_STATUS_OK;
806  ods_log_assert(buffer);
807  ods_log_assert(xfrd);
808  ods_log_assert(xfrd->master);
809  ods_log_assert(xfrd->master->address);
810  zone = (zone_type*) xfrd->zone;
811  ods_log_assert(zone);
812  ods_log_assert(zone->name);
813  /* check packet size */
815  ods_log_error("[%s] unable to parse packet: zone %s received bad "
816  "packet from %s (too small)", xfrd_str, zone->name,
817  xfrd->master->address);
818  return XFRD_PKT_BAD;
819  }
820  /* check query id */
821  if (buffer_pkt_id(buffer) != xfrd->query_id) {
822  ods_log_error("[%s] bad packet: zone %s received bad query id "
823  "%u from %s (expected %u)", xfrd_str, zone->name,
824  buffer_pkt_id(buffer), xfrd->master->address, xfrd->query_id);
825  return XFRD_PKT_BAD;
826  }
827  /* check rcode */
828  if (buffer_pkt_rcode(buffer) != LDNS_RCODE_NOERROR) {
829  ods_log_error("[%s] bad packet: zone %s received error code %s from %s",
830  xfrd_str, zone->name, ldns_pkt_rcode2str(buffer_pkt_rcode(buffer)),
831  xfrd->master->address);
832  if (buffer_pkt_rcode(buffer) == LDNS_RCODE_NOTIMPL) {
833  return XFRD_PKT_NOTIMPL;
834  } else if (buffer_pkt_rcode(buffer) != LDNS_RCODE_NOTAUTH) {
835  return XFRD_PKT_BAD;
836  }
837  }
838  /* check tsig */
839  if (!xfrd_tsig_process(xfrd, buffer)) {
840  ods_log_error("[%s] bad packet: zone %s received bad tsig "
841  "from %s", xfrd_str, zone->name, xfrd->master->address);
842  return XFRD_PKT_BAD;
843  }
844  /* skip header and question section */
846  qdcount = buffer_pkt_qdcount(buffer);
847  for (rrcount = 0; rrcount < qdcount; rrcount++) {
848  if (!buffer_skip_rr(buffer, 1)) {
849  ods_log_error("[%s] bad packet: zone %s received bad "
850  "question section from %s (bad rr)", xfrd_str, zone->name,
851  xfrd->master->address);
852  return XFRD_PKT_BAD;
853  }
854  }
855  /* answer section */
856  ancount = buffer_pkt_ancount(buffer);
857  if (xfrd->msg_rr_count == 0 && ancount == 0) {
858  if (xfrd->tcp_conn == -1 && buffer_pkt_tc(buffer)) {
859  ods_log_debug("[%s] zone %s received tc from %s, retry tcp",
860  xfrd_str, zone->name, xfrd->master->address);
861  return XFRD_PKT_TC;
862  }
863  ods_log_error("[%s] bad packet: zone %s received bad xfr packet "
864  "from %s (nodata)", xfrd_str, zone->name, xfrd->master->address);
865  return XFRD_PKT_BAD;
866  }
867 
868  ancount_todo = ancount;
869  if (xfrd->msg_rr_count == 0) {
870  /* parse the first RR, see if it is a SOA */
871  if (!buffer_skip_dname(buffer) ||
872  !xfrd_parse_soa(xfrd, buffer, 0, 1, 0, &serial)) {
873  ods_log_error("[%s] bad packet: zone %s received bad xfr "
874  "packet from %s (bad soa)", xfrd_str, zone->name,
875  xfrd->master->address);
876  return XFRD_PKT_BAD;
877  }
878  /* check serial */
880  if (xfrd->serial_disk_acquired && xfrd->serial_disk == serial) {
881  ods_log_debug("[%s] zone %s got update indicating current "
882  "serial %u from %s", xfrd_str, zone->name, serial,
883  xfrd->master->address);
884  xfrd->serial_disk_acquired = xfrd_time(xfrd);
885  if (xfrd->serial_xfr == serial) {
887  if (!xfrd->serial_notify_acquired) {
888  /* not notified or anything, so stop asking around */
889  xfrd->round_num = -1; /* next try start a new round */
891  ods_log_debug("[%s] zone %s wait refresh time", xfrd_str,
892  zone->name);
894  return XFRD_PKT_NEWLEASE;
895  }
896  /* try next master */
897  ods_log_debug("[%s] zone %s try next master", xfrd_str,
898  zone->name);
900  return XFRD_PKT_BAD;
901  }
902  }
903  if (xfrd->serial_disk_acquired &&
904  !util_serial_gt(serial, xfrd->serial_disk)) {
905  ods_log_debug("[%s] zone %s ignoring old serial %u from %s "
906  "(have %u)", xfrd_str, zone->name, serial,
907  xfrd->master->address, xfrd->serial_disk);
909  return XFRD_PKT_BAD;
910  }
911 
912  xfrd->msg_new_serial = serial;
913  if (xfrd->serial_disk_acquired) {
914  xfrd->msg_old_serial = xfrd->serial_disk;
915  } else {
916  xfrd->msg_old_serial = 0;
917  }
918  /* update notify serial if this xfr is newer */
919  if (ancount > 1 && xfrd->serial_notify_acquired &&
920  util_serial_gt(serial, xfrd->serial_notify)) {
921  xfrd->serial_notify = serial;
922  }
924  xfrd->msg_rr_count = 1;
925  xfrd->msg_is_ixfr = 0;
926  ancount_todo = ancount - 1;
927  }
928  /* check tc bit */
929  if (xfrd->tcp_conn == -1 && buffer_pkt_tc(buffer)) {
930  ods_log_debug("[%s] zone %s received tc from %s, retry tcp",
931  xfrd_str, zone->name, xfrd->master->address);
932  return XFRD_PKT_TC;
933  }
934  if (xfrd->tcp_conn == -1 && ancount < 2) {
935  /* too short to be a real ixfr/axfr data transfer */
936  ods_log_debug("[%s] zone %s received too short udp reply from %s, "
937  "retry tcp", xfrd_str, zone->name, xfrd->master->address);
938  return XFRD_PKT_TC;
939  }
940  status = xfrd_parse_rrs(xfrd, buffer, ancount_todo, &done);
941  if (status != ODS_STATUS_OK) {
942  ods_log_error("[%s] bad packet: zone %s received bad xfr packet "
943  "from %s (%s)", xfrd_str, zone->name, xfrd->master->address,
944  ods_status2str(status));
945  return XFRD_PKT_BAD;
946  }
947  if (xfrd->tcp_conn == -1 && !done) {
948  ods_log_error("[%s] bad packet: zone %s received bad xfr packet "
949  "(xfr over udp incomplete)", xfrd_str, zone->name,
950  xfrd->master->address);
951  return XFRD_PKT_BAD;
952  }
953  if (!done) {
954  return XFRD_PKT_MORE;
955  }
956  return XFRD_PKT_XFR;
957 }
958 
959 
964 static xfrd_pkt_status
965 xfrd_handle_packet(xfrd_type* xfrd, buffer_type* buffer)
966 {
968  zone_type* zone = NULL;
969  ods_log_assert(xfrd);
970  ods_log_assert(xfrd->master);
971  ods_log_assert(xfrd->master->address);
972  zone = (zone_type*) xfrd->zone;
973  ods_log_assert(zone);
974  ods_log_assert(zone->name);
975  res = xfrd_parse_packet(xfrd, buffer);
976  ods_log_debug("[%s] zone %s xfr packet parsed (res %d)", xfrd_str, zone->name, res);
977 
978  switch (res) {
979  case XFRD_PKT_MORE:
980  case XFRD_PKT_XFR:
981  /* continue with commit */
982  break;
983  case XFRD_PKT_NEWLEASE:
984  case XFRD_PKT_TC:
985  return res;
986  break;
987  case XFRD_PKT_NOTIMPL:
988  case XFRD_PKT_BAD:
989  default:
990  /* rollback */
991  if (xfrd->msg_seq_nr > 0) {
992  buffer_clear(buffer);
993  ods_log_info("[%s] zone %s xfr rollback", xfrd_str,
994  zone->name);
995  buffer_flip(buffer);
996  }
997  return res;
998  break;
999  }
1000  /* dump reply on disk to diff file */
1001  xfrd_dump_packet(xfrd, buffer);
1002  /* more? */
1003  xfrd->msg_seq_nr++;
1004  if (res == XFRD_PKT_MORE) {
1005  /* wait for more */
1006  return XFRD_PKT_MORE;
1007  }
1008  /* done */
1009  buffer_clear(buffer);
1010  buffer_flip(buffer);
1011  /* commit packet */
1012  xfrd_commit_packet(xfrd);
1013  /* next time */
1014  lock_basic_lock(&xfrd->serial_lock);
1015 
1016  ods_log_debug("[%s] zone %s notify acquired %u, serial on disk %u, "
1017  "notify serial %u", xfrd_str, zone->name,
1018  xfrd->serial_notify_acquired, xfrd->serial_disk,
1019  xfrd->serial_notify);
1020 
1021  if (xfrd->serial_notify_acquired &&
1022  !util_serial_gt(xfrd->serial_notify, xfrd->serial_disk)) {
1023  ods_log_debug("[%s] zone %s reset notify acquired", xfrd_str,
1024  zone->name);
1025  xfrd->serial_notify_acquired = 0;
1026  }
1027  if (!xfrd->serial_notify_acquired) {
1028  ods_log_debug("[%s] zone %s xfr done", xfrd_str, zone->name);
1029  xfrd->round_num = -1; /* next try start anew */
1030  xfrd_set_timer_refresh(xfrd);
1032  return XFRD_PKT_XFR;
1033  }
1035  /* try to get an even newer serial */
1036  ods_log_debug("[%s] zone %s get newer serial", xfrd_str, zone->name);
1037  return XFRD_PKT_BAD;
1038 }
1039 
1040 
1048 static void
1049 xfrd_tcp_write(xfrd_type* xfrd, tcp_set_type* set)
1050 {
1051  zone_type* zone = NULL;
1052  tcp_conn_type* tcp = NULL;
1053  int ret = 0;
1054  int error = 0;
1055  socklen_t len = 0;
1056 
1057  ods_log_assert(set);
1058  ods_log_assert(xfrd);
1059  ods_log_assert(xfrd->tcp_conn != -1);
1060  zone = (zone_type*) xfrd->zone;
1061  ods_log_assert(zone);
1062  ods_log_assert(zone->name);
1063  tcp = set->tcp_conn[xfrd->tcp_conn];
1064  if (tcp->total_bytes == 0) {
1065  /* check for pending error from nonblocking connect */
1066  /* from Stevens, unix network programming, vol1, 3rd ed, p450 */
1067  len = sizeof(error);
1068  if (getsockopt(tcp->fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
1069  error = errno; /* on solaris errno is error */
1070  }
1071  if (error == EINPROGRESS || error == EWOULDBLOCK) {
1072  ods_log_debug("[%s] zone %s zero write, write again later (%s)",
1073  xfrd_str, zone->name, strerror(error));
1074  return; /* try again later */
1075  }
1076  if (error != 0) {
1077  ods_log_error("[%s] zone %s cannot tcp connect to %s: %s",
1078  xfrd_str, zone->name, xfrd->master->address, strerror(errno));
1079  xfrd_set_timer_now(xfrd);
1080  xfrd_tcp_release(xfrd, set);
1081  return;
1082  }
1083  }
1084  ret = tcp_conn_write(tcp);
1085  if(ret == -1) {
1086  ods_log_error("[%s] zone %s cannot tcp write to %s: %s",
1087  xfrd_str, zone->name, xfrd->master->address, strerror(errno));
1088  xfrd_set_timer_now(xfrd);
1089  xfrd_tcp_release(xfrd, set);
1090  return;
1091  }
1092  if (ret == 0) {
1093  ods_log_debug("[%s] zone %s zero write, write again later",
1094  xfrd_str, zone->name);
1095  return; /* write again later */
1096  }
1097  /* done writing, get ready for reading */
1098  ods_log_debug("[%s] zone %s done writing, get ready for reading",
1099  xfrd_str, zone->name);
1100  tcp->is_reading = 1;
1101  tcp_conn_ready(tcp);
1103  xfrd_tcp_read(xfrd, set);
1104  return;
1105 }
1106 
1107 
1112 static int
1113 xfrd_tcp_open(xfrd_type* xfrd, tcp_set_type* set)
1114 {
1115  int fd, family, conn;
1116  struct sockaddr_storage to;
1117  socklen_t to_len;
1118  zone_type* zone = NULL;
1119 
1120  ods_log_assert(set);
1121  ods_log_assert(xfrd);
1122  ods_log_assert(xfrd->tcp_conn != -1);
1123  ods_log_assert(xfrd->master);
1124  ods_log_assert(xfrd->master->address);
1125  zone = (zone_type*) xfrd->zone;
1126  ods_log_assert(zone);
1127  ods_log_assert(zone->name);
1128  ods_log_debug("[%s] zone %s open tcp connection to %s", xfrd_str,
1129  zone->name, xfrd->master->address);
1130  set->tcp_conn[xfrd->tcp_conn]->is_reading = 0;
1131  set->tcp_conn[xfrd->tcp_conn]->total_bytes = 0;
1132  set->tcp_conn[xfrd->tcp_conn]->msglen = 0;
1133  if (xfrd->master->family == AF_INET6) {
1134  family = PF_INET6;
1135  } else {
1136  family = PF_INET;
1137  }
1138  fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
1139  set->tcp_conn[xfrd->tcp_conn]->fd = fd;
1140  if (fd == -1) {
1141  ods_log_error("[%s] zone %s cannot create tcp socket to %s: %s",
1142  xfrd_str, zone->name, xfrd->master->address, strerror(errno));
1143  xfrd_set_timer_now(xfrd);
1144  xfrd_tcp_release(xfrd, set);
1145  return 0;
1146  }
1147  if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
1148  ods_log_error("[%s] zone %s cannot fcntl tcp socket to %s: %s",
1149  xfrd_str, zone->name, xfrd->master->address, strerror(errno));
1150  xfrd_set_timer_now(xfrd);
1151  xfrd_tcp_release(xfrd, set);
1152  return 0;
1153  }
1154  to_len = xfrd_acl_sockaddr_to(xfrd->master, &to);
1155  /* bind it? */
1156 
1157  conn = connect(fd, (struct sockaddr*)&to, to_len);
1158  if (conn == -1 && errno != EINPROGRESS) {
1159  ods_log_error("[%s] zone %s cannot connect tcp socket to %s: %s",
1160  xfrd_str, zone->name, xfrd->master->address, strerror(errno));
1161  xfrd_set_timer_now(xfrd);
1162  xfrd_tcp_release(xfrd, set);
1163  return 0;
1164  }
1165  xfrd->handler.fd = fd;
1167  xfrd_set_timer(xfrd, xfrd_time(xfrd) + XFRD_TCP_TIMEOUT);
1168  return 1;
1169 }
1170 
1171 
1176 static void
1177 xfrd_tcp_obtain(xfrd_type* xfrd, tcp_set_type* set)
1178 {
1179  int i = 0;
1180 
1181  ods_log_assert(set);
1182  ods_log_assert(xfrd);
1183  ods_log_assert(xfrd->tcp_conn == -1);
1184  ods_log_assert(xfrd->tcp_waiting == 0);
1185  if (set->tcp_count < TCPSET_MAX) {
1187  set->tcp_count ++;
1188  /* find a free tcp_buffer */
1189  for (i=0; i < TCPSET_MAX; i++) {
1190  if (set->tcp_conn[i]->fd == -1) {
1191  xfrd->tcp_conn = i;
1192  break;
1193  }
1194  }
1195  ods_log_assert(xfrd->tcp_conn != -1);
1196  xfrd->tcp_waiting = 0;
1197  /* stop udp use (if any) */
1198  if (xfrd->handler.fd != -1) {
1199  xfrd_udp_release(xfrd);
1200  }
1201  if (!xfrd_tcp_open(xfrd, set)) {
1202  return;
1203  }
1204  xfrd_tcp_xfr(xfrd, set);
1205  return;
1206  }
1207  /* wait, at end of line */
1208  ods_log_verbose("[%s] max number of tcp connections (%d) reached",
1209  xfrd_str, TCPSET_MAX);
1210  xfrd->tcp_waiting = 1;
1211  xfrd_unset_timer(xfrd);
1212  return;
1213 }
1214 
1215 
1220 static void
1221 xfrd_tcp_xfr(xfrd_type* xfrd, tcp_set_type* set)
1222 {
1223  tcp_conn_type* tcp = NULL;
1224  zone_type* zone = NULL;
1225 
1226  ods_log_assert(set);
1227  ods_log_assert(xfrd);
1228  zone = (zone_type*) xfrd->zone;
1229  ods_log_assert(zone);
1230  ods_log_assert(zone->name);
1231  ods_log_assert(xfrd->tcp_conn != -1);
1232  ods_log_assert(xfrd->tcp_waiting == 0);
1233  ods_log_assert(xfrd->master);
1234  ods_log_assert(xfrd->master->address);
1235  /* start AXFR or IXFR for the zone */
1236  tcp = set->tcp_conn[xfrd->tcp_conn];
1237 
1238  if (xfrd->serial_xfr_acquired <= 0 || xfrd->master->ixfr_disabled) {
1239  ods_log_debug("[%s] zone %s request axfr to %s", xfrd_str,
1240  zone->name, xfrd->master->address);
1241  buffer_pkt_query(tcp->packet, zone->apex, LDNS_RR_TYPE_AXFR,
1242  zone->klass);
1243  } else {
1244  ods_log_debug("[%s] zone %s request ixfr to %s", xfrd_str,
1245  zone->name, xfrd->master->address);
1246  buffer_pkt_query(tcp->packet, zone->apex, LDNS_RR_TYPE_IXFR,
1247  zone->klass);
1248  buffer_pkt_set_nscount(tcp->packet, 1);
1249  xfrd_write_soa(xfrd, tcp->packet);
1250  }
1251  /* make packet */
1252  xfrd->query_id = buffer_pkt_id(tcp->packet);
1253  xfrd->msg_seq_nr = 0;
1254  xfrd->msg_rr_count = 0;
1255  xfrd->msg_old_serial = 0;
1256  xfrd->msg_new_serial = 0;
1257  xfrd->msg_is_ixfr = 0;
1258  xfrd_tsig_sign(xfrd, tcp->packet);
1259  buffer_flip(tcp->packet);
1260  tcp->msglen = buffer_limit(tcp->packet);
1261  ods_log_debug("[%s] zone %s sending tcp query id=%d", xfrd_str,
1262  zone->name, xfrd->query_id);
1263  /* wait for select to complete connect before write */
1264  return;
1265 }
1266 
1267 
1272 static void
1273 xfrd_tcp_read(xfrd_type* xfrd, tcp_set_type* set)
1274 {
1275  tcp_conn_type* tcp = NULL;
1276  int ret = 0;
1277 
1278  ods_log_assert(set);
1279  ods_log_assert(xfrd);
1280  ods_log_assert(xfrd->tcp_conn != -1);
1281  tcp = set->tcp_conn[xfrd->tcp_conn];
1282  ret = tcp_conn_read(tcp);
1283  if (ret == -1) {
1284  xfrd_set_timer_now(xfrd);
1285  xfrd_tcp_release(xfrd, set);
1286  return;
1287  }
1288  if (ret == 0) {
1289  return;
1290  }
1291  /* completed msg */
1292  buffer_flip(tcp->packet);
1293  ret = xfrd_handle_packet(xfrd, tcp->packet);
1294  switch (ret) {
1295  case XFRD_PKT_MORE:
1296  tcp_conn_ready(tcp);
1297  break;
1298  case XFRD_PKT_XFR:
1299  case XFRD_PKT_NEWLEASE:
1300  ods_log_debug("[%s] tcp read %s: release connection", xfrd_str,
1301  XFRD_PKT_XFR?"xfr":"newlease");
1302  xfrd_tcp_release(xfrd, set);
1303  ods_log_assert(xfrd->round_num == -1);
1304  break;
1305  case XFRD_PKT_NOTIMPL:
1306  xfrd->master->ixfr_disabled = time_now();
1307  ods_log_debug("[%s] disable ixfr requests for %s from now (%u)",
1308  xfrd_str, xfrd->master->address, xfrd->master->ixfr_disabled);
1309  /* break; */
1310  case XFRD_PKT_BAD:
1311  default:
1312  ods_log_debug("[%s] tcp read %s: release connection", xfrd_str,
1313  ret==XFRD_PKT_BAD?"bad":"notimpl");
1314  xfrd_tcp_release(xfrd, set);
1315  xfrd_make_request(xfrd);
1316  break;
1317  }
1318  return;
1319 }
1320 
1321 
1326 static void
1327 xfrd_tcp_release(xfrd_type* xfrd, tcp_set_type* set)
1328 {
1329  int conn = 0;
1330  zone_type* zone = NULL;
1331 
1332  ods_log_assert(set);
1333  ods_log_assert(xfrd);
1334  ods_log_assert(xfrd->master);
1335  ods_log_assert(xfrd->master->address);
1336  ods_log_assert(xfrd->tcp_conn != -1);
1337  ods_log_assert(xfrd->tcp_waiting == 0);
1338  zone = (zone_type*) xfrd->zone;
1339  ods_log_debug("[%s] zone %s release tcp connection to %s", xfrd_str,
1340  zone->name, xfrd->master->address);
1341  conn = xfrd->tcp_conn;
1342  xfrd->tcp_conn = -1;
1343  xfrd->tcp_waiting = 0;
1344  xfrd->handler.fd = -1;
1346 
1347  if (set->tcp_conn[conn]->fd != -1) {
1348  close(set->tcp_conn[conn]->fd);
1349  }
1350  set->tcp_conn[conn]->fd = -1;
1351  set->tcp_count --;
1352  return;
1353 }
1354 
1355 
1363 static int
1364 xfrd_udp_send(xfrd_type* xfrd, buffer_type* buffer)
1365 {
1366  struct sockaddr_storage to;
1367  socklen_t to_len = 0;
1368  int fd = -1;
1369  int family = PF_INET;
1370  ssize_t nb = -1;
1371  ods_log_assert(buffer);
1372  ods_log_assert(xfrd);
1373  ods_log_assert(xfrd->master);
1374  ods_log_assert(xfrd->master->address);
1375  /* this will set the remote port to acl->port or TCP_PORT */
1376  to_len = xfrd_acl_sockaddr_to(xfrd->master, &to);
1377  /* get the address family of the remote host */
1378  if (xfrd->master->family == AF_INET6) {
1379  family = PF_INET6;
1380  }
1381  /* create socket */
1382  fd = socket(family, SOCK_DGRAM, IPPROTO_UDP);
1383  if (fd == -1) {
1384  ods_log_error("[%s] unable to send data over udp to %s: "
1385  "socket() failed (%s)", xfrd_str, xfrd->master->address,
1386  strerror(errno));
1387  return -1;
1388  }
1389  /* bind it? */
1390 
1391  /* send it (udp) */
1392  ods_log_deeebug("[%s] send %d bytes over udp to %s", xfrd_str,
1393  buffer_remaining(buffer), xfrd->master->address);
1394  nb = sendto(fd, buffer_current(buffer), buffer_remaining(buffer), 0,
1395  (struct sockaddr*)&to, to_len);
1396  if (nb == -1) {
1397  ods_log_error("[%s] unable to send data over udp to %s: "
1398  "sendto() failed (%s)", xfrd_str, xfrd->master->address,
1399  strerror(errno));
1400  close(fd);
1401  return -1;
1402  }
1403  return fd;
1404 }
1405 
1406 
1411 static int
1412 xfrd_udp_send_request_ixfr(xfrd_type* xfrd)
1413 {
1414  int fd;
1415  xfrhandler_type* xfrhandler = NULL;
1416  zone_type* zone = NULL;
1417  ods_log_assert(xfrd);
1418  ods_log_assert(xfrd->master);
1419  ods_log_assert(xfrd->master->address);
1420  zone = (zone_type*) xfrd->zone;
1421  ods_log_assert(zone);
1422  ods_log_assert(zone->name);
1423  if (xfrd->tcp_conn != -1) {
1424  /* tcp is using the handler.fd */
1425  ods_log_error("[%s] unable to transfer zone %s: tried to send "
1426  "udp while tcp obtained", xfrd_str, zone->name);
1427  return -1;
1428  }
1429  /* make packet */
1430  xfrhandler = (xfrhandler_type*) xfrd->xfrhandler;
1431  ods_log_assert(xfrhandler);
1432  buffer_pkt_query(xfrhandler->packet, zone->apex, LDNS_RR_TYPE_IXFR,
1433  zone->klass);
1434  xfrd->query_id = buffer_pkt_id(xfrhandler->packet);
1435  xfrd->msg_seq_nr = 0;
1436  xfrd->msg_rr_count = 0;
1437  xfrd->msg_old_serial = 0;
1438  xfrd->msg_new_serial = 0;
1439  xfrd->msg_is_ixfr = 0;
1440  buffer_pkt_set_nscount(xfrhandler->packet, 1);
1441  xfrd_write_soa(xfrd, xfrhandler->packet);
1442  xfrd_tsig_sign(xfrd, xfrhandler->packet);
1443  buffer_flip(xfrhandler->packet);
1444  xfrd_set_timer(xfrd, xfrd_time(xfrd) + XFRD_UDP_TIMEOUT);
1445  ods_log_debug("[%s] zone %s sending udp query id=%d qtype=IXFR to %s",
1446  xfrd_str, zone->name, xfrd->query_id, xfrd->master->address);
1447  if((fd = xfrd_udp_send(xfrd, xfrhandler->packet)) == -1) {
1448  return -1;
1449  }
1450  return fd;
1451 }
1452 
1457 static void
1458 xfrd_udp_obtain(xfrd_type* xfrd)
1459 {
1460  xfrhandler_type* xfrhandler = NULL;
1461  ods_log_assert(xfrd);
1462  ods_log_assert(xfrd->xfrhandler);
1463  ods_log_assert(xfrd->udp_waiting == 0);
1464  xfrhandler = (void*) xfrd->xfrhandler;
1465  if (xfrd->tcp_conn != -1) {
1466  /* no tcp and udp at the same time */
1467  xfrd_tcp_release(xfrd, xfrhandler->tcp_set);
1468  }
1469  if (xfrhandler->udp_use_num < XFRD_MAX_UDP) {
1470  xfrhandler->udp_use_num++;
1471  xfrd->handler.fd = xfrd_udp_send_request_ixfr(xfrd);
1472  if (xfrd->handler.fd == -1) {
1473  xfrhandler->udp_use_num--;
1474  }
1475  return;
1476  }
1477  /* queue the zone as last */
1478  xfrd->udp_waiting = 1;
1479  xfrd->udp_waiting_next = NULL;
1480  if (!xfrhandler->udp_waiting_first) {
1481  xfrhandler->udp_waiting_first = xfrd;
1482  }
1483  if (xfrhandler->udp_waiting_last) {
1484  xfrhandler->udp_waiting_last->udp_waiting_next = xfrd;
1485  }
1486  xfrhandler->udp_waiting_last = xfrd;
1487  xfrd_unset_timer(xfrd);
1488  return;
1489 }
1490 
1491 
1496 static int
1497 xfrd_udp_read_packet(xfrd_type* xfrd)
1498 {
1499  xfrhandler_type* xfrhandler = NULL;
1500  ssize_t received = 0;
1501  ods_log_assert(xfrd);
1502  xfrhandler = (xfrhandler_type*) xfrd->xfrhandler;
1503  ods_log_assert(xfrhandler);
1504  /* read the data */
1505  buffer_clear(xfrhandler->packet);
1506  received = recvfrom(xfrd->handler.fd, buffer_begin(xfrhandler->packet),
1507  buffer_remaining(xfrhandler->packet), 0, NULL, NULL);
1508  if (received == -1) {
1509  ods_log_error("[%s] unable to read packet: recvfrom() failed fd %d "
1510  "(%s)", xfrd_str, xfrd->handler.fd, strerror(errno));
1511  return 0;
1512  }
1513  buffer_set_limit(xfrhandler->packet, received);
1514  return 1;
1515 }
1516 
1517 
1522 static void
1523 xfrd_udp_read(xfrd_type* xfrd)
1524 {
1525  xfrhandler_type* xfrhandler = NULL;
1526  zone_type* zone = NULL;
1528  ods_log_assert(xfrd);
1529  zone = (zone_type*) xfrd->zone;
1530  ods_log_assert(zone);
1531  ods_log_assert(zone->name);
1532  ods_log_debug("[%s] zone %s read data from udp", xfrd_str,
1533  zone->name);
1534  if (!xfrd_udp_read_packet(xfrd)) {
1535  ods_log_error("[%s] unable to read data from udp zone %s: "
1536  "xfrd_udp_read_packet() failed", xfrd_str, zone->name);
1537  xfrd_udp_release(xfrd);
1538  return;
1539  }
1540  xfrhandler = (xfrhandler_type*) xfrd->xfrhandler;
1541  ods_log_assert(xfrhandler);
1542  res = xfrd_handle_packet(xfrd, xfrhandler->packet);
1543  switch (res) {
1544  case XFRD_PKT_TC:
1545  ods_log_debug("[%s] truncation from %s",
1546  xfrd_str, xfrd->master->address);
1547  xfrd_udp_release(xfrd);
1548  xfrd_set_timer(xfrd, xfrd_time(xfrd) + XFRD_TCP_TIMEOUT);
1549  xfrd_tcp_obtain(xfrd, xfrhandler->tcp_set);
1550  break;
1551  case XFRD_PKT_XFR:
1552  case XFRD_PKT_NEWLEASE:
1553  ods_log_debug("[%s] xfr/newlease from %s",
1554  xfrd_str, xfrd->master->address);
1555  /* nothing more to do */
1556  ods_log_assert(xfrd->round_num == -1);
1557  xfrd_udp_release(xfrd);
1558  break;
1559  case XFRD_PKT_NOTIMPL:
1560  xfrd->master->ixfr_disabled = time_now();
1561  ods_log_debug("[%s] disable ixfr requests for %s from now (%u)",
1562  xfrd_str, xfrd->master->address, xfrd->master->ixfr_disabled);
1563  /* break; */
1564  case XFRD_PKT_BAD:
1565  default:
1566  ods_log_debug("[%s] bad ixfr packet from %s",
1567  xfrd_str, xfrd->master->address);
1568  xfrd_udp_release(xfrd);
1569  xfrd_make_request(xfrd);
1570  break;
1571  }
1572  return;
1573 }
1574 
1575 
1580 static void
1581 xfrd_udp_release(xfrd_type* xfrd)
1582 {
1583  xfrhandler_type* xfrhandler = NULL;
1584 
1585  ods_log_assert(xfrd);
1586  ods_log_assert(xfrd->udp_waiting == 0);
1587  if(xfrd->handler.fd != -1)
1588  close(xfrd->handler.fd);
1589  xfrd->handler.fd = -1;
1590  xfrhandler = (xfrhandler_type*) xfrd->xfrhandler;
1591  ods_log_assert(xfrhandler);
1592  /* see if there are waiting zones */
1593  if (xfrhandler->udp_use_num == XFRD_MAX_UDP) {
1594  while (xfrhandler->udp_waiting_first) {
1595  /* snip off waiting list */
1596  xfrd_type* wf = xfrhandler->udp_waiting_first;
1598  wf->udp_waiting = 0;
1599  xfrhandler->udp_waiting_first = wf->udp_waiting_next;
1600  if (xfrhandler->udp_waiting_last == wf) {
1601  xfrhandler->udp_waiting_last = NULL;
1602  }
1603  /* see if this zone needs udp connection */
1604  if (wf->tcp_conn == -1) {
1605  wf->handler.fd = xfrd_udp_send_request_ixfr(wf);
1606  if (wf->handler.fd != -1) {
1607  return;
1608  }
1609  }
1610  }
1611  }
1612  /* no waiting zones */
1613  if (xfrhandler->udp_use_num > 0) {
1614  xfrhandler->udp_use_num --;
1615  }
1616  return;
1617 }
1618 
1619 
1624 static void
1625 xfrd_make_request(xfrd_type* xfrd)
1626 {
1627  zone_type* zone = NULL;
1628  dnsin_type* dnsin = NULL;
1629  if (!xfrd || !xfrd->xfrhandler) {
1630  return;
1631  }
1632  zone = (zone_type*) xfrd->zone;
1633  ods_log_assert(zone);
1634  ods_log_assert(zone->name);
1635  ods_log_assert(zone->adinbound);
1638 
1639  dnsin = (dnsin_type*) zone->adinbound->config;
1640  if (xfrd->next_master != -1) {
1641  /* we are told to use this next master */
1642  xfrd->master_num = xfrd->next_master;
1643  xfrd->master = NULL; /* acl_find_num(...) */
1644  /* if there is no next master, fallback to use the first one */
1645  if (!xfrd->master) {
1646  xfrd->master = dnsin->request_xfr;
1647  xfrd->master_num = 0;
1648  }
1649  /* fallback to cycle master */
1650  xfrd->next_master = -1;
1651  xfrd->round_num = 0; /* fresh set of retries after notify */
1652  } else {
1653  /* cycle master */
1654  if (xfrd->round_num != -1 && xfrd->master &&
1655  xfrd->master->next) {
1656  /* try the next master */
1657  xfrd->master = xfrd->master->next;
1658  xfrd->master_num++;
1659  } else {
1660  /* start a new round */
1661  xfrd->master = dnsin->request_xfr;
1662  xfrd->master_num = 0;
1663  xfrd->round_num++;
1664  }
1665  if (xfrd->round_num >= XFRD_MAX_ROUNDS) {
1666  /* tried all servers that many times, wait */
1667  xfrd->round_num = -1;
1668  xfrd_set_timer_retry(xfrd);
1669  ods_log_verbose("[%s] zone %s make request wait retry",
1670  xfrd_str, zone->name);
1671  return;
1672  }
1673  }
1674  if (!xfrd->master) {
1675  ods_log_debug("[%s] unable to make request for zone %s: no master",
1676  xfrd_str, zone->name);
1677  xfrd->round_num = -1;
1678  xfrd_set_timer_retry(xfrd);
1679  return;
1680  }
1681  /* cache ixfr_disabled only for XFRD_NO_IXFR_CACHE time */
1682  if (xfrd->master->ixfr_disabled &&
1684  xfrd_time(xfrd)) {
1685  ods_log_verbose("[%s] clear negative caching ixfr disabled for "
1686  "master %s", xfrd_str, xfrd->master->address);
1687  ods_log_debug("[%s] clear negative caching calc: %u + %u <= %u",
1688  xfrd_str, xfrd->master->ixfr_disabled, XFRD_NO_IXFR_CACHE,
1689  xfrd_time(xfrd));
1690  xfrd->master->ixfr_disabled = 0;
1691  }
1692  /* perform xfr request */
1693  ods_log_debug("[%s] zone %s make request round %d master %s:%u",
1694  xfrd_str, zone->name, xfrd->round_num, xfrd->master->address,
1695  xfrd->master->port);
1696  if (xfrd->serial_xfr_acquired && !xfrd->master->ixfr_disabled) {
1697  xfrd_set_timer(xfrd, xfrd_time(xfrd) + XFRD_UDP_TIMEOUT);
1698  xfrd_udp_obtain(xfrd);
1699  } else if (xfrd->serial_xfr_acquired <= 0 ||
1700  xfrd->master->ixfr_disabled) {
1701  xfrhandler_type* xfrhandler = (xfrhandler_type*) xfrd->xfrhandler;
1702  ods_log_assert(xfrhandler);
1703  xfrd_set_timer(xfrd, xfrd_time(xfrd) + XFRD_TCP_TIMEOUT);
1704  xfrd_tcp_obtain(xfrd, xfrhandler->tcp_set);
1705  }
1706  return;
1707 }
1708 
1709 
1714 static void
1715 xfrd_handle_zone(netio_type* ATTR_UNUSED(netio),
1716  netio_handler_type* handler, netio_events_type event_types)
1717 {
1718  xfrd_type* xfrd = NULL;
1719  zone_type* zone = NULL;
1720 
1721  if (!handler) {
1722  return;
1723  }
1724  xfrd = (xfrd_type*) handler->user_data;
1725  ods_log_assert(xfrd);
1726  zone = (zone_type*) xfrd->zone;
1727  ods_log_assert(zone);
1728  ods_log_assert(zone->name);
1729 
1730  if (xfrd->tcp_conn != -1) {
1731  /* busy in tcp transaction */
1732  xfrhandler_type* xfrhandler = (xfrhandler_type*) xfrd->xfrhandler;
1733  ods_log_assert(xfrhandler);
1734  if (event_types & NETIO_EVENT_READ) {
1735  ods_log_deeebug("[%s] zone %s event tcp read", xfrd_str, zone->name);
1736  xfrd_set_timer(xfrd, xfrd_time(xfrd) + XFRD_TCP_TIMEOUT);
1737  xfrd_tcp_read(xfrd, xfrhandler->tcp_set);
1738  return;
1739  } else if (event_types & NETIO_EVENT_WRITE) {
1740  ods_log_deeebug("[%s] zone %s event tcp write", xfrd_str,
1741  zone->name);
1742  xfrd_set_timer(xfrd, xfrd_time(xfrd) + XFRD_TCP_TIMEOUT);
1743  xfrd_tcp_write(xfrd, xfrhandler->tcp_set);
1744  return;
1745  } else if (event_types & NETIO_EVENT_TIMEOUT) {
1746  /* tcp connection timed out. Stop it. */
1747  ods_log_deeebug("[%s] zone %s event tcp timeout", xfrd_str,
1748  zone->name);
1749  xfrd_tcp_release(xfrd, xfrhandler->tcp_set);
1750  /* continue to retry; as if a timeout happened */
1751  event_types = NETIO_EVENT_TIMEOUT;
1752  }
1753  }
1754 
1755  if (event_types & NETIO_EVENT_READ) {
1756  /* busy in udp transaction */
1757  ods_log_deeebug("[%s] zone %s event udp read", xfrd_str,
1758  zone->name);
1759  xfrd_set_timer_now(xfrd);
1760  xfrd_udp_read(xfrd);
1761  return;
1762  }
1763 
1764  /* timeout */
1765  ods_log_deeebug("[%s] zone %s timeout", xfrd_str, zone->name);
1766  if (handler->fd != -1) {
1767  ods_log_assert(xfrd->tcp_conn == -1);
1768  xfrd_udp_release(xfrd);
1769  }
1770  if (xfrd->tcp_waiting) {
1771  ods_log_deeebug("[%s] zone %s skips retry: tcp connections full",
1772  xfrd_str, zone->name);
1773  xfrd_unset_timer(xfrd);
1774  return;
1775  }
1776  if (xfrd->udp_waiting) {
1777  ods_log_deeebug("[%s] zone %s skips retry: udp connections full",
1778  xfrd_str, zone->name);
1779  xfrd_unset_timer(xfrd);
1780  return;
1781  }
1782  /* make a new request */
1783  xfrd_make_request(xfrd);
1784  return;
1785 }
1786 
1787 
1792 void
1794 {
1795  allocator_type* allocator = NULL;
1796  lock_basic_type serial_lock;
1797  lock_basic_type rw_lock;
1798  if (!xfrd) {
1799  return;
1800  }
1801  allocator = xfrd->allocator;
1802  serial_lock = xfrd->serial_lock;
1803  rw_lock = xfrd->rw_lock;
1804  tsig_rr_cleanup(xfrd->tsig_rr);
1805  allocator_deallocate(allocator, (void*) xfrd);
1806  allocator_cleanup(allocator);
1807  lock_basic_destroy(&serial_lock);
1808  lock_basic_destroy(&rw_lock);
1809  return;
1810 }
1811 
#define XFRD_TSIG_MAX_UNSIGNED
Definition: xfrd.c:50
tsig_algo_type * algo
Definition: tsig.h:133
int next_master
Definition: xfrd.h:105
void tsig_rr_update(tsig_rr_type *trr, buffer_type *buffer, size_t length)
Definition: tsig.c:606
#define PF_INET6
Definition: netio.h:63
tsig_status status
Definition: tsig.h:128
void engine_wakeup_workers(engine_type *engine)
Definition: engine.c:456
#define XFRD_MAX_ROUNDS
Definition: xfrd.h:49
xfrd_type * udp_waiting_first
Definition: xfrhandler.h:63
xfrd_type * udp_waiting_last
Definition: xfrhandler.h:64
#define DNS_PORT_STRING
Definition: listener.h:53
size_t tcp_count
Definition: tcpset.h:72
void * config
Definition: adapter.h:63
#define XFRD_UDP_TIMEOUT
Definition: xfrd.h:53
void ods_log_debug(const char *format,...)
Definition: log.c:272
xfrd_type * tcp_waiting_next
Definition: xfrd.h:130
void xfrd_set_timer_refresh(xfrd_type *xfrd)
Definition: xfrd.c:279
#define lock_basic_destroy(lock)
Definition: locks.h:92
uint16_t buffer_pkt_arcount(buffer_type *buffer)
Definition: buffer.c:1138
#define XFRD_TCP_TIMEOUT
Definition: xfrd.h:52
#define BUFFER_PKT_HEADER_SIZE
Definition: buffer.h:45
void * allocator_alloc(allocator_type *allocator, size_t size)
Definition: allocator.c:68
uint16_t error_code
Definition: tsig.h:146
const char * tsig_strerror(uint16_t error)
Definition: tsig.c:830
time_t serial_xfr_acquired
Definition: xfrd.h:112
uint32_t serial_notify
Definition: xfrd.h:110
uint16_t buffer_pkt_qdcount(buffer_type *buffer)
Definition: buffer.c:1063
buffer_type * packet
Definition: xfrhandler.h:62
void buffer_skip(buffer_type *buffer, ssize_t count)
Definition: buffer.c:188
size_t msg_rr_count
Definition: xfrd.h:126
uint16_t buffer_read_u16(buffer_type *buffer)
Definition: buffer.c:783
int buffer_skip_rr(buffer_type *buffer, unsigned qrr)
Definition: buffer.c:382
void buffer_flip(buffer_type *buffer)
Definition: buffer.c:135
#define XFRD_NO_IXFR_CACHE
Definition: xfrd.h:51
void buffer_clear(buffer_type *buffer)
Definition: buffer.c:121
int round_num
Definition: xfrd.h:103
void ods_log_info(const char *format,...)
Definition: log.c:304
time_t serial_notify_acquired
Definition: xfrd.h:113
allocator_type * allocator
Definition: xfrd.h:95
void * zone
Definition: xfrd.h:97
uint8_t mname[MAXDOMAINLEN+2]
Definition: xfrd.h:79
enum ods_enum_status ods_status
Definition: status.h:91
enum netio_events_enum netio_events_type
Definition: netio.h:78
lock_basic_type zone_lock
Definition: zone.h:97
socklen_t xfrd_acl_sockaddr_to(acl_type *acl, struct sockaddr_storage *to)
Definition: xfrd.c:327
time_t ixfr_disabled
Definition: acl.h:73
tsig_algo_type * tsig_lookup_algo(const char *name)
Definition: tsig.c:290
tcp_conn_type * tcp_conn[TCPSET_MAX]
Definition: tcpset.h:69
xfrd_type * tcp_waiting_first
Definition: tcpset.h:70
void ods_log_error(const char *format,...)
Definition: log.c:336
acl_type * next
Definition: acl.h:61
const char * ods_status2str(ods_status status)
Definition: status.c:112
adapter_mode type
Definition: adapter.h:60
int tcp_conn_write(tcp_conn_type *tcp)
Definition: tcpset.c:187
int family
Definition: acl.h:65
union acl_addr_storage addr
Definition: acl.h:66
ldns_rdf * wf_name
Definition: tsig.h:94
buffer_type * packet
Definition: tcpset.h:58
void tsig_rr_reset(tsig_rr_type *trr, tsig_algo_type *algo, tsig_key_type *key)
Definition: tsig.c:334
void tsig_rr_append(tsig_rr_type *trr, buffer_type *buffer)
Definition: tsig.c:722
uint32_t msg_seq_nr
Definition: xfrd.h:123
uint32_t retry
Definition: xfrd.h:83
size_t update_since_last_prepare
Definition: tsig.h:131
void buffer_write(buffer_type *buffer, const void *data, size_t count)
Definition: buffer.c:594
uint16_t buffer_pkt_id(buffer_type *buffer)
Definition: buffer.c:813
lock_basic_type serial_lock
Definition: xfrd.h:98
uint8_t * buffer_current(buffer_type *buffer)
Definition: buffer.c:491
#define XFRD_MAX_UDP
Definition: xfrd.h:50
uint32_t ttl
Definition: xfrd.h:77
FILE * ods_fopen(const char *file, const char *dir, const char *mode)
Definition: file.c:187
const char * algorithm
Definition: tsig.h:116
void * user_data
Definition: netio.h:121
unsigned tcp_waiting
Definition: xfrd.h:132
int util_serial_gt(uint32_t serial_new, uint32_t serial_old)
Definition: util.c:74
uint16_t buffer_pkt_ancount(buffer_type *buffer)
Definition: buffer.c:1088
size_t buffer_limit(buffer_type *buffer)
Definition: buffer.c:413
xfrd_type * udp_waiting_next
Definition: xfrd.h:131
void tsig_rr_prepare(tsig_rr_type *trr)
Definition: tsig.c:581
tsig_key_type * key
Definition: tsig.h:118
void ods_log_crit(const char *format,...)
Definition: log.c:352
time_t xfrhandler_time(xfrhandler_type *xfrhandler)
Definition: xfrhandler.c:158
uint32_t refresh
Definition: xfrd.h:82
#define lock_basic_lock(lock)
Definition: locks.h:93
size_t udp_use_num
Definition: xfrhandler.h:65
void buffer_pkt_set_nscount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1125
ldns_rdf * key_name
Definition: tsig.h:138
void buffer_set_limit(buffer_type *buffer, size_t limit)
Definition: buffer.c:425
allocator_type * allocator_create(void *(*allocator)(size_t size), void(*deallocator)(void *))
Definition: allocator.c:49
Definition: task.h:45
uint32_t msg_new_serial
Definition: xfrd.h:125
acl_type * master
Definition: xfrd.h:106
int lock_basic_type
Definition: locks.h:90
netio_event_handler_type event_handler
Definition: netio.h:133
tcp_set_type * tcp_set
Definition: xfrhandler.h:61
Definition: tsig.h:60
void tsig_rr_cleanup(tsig_rr_type *trr)
Definition: tsig.c:885
adapter_type * adinbound
Definition: zone.h:83
void xfrd_set_timer_retry(xfrd_type *xfrd)
Definition: xfrd.c:260
int buffer_skip_dname(buffer_type *buffer)
Definition: buffer.c:350
void log_dname(ldns_rdf *rdf, const char *pre, int level)
Definition: domain.c:50
int tcp_conn
Definition: xfrd.h:102
uint16_t msglen
Definition: tcpset.h:56
uint32_t buffer_read_u32(buffer_type *buffer)
Definition: buffer.c:798
uint32_t minimum
Definition: xfrd.h:85
tsig_rr_type * tsig_rr
Definition: xfrd.h:128
tsig_key_type * key
Definition: tsig.h:134
void buffer_pkt_query(buffer_type *buffer, ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_class qclass)
Definition: buffer.c:1194
int tsig_rr_verify(tsig_rr_type *trr)
Definition: tsig.c:700
void buffer_write_u16(buffer_type *buffer, uint16_t data)
Definition: buffer.c:623
size_t buffer_read_dname(buffer_type *buffer, uint8_t *dname, unsigned allow_pointers)
Definition: buffer.c:286
ldns_rdf * dname
Definition: tsig.h:82
acl_type * request_xfr
Definition: addns.h:54
char * address
Definition: acl.h:63
void buffer_write_u32(buffer_type *buffer, uint32_t data)
Definition: buffer.c:637
void xfrd_cleanup(xfrd_type *xfrd)
Definition: xfrd.c:1793
ods_status zone_reschedule_task(zone_type *zone, schedule_type *taskq, task_id what)
Definition: zone.c:189
tsig_rr_type * tsig_rr_create(allocator_type *allocator)
Definition: tsig.c:307
uint32_t expire
Definition: xfrd.h:84
char * ods_build_path(const char *file, const char *suffix, int dir, int no_slash)
Definition: file.c:127
uint8_t rname[MAXDOMAINLEN+2]
Definition: xfrd.h:80
uint32_t total_bytes
Definition: tcpset.h:54
uint32_t msg_old_serial
Definition: xfrd.h:124
struct timespec timeout
Definition: xfrd.h:118
unsigned is_reading
Definition: tcpset.h:60
int tcp_conn_read(tcp_conn_type *tcp)
Definition: tcpset.c:113
void ods_log_verbose(const char *format,...)
Definition: log.c:288
ldns_rr_class klass
Definition: zone.h:71
size_t position
Definition: tsig.h:129
void buffer_write_u16_at(buffer_type *buffer, size_t at, uint16_t data)
Definition: buffer.c:566
void buffer_set_position(buffer_type *buffer, size_t pos)
Definition: buffer.c:174
#define lock_basic_init(lock)
Definition: locks.h:91
int tsig_rr_find(tsig_rr_type *trr, buffer_type *buffer)
Definition: tsig.c:479
void ods_fclose(FILE *fd)
Definition: file.c:247
void xfrd_set_timer_now(xfrd_type *xfrd)
Definition: xfrd.c:241
netio_events_type event_types
Definition: netio.h:126
uint8_t msg_is_ixfr
Definition: xfrd.h:127
int buffer_available(buffer_type *buffer, size_t count)
Definition: buffer.c:540
void allocator_cleanup(allocator_type *allocator)
Definition: allocator.c:153
const char * name
Definition: zone.h:78
#define PF_INET
Definition: netio.h:60
size_t buffer_remaining(buffer_type *buffer)
Definition: buffer.c:516
void ods_log_deeebug(const char *format,...)
Definition: log.c:256
uint32_t serial_xfr
Definition: xfrd.h:109
uint16_t query_id
Definition: xfrd.h:122
void * xfrhandler
Definition: xfrd.h:96
void buffer_write_rdf(buffer_type *buffer, ldns_rdf *rdf)
Definition: buffer.c:651
int master_num
Definition: xfrd.h:104
void tsig_rr_sign(tsig_rr_type *trr)
Definition: tsig.c:678
void allocator_deallocate(allocator_type *allocator, void *data)
Definition: allocator.c:137
#define TCPSET_MAX
Definition: tcpset.h:44
lock_basic_type rw_lock
Definition: xfrd.h:99
#define LOG_DEBUG
Definition: log.h:53
unsigned int port
Definition: acl.h:64
void tcp_conn_ready(tcp_conn_type *tcp)
Definition: tcpset.c:98
unsigned udp_waiting
Definition: xfrd.h:133
size_t buffer_position(buffer_type *buffer)
Definition: buffer.c:162
ldns_rdf * algo_name
Definition: tsig.h:139
uint32_t serial
Definition: xfrd.h:81
void buffer_pkt_set_arcount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1150
struct in_addr addr
Definition: listener.h:62
struct timespec * timeout
Definition: netio.h:117
#define ods_log_assert(x)
Definition: log.h:156
netio_handler_type handler
Definition: xfrd.h:119
soa_type soa
Definition: xfrd.h:115
xfrd_type * xfrd_create(void *xfrhandler, void *zone)
Definition: xfrd.c:97
#define lock_basic_unlock(lock)
Definition: locks.h:94
uint16_t original_query_id
Definition: tsig.h:145
tsig_type * tsig
Definition: acl.h:71
enum xfrd_pkt_enum xfrd_pkt_status
Definition: xfrd.h:67
ldns_rdf * apex
Definition: zone.h:70
time_t serial_disk_acquired
Definition: xfrd.h:114
struct in6_addr addr6
Definition: listener.h:63
uint8_t * buffer_begin(buffer_type *buffer)
Definition: buffer.c:467
time_t time_now(void)
Definition: duration.c:515
uint32_t serial_disk
Definition: xfrd.h:111
ldns_pkt_rcode buffer_pkt_rcode(buffer_type *buffer)
Definition: buffer.c:1022
int buffer_pkt_tc(buffer_type *buffer)
Definition: buffer.c:962
Definition: acl.h:60