/** move entry into cache */ static int move_into_cache(struct ub_packed_rrset_key* k, struct packed_rrset_data* d, struct worker* worker) { struct ub_packed_rrset_key* ak; struct packed_rrset_data* ad; size_t s, i, num = d->count + d->rrsig_count; struct rrset_ref ref; uint8_t* p; ak = alloc_special_obtain(&worker->alloc); if(!ak) { log_warn("error out of memory"); return 0; } ak->entry.data = NULL; ak->rk = k->rk; ak->entry.hash = rrset_key_hash(&k->rk); ak->rk.dname = (uint8_t*)memdup(k->rk.dname, k->rk.dname_len); if(!ak->rk.dname) { log_warn("error out of memory"); ub_packed_rrset_parsedelete(ak, &worker->alloc); return 0; } s = sizeof(*ad) + (sizeof(size_t) + sizeof(uint8_t*) + sizeof(time_t))* num; for(i=0; i<num; i++) s += d->rr_len[i]; ad = (struct packed_rrset_data*)malloc(s); if(!ad) { log_warn("error out of memory"); ub_packed_rrset_parsedelete(ak, &worker->alloc); return 0; } p = (uint8_t*)ad; memmove(p, d, sizeof(*ad)); p += sizeof(*ad); memmove(p, &d->rr_len[0], sizeof(size_t)*num); p += sizeof(size_t)*num; memmove(p, &d->rr_data[0], sizeof(uint8_t*)*num); p += sizeof(uint8_t*)*num; memmove(p, &d->rr_ttl[0], sizeof(time_t)*num); p += sizeof(time_t)*num; for(i=0; i<num; i++) { memmove(p, d->rr_data[i], d->rr_len[i]); p += d->rr_len[i]; } packed_rrset_ptr_fixup(ad); ak->entry.data = ad; ref.key = ak; ref.id = ak->id; (void)rrset_cache_update(worker->env.rrset_cache, &ref, &worker->alloc, *worker->env.now); return 1; }
void reply_info_parsedelete(struct reply_info* rep, struct alloc_cache* alloc) { size_t i; if(!rep) return; /* no need to lock, since not shared in hashtables. */ for(i=0; i<rep->rrset_count; i++) { ub_packed_rrset_parsedelete(rep->rrsets[i], alloc); } free(rep); }
/** verify from a file */ static void verifytest_file(const char* fname, const char* at_date) { /* * The file contains a list of ldns-testpkts entries. * The first entry must be a query for DNSKEY. * The answer rrset is the keyset that will be used for verification */ struct ub_packed_rrset_key* dnskey; struct regional* region = regional_create(); struct alloc_cache alloc; ldns_buffer* buf = ldns_buffer_new(65535); struct entry* e; struct entry* list = read_datafile(fname); struct module_env env; struct val_env ve; uint32_t now = time(NULL); if(!list) fatal_exit("could not read %s: %s", fname, strerror(errno)); alloc_init(&alloc, NULL, 1); memset(&env, 0, sizeof(env)); memset(&ve, 0, sizeof(ve)); env.scratch = region; env.scratch_buffer = buf; env.now = &now; ve.date_override = cfg_convert_timeval(at_date); unit_assert(region && buf); dnskey = extract_keys(list, &alloc, region, buf); if(vsig) log_nametypeclass(VERB_QUERY, "test dnskey", dnskey->rk.dname, ntohs(dnskey->rk.type), ntohs(dnskey->rk.rrset_class)); /* ready to go! */ for(e = list->next; e; e = e->next) { verifytest_entry(e, &alloc, region, buf, dnskey, &env, &ve); } ub_packed_rrset_parsedelete(dnskey, &alloc); delete_entry(list); regional_destroy(region); alloc_clear(&alloc); ldns_buffer_free(buf); }