Lines Matching defs:xfr
100 static void xfr_set_timeout(struct auth_xfer* xfr, struct module_env* env,
103 static void xfr_probe_send_or_end(struct auth_xfer* xfr,
107 static int xfr_start_probe(struct auth_xfer* xfr, struct module_env* env,
110 void auth_xfer_delete(struct auth_xfer* xfr);
2012 /** Find auth_zone SOA and populate the values in xfr(soa values). */
2014 xfr_find_soa(struct auth_zone* z, struct auth_xfer* xfr)
2028 xfr->have_zone = 1;
2029 xfr->serial = sldns_read_uint32(d->rr_data[0]+(d->rr_len[0]-20));
2030 xfr->refresh = sldns_read_uint32(d->rr_data[0]+(d->rr_len[0]-16));
2031 xfr->retry = sldns_read_uint32(d->rr_data[0]+(d->rr_len[0]-12));
2032 xfr->expiry = sldns_read_uint32(d->rr_data[0]+(d->rr_len[0]-8));
2209 * workers, so the xfr can just be deleted. */
2215 struct auth_xfer* xfr;
2233 xfr = auth_xfer_find(az, z->name, z->namelen, z->dclass);
2234 if(xfr) {
2235 (void)rbtree_delete(&az->xtree, &xfr->node);
2236 auth_xfer_delete(xfr);
2321 * @param xfr: delete this xfer and its tasks.
2324 auth_xfer_delete(struct auth_xfer* xfr)
2326 if(!xfr) return;
2327 lock_basic_destroy(&xfr->lock);
2328 free(xfr->name);
2329 if(xfr->task_nextprobe) {
2330 comm_timer_delete(xfr->task_nextprobe->timer);
2331 free(xfr->task_nextprobe);
2333 if(xfr->task_probe) {
2334 auth_free_masters(xfr->task_probe->masters);
2335 comm_point_delete(xfr->task_probe->cp);
2336 comm_timer_delete(xfr->task_probe->timer);
2337 free(xfr->task_probe);
2339 if(xfr->task_transfer) {
2340 auth_free_masters(xfr->task_transfer->masters);
2341 comm_point_delete(xfr->task_transfer->cp);
2342 comm_timer_delete(xfr->task_transfer->timer);
2343 if(xfr->task_transfer->chunks_first) {
2344 auth_chunks_delete(xfr->task_transfer);
2346 free(xfr->task_transfer);
2348 auth_free_masters(xfr->allow_notify_list);
2349 free(xfr);
3740 az_xfr_allowed_notify(struct auth_xfer* xfr, struct sockaddr_storage* addr,
3744 for(p=xfr->allow_notify_list; p; p=p->next) {
3755 xfr_serial_means_update(struct auth_xfer* xfr, uint32_t serial)
3757 if(!xfr->have_zone)
3759 if(xfr->zone_expired)
3762 if(compare_serial(xfr->serial, serial) < 0)
3768 /** note notify serial, updates the notify information in the xfr struct */
3770 xfr_note_notify_serial(struct auth_xfer* xfr, int has_serial, uint32_t serial)
3772 if(xfr->notify_received && xfr->notify_has_serial && has_serial) {
3774 if(compare_serial(xfr->notify_serial, serial) < 0)
3775 xfr->notify_serial = serial;
3776 } else if(xfr->notify_received && xfr->notify_has_serial &&
3779 xfr->notify_has_serial = 0;
3780 xfr->notify_serial = 0;
3781 } else if(xfr->notify_received && !xfr->notify_has_serial) {
3786 xfr->notify_received = 1;
3787 xfr->notify_has_serial = has_serial;
3788 xfr->notify_serial = serial;
3792 /** process a notify serial, start new probe or note serial. xfr is locked */
3794 xfr_process_notify(struct auth_xfer* xfr, struct module_env* env,
3799 if(has_serial && !xfr_serial_means_update(xfr, serial)) {
3800 lock_basic_unlock(&xfr->lock);
3804 if(!xfr_start_probe(xfr, env, fromhost)) {
3806 xfr_note_notify_serial(xfr, has_serial, serial);
3807 lock_basic_unlock(&xfr->lock);
3809 /* successful end of start_probe unlocked xfr->lock */
3817 struct auth_xfer* xfr;
3821 xfr = auth_xfer_find(az, nm, nmlen, dclass);
3822 if(!xfr) {
3828 lock_basic_lock(&xfr->lock);
3832 if(!az_xfr_allowed_notify(xfr, addr, addrlen, &fromhost)) {
3833 lock_basic_unlock(&xfr->lock);
3840 xfr_process_notify(xfr, env, has_serial, serial, fromhost);
3847 struct auth_xfer* xfr;
3849 xfr = auth_xfer_find(az, nm, nmlen, dclass);
3850 if(!xfr) {
3854 lock_basic_lock(&xfr->lock);
3857 xfr_process_notify(xfr, env, 0, 0, NULL);
3863 auth_xfer_set_expired(struct auth_xfer* xfr, struct module_env* env,
3868 /* expire xfr */
3869 lock_basic_lock(&xfr->lock);
3870 xfr->zone_expired = expired;
3871 lock_basic_unlock(&xfr->lock);
3875 z = auth_zone_find(env->auth_zones, xfr->name, xfr->namelen,
3876 xfr->dclass);
3979 probe_copy_masters_for_allow_notify(struct auth_xfer* xfr)
3984 for(p = xfr->task_transfer->masters; p; p=p->next) {
3997 auth_free_masters(xfr->allow_notify_list);
3998 xfr->allow_notify_list = list;
4003 xfr_transfer_start_lookups(struct auth_xfer* xfr)
4006 xfr->task_transfer->scan_addr = NULL;
4007 xfr_masterlist_free_addrs(xfr->task_transfer->masters);
4010 xfr->task_transfer->lookup_target = xfr->task_transfer->masters;
4011 xfr->task_transfer->lookup_aaaa = 0;
4016 xfr_transfer_move_to_next_lookup(struct auth_xfer* xfr, struct module_env* env)
4018 if(!xfr->task_transfer->lookup_target)
4020 if(!xfr->task_transfer->lookup_aaaa && env->cfg->do_ip6) {
4022 xfr->task_transfer->lookup_aaaa = 1;
4025 xfr->task_transfer->lookup_target =
4026 xfr->task_transfer->lookup_target->next;
4027 xfr->task_transfer->lookup_aaaa = 0;
4028 if(!env->cfg->do_ip4 && xfr->task_transfer->lookup_target!=NULL)
4029 xfr->task_transfer->lookup_aaaa = 1;
4034 xfr_probe_start_lookups(struct auth_xfer* xfr)
4037 xfr->task_probe->scan_addr = NULL;
4038 xfr_masterlist_free_addrs(xfr->task_probe->masters);
4041 xfr->task_probe->lookup_target = xfr->task_probe->masters;
4042 xfr->task_probe->lookup_aaaa = 0;
4047 xfr_probe_move_to_next_lookup(struct auth_xfer* xfr, struct module_env* env)
4049 if(!xfr->task_probe->lookup_target)
4051 if(!xfr->task_probe->lookup_aaaa && env->cfg->do_ip6) {
4053 xfr->task_probe->lookup_aaaa = 1;
4056 xfr->task_probe->lookup_target = xfr->task_probe->lookup_target->next;
4057 xfr->task_probe->lookup_aaaa = 0;
4058 if(!env->cfg->do_ip4 && xfr->task_probe->lookup_target!=NULL)
4059 xfr->task_probe->lookup_aaaa = 1;
4064 xfr_transfer_start_list(struct auth_xfer* xfr, struct auth_master* spec)
4067 xfr->task_transfer->scan_specific = find_master_by_host(
4068 xfr->task_transfer->masters, spec->host);
4069 if(xfr->task_transfer->scan_specific) {
4070 xfr->task_transfer->scan_target = NULL;
4071 xfr->task_transfer->scan_addr = NULL;
4072 if(xfr->task_transfer->scan_specific->list)
4073 xfr->task_transfer->scan_addr =
4074 xfr->task_transfer->scan_specific->list;
4079 xfr->task_transfer->scan_specific = NULL;
4080 xfr->task_transfer->scan_addr = NULL;
4082 xfr->task_transfer->scan_target = xfr->task_transfer->masters;
4083 if(xfr->task_transfer->scan_target && xfr->task_transfer->
4085 xfr->task_transfer->scan_addr =
4086 xfr->task_transfer->scan_target->list;
4091 xfr_probe_start_list(struct auth_xfer* xfr, struct auth_master* spec)
4094 xfr->task_probe->scan_specific = find_master_by_host(
4095 xfr->task_probe->masters, spec->host);
4096 if(xfr->task_probe->scan_specific) {
4097 xfr->task_probe->scan_target = NULL;
4098 xfr->task_probe->scan_addr = NULL;
4099 if(xfr->task_probe->scan_specific->list)
4100 xfr->task_probe->scan_addr =
4101 xfr->task_probe->scan_specific->list;
4106 xfr->task_probe->scan_specific = NULL;
4107 xfr->task_probe->scan_addr = NULL;
4109 xfr->task_probe->scan_target = xfr->task_probe->masters;
4110 if(xfr->task_probe->scan_target && xfr->task_probe->scan_target->list)
4111 xfr->task_probe->scan_addr =
4112 xfr->task_probe->scan_target->list;
4117 xfr_transfer_current_master(struct auth_xfer* xfr)
4119 if(xfr->task_transfer->scan_specific)
4120 return xfr->task_transfer->scan_specific;
4121 return xfr->task_transfer->scan_target;
4126 xfr_probe_current_master(struct auth_xfer* xfr)
4128 if(xfr->task_probe->scan_specific)
4129 return xfr->task_probe->scan_specific;
4130 return xfr->task_probe->scan_target;
4135 xfr_transfer_end_of_list(struct auth_xfer* xfr)
4137 return !xfr->task_transfer->scan_specific &&
4138 !xfr->task_transfer->scan_target;
4143 xfr_probe_end_of_list(struct auth_xfer* xfr)
4145 return !xfr->task_probe->scan_specific && !xfr->task_probe->scan_target;
4150 xfr_transfer_nextmaster(struct auth_xfer* xfr)
4152 if(!xfr->task_transfer->scan_specific &&
4153 !xfr->task_transfer->scan_target)
4155 if(xfr->task_transfer->scan_addr) {
4156 xfr->task_transfer->scan_addr =
4157 xfr->task_transfer->scan_addr->next;
4158 if(xfr->task_transfer->scan_addr)
4161 if(xfr->task_transfer->scan_specific) {
4162 xfr->task_transfer->scan_specific = NULL;
4163 xfr->task_transfer->scan_target = xfr->task_transfer->masters;
4164 if(xfr->task_transfer->scan_target && xfr->task_transfer->
4166 xfr->task_transfer->scan_addr =
4167 xfr->task_transfer->scan_target->list;
4170 if(!xfr->task_transfer->scan_target)
4172 xfr->task_transfer->scan_target = xfr->task_transfer->scan_target->next;
4173 if(xfr->task_transfer->scan_target && xfr->task_transfer->
4175 xfr->task_transfer->scan_addr =
4176 xfr->task_transfer->scan_target->list;
4182 xfr_probe_nextmaster(struct auth_xfer* xfr)
4184 if(!xfr->task_probe->scan_specific && !xfr->task_probe->scan_target)
4186 if(xfr->task_probe->scan_addr) {
4187 xfr->task_probe->scan_addr = xfr->task_probe->scan_addr->next;
4188 if(xfr->task_probe->scan_addr)
4191 if(xfr->task_probe->scan_specific) {
4192 xfr->task_probe->scan_specific = NULL;
4193 xfr->task_probe->scan_target = xfr->task_probe->masters;
4194 if(xfr->task_probe->scan_target && xfr->task_probe->
4196 xfr->task_probe->scan_addr =
4197 xfr->task_probe->scan_target->list;
4200 if(!xfr->task_probe->scan_target)
4202 xfr->task_probe->scan_target = xfr->task_probe->scan_target->next;
4203 if(xfr->task_probe->scan_target && xfr->task_probe->
4205 xfr->task_probe->scan_addr =
4206 xfr->task_probe->scan_target->list;
4210 /** create SOA probe packet for xfr */
4212 xfr_create_soa_probe_packet(struct auth_xfer* xfr, sldns_buffer* buf,
4218 qinfo.qname = xfr->name;
4219 qinfo.qname_len = xfr->namelen;
4221 qinfo.qclass = xfr->dclass;
4226 /** create IXFR/AXFR packet for xfr */
4228 xfr_create_ixfr_packet(struct auth_xfer* xfr, sldns_buffer* buf, uint16_t id,
4234 have_zone = xfr->have_zone;
4235 serial = xfr->serial;
4238 qinfo.qname = xfr->name;
4239 qinfo.qname_len = xfr->namelen;
4240 xfr->task_transfer->got_xfr_serial = 0;
4241 xfr->task_transfer->rr_scan_num = 0;
4242 xfr->task_transfer->incoming_xfr_serial = 0;
4243 xfr->task_transfer->on_ixfr_is_axfr = 0;
4244 xfr->task_transfer->on_ixfr = 1;
4246 if(!have_zone || xfr->task_transfer->ixfr_fail || !master->ixfr) {
4248 xfr->task_transfer->ixfr_fail = 0;
4249 xfr->task_transfer->on_ixfr = 0;
4252 qinfo.qclass = xfr->dclass;
4283 check_packet_ok(sldns_buffer* pkt, uint16_t qtype, struct auth_xfer* xfr,
4293 if(LDNS_ID_WIRE(sldns_buffer_begin(pkt)) != xfr->task_probe->id)
4308 if(sldns_buffer_remaining(pkt) < xfr->namelen)
4310 if(query_dname_compare(sldns_buffer_current(pkt), xfr->name) != 0)
4312 sldns_buffer_skip(pkt, (ssize_t)xfr->namelen);
4319 if(sldns_buffer_read_u16(pkt) != xfr->dclass)
4331 xfr->name) != 0)
4340 if(sldns_buffer_read_u16(pkt) != xfr->dclass)
4573 http_zonefile_syntax_check(struct auth_xfer* xfr, sldns_buffer* buf)
4583 if(xfr->namelen < sizeof(pstate.origin)) {
4584 pstate.origin_len = xfr->namelen;
4585 memmove(pstate.origin, xfr->name, xfr->namelen);
4587 chunk = xfr->task_transfer->chunks_first;
4604 if(sldns_wirerr_get_class(rr, rr_len, dname_len) != xfr->dclass) {
4643 http_parse_add_rr(struct auth_xfer* xfr, struct auth_zone* z,
4657 xfr->task_transfer->master->host,
4658 xfr->task_transfer->master->file,
4679 chunk_rrlist_start(struct auth_xfer* xfr, struct auth_chunk** rr_chunk,
4682 *rr_chunk = xfr->task_transfer->chunks_first;
4850 apply_ixfr(struct auth_xfer* xfr, struct auth_zone* z,
4867 chunk_rrlist_start(xfr, &rr_chunk, &rr_num, &rr_pos);
4898 transfer_serial, xfr->serial)) {
4919 xfr->serial = transfer_serial;
4987 apply_axfr(struct auth_xfer* xfr, struct auth_zone* z,
5008 xfr->have_zone = 0;
5009 xfr->serial = 0;
5014 chunk_rrlist_start(xfr, &rr_chunk, &rr_num, &rr_pos);
5050 xfr->serial = serial;
5051 xfr->have_zone = 1;
5057 apply_http(struct auth_xfer* xfr, struct auth_zone* z,
5069 if(xfr->namelen < sizeof(pstate.origin)) {
5070 pstate.origin_len = xfr->namelen;
5071 memmove(pstate.origin, xfr->name, xfr->namelen);
5076 xfr->task_transfer->master->file,
5077 (int)chunklist_sum(xfr->task_transfer->chunks_first));
5078 if(xfr->task_transfer->chunks_first && verbosity >= VERB_ALGO) {
5080 if(xfr->task_transfer->chunks_first->len+1 > sizeof(preview)) {
5081 memmove(preview, xfr->task_transfer->chunks_first->data,
5085 memmove(preview, xfr->task_transfer->chunks_first->data,
5086 xfr->task_transfer->chunks_first->len);
5087 preview[xfr->task_transfer->chunks_first->len]=0;
5094 if(!http_zonefile_syntax_check(xfr, scratch_buffer)) {
5096 "but got '%s'", xfr->task_transfer->master->host,
5097 xfr->task_transfer->master->file,
5109 xfr->have_zone = 0;
5110 xfr->serial = 0;
5112 chunk = xfr->task_transfer->chunks_first;
5126 xfr->task_transfer->master->file,
5136 xfr->task_transfer->master->file,
5143 if(!http_parse_add_rr(xfr, z, scratch_buffer, &pstate)) {
5145 xfr->task_transfer->master->file,
5156 auth_zone_write_chunks(struct auth_xfer* xfr, const char* fname)
5165 for(p = xfr->task_transfer->chunks_first; p ; p = p->next) {
5178 xfr_write_after_update(struct auth_xfer* xfr, struct module_env* env)
5184 lock_basic_unlock(&xfr->lock);
5189 z = auth_zone_find(env->auth_zones, xfr->name, xfr->namelen,
5190 xfr->dclass);
5193 /* the zone is gone, ignore xfr results */
5194 lock_basic_lock(&xfr->lock);
5198 lock_basic_lock(&xfr->lock);
5225 if(xfr->task_transfer->master->http) {
5227 if(!auth_zone_write_chunks(xfr, tmpfile)) {
5251 * with xfr and z locks, if fail, no z lock */
5252 static int xfr_process_reacquire_locks(struct auth_xfer* xfr,
5255 /* release xfr lock, then, while holding az->lock grab both
5256 * z->lock and xfr->lock */
5258 *z = auth_zone_find(env->auth_zones, xfr->name, xfr->namelen,
5259 xfr->dclass);
5262 lock_basic_lock(&xfr->lock);
5267 lock_basic_lock(&xfr->lock);
5275 xfr_process_chunk_list(struct auth_xfer* xfr, struct module_env* env,
5281 lock_basic_unlock(&xfr->lock);
5282 if(!xfr_process_reacquire_locks(xfr, env, &z)) {
5283 /* the zone is gone, ignore xfr results */
5286 /* holding xfr and z locks */
5289 if(xfr->task_transfer->master->http) {
5290 if(!apply_http(xfr, z, env->scratch_buffer)) {
5293 xfr->task_transfer->master->host);
5296 } else if(xfr->task_transfer->on_ixfr &&
5297 !xfr->task_transfer->on_ixfr_is_axfr) {
5298 if(!apply_ixfr(xfr, z, env->scratch_buffer)) {
5300 verbose(VERB_ALGO, "xfr from %s: could not store IXFR"
5301 " data", xfr->task_transfer->master->host);
5306 if(!apply_axfr(xfr, z, env->scratch_buffer)) {
5308 verbose(VERB_ALGO, "xfr from %s: could not store AXFR"
5309 " data", xfr->task_transfer->master->host);
5313 xfr->zone_expired = 0;
5315 if(!xfr_find_soa(z, xfr)) {
5317 verbose(VERB_ALGO, "xfr from %s: no SOA in zone after update"
5318 " (or malformed RR)", xfr->task_transfer->master->host);
5322 /* release xfr lock while verifying zonemd because it may have
5324 lock_basic_unlock(&xfr->lock);
5330 /* reacquire locks, so we hold xfr lock on exit of routine,
5331 * and both xfr and z again after releasing xfr for potential
5334 if(!xfr_process_reacquire_locks(xfr, env, &z))
5336 dname_str(xfr->name, zname);
5337 verbose(VERB_ALGO, "xfr from %s: ZONEMD failed for %s, transfer is failed", xfr->task_transfer->master->host, zname);
5338 xfr->zone_expired = 1;
5342 /* reacquire locks, so we hold xfr lock on exit of routine,
5343 * and both xfr and z again after releasing xfr for potential
5346 if(!xfr_process_reacquire_locks(xfr, env, &z))
5348 /* holding xfr and z locks */
5350 if(xfr->have_zone)
5351 xfr->lease_time = *env->now;
5359 if(verbosity >= VERB_QUERY && xfr->have_zone) {
5361 dname_str(xfr->name, zname);
5363 (unsigned)xfr->serial);
5366 xfr_write_after_update(xfr, env);
5370 /** disown task_transfer. caller must hold xfr.lock */
5372 xfr_transfer_disown(struct auth_xfer* xfr)
5375 comm_timer_delete(xfr->task_transfer->timer);
5376 xfr->task_transfer->timer = NULL;
5378 comm_point_delete(xfr->task_transfer->cp);
5379 xfr->task_transfer->cp = NULL;
5381 xfr->task_transfer->worker = NULL;
5382 xfr->task_transfer->env = NULL;
5387 xfr_transfer_lookup_host(struct auth_xfer* xfr, struct module_env* env)
5391 struct auth_master* master = xfr->task_transfer->lookup_target;
5415 qinfo.qclass = xfr->dclass;
5417 if(xfr->task_transfer->lookup_aaaa)
5423 dname_str(xfr->name, buf2);
5442 /* unlock xfr during mesh_new_callback() because the callback can be
5444 lock_basic_unlock(&xfr->lock);
5446 &auth_xfer_transfer_lookup_callback, xfr, 0)) {
5447 lock_basic_lock(&xfr->lock);
5451 lock_basic_lock(&xfr->lock);
5458 xfr_transfer_init_fetch(struct auth_xfer* xfr, struct module_env* env)
5462 struct auth_master* master = xfr->task_transfer->master;
5470 if(xfr->task_transfer->scan_addr) {
5471 addrlen = xfr->task_transfer->scan_addr->addrlen;
5472 memmove(&addr, &xfr->task_transfer->scan_addr->addr, addrlen);
5479 dname_str(xfr->name, zname);
5487 if(xfr->task_transfer->cp) {
5488 comm_point_delete(xfr->task_transfer->cp);
5489 xfr->task_transfer->cp = NULL;
5491 if(!xfr->task_transfer->timer) {
5492 xfr->task_transfer->timer = comm_timer_create(env->worker_base,
5493 auth_xfer_transfer_timer_callback, xfr);
5494 if(!xfr->task_transfer->timer) {
5509 xfr->task_transfer->on_ixfr = 0;
5512 xfr->task_transfer->cp = outnet_comm_point_for_http(
5513 env->outnet, auth_xfer_transfer_http_callback, xfr,
5516 if(!xfr->task_transfer->cp) {
5518 dname_str(xfr->name, zname);
5524 comm_timer_set(xfr->task_transfer->timer, &t);
5527 dname_str(xfr->name, zname);
5532 probe_copy_masters_for_allow_notify(xfr);
5539 xfr->task_transfer->id = GET_RANDOM_ID(env->rnd);
5540 xfr_create_ixfr_packet(xfr, env->scratch_buffer,
5541 xfr->task_transfer->id, master);
5544 xfr->task_transfer->cp = outnet_comm_point_for_tcp(env->outnet,
5545 auth_xfer_transfer_tcp_callback, xfr, &addr, addrlen,
5548 if(!xfr->task_transfer->cp) {
5550 dname_str(xfr->name, zname);
5553 "xfr %s to %s", zname, as);
5556 comm_timer_set(xfr->task_transfer->timer, &t);
5559 dname_str(xfr->name, zname);
5562 (xfr->task_transfer->on_ixfr?"IXFR":"AXFR"), as);
5569 xfr_transfer_nexttarget_or_end(struct auth_xfer* xfr, struct module_env* env)
5571 log_assert(xfr->task_transfer->worker == env->worker);
5574 while(xfr->task_transfer->lookup_target) {
5575 if(xfr_transfer_lookup_host(xfr, env)) {
5583 dname_str(xfr->name, zname);
5586 lock_basic_unlock(&xfr->lock);
5589 xfr_transfer_move_to_next_lookup(xfr, env);
5594 while(!xfr_transfer_end_of_list(xfr)) {
5595 xfr->task_transfer->master = xfr_transfer_current_master(xfr);
5596 if(xfr_transfer_init_fetch(xfr, env)) {
5598 lock_basic_unlock(&xfr->lock);
5602 xfr_transfer_nextmaster(xfr);
5606 dname_str(xfr->name, zname);
5612 xfr_transfer_disown(xfr);
5615 if(xfr->task_nextprobe->worker == NULL)
5616 xfr_set_timeout(xfr, env, 1, 0);
5617 lock_basic_unlock(&xfr->lock);
5678 struct auth_xfer* xfr = (struct auth_xfer*)arg;
5680 log_assert(xfr->task_transfer);
5681 lock_basic_lock(&xfr->lock);
5682 env = xfr->task_transfer->env;
5684 lock_basic_unlock(&xfr->lock);
5694 if(xfr->task_transfer->lookup_aaaa)
5704 xfr_master_add_addrs(xfr->task_transfer->
5709 dname_str(xfr->name, zname);
5710 verbose(VERB_ALGO, "auth zone %s host %s type %s transfer lookup has nodata", zname, xfr->task_transfer->lookup_target->host, (xfr->task_transfer->lookup_aaaa?"AAAA":"A"));
5716 dname_str(xfr->name, zname);
5717 verbose(VERB_ALGO, "auth zone %s host %s type %s transfer lookup has no answer", zname, xfr->task_transfer->lookup_target->host, (xfr->task_transfer->lookup_aaaa?"AAAA":"A"));
5724 dname_str(xfr->name, zname);
5725 verbose(VERB_ALGO, "auth zone %s host %s type %s transfer lookup failed", zname, xfr->task_transfer->lookup_target->host, (xfr->task_transfer->lookup_aaaa?"AAAA":"A"));
5728 if(xfr->task_transfer->lookup_target->list &&
5729 xfr->task_transfer->lookup_target == xfr_transfer_current_master(xfr))
5730 xfr->task_transfer->scan_addr = xfr->task_transfer->lookup_target->list;
5734 xfr_transfer_move_to_next_lookup(xfr, env);
5735 xfr_transfer_nexttarget_or_end(xfr, env);
5746 check_xfer_packet(sldns_buffer* pkt, struct auth_xfer* xfr,
5752 verbose(VERB_ALGO, "xfr to %s failed, packet too small",
5753 xfr->task_transfer->master->host);
5757 verbose(VERB_ALGO, "xfr to %s failed, packet has no QR flag",
5758 xfr->task_transfer->master->host);
5762 verbose(VERB_ALGO, "xfr to %s failed, packet has TC flag",
5763 xfr->task_transfer->master->host);
5767 if(LDNS_ID_WIRE(wire) != xfr->task_transfer->id) {
5768 verbose(VERB_ALGO, "xfr to %s failed, packet wrong ID",
5769 xfr->task_transfer->master->host);
5777 if(xfr->task_transfer->on_ixfr) {
5782 verbose(VERB_ALGO, "xfr to %s, fallback "
5784 xfr->task_transfer->master->host,
5786 xfr->task_transfer->ixfr_fail = 1;
5791 verbose(VERB_ALGO, "xfr to %s failed, packet with rcode %s",
5792 xfr->task_transfer->master->host, rcode);
5796 verbose(VERB_ALGO, "xfr to %s failed, packet with bad opcode",
5797 xfr->task_transfer->master->host);
5801 verbose(VERB_ALGO, "xfr to %s failed, packet has qdcount %d",
5802 xfr->task_transfer->master->host,
5813 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5815 xfr->task_transfer->master->host);
5819 xfr->name) != 0) {
5820 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5822 xfr->task_transfer->master->host);
5826 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5828 xfr->task_transfer->master->host);
5833 if(qclass != xfr->dclass) {
5834 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5836 xfr->task_transfer->master->host);
5839 if(xfr->task_transfer->on_ixfr) {
5841 verbose(VERB_ALGO, "xfr to %s failed, packet "
5843 xfr->task_transfer->master->host);
5848 verbose(VERB_ALGO, "xfr to %s failed, packet "
5850 xfr->task_transfer->master->host);
5863 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5865 xfr->task_transfer->master->host);
5869 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5871 xfr->task_transfer->master->host);
5879 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5881 xfr->task_transfer->master->host);
5887 if(xfr->task_transfer->rr_scan_num == 0 &&
5889 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5891 xfr->task_transfer->master->host);
5894 if(xfr->task_transfer->rr_scan_num == 1 &&
5898 xfr->task_transfer->on_ixfr_is_axfr = 1;
5903 verbose(VERB_ALGO, "xfr to %s failed, packet "
5905 xfr->task_transfer->master->host);
5909 xfr->name) != 0) {
5910 verbose(VERB_ALGO, "xfr to %s failed, packet "
5912 xfr->task_transfer->master->host);
5921 if(xfr->task_transfer->on_ixfr &&
5922 xfr->task_transfer->rr_scan_num == 0 &&
5924 verbose(VERB_ALGO, "xfr to %s ended, "
5927 xfr->task_transfer->master->host,
5929 xfr->task_transfer->ixfr_fail = 1;
5935 if(xfr->task_transfer->got_xfr_serial == 0) {
5936 xfr->task_transfer->got_xfr_serial = 1;
5937 xfr->task_transfer->incoming_xfr_serial =
5939 verbose(VERB_ALGO, "xfr %s: contains "
5941 xfr->task_transfer->master->host,
5944 } else if(!xfr->task_transfer->on_ixfr ||
5945 xfr->task_transfer->on_ixfr_is_axfr) {
5949 verbose(VERB_ALGO, "xfr %s: last AXFR packet",
5950 xfr->task_transfer->master->host);
5952 } else if(xfr->task_transfer->incoming_xfr_serial ==
5953 serial && xfr->task_transfer->got_xfr_serial
5955 xfr->task_transfer->got_xfr_serial++;
5958 } else if(xfr->task_transfer->incoming_xfr_serial ==
5959 serial && xfr->task_transfer->got_xfr_serial
5961 verbose(VERB_ALGO, "xfr %s: last IXFR packet",
5962 xfr->task_transfer->master->host);
5968 xfr->task_transfer->rr_scan_num++;
5979 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5981 xfr->task_transfer->master->host);
5985 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5987 xfr->task_transfer->master->host);
5995 verbose(VERB_ALGO, "xfr to %s failed, packet with "
5997 xfr->task_transfer->master->host);
6008 verbose(VERB_ALGO, "xfr to %s failed, packet with "
6010 xfr->task_transfer->master->host);
6014 verbose(VERB_ALGO, "xfr to %s failed, packet with "
6016 xfr->task_transfer->master->host);
6024 verbose(VERB_ALGO, "xfr to %s failed, packet with "
6026 xfr->task_transfer->master->host);
6038 xfer_link_data(sldns_buffer* pkt, struct auth_xfer* xfr)
6053 if(!xfr->task_transfer->chunks_first)
6054 xfr->task_transfer->chunks_first = e;
6055 if(xfr->task_transfer->chunks_last)
6056 xfr->task_transfer->chunks_last->next = e;
6057 xfr->task_transfer->chunks_last = e;
6064 process_list_end_transfer(struct auth_xfer* xfr, struct module_env* env)
6067 if(xfr_process_chunk_list(xfr, env, &ixfr_fail)) {
6069 auth_chunks_delete(xfr->task_transfer);
6072 xfr_transfer_disown(xfr);
6074 if(xfr->notify_received && (!xfr->notify_has_serial ||
6075 (xfr->notify_has_serial &&
6076 xfr_serial_means_update(xfr, xfr->notify_serial)))) {
6077 uint32_t sr = xfr->notify_serial;
6078 int has_sr = xfr->notify_has_serial;
6081 xfr->notify_received = 0;
6082 xfr->notify_has_serial = 0;
6083 xfr->notify_serial = 0;
6084 if(!xfr_start_probe(xfr, env, NULL)) {
6087 * while xfr still locked */
6088 xfr->notify_received = 1;
6089 xfr->notify_has_serial = has_sr;
6090 xfr->notify_serial = sr;
6091 lock_basic_unlock(&xfr->lock);
6096 if(xfr->task_nextprobe->worker == NULL)
6097 xfr_set_timeout(xfr, env, 0, 0);
6099 lock_basic_unlock(&xfr->lock);
6104 auth_chunks_delete(xfr->task_transfer);
6106 xfr->task_transfer->ixfr_fail = 1;
6108 xfr_transfer_nextmaster(xfr);
6110 xfr_transfer_nexttarget_or_end(xfr, env);
6117 struct auth_xfer* xfr = (struct auth_xfer*)arg;
6120 log_assert(xfr->task_transfer);
6121 lock_basic_lock(&xfr->lock);
6122 env = xfr->task_transfer->env;
6124 lock_basic_unlock(&xfr->lock);
6128 verbose(VERB_ALGO, "xfr stopped, connection timeout to %s",
6129 xfr->task_transfer->master->host);
6132 if(xfr->task_transfer->on_ixfr) {
6133 xfr->task_transfer->ixfr_possible_timeout_count++;
6134 if(xfr->task_transfer->ixfr_possible_timeout_count >=
6136 verbose(VERB_ALGO, "xfr to %s, fallback "
6138 xfr->task_transfer->master->host);
6139 xfr->task_transfer->ixfr_fail = 1;
6145 auth_chunks_delete(xfr->task_transfer);
6146 comm_point_delete(xfr->task_transfer->cp);
6147 xfr->task_transfer->cp = NULL;
6149 xfr_transfer_nextmaster(xfr);
6150 xfr_transfer_nexttarget_or_end(xfr, env);
6158 struct auth_xfer* xfr = (struct auth_xfer*)arg;
6162 log_assert(xfr->task_transfer);
6163 lock_basic_lock(&xfr->lock);
6164 env = xfr->task_transfer->env;
6166 lock_basic_unlock(&xfr->lock);
6170 comm_timer_disable(xfr->task_transfer->timer);
6176 verbose(VERB_ALGO, "xfr stopped, connection lost to %s",
6177 xfr->task_transfer->master->host);
6180 if(xfr->task_transfer->on_ixfr) {
6181 xfr->task_transfer->ixfr_possible_timeout_count++;
6182 if(xfr->task_transfer->ixfr_possible_timeout_count >=
6184 verbose(VERB_ALGO, "xfr to %s, fallback "
6186 xfr->task_transfer->master->host);
6187 xfr->task_transfer->ixfr_fail = 1;
6194 auth_chunks_delete(xfr->task_transfer);
6195 comm_point_delete(xfr->task_transfer->cp);
6196 xfr->task_transfer->cp = NULL;
6198 xfr_transfer_nextmaster(xfr);
6199 xfr_transfer_nexttarget_or_end(xfr, env);
6203 if(xfr->task_transfer->on_ixfr)
6204 xfr->task_transfer->ixfr_possible_timeout_count = 0;
6209 if(!check_xfer_packet(c->buffer, xfr, &gonextonfail, &transferdone)) {
6214 if(!xfer_link_data(c->buffer, xfr)) {
6215 verbose(VERB_ALGO, "xfr stopped to %s, malloc failed",
6216 xfr->task_transfer->master->host);
6221 comm_point_delete(xfr->task_transfer->cp);
6222 xfr->task_transfer->cp = NULL;
6223 process_list_end_transfer(xfr, env);
6229 lock_basic_unlock(&xfr->lock);
6241 struct auth_xfer* xfr = (struct auth_xfer*)arg;
6243 log_assert(xfr->task_transfer);
6244 lock_basic_lock(&xfr->lock);
6245 env = xfr->task_transfer->env;
6247 lock_basic_unlock(&xfr->lock);
6252 comm_timer_disable(xfr->task_transfer->timer);
6259 xfr->task_transfer->master->host);
6262 auth_chunks_delete(xfr->task_transfer);
6265 comm_point_delete(xfr->task_transfer->cp);
6266 xfr->task_transfer->cp = NULL;
6267 xfr_transfer_nextmaster(xfr);
6268 xfr_transfer_nexttarget_or_end(xfr, env);
6277 if(!xfer_link_data(c->buffer, xfr)) {
6279 xfr->task_transfer->master->host);
6287 comm_point_delete(xfr->task_transfer->cp);
6288 xfr->task_transfer->cp = NULL;
6289 process_list_end_transfer(xfr, env);
6295 lock_basic_unlock(&xfr->lock);
6303 /** start transfer task by this worker , xfr is locked. */
6305 xfr_start_transfer(struct auth_xfer* xfr, struct module_env* env,
6308 log_assert(xfr->task_transfer != NULL);
6309 log_assert(xfr->task_transfer->worker == NULL);
6310 log_assert(xfr->task_transfer->chunks_first == NULL);
6311 log_assert(xfr->task_transfer->chunks_last == NULL);
6312 xfr->task_transfer->worker = env->worker;
6313 xfr->task_transfer->env = env;
6317 xfr_transfer_start_list(xfr, master);
6319 xfr_transfer_start_lookups(xfr);
6322 xfr_transfer_nexttarget_or_end(xfr, env);
6325 /** disown task_probe. caller must hold xfr.lock */
6327 xfr_probe_disown(struct auth_xfer* xfr)
6330 comm_timer_delete(xfr->task_probe->timer);
6331 xfr->task_probe->timer = NULL;
6333 comm_point_delete(xfr->task_probe->cp);
6334 xfr->task_probe->cp = NULL;
6336 xfr->task_probe->worker = NULL;
6337 xfr->task_probe->env = NULL;
6342 xfr_probe_send_probe(struct auth_xfer* xfr, struct module_env* env,
6349 struct auth_master* master = xfr_probe_current_master(xfr);
6357 if(xfr->task_probe->scan_addr) {
6358 addrlen = xfr->task_probe->scan_addr->addrlen;
6359 memmove(&addr, &xfr->task_probe->scan_addr->addr, addrlen);
6366 dname_str(xfr->name, zname);
6389 xfr->task_probe->id = GET_RANDOM_ID(env->rnd);
6390 xfr_create_soa_probe_packet(xfr, env->scratch_buffer,
6391 xfr->task_probe->id);
6393 if(xfr->task_probe->cp &&
6394 ((xfr->task_probe->cp_is_ip6 && !addr_is_ip6(&addr, addrlen)) ||
6395 (!xfr->task_probe->cp_is_ip6 && addr_is_ip6(&addr, addrlen)))
6397 comm_point_delete(xfr->task_probe->cp);
6398 xfr->task_probe->cp = NULL;
6400 if(!xfr->task_probe->cp) {
6402 xfr->task_probe->cp_is_ip6 = 1;
6403 else xfr->task_probe->cp_is_ip6 = 0;
6404 xfr->task_probe->cp = outnet_comm_point_for_udp(env->outnet,
6405 auth_xfer_probe_udp_callback, xfr, &addr, addrlen);
6406 if(!xfr->task_probe->cp) {
6408 dname_str(xfr->name, zname);
6415 if(!xfr->task_probe->timer) {
6416 xfr->task_probe->timer = comm_timer_create(env->worker_base,
6417 auth_xfer_probe_timer_callback, xfr);
6418 if(!xfr->task_probe->timer) {
6425 if(!comm_point_send_udp_msg(xfr->task_probe->cp, env->scratch_buffer,
6428 dname_str(xfr->name, zname);
6436 dname_str(xfr->name, zname);
6441 xfr->task_probe->timeout = timeout;
6446 comm_timer_set(xfr->task_probe->timer, &t);
6455 struct auth_xfer* xfr = (struct auth_xfer*)arg;
6457 log_assert(xfr->task_probe);
6458 lock_basic_lock(&xfr->lock);
6459 env = xfr->task_probe->env;
6461 lock_basic_unlock(&xfr->lock);
6467 dname_str(xfr->name, zname);
6470 if(xfr->task_probe->timeout <= AUTH_PROBE_TIMEOUT_STOP) {
6472 if(xfr_probe_send_probe(xfr, env, xfr->task_probe->timeout*2)) {
6473 lock_basic_unlock(&xfr->lock);
6478 comm_point_delete(xfr->task_probe->cp);
6479 xfr->task_probe->cp = NULL;
6482 xfr_probe_nextmaster(xfr);
6483 xfr_probe_send_or_end(xfr, env);
6491 struct auth_xfer* xfr = (struct auth_xfer*)arg;
6493 log_assert(xfr->task_probe);
6494 lock_basic_lock(&xfr->lock);
6495 env = xfr->task_probe->env;
6497 lock_basic_unlock(&xfr->lock);
6505 comm_timer_disable(xfr->task_probe->timer);
6510 if(check_packet_ok(c->buffer, LDNS_RR_TYPE_SOA, xfr,
6515 dname_str(xfr->name, buf);
6521 if(xfr_serial_means_update(xfr, serial)) {
6524 if(xfr->task_transfer->worker == NULL) {
6526 xfr_probe_current_master(xfr);
6530 if(xfr->task_transfer->masters &&
6531 xfr->task_transfer->masters->http)
6533 xfr_probe_disown(xfr);
6534 xfr_start_transfer(xfr, env, master);
6539 xfr_probe_disown(xfr);
6540 lock_basic_unlock(&xfr->lock);
6549 xfr->task_probe->have_new_lease = 1;
6554 dname_str(xfr->name, buf);
6561 dname_str(xfr->name, buf);
6568 comm_point_delete(xfr->task_probe->cp);
6569 xfr->task_probe->cp = NULL;
6573 xfr_probe_nextmaster(xfr);
6574 xfr_probe_send_or_end(xfr, env);
6580 xfr_probe_lookup_host(struct auth_xfer* xfr, struct module_env* env)
6584 struct auth_master* master = xfr->task_probe->lookup_target;
6610 qinfo.qclass = xfr->dclass;
6612 if(xfr->task_probe->lookup_aaaa)
6618 dname_str(xfr->name, buf2);
6637 /* unlock xfr during mesh_new_callback() because the callback can be
6639 lock_basic_unlock(&xfr->lock);
6641 &auth_xfer_probe_lookup_callback, xfr, 0)) {
6642 lock_basic_lock(&xfr->lock);
6646 lock_basic_lock(&xfr->lock);
6652 xfr_probe_send_or_end(struct auth_xfer* xfr, struct module_env* env)
6655 while(xfr->task_probe->lookup_target) {
6656 if(xfr_probe_lookup_host(xfr, env)) {
6664 dname_str(xfr->name, zname);
6667 lock_basic_unlock(&xfr->lock);
6670 xfr_probe_move_to_next_lookup(xfr, env);
6674 probe_copy_masters_for_allow_notify(xfr);
6677 dname_str(xfr->name, zname);
6680 if(xfr->task_probe->only_lookup) {
6682 xfr->task_probe->only_lookup = 0;
6685 dname_str(xfr->name, zname);
6688 xfr_probe_disown(xfr);
6689 if(xfr->task_nextprobe->worker == NULL)
6690 xfr_set_timeout(xfr, env, 0, 0);
6691 lock_basic_unlock(&xfr->lock);
6696 while(!xfr_probe_end_of_list(xfr)) {
6697 if(xfr_probe_send_probe(xfr, env, AUTH_PROBE_TIMEOUT)) {
6699 lock_basic_unlock(&xfr->lock);
6703 xfr_probe_nextmaster(xfr);
6707 if(xfr->task_probe->have_new_lease) {
6711 dname_str(xfr->name, zname);
6714 xfr_probe_disown(xfr);
6715 if(xfr->have_zone)
6716 xfr->lease_time = *env->now;
6717 if(xfr->task_nextprobe->worker == NULL)
6718 xfr_set_timeout(xfr, env, 0, 0);
6722 dname_str(xfr->name, zname);
6727 xfr_probe_disown(xfr);
6729 if(xfr->task_nextprobe->worker == NULL)
6730 xfr_set_timeout(xfr, env, 1, 0);
6733 lock_basic_unlock(&xfr->lock);
6741 struct auth_xfer* xfr = (struct auth_xfer*)arg;
6743 log_assert(xfr->task_probe);
6744 lock_basic_lock(&xfr->lock);
6745 env = xfr->task_probe->env;
6747 lock_basic_unlock(&xfr->lock);
6757 if(xfr->task_probe->lookup_aaaa)
6767 xfr_master_add_addrs(xfr->task_probe->
6772 dname_str(xfr->name, zname);
6773 verbose(VERB_ALGO, "auth zone %s host %s type %s probe lookup has nodata", zname, xfr->task_probe->lookup_target->host, (xfr->task_probe->lookup_aaaa?"AAAA":"A"));
6779 dname_str(xfr->name, zname);
6780 verbose(VERB_ALGO, "auth zone %s host %s type %s probe lookup has no address", zname, xfr->task_probe->lookup_target->host, (xfr->task_probe->lookup_aaaa?"AAAA":"A"));
6787 dname_str(xfr->name, zname);
6788 verbose(VERB_ALGO, "auth zone %s host %s type %s probe lookup failed", zname, xfr->task_probe->lookup_target->host, (xfr->task_probe->lookup_aaaa?"AAAA":"A"));
6791 if(xfr->task_probe->lookup_target->list &&
6792 xfr->task_probe->lookup_target == xfr_probe_current_master(xfr))
6793 xfr->task_probe->scan_addr = xfr->task_probe->lookup_target->list;
6797 xfr_probe_move_to_next_lookup(xfr, env);
6798 xfr_probe_send_or_end(xfr, env);
6801 /** disown task_nextprobe. caller must hold xfr.lock */
6803 xfr_nextprobe_disown(struct auth_xfer* xfr)
6807 comm_timer_delete(xfr->task_nextprobe->timer);
6808 xfr->task_nextprobe->timer = NULL;
6809 xfr->task_nextprobe->next_probe = 0;
6811 xfr->task_nextprobe->worker = NULL;
6812 xfr->task_nextprobe->env = NULL;
6819 struct auth_xfer* xfr = (struct auth_xfer*)arg;
6821 log_assert(xfr->task_nextprobe);
6822 lock_basic_lock(&xfr->lock);
6823 env = xfr->task_nextprobe->env;
6825 lock_basic_unlock(&xfr->lock);
6830 if(xfr->have_zone && !xfr->zone_expired &&
6831 *env->now >= xfr->lease_time + xfr->expiry) {
6832 lock_basic_unlock(&xfr->lock);
6833 auth_xfer_set_expired(xfr, env, 1);
6834 lock_basic_lock(&xfr->lock);
6837 xfr_nextprobe_disown(xfr);
6839 if(!xfr_start_probe(xfr, env, NULL)) {
6841 lock_basic_unlock(&xfr->lock);
6861 xfr_start_probe(struct auth_xfer* xfr, struct module_env* env,
6866 if(xfr->task_probe->worker == NULL) {
6867 if(!have_probe_targets(xfr->task_probe->masters) &&
6868 !(xfr->task_probe->only_lookup &&
6869 xfr->task_probe->masters != NULL)) {
6872 if(xfr->task_transfer->worker == NULL) {
6873 xfr_start_transfer(xfr, env, spec);
6881 xfr->task_probe->worker = env->worker;
6882 xfr->task_probe->env = env;
6883 xfr->task_probe->cp = NULL;
6887 xfr->task_probe->have_new_lease = 0;
6891 xfr_probe_start_list(xfr, spec);
6893 xfr_probe_start_lookups(xfr);
6895 xfr_probe_send_or_end(xfr, env);
6903 * @param xfr: task structure
6909 xfr_set_timeout(struct auth_xfer* xfr, struct module_env* env,
6913 log_assert(xfr->task_nextprobe != NULL);
6914 log_assert(xfr->task_nextprobe->worker == NULL ||
6915 xfr->task_nextprobe->worker == env->worker);
6919 xfr->task_nextprobe->next_probe = *env->now;
6920 if(xfr->lease_time && !failure)
6921 xfr->task_nextprobe->next_probe = xfr->lease_time;
6924 xfr->task_nextprobe->backoff = 0;
6926 if(xfr->task_nextprobe->backoff == 0)
6927 xfr->task_nextprobe->backoff = 3;
6928 else xfr->task_nextprobe->backoff *= 2;
6929 if(xfr->task_nextprobe->backoff > AUTH_TRANSFER_MAX_BACKOFF)
6930 xfr->task_nextprobe->backoff =
6934 if(xfr->have_zone) {
6935 time_t wait = xfr->refresh;
6936 if(failure) wait = xfr->retry;
6937 if(xfr->expiry < wait)
6938 xfr->task_nextprobe->next_probe += xfr->expiry;
6939 else xfr->task_nextprobe->next_probe += wait;
6941 xfr->task_nextprobe->next_probe +=
6942 xfr->task_nextprobe->backoff;
6944 if(xfr->lease_time && xfr->lease_time+xfr->expiry <
6945 xfr->task_nextprobe->next_probe &&
6946 xfr->lease_time+xfr->expiry > *env->now)
6947 xfr->task_nextprobe->next_probe =
6948 xfr->lease_time+xfr->expiry;
6950 xfr->task_nextprobe->next_probe +=
6951 xfr->task_nextprobe->backoff;
6954 if(!xfr->task_nextprobe->timer) {
6955 xfr->task_nextprobe->timer = comm_timer_create(
6956 env->worker_base, auth_xfer_timer, xfr);
6957 if(!xfr->task_nextprobe->timer) {
6961 dname_str(xfr->name, zname);
6967 xfr->task_nextprobe->worker = env->worker;
6968 xfr->task_nextprobe->env = env;
6969 if(*(xfr->task_nextprobe->env->now) <= xfr->task_nextprobe->next_probe)
6970 tv.tv_sec = xfr->task_nextprobe->next_probe -
6971 *(xfr->task_nextprobe->env->now);
6973 if(tv.tv_sec != 0 && lookup_only && xfr->task_probe->masters) {
6977 if(xfr->task_probe->worker == NULL)
6978 xfr->task_probe->only_lookup = 1;
6982 dname_str(xfr->name, zname);
6987 comm_timer_set(xfr->task_nextprobe->timer, &tv);
7039 struct auth_xfer* xfr;
7040 xfr = (struct auth_xfer*)calloc(1, sizeof(*xfr));
7041 if(!xfr) return NULL;
7042 xfr->name = memdup(z->name, z->namelen);
7043 if(!xfr->name) {
7044 free(xfr);
7047 xfr->node.key = xfr;
7048 xfr->namelen = z->namelen;
7049 xfr->namelabs = z->namelabs;
7050 xfr->dclass = z->dclass;
7052 xfr->task_nextprobe = (struct auth_nextprobe*)calloc(1,
7054 if(!xfr->task_nextprobe) {
7055 free(xfr->name);
7056 free(xfr);
7059 xfr->task_probe = (struct auth_probe*)calloc(1,
7061 if(!xfr->task_probe) {
7062 free(xfr->task_nextprobe);
7063 free(xfr->name);
7064 free(xfr);
7067 xfr->task_transfer = (struct auth_transfer*)calloc(1,
7069 if(!xfr->task_transfer) {
7070 free(xfr->task_probe);
7071 free(xfr->task_nextprobe);
7072 free(xfr->name);
7073 free(xfr);
7077 lock_basic_init(&xfr->lock);
7078 lock_protect(&xfr->lock, &xfr->name, sizeof(xfr->name));
7079 lock_protect(&xfr->lock, &xfr->namelen, sizeof(xfr->namelen));
7080 lock_protect(&xfr->lock, xfr->name, xfr->namelen);
7081 lock_protect(&xfr->lock, &xfr->namelabs, sizeof(xfr->namelabs));
7082 lock_protect(&xfr->lock, &xfr->dclass, sizeof(xfr->dclass));
7083 lock_protect(&xfr->lock, &xfr->notify_received, sizeof(xfr->notify_received));
7084 lock_protect(&xfr->lock, &xfr->notify_serial, sizeof(xfr->notify_serial));
7085 lock_protect(&xfr->lock, &xfr->zone_expired, sizeof(xfr->zone_expired));
7086 lock_protect(&xfr->lock, &xfr->have_zone, sizeof(xfr->have_zone));
7087 lock_protect(&xfr->lock, &xfr->serial, sizeof(xfr->serial));
7088 lock_protect(&xfr->lock, &xfr->retry, sizeof(xfr->retry));
7089 lock_protect(&xfr->lock, &xfr->refresh, sizeof(xfr->refresh));
7090 lock_protect(&xfr->lock, &xfr->expiry, sizeof(xfr->expiry));
7091 lock_protect(&xfr->lock, &xfr->lease_time, sizeof(xfr->lease_time));
7092 lock_protect(&xfr->lock, &xfr->task_nextprobe->worker,
7093 sizeof(xfr->task_nextprobe->worker));
7094 lock_protect(&xfr->lock, &xfr->task_probe->worker,
7095 sizeof(xfr->task_probe->worker));
7096 lock_protect(&xfr->lock, &xfr->task_transfer->worker,
7097 sizeof(xfr->task_transfer->worker));
7098 lock_basic_lock(&xfr->lock);
7099 return xfr;
7110 struct auth_xfer* xfr;
7113 xfr = auth_xfer_new(z);
7114 if(!xfr) {
7119 (void)rbtree_insert(&az->xtree, &xfr->node);
7120 return xfr;