/** test set of one anchor */ static void test_anchor_one(sldns_buffer* buff, struct val_anchors* a) { struct trust_anchor* ta; uint16_t c = LDNS_RR_CLASS_IN; unit_assert(anchor_store_str(a, buff, "nl. DS 42860 5 1 14D739EB566D2B1A5E216A0BA4D17FA9B038BE4A")); unit_assert(anchors_lookup(a, (uint8_t*)"\000", 1, c) == NULL); unit_assert(anchors_lookup(a, (uint8_t*)"\003com\000", 5, c) == NULL); unit_assert(anchors_lookup(a, (uint8_t*)"\007example\003com\000", 11, c) == NULL); unit_assert((ta=anchors_lookup(a, (uint8_t*)"\002nl\000", 4, c)) != NULL); lock_basic_unlock(&ta->lock); unit_assert((ta=anchors_lookup(a, (uint8_t*)"\004labs\002nl\000", 9, c)) != NULL); lock_basic_unlock(&ta->lock); unit_assert((ta=anchors_lookup(a, (uint8_t*)"\004fabs\002nl\000", 9, c)) != NULL); lock_basic_unlock(&ta->lock); unit_assert(anchors_lookup(a, (uint8_t*)"\002oo\000", 4, c) == NULL); }
//test lru_front and lru_remove static void test_lru(struct lruhash *table) { testkey *k1 = newkey(12); testkey *k2 = newkey(14); lock_basic_lock(&table->lock); unit_assert(table->lru_head == NULL && table->lru_tail == NULL); lru_remove(table, &k1->entry); unit_assert(table->lru_head == NULL && table->lru_tail == NULL); //add one lru_front(table, &k1->entry); unit_assert( table->lru_head == &k1->entry && table->lru_tail == &k1->entry); //remove lru_remove(table, &k1->entry); unit_assert(table->lru_head == NULL && table->lru_tail == NULL); //add two lru_front(table, &k1->entry); unit_assert(table->lru_head == &k1->entry && table->lru_tail == &k1->entry); lru_front(table, &k2->entry); unit_assert(table->lru_head == &k2->entry && table->lru_tail == &k1->entry); //remove first lru_remove(table, &k2->entry); unit_assert(table->lru_head == &k1->entry && table->lru_tail == &k1->entry); lru_front(table, &k2->entry); unit_assert(table->lru_head == &k2->entry && table->lru_tail == &k1->entry); //remove last lru_remove(table, &k1->entry); unit_assert(table->lru_head == &k2->entry && table->lru_tail == &k2->entry); //empty lru_remove(table, &k2->entry); unit_assert(table->lru_head == NULL && table->lru_tail == NULL); lock_basic_unlock(&table->lock); delkey(k1); delkey(k2); }
void dname_test(void) { sldns_buffer* loopbuf = sldns_buffer_new(14); sldns_buffer* boundbuf = sldns_buffer_new(16); sldns_buffer* buff = sldns_buffer_new(65800); unit_assert(loopbuf && boundbuf && buff); sldns_buffer_flip(buff); dname_setup_bufs(loopbuf, boundbuf); dname_test_qdl(buff); dname_test_qdtl(buff); dname_test_pdtl(loopbuf, boundbuf); dname_test_query_dname_compare(); dname_test_count_labels(); dname_test_count_size_labels(); dname_test_dname_lab_cmp(); dname_test_pkt_dname_len(buff); dname_test_strict_subdomain(); dname_test_subdomain(); dname_test_isroot(); dname_test_removelabel(); dname_test_sigcount(); dname_test_iswild(); dname_test_canoncmp(); dname_test_topdomain(); dname_test_valid(); sldns_buffer_free(buff); sldns_buffer_free(loopbuf); sldns_buffer_free(boundbuf); }
/** perf test a packet */ static void perftestpkt(sldns_buffer* pkt, struct alloc_cache* alloc, sldns_buffer* out, const char* hex) { struct query_info qi; struct reply_info* rep = 0; int ret; uint16_t id; uint16_t flags; time_t timenow = 0; struct regional* region = regional_create(); struct edns_data edns; hex_to_buf(pkt, hex); memmove(&id, sldns_buffer_begin(pkt), sizeof(id)); if(sldns_buffer_limit(pkt) < 2) flags = 0; else memmove(&flags, sldns_buffer_at(pkt, 2), sizeof(flags)); flags = ntohs(flags); ret = reply_info_parse(pkt, alloc, &qi, &rep, region, &edns); if(ret != 0) { char rbuf[16]; sldns_wire2str_rcode_buf(ret, rbuf, sizeof(rbuf)); if(vbmp) printf("parse code %d: %s\n", ret, rbuf); if(ret == LDNS_RCODE_FORMERR) checkformerr(pkt); unit_assert(ret != LDNS_RCODE_SERVFAIL); } else { perf_encode(&qi, rep, id, flags, out, timenow, &edns); } query_info_clear(&qi); reply_info_parsedelete(rep, alloc); regional_destroy(region); }
static void *test_thr_main(void *arg) { struct test_thr *t = (struct test_thr *)arg; int i; for(i = 0; i < 1000; i++) { switch(random() % 4) { case 0: case 3: testadd(t->table, NULL); break; case 1: testremove(t->table, NULL); break; case 2: testlookup(t->table, NULL); break; default: unit_assert(0); } if(i % 100 == 0) check_table(t->table); } check_table(t->table); return NULL; }
/** verify DS matches DNSKEY from a file */ static void dstest_file(const char* fname) { /* * 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 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; if(!list) fatal_exit("could not read %s: %s", fname, strerror(errno)); alloc_init(&alloc, NULL, 1); memset(&env, 0, sizeof(env)); env.scratch = region; env.scratch_buffer = buf; unit_assert(region && buf); /* ready to go! */ for(e = list; e; e = e->next) { dstest_entry(e, &alloc, region, buf, &env); } delete_entry(list); regional_destroy(region); alloc_clear(&alloc); ldns_buffer_free(buf); }
/** perform stress test on insert and delete in neg cache */ static void stress_test(struct val_neg_cache* neg) { int i; if(negverbose) printf("negcache test\n"); for(i=0; i<100; i++) { if(random() % 10 < 8) add_item(neg); else remove_item(neg); check_neg_invariants(neg); } /* empty it */ if(negverbose) printf("neg stress empty\n"); while(neg->first) { remove_item(neg); check_neg_invariants(neg); } if(negverbose) printf("neg stress emptied\n"); unit_assert(neg->first == NULL); /* insert again */ for(i=0; i<100; i++) { if(random() % 10 < 8) add_item(neg); else remove_item(neg); check_neg_invariants(neg); } }
/** performance test message encoding */ static void perf_encode(struct query_info* qi, struct reply_info* rep, uint16_t id, uint16_t flags, sldns_buffer* out, time_t timenow, struct edns_data* edns) { static int num = 0; int ret; size_t max = 10000; size_t i; struct timeval start, end; double dt; struct regional* r2 = regional_create(); if(gettimeofday(&start, NULL) < 0) fatal_exit("gettimeofday: %s", strerror(errno)); /* encode a couple times */ for(i=0; i<max; i++) { ret = reply_info_encode(qi, rep, id, flags, out, timenow, r2, 65535, (int)(edns->bits & EDNS_DO) ); unit_assert(ret != 0); /* udp packets should fit */ attach_edns_record(out, edns); regional_free_all(r2); } if(gettimeofday(&end, NULL) < 0) fatal_exit("gettimeofday: %s", strerror(errno)); /* time in millisec */ dt = (double)(end.tv_sec - start.tv_sec)*1000. + ((double)end.tv_usec - (double)start.tv_usec)/1000.; printf("[%d] did %u in %g msec for %f encode/sec size %d\n", num++, (unsigned)max, dt, (double)max / (dt/1000.), (int)sldns_buffer_limit(out)); regional_destroy(r2); }
/** main routine for threaded hash table test */ static void* test_thr_main(void* arg) { struct test_thr* t = (struct test_thr*)arg; int i; log_thread_set(&t->num); for(i=0; i<1000; i++) { switch(random() % 4) { case 0: case 3: testadd_unlim(t->table, NULL); break; case 1: testremove_unlim(t->table, NULL); break; case 2: testlookup_unlim(t->table, NULL); break; default: unit_assert(0); } if(0) lruhash_status(t->table, "hashtest", 1); if(i % 100 == 0) /* because of locking, not all the time */ check_table(t->table); } check_table(t->table); return NULL; }
/** test adding a random element */ static void testlookup(struct lruhash* table, testdata_t* ref[]) { int num = random() % HASHTESTMAX; testkey_t* key = newkey(num); struct lruhash_entry* en = lruhash_lookup(table, myhash(num), key, 0); testdata_t* data = en? (testdata_t*)en->data : NULL; if(en) { unit_assert(en->key); unit_assert(en->data); } if(0) log_info("lookup %d got %d, expect %d", num, en? data->data :-1, ref[num]? ref[num]->data : -1); unit_assert( data == ref[num] ); if(en) { lock_rw_unlock(&en->lock); } delkey(key); }
//test lookup a random element static void testlookup(struct lruhash *table, testdata *ref[]) { int num = random() % MAXHASH; testkey *key = newkey(num); struct lruhash_entry *e = lruhash_lookup(table, simplehash(num), key); testdata *data = e ? (testdata *)e->data : NULL; if(e) { unit_assert(e->key); unit_assert(e->data); lock_basic_unlock(&e->lock); } if (ref) unit_assert(data == ref[num]); delkey(key); }
/** test dname_count_size_labels */ static void dname_test_count_size_labels(void) { size_t sz = 0; unit_show_func("util/data/dname.c", "dname_count_size_labels"); unit_assert(dname_count_size_labels((uint8_t*)"", &sz) == 1); unit_assert(sz == 1); unit_assert(dname_count_size_labels((uint8_t*)"\003com", &sz) == 2); unit_assert(sz == 5); unit_assert(dname_count_size_labels((uint8_t*)"\003org", &sz) == 2); unit_assert(sz == 5); unit_assert(dname_count_size_labels((uint8_t*)"\007example\003com", &sz) == 3); unit_assert(sz == 13); unit_assert(dname_count_size_labels((uint8_t*)"\003bla\007example" "\003com", &sz) == 4); unit_assert(sz == 17); }
/** Test dname_valid */ static void dname_test_valid(void) { unit_show_func("util/data/dname.c", "dname_valid"); unit_assert( dname_valid( (uint8_t*)"\003www\007example\003com", 255) == 17); unit_assert( dname_valid((uint8_t*)"", 255) == 1); unit_assert( dname_valid( (uint8_t*) "\020a1cdef5555544444" "\020a2cdef5555544444" "\020a3cdef5555544444" "\020a4cdef5555544444" "\020a5cdef5555544444" "\020a6cdef5555544444" "\020a7cdef5555544444" "\020a8cdef5555544444" "\020a9cdef5555544444" "\020aAcdef5555544444" "\020aBcdef5555544444" "\020aCcdef5555544444" "\020aDcdef5555544444" "\020aEcdef5555544444" /* 238 up to here */ "\007aabbccd" /* 246 up to here */ "\007example\000" /* 255 to here */ , 255) == 255); unit_assert( dname_valid( (uint8_t*) "\020a1cdef5555544444" "\020a2cdef5555544444" "\020a3cdef5555544444" "\020a4cdef5555544444" "\020a5cdef5555544444" "\020a6cdef5555544444" "\020a7cdef5555544444" "\020a8cdef5555544444" "\020a9cdef5555544444" "\020aAcdef5555544444" "\020aBcdef5555544444" "\020aCcdef5555544444" "\020aDcdef5555544444" "\020aEcdef5555544444" /* 238 up to here */ "\007aabbccd" /* 246 up to here */ "\010exampleX\000" /* 256 to here */ , 4096) == 0); }
/** test lru_front lru_remove */ static void test_lru(struct lruhash* table) { testkey_t* k = newkey(12); testkey_t* k2 = newkey(14); lock_quick_lock(&table->lock); unit_assert( table->lru_start == NULL && table->lru_end == NULL); lru_remove(table, &k->entry); unit_assert( table->lru_start == NULL && table->lru_end == NULL); /* add one */ lru_front(table, &k->entry); unit_assert( table->lru_start == &k->entry && table->lru_end == &k->entry); /* remove it */ lru_remove(table, &k->entry); unit_assert( table->lru_start == NULL && table->lru_end == NULL); /* add two */ lru_front(table, &k->entry); unit_assert( table->lru_start == &k->entry && table->lru_end == &k->entry); lru_front(table, &k2->entry); unit_assert( table->lru_start == &k2->entry && table->lru_end == &k->entry); /* remove first in list */ lru_remove(table, &k2->entry); unit_assert( table->lru_start == &k->entry && table->lru_end == &k->entry); lru_front(table, &k2->entry); unit_assert( table->lru_start == &k2->entry && table->lru_end == &k->entry); /* remove last in list */ lru_remove(table, &k->entry); unit_assert( table->lru_start == &k2->entry && table->lru_end == &k2->entry); /* empty the list */ lru_remove(table, &k2->entry); unit_assert( table->lru_start == NULL && table->lru_end == NULL); lock_quick_unlock(&table->lock); delkey(k); delkey(k2); }
/** test adding a random element (unlimited range) */ static void testlookup_unlim(struct lruhash* table, testdata_t** ref) { int num = random() % (HASHTESTMAX*10); testkey_t* key = newkey(num); struct lruhash_entry* en = lruhash_lookup(table, myhash(num), key, 0); testdata_t* data = en? (testdata_t*)en->data : NULL; if(en) { unit_assert(en->key); unit_assert(en->data); } if(0 && ref) log_info("lookup unlim %d got %d, expect %d", num, en ? data->data :-1, ref[num] ? ref[num]->data : -1); if(data && ref) { /* its okay for !data, it fell off the lru */ unit_assert( data == ref[num] ); } if(en) { lock_rw_unlock(&en->lock); } delkey(key); }
/** Test dname_get_shared_topdomain */ static void dname_test_topdomain(void) { unit_show_func("util/data/dname.c", "dname_get_shared_topdomain"); unit_assert( query_dname_compare( dname_get_shared_topdomain( (uint8_t*)"", (uint8_t*)""), (uint8_t*)"") == 0); unit_assert( query_dname_compare( dname_get_shared_topdomain( (uint8_t*)"\003www\007example\003com", (uint8_t*)"\003www\007example\003com"), (uint8_t*)"\003www\007example\003com") == 0); unit_assert( query_dname_compare( dname_get_shared_topdomain( (uint8_t*)"\003www\007example\003com", (uint8_t*)"\003bla\007example\003com"), (uint8_t*)"\007example\003com") == 0); }
/** Test hash algo - NSEC3 hash it and compare result */ static void nsec3_hash_test_entry(struct entry* e, rbtree_type* ct, struct alloc_cache* alloc, struct regional* region, sldns_buffer* buf) { struct query_info qinfo; struct reply_info* rep = NULL; struct ub_packed_rrset_key* answer, *nsec3; struct nsec3_cached_hash* hash = NULL; int ret; uint8_t* qname; if(vsig) { char* s = sldns_wire2str_pkt(e->reply_list->reply_pkt, e->reply_list->reply_len); printf("verifying NSEC3 hash:\n%s\n", s?s:"outofmemory"); free(s); } entry_to_repinfo(e, alloc, region, buf, &qinfo, &rep); nsec3 = find_rrset_type(rep, LDNS_RR_TYPE_NSEC3); answer = find_rrset_type(rep, LDNS_RR_TYPE_AAAA); qname = regional_alloc_init(region, qinfo.qname, qinfo.qname_len); /* check test is OK */ unit_assert(nsec3 && answer && qname); ret = nsec3_hash_name(ct, region, buf, nsec3, 0, qname, qinfo.qname_len, &hash); if(ret != 1) { printf("Bad nsec3_hash_name retcode %d\n", ret); unit_assert(ret == 1); } unit_assert(hash->dname && hash->hash && hash->hash_len && hash->b32 && hash->b32_len); unit_assert(hash->b32_len == (size_t)answer->rk.dname[0]); /* does not do lowercasing. */ unit_assert(memcmp(hash->b32, answer->rk.dname+1, hash->b32_len) == 0); reply_info_parsedelete(rep, alloc); query_info_clear(&qinfo); }
/** DS sig test an entry - get DNSKEY and DS in entry and verify */ static void dstest_entry(struct entry* e, struct alloc_cache* alloc, struct regional* region, sldns_buffer* pkt, struct module_env* env) { struct query_info qinfo; struct reply_info* rep = NULL; struct ub_packed_rrset_key* ds, *dnskey; int ret; regional_free_all(region); if(vsig) { char* s = sldns_wire2str_pkt(e->reply_list->reply_pkt, e->reply_list->reply_len); printf("verifying DS-DNSKEY match:\n%s\n", s?s:"outofmemory"); free(s); } entry_to_repinfo(e, alloc, region, pkt, &qinfo, &rep); ds = find_rrset_type(rep, LDNS_RR_TYPE_DS); dnskey = find_rrset_type(rep, LDNS_RR_TYPE_DNSKEY); /* check test is OK */ unit_assert(ds && dnskey); ret = ds_digest_match_dnskey(env, dnskey, 0, ds, 0); if(strncmp((char*)qinfo.qname, "\003yes", 4) == 0) { if(vsig) { printf("result(yes)= %s\n", ret?"yes":"no"); } unit_assert(ret); } else if (strncmp((char*)qinfo.qname, "\002no", 3) == 0) { if(vsig) { printf("result(no)= %s\n", ret?"yes":"no"); } unit_assert(!ret); verbose(VERB_QUERY, "DS fail: OK; matched unit test"); } else { fatal_exit("Bad qname in DS unit test, yes or no"); } reply_info_parsedelete(rep, alloc); query_info_clear(&qinfo); }
/** test hashtable using short sequence */ static void test_short_table(struct lruhash* table) { testkey_t* k = newkey(12); testkey_t* k2 = newkey(14); testdata_t* d = newdata(128); testdata_t* d2 = newdata(129); k->entry.data = d; k2->entry.data = d2; lruhash_insert(table, myhash(12), &k->entry, d, NULL); lruhash_insert(table, myhash(14), &k2->entry, d2, NULL); unit_assert( lruhash_lookup(table, myhash(12), k, 0) == &k->entry); lock_rw_unlock( &k->entry.lock ); unit_assert( lruhash_lookup(table, myhash(14), k2, 0) == &k2->entry); lock_rw_unlock( &k2->entry.lock ); lruhash_remove(table, myhash(12), k); lruhash_remove(table, myhash(14), k2); }
void anchors_test(void) { sldns_buffer* buff = sldns_buffer_new(65800); struct val_anchors* a; unit_show_feature("trust anchor store"); unit_assert(a = anchors_create()); sldns_buffer_flip(buff); test_anchor_empty(a); test_anchor_one(buff, a); test_anchors(buff, a); anchors_delete(a); sldns_buffer_free(buff); }
/** test query_dname_tolower */ static void dname_test_qdtl(sldns_buffer* buff) { unit_show_func("util/data/dname.c", "query_dname_tolower"); sldns_buffer_write_at(buff, 0, "\012abCDeaBCde\003cOm\000", 16); query_dname_tolower(sldns_buffer_begin(buff)); unit_assert( memcmp(sldns_buffer_begin(buff), "\012abcdeabcde\003com\000", 16) == 0); sldns_buffer_write_at(buff, 0, "\001+\012abC{e-ZYXe\003NET\000", 18); query_dname_tolower(sldns_buffer_begin(buff)); unit_assert( memcmp(sldns_buffer_begin(buff), "\001+\012abc{e-zyxe\003net\000", 18) == 0); sldns_buffer_write_at(buff, 0, "\000", 1); query_dname_tolower(sldns_buffer_begin(buff)); unit_assert( memcmp(sldns_buffer_begin(buff), "\000", 1) == 0); sldns_buffer_write_at(buff, 0, "\002NL\000", 4); query_dname_tolower(sldns_buffer_begin(buff)); unit_assert( memcmp(sldns_buffer_begin(buff), "\002nl\000", 4) == 0); }
/** entry to packet buffer with wireformat */ static void entry_to_buf(struct entry* e, sldns_buffer* pkt) { unit_assert(e->reply_list); if(e->reply_list->reply_from_hex) { sldns_buffer_copy(pkt, e->reply_list->reply_from_hex); } else { sldns_buffer_clear(pkt); sldns_buffer_write(pkt, e->reply_list->reply_pkt, e->reply_list->reply_len); sldns_buffer_flip(pkt); } }
//test lruhash_insert, lruhash_lookup and lruhash_remove static void test_short_table(struct lruhash *table) { testkey *k1 = newkey(12); testkey *k2 = newkey(14); testdata *d1 = newdata(128); testdata *d2 = newdata(129); k1->entry.data = d1; k2->entry.data = d2; lruhash_insert(table, simplehash(12), &k1->entry, d1); lruhash_insert(table, simplehash(14), &k2->entry, d2); unit_assert(lruhash_lookup(table, simplehash(12), k1) == &k1->entry); lock_basic_unlock(&k1->entry.lock); unit_assert(lruhash_lookup(table, simplehash(14), k2) == &k2->entry); lock_basic_unlock(&k2->entry.lock ); lruhash_remove(table, simplehash(12), k1); lruhash_remove(table, simplehash(14), k2); }
/** print buffer to hex into string */ static void buf_to_hex(uint8_t* b, size_t blen, char* s, size_t slen) { const char* h = "0123456789ABCDEF"; size_t i; if(slen < blen*2+2 && vbmp) printf("hexstring buffer too small\n"); unit_assert(slen >= blen*2+2); for(i=0; i<blen; i++) { s[i*2] = h[(b[i]&0xf0)>>4]; s[i*2+1] = h[b[i]&0x0f]; } s[blen*2] = '\n'; s[blen*2+1] = 0; }
/** Check if results are correct */ static void rr_checks(char* wire_chk, char* txt_chk, char* txt_out, char* wire_out, char* back) { #ifdef __APPLE__ /* the wiretostr on ipv6 is weird on apple, we cannot check it. * skip AAAA on OSX */ if(strstr(txt_out, "IN AAAA")) txt_out = txt_chk; /* skip this test, but test wirefmt */ /* so we know that txt_out back to wire is the same */ #endif if(strcmp(txt_chk, txt_out) != 0 && vbmp) printf("txt different\n"); if(strcmp(wire_chk, wire_out) != 0 && vbmp) printf("wire1 different\n"); if(strcmp(wire_chk, back) != 0 && vbmp) printf("wire2 different\n"); unit_assert(strcmp(txt_chk, txt_out) == 0); unit_assert(strcmp(wire_chk, wire_out) == 0); unit_assert(strcmp(wire_chk, back) == 0); }
void neg_test(void) { struct val_neg_cache* neg; srandom(48); unit_show_feature("negative cache"); /* create with defaults */ neg = val_neg_create(NULL, 1500); unit_assert(neg); stress_test(neg); neg_cache_delete(neg); }
/** check if unbound formerr equals ldns formerr */ static void checkformerr(ldns_buffer* pkt) { ldns_pkt* p; ldns_status status = ldns_buffer2pkt_wire(&p, pkt); if(vbmp) printf("formerr, ldns parse is: %s\n", ldns_get_errorstr_by_id(status)); if(status == LDNS_STATUS_OK) { printf("Formerr, but ldns gives packet:\n"); ldns_pkt_print(stdout, p); exit(1); } unit_assert(status != LDNS_STATUS_OK); }
/** Transform input. * @param txt_in: input text format. * @param wire1: output wireformat in hex (txt_in converted to wire). * @param txt_out: output text format (converted from wire_out). * @param wire2: output wireformat in hex, txt_out converted back to wireformat. * @param bufs: size of the text buffers. */ static void rr_transform(char* txt_in, char* wire1, char* txt_out, char* wire2, size_t bufs) { uint8_t b[65536]; size_t len; int err; len = sizeof(b); err = sldns_str2wire_rr_buf(txt_in, b, &len, NULL, 3600, NULL, 0, NULL, 0); if(err != 0) { if(vbmp) printf("sldns_str2wire_rr_buf, pos %d: %s\n", LDNS_WIREPARSE_OFFSET(err), sldns_get_errorstr_parse(err)); } unit_assert(err == 0); buf_to_hex(b, len, wire1, bufs); if(vbmp) printf("wire1: %s", wire1); err = sldns_wire2str_rr_buf(b, len, txt_out, bufs); unit_assert(err < (int)bufs && err > 0); if(vbmp) printf("txt: %s", txt_out); len = sizeof(b); err = sldns_str2wire_rr_buf(txt_out, b, &len, NULL, 3600, NULL, 0, NULL, 0); if(err != 0) { if(vbmp) printf("sldns_str2wire_rr_buf-2, pos %d: %s\n", LDNS_WIREPARSE_OFFSET(err), sldns_get_errorstr_parse(err)); } unit_assert(err == 0); buf_to_hex(b, len, wire2, bufs); if(vbmp) printf("wire2: %s", wire2); }
/** test dname_signame_label_count */ static void dname_test_sigcount(void) { unit_show_func("util/data/dname.c", "dname_signame_label_count"); unit_assert(dname_signame_label_count((uint8_t*)"\000") == 0); unit_assert(dname_signame_label_count((uint8_t*)"\001*\000") == 0); unit_assert(dname_signame_label_count((uint8_t*)"\003xom\000") == 1); unit_assert(dname_signame_label_count( (uint8_t*)"\001*\003xom\000") == 1); unit_assert(dname_signame_label_count( (uint8_t*)"\007example\003xom\000") == 2); unit_assert(dname_signame_label_count( (uint8_t*)"\001*\007example\003xom\000") == 2); unit_assert(dname_signame_label_count( (uint8_t*)"\003www\007example\003xom\000") == 3); unit_assert(dname_signame_label_count( (uint8_t*)"\001*\003www\007example\003xom\000") == 3); }
/** add a random item */ static void add_item(struct val_neg_cache* neg) { struct val_neg_zone* z; struct packed_rrset_data rd; struct ub_packed_rrset_key nsec; size_t rr_len; time_t rr_ttl; uint8_t* rr_data; char* zname = get_random_zone(); char* from, *to; lock_basic_lock(&neg->lock); if(negverbose) log_nametypeclass(0, "add to zone", (uint8_t*)zname, 0, 0); z = neg_find_zone(neg, (uint8_t*)zname, strlen(zname)+1, LDNS_RR_CLASS_IN); if(!z) { z = neg_create_zone(neg, (uint8_t*)zname, strlen(zname)+1, LDNS_RR_CLASS_IN); } unit_assert(z); val_neg_zone_take_inuse(z); /* construct random NSEC item */ get_random_data(&from, &to, zname); /* create nsec and insert it */ memset(&rd, 0, sizeof(rd)); memset(&nsec, 0, sizeof(nsec)); nsec.rk.dname = (uint8_t*)from; nsec.rk.dname_len = strlen(from)+1; nsec.rk.type = htons(LDNS_RR_TYPE_NSEC); nsec.rk.rrset_class = htons(LDNS_RR_CLASS_IN); nsec.entry.data = &rd; rd.security = sec_status_secure; rd.count = 1; rd.rr_len = &rr_len; rr_len = 19; rd.rr_ttl = &rr_ttl; rr_ttl = 0; rd.rr_data = &rr_data; rr_data = (uint8_t*)to; neg_insert_data(neg, z, &nsec); lock_basic_unlock(&neg->lock); }