49 #define XFRD_TSIG_MAX_UNSIGNED 100 51 static const char* xfrd_str =
"xfrd";
53 static void xfrd_handle_zone(
netio_type* netio,
55 static void xfrd_make_request(
xfrd_type* xfrd);
57 static socklen_t xfrd_acl_sockaddr(
acl_type* acl,
unsigned int port,
58 struct sockaddr_storage *sck);
62 unsigned rdata_only,
unsigned update, uint32_t t,
65 uint16_t count,
int* done);
78 static void xfrd_udp_obtain(
xfrd_type* xfrd);
79 static void xfrd_udp_read(
xfrd_type* xfrd);
80 static void xfrd_udp_release(
xfrd_type* xfrd);
81 static int xfrd_udp_read_packet(
xfrd_type* xfrd);
83 static int xfrd_udp_send_request_ixfr(
xfrd_type* xfrd);
86 static void xfrd_set_timer(
xfrd_type* xfrd, time_t t);
87 static void xfrd_set_timer_time(
xfrd_type* xfrd, time_t t);
88 static void xfrd_unset_timer(
xfrd_type* xfrd);
96 xfrd_recover_dname(uint8_t* dname,
const char* name)
98 const uint8_t *s = (
const uint8_t *) name;
104 if (strcmp(name,
".") == 0) {
109 for (h = d, p = h + 1; *s; ++s, ++p) {
119 label_length = p - h - 1;
129 if (isdigit(s[1]) && isdigit(s[2]) && isdigit(s[3])) {
130 int val = (ldns_hexdigit_to_int(s[1]) * 100 +
131 ldns_hexdigit_to_int(s[2]) * 10 +
132 ldns_hexdigit_to_int(s[3]));
133 if (0 <= val && val <= 255) {
139 }
else if (s[1] !=
'\0') {
150 label_length = p - h - 1;
176 uint32_t timeout = 0;
177 uint32_t serial_xfr = 0;
178 uint32_t serial_notify = 0;
179 uint32_t serial_disk = 0;
180 time_t serial_xfr_acquired = 0;
181 time_t serial_notify_acquired = 0;
182 time_t serial_disk_acquired = 0;
183 uint32_t soa_ttl = 0;
184 uint32_t soa_serial = 0;
185 uint32_t soa_refresh = 0;
186 uint32_t soa_retry = 0;
187 uint32_t soa_expire = 0;
188 uint32_t soa_minimum = 0;
189 const char* soa_mname = NULL;
190 const char* soa_rname = NULL;
192 if (zone && zone->
name && zone->
db &&
202 "magic (start) error", xfrd_str, zone->
name);
203 goto xfrd_recover_error;
225 ";;Zone error", xfrd_str, zone->
name);
226 goto xfrd_recover_error;
238 ";;Master error", xfrd_str, zone->
name);
239 goto xfrd_recover_error;
252 ";;Serial error", xfrd_str, zone->
name);
253 goto xfrd_recover_error;
257 "magic (end) error", xfrd_str, zone->
name);
258 goto xfrd_recover_error;
265 xfrd->
timeout.tv_sec = timeout;
284 if (!timeout || serial_notify_acquired ||
285 (serial_disk_acquired &&
286 (uint32_t)xfrd_time(xfrd) - serial_disk_acquired >
290 if (serial_disk_acquired &&
291 ((uint32_t)xfrd_time(xfrd) - serial_disk_acquired >
297 free((
void*)soa_mname);
298 free((
void*)soa_rname);
304 ods_log_verbose(
"[%s] did not recover xfrd.state file zone %s", xfrd_str,
305 (zone && zone->
name)?zone->
name:
"(null)");
320 if (!xfrhandler || !zone) {
326 "allocator_create() failed", xfrd_str);
332 " allocator_alloc() failed", xfrd_str);
372 memset(&xfrd->
soa, 0,
sizeof(xfrd->
soa));
387 xfrd_set_timer_time(xfrd, 0);
411 xfrd_set_timer(
xfrd_type* xfrd, time_t t)
420 if(t > xfrd_time(xfrd) + 10) {
421 time_t extra = t - xfrd_time(xfrd);
422 time_t base = extra*9/10;
423 #ifdef HAVE_ARC4RANDOM_UNIFORM 424 t = xfrd_time(xfrd) + base +
425 arc4random_uniform(extra-base);
426 #elif HAVE_ARC4RANDOM 427 t = xfrd_time(xfrd) + base +
428 arc4random()%(extra-base);
430 t = xfrd_time(xfrd) + base +
431 random()%(extra-base);
459 xfrd_set_timer_time(
xfrd_type* xfrd, time_t t)
462 xfrd_set_timer(xfrd, xfrd_time(xfrd) + t);
479 ods_log_debug(
"[%s] zone %s sets timer timeout now", xfrd_str,
481 xfrd_set_timer_time(xfrd, 0);
498 ods_log_debug(
"[%s] zone %s sets timer timeout retry %u", xfrd_str,
500 xfrd_set_timer_time(xfrd, xfrd->
soa.
retry);
517 ods_log_debug(
"[%s] zone %s sets timer timeout refresh %u", xfrd_str,
529 xfrd_acl_sockaddr(
acl_type* acl,
unsigned int port,
530 struct sockaddr_storage *sck)
535 memset(sck, 0,
sizeof(
struct sockaddr_storage));
536 if (acl->
family == AF_INET6) {
537 struct sockaddr_in6* sa = (
struct sockaddr_in6*)sck;
538 sa->sin6_family = AF_INET6;
539 sa->sin6_port = htons(port);
541 return sizeof(
struct sockaddr_in6);
543 struct sockaddr_in* sa = (
struct sockaddr_in*)sck;
544 sa->sin_family = AF_INET;
545 sa->sin_port = htons(port);
547 return sizeof(
struct sockaddr_in);
560 unsigned int port = 0;
565 return xfrd_acl_sockaddr(acl, port, to);
583 ods_log_error(
"[%s] unable to sign request: tsig unknown algorithm " 598 ods_log_debug(
"[%s] tsig append rr to request id=%u", xfrd_str,
625 ods_log_error(
"[%s] unable to process tsig: xfr zone %s from %s " 626 "has malformed tsig rr", xfrd_str, zone->
name,
645 ods_log_error(
"[%s] unable to process tsig: xfr zone %s from %s " 646 "has bad tsig signature", xfrd_str, zone->
name,
655 ods_log_error(
"[%s] unable to process tsig: xfr zone %s, from %s " 656 "has too many consecutive packets without tsig", xfrd_str,
661 ods_log_error(
"[%s] unable to process tsig: xfr zone %s from %s " 662 "has no tsig in first packet of reply", xfrd_str,
679 char* xfrfile = NULL;
681 time_t serial_disk_acq = 0;
686 ods_log_crit(
"[%s] unable to commit xfr zone %s: build path failed",
687 xfrd_str, zone->
name);
697 free((
void*)xfrfile);
699 fprintf(fd,
";;ENDPACKET\n");
705 ods_log_crit(
"[%s] unable to commit xfr zone %s: ods_fopen() failed " 706 "(%s)", xfrd_str, zone->
name, strerror(errno));
727 ods_log_debug(
"[%s] reschedule task for zone %s: disk serial=%u " 728 "acquired=%u, memory serial=%u acquired=%u", xfrd_str,
734 ods_log_crit(
"[%s] unable to reschedule task for zone %s: %s",
758 char* xfrfile = NULL;
760 ldns_pkt* pkt = NULL;
761 ldns_status status = LDNS_STATUS_OK;
768 if (status != LDNS_STATUS_OK) {
769 ods_log_crit(
"[%s] unable to dump packet zone %s: ldns_wire2pkt() " 770 "failed (%s)", xfrd_str, zone->
name,
771 ldns_get_errorstr_by_id(status));
777 ods_log_crit(
"[%s] unable to dump packet zone %s: build path failed",
778 xfrd_str, zone->
name);
787 free((
void*) xfrfile);
789 ods_log_crit(
"[%s] unable to dump packet zone %s: ods_fopen() failed " 790 "(%s)", xfrd_str, zone->
name, strerror(errno));
796 fprintf(fd,
";;BEGINPACKET\n");
798 ldns_rr_list_print(fd, ldns_pkt_answer(pkt));
814 size_t rdlength_pos = 0;
815 uint16_t rdlength = 0;
846 uint16_t mname_pos, uint16_t rname_pos,
847 uint32_t refresh, uint32_t retry, uint32_t expire, uint32_t minimum)
882 unsigned update, uint32_t t, uint32_t* soa_serial)
884 ldns_rr_type type = LDNS_RR_TYPE_SOA;
885 uint16_t mname_pos = 0;
886 uint16_t rname_pos = 0;
889 uint32_t refresh = 0;
892 uint32_t minimum = 0;
905 if (type != LDNS_RR_TYPE_SOA) {
907 xfrd_str, (
unsigned) type);
940 *soa_serial = serial;
943 xfrd_update_soa(xfrd, buffer, ttl, mname_pos, rname_pos,
944 refresh, retry, expire, minimum);
959 ldns_rr_type type = 0;
963 uint32_t tmp_serial = 0;
986 if (type == LDNS_RR_TYPE_SOA) {
987 if (!xfrd_parse_soa(xfrd, buffer, 1, 0, ttl, &serial)) {
1006 tmp_serial = serial;
1025 tmp_serial = serial;
1043 uint16_t qdcount = 0;
1044 uint16_t ancount = 0;
1045 uint16_t ancount_todo = 0;
1046 uint16_t rrcount = 0;
1047 uint32_t serial = 0;
1059 ods_log_error(
"[%s] unable to parse packet: zone %s received bad " 1060 "packet from %s (too small)", xfrd_str, zone->
name,
1066 ods_log_error(
"[%s] bad packet: zone %s received bad query id " 1067 "%u from %s (expected %u)", xfrd_str, zone->
name,
1073 ods_log_error(
"[%s] bad packet: zone %s received error code %s from %s",
1083 if (!xfrd_tsig_process(xfrd, buffer)) {
1091 for (rrcount = 0; rrcount < qdcount; rrcount++) {
1094 "question section from %s (bad rr)", xfrd_str, zone->
name,
1103 ods_log_info(
"[%s] zone %s received tc from %s, retry tcp",
1107 ods_log_error(
"[%s] bad packet: zone %s received bad xfr packet " 1112 ancount_todo = ancount;
1116 !xfrd_parse_soa(xfrd, buffer, 0, 1, 0, &serial)) {
1118 "packet from %s (bad soa)", xfrd_str, zone->
name,
1126 ods_log_info(
"[%s] zone %s got update indicating current " 1127 "serial %u from %s", xfrd_str, zone->
name, serial,
1150 ods_log_info(
"[%s] zone %s ignoring old serial %u from %s " 1151 "(have %u)", xfrd_str, zone->
name, serial,
1171 ancount_todo = ancount - 1;
1175 ods_log_info(
"[%s] zone %s received tc from %s, retry tcp",
1179 if (xfrd->
tcp_conn == -1 && ancount < 2) {
1181 ods_log_info(
"[%s] zone %s received too short udp reply from %s, " 1185 status = xfrd_parse_rrs(xfrd, buffer, ancount_todo, &done);
1187 ods_log_error(
"[%s] bad packet: zone %s received bad xfr packet " 1192 if (xfrd->
tcp_conn == -1 && !done) {
1193 ods_log_error(
"[%s] bad packet: zone %s received bad xfr packet " 1194 "(xfr over udp incomplete)", xfrd_str, zone->
name,
1220 res = xfrd_parse_packet(xfrd, buffer);
1221 ods_log_debug(
"[%s] zone %s xfr packet parsed (res %d)", xfrd_str,
1247 xfrd_dump_packet(xfrd, buffer);
1258 xfrd_commit_packet(xfrd);
1262 ods_log_info(
"[%s] zone %s transfer done [notify acquired %u, serial on " 1263 "disk %u, notify serial %u]", xfrd_str, zone->
name,
1309 tcp =
set->tcp_conn[xfrd->
tcp_conn];
1313 len =
sizeof(error);
1314 if (getsockopt(tcp->
fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
1317 if (error == EINPROGRESS || error == EWOULDBLOCK) {
1318 ods_log_debug(
"[%s] zone %s zero write, write again later (%s)",
1319 xfrd_str, zone->
name, strerror(error));
1326 xfrd_tcp_release(xfrd,
set);
1335 xfrd_tcp_release(xfrd,
set);
1340 xfrd_str, zone->
name);
1344 ods_log_debug(
"[%s] zone %s done writing, get ready for reading",
1345 xfrd_str, zone->
name);
1349 xfrd_tcp_read(xfrd,
set);
1361 int fd, family, conn;
1362 struct sockaddr_storage to;
1374 ods_log_debug(
"[%s] zone %s open tcp connection to %s", xfrd_str,
1376 set->tcp_conn[xfrd->
tcp_conn]->is_reading = 0;
1377 set->tcp_conn[xfrd->
tcp_conn]->total_bytes = 0;
1378 set->tcp_conn[xfrd->
tcp_conn]->msglen = 0;
1384 fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
1385 set->tcp_conn[xfrd->
tcp_conn]->fd = fd;
1387 ods_log_error(
"[%s] zone %s cannot create tcp socket to %s: %s",
1390 xfrd_tcp_release(xfrd,
set);
1393 if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
1394 ods_log_error(
"[%s] zone %s cannot fcntl tcp socket to %s: %s",
1397 xfrd_tcp_release(xfrd,
set);
1403 conn = connect(fd, (
struct sockaddr*)&to, to_len);
1404 if (conn == -1 && errno != EINPROGRESS) {
1405 ods_log_error(
"[%s] zone %s cannot connect tcp socket to %s: %s",
1408 xfrd_tcp_release(xfrd,
set);
1436 if (set->tcp_conn[i]->fd == -1) {
1445 xfrd_udp_release(xfrd);
1447 if (!xfrd_tcp_open(xfrd,
set)) {
1450 xfrd_tcp_xfr(xfrd,
set);
1457 xfrd_unset_timer(xfrd);
1482 tcp =
set->tcp_conn[xfrd->
tcp_conn];
1486 ods_log_info(
"[%s] zone %s request axfr to %s", xfrd_str,
1491 ods_log_info(
"[%s] zone %s request tcp/ixfr=%u to %s", xfrd_str,
1496 xfrd_write_soa(xfrd, tcp->
packet);
1505 xfrd_tsig_sign(xfrd, tcp->
packet);
1528 tcp =
set->tcp_conn[xfrd->
tcp_conn];
1532 xfrd_tcp_release(xfrd,
set);
1540 ret = xfrd_handle_packet(xfrd, tcp->
packet);
1549 xfrd_tcp_release(xfrd,
set);
1559 ods_log_debug(
"[%s] tcp read %s: release connection", xfrd_str,
1561 xfrd_tcp_release(xfrd,
set);
1562 xfrd_make_request(xfrd);
1586 ods_log_debug(
"[%s] zone %s release tcp connection to %s", xfrd_str,
1594 if (set->tcp_conn[conn]->fd != -1) {
1595 close(set->tcp_conn[conn]->fd);
1597 set->tcp_conn[conn]->fd = -1;
1613 struct sockaddr_storage to;
1614 socklen_t to_len = 0;
1629 fd = socket(family, SOCK_DGRAM, IPPROTO_UDP);
1642 (
struct sockaddr*)&to, to_len);
1659 xfrd_udp_send_request_ixfr(
xfrd_type* xfrd)
1672 ods_log_error(
"[%s] unable to transfer zone %s: tried to send " 1673 "udp while tcp obtained", xfrd_str, zone->
name);
1688 xfrd_write_soa(xfrd, xfrhandler->
packet);
1689 xfrd_tsig_sign(xfrd, xfrhandler->
packet);
1692 ods_log_info(
"[%s] zone %s request udp/ixfr=%u to %s", xfrd_str,
1694 if((fd = xfrd_udp_send(xfrd, xfrhandler->
packet)) == -1) {
1714 xfrd_tcp_release(xfrd, xfrhandler->
tcp_set);
1718 xfrd->
handler.
fd = xfrd_udp_send_request_ixfr(xfrd);
1734 xfrd_unset_timer(xfrd);
1747 ssize_t received = 0;
1755 if (received == -1) {
1756 ods_log_error(
"[%s] unable to read packet: recvfrom() failed fd %d " 1757 "(%s)", xfrd_str, xfrd->
handler.
fd, strerror(errno));
1781 if (!xfrd_udp_read_packet(xfrd)) {
1783 "xfrd_udp_read_packet() failed", xfrd_str, zone->
name);
1784 xfrd_udp_release(xfrd);
1789 res = xfrd_handle_packet(xfrd, xfrhandler->
packet);
1794 xfrd_udp_release(xfrd);
1796 xfrd_tcp_obtain(xfrd, xfrhandler->
tcp_set);
1804 xfrd_udp_release(xfrd);
1815 xfrd_udp_release(xfrd);
1816 xfrd_make_request(xfrd);
1852 wf->
handler.
fd = xfrd_udp_send_request_ixfr(wf);
1917 xfrd_str, zone->
name);
1922 ods_log_debug(
"[%s] unable to make request for zone %s: no master",
1923 xfrd_str, zone->
name);
1934 ods_log_debug(
"[%s] clear negative caching calc: %u + %u <= %u",
1944 ods_log_verbose(
"[%s] zone %s make request [udp round %d master %s:%u]",
1947 xfrd_udp_obtain(xfrd);
1958 ods_log_verbose(
"[%s] zone %s make request [tcp round %d master %s:%u]",
1961 xfrd_tcp_obtain(xfrd, xfrhandler->
tcp_set);
1972 xfrd_handle_zone(
netio_type* ATTR_UNUSED(netio),
1994 xfrd_tcp_read(xfrd, xfrhandler->
tcp_set);
2000 xfrd_tcp_write(xfrd, xfrhandler->
tcp_set);
2006 xfrd_tcp_release(xfrd, xfrhandler->
tcp_set);
2017 xfrd_udp_read(xfrd);
2023 if (handler->
fd != -1) {
2025 xfrd_udp_release(xfrd);
2029 xfrd_str, zone->
name);
2030 xfrd_unset_timer(xfrd);
2035 xfrd_str, zone->
name);
2036 xfrd_unset_timer(xfrd);
2040 xfrd_make_request(xfrd);
2050 xfrd_backup_dname(FILE* out, uint8_t* dname)
2052 uint8_t* d= dname+1;
2061 for (i=0; i<len; i++) {
2063 if (isalnum(ch) || ch ==
'-' || ch ==
'_') {
2064 fprintf(out,
"%c", ch);
2065 }
else if (ch ==
'.' || ch ==
'\\') {
2066 fprintf(out,
"\\%c", ch);
2068 fprintf(out,
"\\%03u", (
unsigned int)ch);
2089 if (zone && zone->
name) {
2095 timeout = xfrd->
timeout.tv_sec;
2097 fprintf(fd,
"%s\n", ODS_SE_FILE_MAGIC_V3);
2098 fprintf(fd,
";;Zone: name %s ttl %u mname ",
2100 (
unsigned) xfrd->
soa.
ttl);
2101 xfrd_backup_dname(fd, xfrd->
soa.
mname),
2102 fprintf(fd,
" rname ");
2103 xfrd_backup_dname(fd, xfrd->
soa.
rname),
2104 fprintf(fd,
" serial %u refresh %u retry %u expire %u " 2111 fprintf(fd,
";;Master: num %d next %d round %d timeout %d\n",
2116 fprintf(fd,
";;Serial: xfr %u %u notify %u %u disk %u %u\n",
2123 fprintf(fd,
"%s\n", ODS_SE_FILE_MAGIC_V3);
2142 if (zone && zone->
name) {
#define XFRD_TSIG_MAX_UNSIGNED
int backup_read_str(FILE *in, const char **str)
void tsig_rr_update(tsig_rr_type *trr, buffer_type *buffer, size_t length)
void engine_wakeup_workers(engine_type *engine)
xfrd_type * udp_waiting_first
xfrd_type * udp_waiting_last
void ods_log_debug(const char *format,...)
xfrd_type * tcp_waiting_next
void xfrd_set_timer_refresh(xfrd_type *xfrd)
#define lock_basic_destroy(lock)
uint16_t buffer_pkt_arcount(buffer_type *buffer)
#define BUFFER_PKT_HEADER_SIZE
void * allocator_alloc(allocator_type *allocator, size_t size)
const char * tsig_strerror(uint16_t error)
time_t serial_xfr_acquired
uint16_t buffer_pkt_qdcount(buffer_type *buffer)
void buffer_skip(buffer_type *buffer, ssize_t count)
uint16_t buffer_read_u16(buffer_type *buffer)
int buffer_skip_rr(buffer_type *buffer, unsigned qrr)
void buffer_flip(buffer_type *buffer)
#define XFRD_NO_IXFR_CACHE
void buffer_clear(buffer_type *buffer)
void ods_log_info(const char *format,...)
time_t serial_notify_acquired
int backup_read_time_t(FILE *in, time_t *v)
allocator_type * allocator
uint8_t mname[MAXDOMAINLEN+2]
enum ods_enum_status ods_status
enum netio_events_enum netio_events_type
lock_basic_type zone_lock
socklen_t xfrd_acl_sockaddr_to(acl_type *acl, struct sockaddr_storage *to)
tsig_algo_type * tsig_lookup_algo(const char *name)
void ods_log_error(const char *format,...)
const char * ods_status2str(ods_status status)
int tcp_conn_write(tcp_conn_type *tcp)
union acl_addr_storage addr
int backup_read_int(FILE *in, int *v)
void tsig_rr_reset(tsig_rr_type *trr, tsig_algo_type *algo, tsig_key_type *key)
void tsig_rr_append(tsig_rr_type *trr, buffer_type *buffer)
size_t update_since_last_prepare
void buffer_write(buffer_type *buffer, const void *data, size_t count)
uint16_t buffer_pkt_id(buffer_type *buffer)
lock_basic_type serial_lock
uint8_t * buffer_current(buffer_type *buffer)
FILE * ods_fopen(const char *file, const char *dir, const char *mode)
int util_serial_gt(uint32_t serial_new, uint32_t serial_old)
uint16_t buffer_pkt_ancount(buffer_type *buffer)
size_t buffer_limit(buffer_type *buffer)
xfrd_type * udp_waiting_next
void tsig_rr_prepare(tsig_rr_type *trr)
void ods_log_crit(const char *format,...)
time_t xfrhandler_time(xfrhandler_type *xfrhandler)
#define lock_basic_lock(lock)
void buffer_pkt_set_nscount(buffer_type *buffer, uint16_t count)
void buffer_set_limit(buffer_type *buffer, size_t limit)
allocator_type * allocator_create(void *(*allocator)(size_t size), void(*deallocator)(void *))
netio_event_handler_type event_handler
void tsig_rr_cleanup(tsig_rr_type *trr)
void xfrd_set_timer_retry(xfrd_type *xfrd)
int buffer_skip_dname(buffer_type *buffer)
void log_dname(ldns_rdf *rdf, const char *pre, int level)
uint32_t buffer_read_u32(buffer_type *buffer)
void xfrd_cleanup(xfrd_type *xfrd, int backup)
void buffer_pkt_query(buffer_type *buffer, ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_class qclass)
int tsig_rr_verify(tsig_rr_type *trr)
void buffer_write_u16(buffer_type *buffer, uint16_t data)
size_t buffer_read_dname(buffer_type *buffer, uint8_t *dname, unsigned allow_pointers)
void buffer_write_u32(buffer_type *buffer, uint32_t data)
ods_status zone_reschedule_task(zone_type *zone, schedule_type *taskq, task_id what)
tsig_rr_type * tsig_rr_create(allocator_type *allocator)
char * ods_build_path(const char *file, const char *suffix, int dir, int no_slash)
uint8_t rname[MAXDOMAINLEN+2]
int tcp_conn_read(tcp_conn_type *tcp)
void ods_log_verbose(const char *format,...)
void buffer_write_u16_at(buffer_type *buffer, size_t at, uint16_t data)
void buffer_set_position(buffer_type *buffer, size_t pos)
#define lock_basic_init(lock)
int tsig_rr_find(tsig_rr_type *trr, buffer_type *buffer)
void ods_fclose(FILE *fd)
void xfrd_set_timer_now(xfrd_type *xfrd)
netio_events_type event_types
int buffer_available(buffer_type *buffer, size_t count)
void allocator_cleanup(allocator_type *allocator)
uint8_t serial_retransfer
int backup_read_check_str(FILE *in, const char *str)
size_t buffer_remaining(buffer_type *buffer)
void ods_log_deeebug(const char *format,...)
void buffer_write_rdf(buffer_type *buffer, ldns_rdf *rdf)
void tsig_rr_sign(tsig_rr_type *trr)
void allocator_deallocate(allocator_type *allocator, void *data)
void tcp_conn_ready(tcp_conn_type *tcp)
size_t buffer_position(buffer_type *buffer)
void buffer_pkt_set_arcount(buffer_type *buffer, uint16_t count)
struct timespec * timeout
#define ods_log_assert(x)
netio_handler_type handler
xfrd_type * xfrd_create(void *xfrhandler, void *zone)
#define lock_basic_unlock(lock)
uint16_t original_query_id
enum xfrd_pkt_enum xfrd_pkt_status
time_t serial_disk_acquired
uint8_t * buffer_begin(buffer_type *buffer)
ldns_pkt_rcode buffer_pkt_rcode(buffer_type *buffer)
int backup_read_uint32_t(FILE *in, uint32_t *v)
int buffer_pkt_tc(buffer_type *buffer)
uint8_t msg_do_retransfer