WEBDIENSTE/unbound
1
0
Fork 0
mirror of https://github.com/NLnetLabs/unbound.git synced 2026-09-12 04:47:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

- Fix sldns to use sldns_ prefix for all ldns_ variables.

Browse Source 
git-svn-id: file:///svn/unbound/trunk@3022 be551aaa-1e26-0410-a405-d3ace91eadb9
This commit is contained in:
Wouter Wijngaards
2013-12-03 09:11:16 +00:00
parent 3de090dadb
commit d3cbd76546
104 changed files with 2900 additions and 2920 deletions
Download Patch File Download Diff File Expand all files Collapse all files
testcode/delayer.c
+30 -30
View File
@@ -222,15 +222,15 @@ ring_delete(struct ringbuf* r)
/** add entry to ringbuffer */
static void
ring_add(struct ringbuf* r, ldns_buffer* pkt, struct timeval* now,
ring_add(struct ringbuf* r, sldns_buffer* pkt, struct timeval* now,
struct timeval* delay, struct proxy* p)
{
/* time -- proxy* -- 16bitlen -- message */
uint16_t len = (uint16_t)ldns_buffer_limit(pkt);
uint16_t len = (uint16_t)sldns_buffer_limit(pkt);
struct timeval when;
size_t needed;
uint8_t* where = NULL;
log_assert(ldns_buffer_limit(pkt) <= 65535);
log_assert(sldns_buffer_limit(pkt) <= 65535);
needed = sizeof(when) + sizeof(p) + sizeof(len) + len;
/* put item into ringbuffer */
if(r->low < r->high) {
@@ -279,7 +279,7 @@ ring_add(struct ringbuf* r, ldns_buffer* pkt, struct timeval* now,
memmove(where+sizeof(when), &p, sizeof(p));
memmove(where+sizeof(when)+sizeof(p), &len, sizeof(len));
memmove(where+sizeof(when)+sizeof(p)+sizeof(len),
ldns_buffer_begin(pkt), len);
sldns_buffer_begin(pkt), len);
}
/** see if the ringbuffer is empty */
@@ -300,7 +300,7 @@ ring_peek_time(struct ringbuf* r)
/** get entry from ringbuffer */
static int
ring_pop(struct ringbuf* r, ldns_buffer* pkt, struct timeval* tv,
ring_pop(struct ringbuf* r, sldns_buffer* pkt, struct timeval* tv,
struct proxy** p)
{
/* time -- proxy* -- 16bitlen -- message */
@@ -313,9 +313,9 @@ ring_pop(struct ringbuf* r, ldns_buffer* pkt, struct timeval* tv,
memmove(tv, where, sizeof(*tv));
memmove(p, where+sizeof(*tv), sizeof(*p));
memmove(&len, where+sizeof(*tv)+sizeof(*p), sizeof(len));
memmove(ldns_buffer_begin(pkt),
memmove(sldns_buffer_begin(pkt),
where+sizeof(*tv)+sizeof(*p)+sizeof(len), len);
ldns_buffer_set_limit(pkt, (size_t)len);
sldns_buffer_set_limit(pkt, (size_t)len);
done = sizeof(*tv)+sizeof(*p)+sizeof(len)+len;
/* move lowmark */
if(r->low < r->high) {
@@ -353,7 +353,7 @@ static RETSIGTYPE delayer_sigh(int sig)
/** send out waiting packets */
static void
service_send(struct ringbuf* ring, struct timeval* now, ldns_buffer* pkt,
service_send(struct ringbuf* ring, struct timeval* now, sldns_buffer* pkt,
struct sockaddr_storage* srv_addr, socklen_t srv_len)
{
struct proxy* p;
@@ -368,8 +368,8 @@ service_send(struct ringbuf* ring, struct timeval* now, ldns_buffer* pkt,
(unsigned)tv.tv_sec, (unsigned)tv.tv_usec);
log_addr(1, "from client", &p->addr, p->addr_len);
/* send it */
sent = sendto(p->s, (void*)ldns_buffer_begin(pkt),
ldns_buffer_limit(pkt), 0,
sent = sendto(p->s, (void*)sldns_buffer_begin(pkt),
sldns_buffer_limit(pkt), 0,
(struct sockaddr*)srv_addr, srv_len);
if(sent == -1) {
#ifndef USE_WINSOCK
@@ -377,7 +377,7 @@ service_send(struct ringbuf* ring, struct timeval* now, ldns_buffer* pkt,
#else
log_err("sendto: %s", wsa_strerror(WSAGetLastError()));
#endif
} else if(sent != (ssize_t)ldns_buffer_limit(pkt)) {
} else if(sent != (ssize_t)sldns_buffer_limit(pkt)) {
log_err("sendto: partial send");
}
p->lastuse = *now;
@@ -387,13 +387,13 @@ service_send(struct ringbuf* ring, struct timeval* now, ldns_buffer* pkt,
/** do proxy for one readable client */
static void
do_proxy(struct proxy* p, int retsock, ldns_buffer* pkt)
do_proxy(struct proxy* p, int retsock, sldns_buffer* pkt)
{
int i;
ssize_t r;
for(i=0; i<TRIES_PER_SELECT; i++) {
r = recv(p->s, (void*)ldns_buffer_begin(pkt),
ldns_buffer_capacity(pkt), 0);
r = recv(p->s, (void*)sldns_buffer_begin(pkt),
sldns_buffer_capacity(pkt), 0);
if(r == -1) {
#ifndef USE_WINSOCK
if(errno == EAGAIN || errno == EINTR)
@@ -407,11 +407,11 @@ do_proxy(struct proxy* p, int retsock, ldns_buffer* pkt)
#endif
return;
}
ldns_buffer_set_limit(pkt, (size_t)r);
sldns_buffer_set_limit(pkt, (size_t)r);
log_addr(1, "return reply to client", &p->addr, p->addr_len);
/* send reply back to the real client */
p->numreturn++;
r = sendto(retsock, (void*)ldns_buffer_begin(pkt), (size_t)r,
r = sendto(retsock, (void*)sldns_buffer_begin(pkt), (size_t)r,
0, (struct sockaddr*)&p->addr, p->addr_len);
if(r == -1) {
#ifndef USE_WINSOCK
@@ -426,7 +426,7 @@ do_proxy(struct proxy* p, int retsock, ldns_buffer* pkt)
/** proxy return replies to clients */
static void
service_proxy(fd_set* rset, int retsock, struct proxy* proxies,
ldns_buffer* pkt, struct timeval* now)
sldns_buffer* pkt, struct timeval* now)
{
struct proxy* p;
for(p = proxies; p; p = p->next) {
@@ -488,7 +488,7 @@ find_create_proxy(struct sockaddr_storage* from, socklen_t from_len,
/** recv new waiting packets */
static void
service_recv(int s, struct ringbuf* ring, ldns_buffer* pkt,
service_recv(int s, struct ringbuf* ring, sldns_buffer* pkt,
fd_set* rorig, int* max, struct proxy** proxies,
struct sockaddr_storage* srv_addr, socklen_t srv_len,
struct timeval* now, struct timeval* delay, struct timeval* reuse)
@@ -500,8 +500,8 @@ service_recv(int s, struct ringbuf* ring, ldns_buffer* pkt,
struct proxy* p;
for(i=0; i<TRIES_PER_SELECT; i++) {
from_len = (socklen_t)sizeof(from);
len = recvfrom(s, (void*)ldns_buffer_begin(pkt),
ldns_buffer_capacity(pkt), 0,
len = recvfrom(s, (void*)sldns_buffer_begin(pkt),
sldns_buffer_capacity(pkt), 0,
(struct sockaddr*)&from, &from_len);
if(len < 0) {
#ifndef USE_WINSOCK
@@ -516,7 +516,7 @@ service_recv(int s, struct ringbuf* ring, ldns_buffer* pkt,
wsa_strerror(WSAGetLastError()));
#endif
}
ldns_buffer_set_limit(pkt, (size_t)len);
sldns_buffer_set_limit(pkt, (size_t)len);
/* find its proxy element */
p = find_create_proxy(&from, from_len, rorig, max, proxies,
addr_is_ip6(srv_addr, srv_len), now, reuse);
@@ -641,11 +641,11 @@ service_tcp_listen(int s, fd_set* rorig, int* max, struct tcp_proxy** proxies,
static int
tcp_relay_read(int s, struct tcp_send_list** first,
struct tcp_send_list** last, struct timeval* now,
struct timeval* delay, ldns_buffer* pkt)
struct timeval* delay, sldns_buffer* pkt)
{
struct tcp_send_list* item;
ssize_t r = recv(s, (void*)ldns_buffer_begin(pkt),
ldns_buffer_capacity(pkt), 0);
ssize_t r = recv(s, (void*)sldns_buffer_begin(pkt),
sldns_buffer_capacity(pkt), 0);
if(r == -1) {
#ifndef USE_WINSOCK
if(errno == EINTR || errno == EAGAIN)
@@ -669,7 +669,7 @@ tcp_relay_read(int s, struct tcp_send_list** first,
}
verbose(1, "read item len %d", (int)r);
item->len = (size_t)r;
item->item = memdup(ldns_buffer_begin(pkt), item->len);
item->item = memdup(sldns_buffer_begin(pkt), item->len);
if(!item->item) {
free(item);
log_err("out of memory");
@@ -741,7 +741,7 @@ tcp_relay_write(int s, struct tcp_send_list** first,
/** perform TCP relaying */
static void
service_tcp_relay(struct tcp_proxy** tcp_proxies, struct timeval* now,
struct timeval* delay, struct timeval* tcp_timeout, ldns_buffer* pkt,
struct timeval* delay, struct timeval* tcp_timeout, sldns_buffer* pkt,
fd_set* rset, fd_set* rorig, fd_set* worig)
{
struct tcp_proxy* p, **prev;
@@ -928,7 +928,7 @@ static void
service_loop(int udp_s, int listen_s, struct ringbuf* ring,
struct timeval* delay, struct timeval* reuse,
struct sockaddr_storage* srv_addr, socklen_t srv_len,
ldns_buffer* pkt)
sldns_buffer* pkt)
{
fd_set rset, rorig;
fd_set wset, worig;
@@ -997,7 +997,7 @@ service(const char* bind_str, int bindport, const char* serv_str,
socklen_t bind_len, srv_len;
struct ringbuf* ring = ring_create(memsize);
struct timeval delay, reuse;
ldns_buffer* pkt;
sldns_buffer* pkt;
int i, s, listen_s;
#ifndef S_SPLINT_S
delay.tv_sec = delay_msec / 1000;
@@ -1013,7 +1013,7 @@ service(const char* bind_str, int bindport, const char* serv_str,
printf("cannot parse forward address: %s\n", serv_str);
exit(1);
}
pkt = ldns_buffer_new(65535);
pkt = sldns_buffer_new(65535);
if(!pkt)
fatal_exit("out of memory");
if( signal(SIGINT, delayer_sigh) == SIG_ERR ||
@@ -1116,7 +1116,7 @@ service(const char* bind_str, int bindport, const char* serv_str,
closesocket(s);
closesocket(listen_s);
#endif
ldns_buffer_free(pkt);
sldns_buffer_free(pkt);
ring_delete(ring);
}
testcode/fake_event.c
+53 -53
View File
@@ -109,11 +109,11 @@ fake_event_cleanup(void)
saved_scenario = NULL;
}
/** helper function that logs a ldns_pkt packet to logfile */
/** helper function that logs a sldns_pkt packet to logfile */
static void
log_pkt(const char* desc, uint8_t* pkt, size_t len)
{
char* str = ldns_wire2str_pkt(pkt, len);
char* str = sldns_wire2str_pkt(pkt, len);
if(!str)
fatal_exit("%s: (failed out of memory wire2str_pkt)", desc);
else {
@@ -152,7 +152,7 @@ delete_fake_pending(struct fake_pending* pend)
if(!pend)
return;
free(pend->zone);
ldns_buffer_free(pend->buffer);
sldns_buffer_free(pend->buffer);
free(pend->pkt);
free(pend);
}
@@ -164,7 +164,7 @@ delete_replay_answer(struct replay_answer* a)
if(!a)
return;
if(a->repinfo.c) {
ldns_buffer_free(a->repinfo.c->buffer);
sldns_buffer_free(a->repinfo.c->buffer);
free(a->repinfo.c);
}
free(a->pkt);
@@ -282,16 +282,16 @@ pending_list_delete(struct replay_runtime* runtime, struct fake_pending* pend)
* Fill buffer with reply from the entry.
*/
static void
fill_buffer_with_reply(ldns_buffer* buffer, struct entry* entry, uint8_t* q,
fill_buffer_with_reply(sldns_buffer* buffer, struct entry* entry, uint8_t* q,
size_t qlen)
{
uint8_t* c;
size_t clen;
log_assert(entry && entry->reply_list);
ldns_buffer_clear(buffer);
sldns_buffer_clear(buffer);
if(entry->reply_list->reply_from_hex) {
c = ldns_buffer_begin(entry->reply_list->reply_from_hex);
clen = ldns_buffer_limit(entry->reply_list->reply_from_hex);
c = sldns_buffer_begin(entry->reply_list->reply_from_hex);
clen = sldns_buffer_limit(entry->reply_list->reply_from_hex);
if(!c) fatal_exit("out of memory");
} else {
c = entry->reply_list->reply_pkt;
@@ -299,10 +299,10 @@ fill_buffer_with_reply(ldns_buffer* buffer, struct entry* entry, uint8_t* q,
}
if(c) {
if(q) adjust_packet(entry, &c, &clen, q, qlen);
ldns_buffer_write(buffer, c, clen);
sldns_buffer_write(buffer, c, clen);
if(q) free(c);
}
ldns_buffer_flip(buffer);
sldns_buffer_flip(buffer);
}
/**
@@ -322,7 +322,7 @@ answer_callback_from_entry(struct replay_runtime* runtime,
memset(&c, 0, sizeof(c));
c.fd = -1;
c.buffer = ldns_buffer_new(runtime->bufsize);
c.buffer = sldns_buffer_new(runtime->bufsize);
c.type = comm_udp;
if(pend->transport == transport_tcp)
c.type = comm_tcp;
@@ -335,7 +335,7 @@ answer_callback_from_entry(struct replay_runtime* runtime,
if((*cb)(&c, cb_arg, NETEVENT_NOERROR, &repinfo)) {
fatal_exit("testbound: unexpected: callback returned 1");
}
ldns_buffer_free(c.buffer);
sldns_buffer_free(c.buffer);
}
/** Check the now moment answer check event */
@@ -393,7 +393,7 @@ fake_front_query(struct replay_runtime* runtime, struct replay_moment *todo)
}
repinfo.c->fd = -1;
repinfo.c->ev = (struct internal_event*)runtime;
repinfo.c->buffer = ldns_buffer_new(runtime->bufsize);
repinfo.c->buffer = sldns_buffer_new(runtime->bufsize);
if(todo->match->match_transport == transport_tcp)
repinfo.c->type = comm_tcp;
else repinfo.c->type = comm_udp;
@@ -428,7 +428,7 @@ fake_pending_callback(struct replay_runtime* runtime,
if(!p) fatal_exit("No pending queries.");
cb_arg = p->cb_arg;
cb = p->callback;
c.buffer = ldns_buffer_new(runtime->bufsize);
c.buffer = sldns_buffer_new(runtime->bufsize);
c.type = comm_udp;
if(p->transport == transport_tcp)
c.type = comm_tcp;
@@ -445,7 +445,7 @@ fake_pending_callback(struct replay_runtime* runtime,
fatal_exit("unexpected: pending callback returned 1");
}
/* delete the pending item. */
ldns_buffer_free(c.buffer);
sldns_buffer_free(c.buffer);
}
/** pass time */
@@ -557,7 +557,7 @@ do_infra_rtt(struct replay_runtime* runtime)
struct replay_moment* now = runtime->now;
int rto;
size_t dplen = 0;
uint8_t* dp = ldns_str2wire_dname(now->variable, &dplen);
uint8_t* dp = sldns_str2wire_dname(now->variable, &dplen);
if(!dp) fatal_exit("cannot parse %s", now->variable);
rto = infra_rtt_update(runtime->infra, &now->addr, now->addrlen,
dp, dplen, LDNS_RR_TYPE_A, atoi(now->string),
@@ -741,7 +741,7 @@ listen_create(struct comm_base* base, struct listen_port* ATTR_UNUSED(ports),
if(!l)
return NULL;
l->base = base;
l->udp_buff = ldns_buffer_new(bufsize);
l->udp_buff = sldns_buffer_new(bufsize);
if(!l->udp_buff) {
free(l);
return NULL;
@@ -757,7 +757,7 @@ listen_delete(struct listen_dnsport* listen)
{
if(!listen)
return;
ldns_buffer_free(listen->udp_buff);
sldns_buffer_free(listen->udp_buff);
free(listen);
}
@@ -873,9 +873,9 @@ comm_point_send_reply(struct comm_reply* repinfo)
runtime->answer_last = ans;
/* try to parse packet */
ans->pkt = memdup(ldns_buffer_begin(ans->repinfo.c->buffer),
ldns_buffer_limit(ans->repinfo.c->buffer));
ans->pkt_len = ldns_buffer_limit(ans->repinfo.c->buffer);
ans->pkt = memdup(sldns_buffer_begin(ans->repinfo.c->buffer),
sldns_buffer_limit(ans->repinfo.c->buffer));
ans->pkt_len = sldns_buffer_limit(ans->repinfo.c->buffer);
if(!ans->pkt) fatal_exit("out of memory");
log_pkt("reply pkt: ", ans->pkt, ans->pkt_len);
}
@@ -885,7 +885,7 @@ comm_point_drop_reply(struct comm_reply* repinfo)
{
log_info("comm_point_drop_reply fake");
if(repinfo->c) {
ldns_buffer_free(repinfo->c->buffer);
sldns_buffer_free(repinfo->c->buffer);
free(repinfo->c);
}
}
@@ -910,7 +910,7 @@ outside_network_create(struct comm_base* base, size_t bufsize,
return NULL;
runtime->infra = infra;
outnet->base = base;
outnet->udp_buff = ldns_buffer_new(bufsize);
outnet->udp_buff = sldns_buffer_new(bufsize);
if(!outnet->udp_buff) {
free(outnet);
return NULL;
@@ -923,7 +923,7 @@ outside_network_delete(struct outside_network* outnet)
{
if(!outnet)
return;
ldns_buffer_free(outnet->udp_buff);
sldns_buffer_free(outnet->udp_buff);
free(outnet);
}
@@ -933,7 +933,7 @@ outside_network_quit_prepare(struct outside_network* ATTR_UNUSED(outnet))
}
struct pending*
pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
pending_udp_query(struct outside_network* outnet, sldns_buffer* packet,
struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* callback, void* callback_arg)
{
@@ -941,11 +941,11 @@ pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
struct fake_pending* pend = (struct fake_pending*)calloc(1,
sizeof(struct fake_pending));
log_assert(pend);
pend->buffer = ldns_buffer_new(ldns_buffer_capacity(packet));
pend->buffer = sldns_buffer_new(sldns_buffer_capacity(packet));
log_assert(pend->buffer);
ldns_buffer_write(pend->buffer, ldns_buffer_begin(packet),
ldns_buffer_limit(packet));
ldns_buffer_flip(pend->buffer);
sldns_buffer_write(pend->buffer, sldns_buffer_begin(packet),
sldns_buffer_limit(packet));
sldns_buffer_flip(pend->buffer);
memcpy(&pend->addr, addr, addrlen);
pend->addrlen = addrlen;
pend->callback = callback;
@@ -956,8 +956,8 @@ pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
pend->zone = NULL;
pend->serviced = 0;
pend->runtime = runtime;
pend->pkt_len = ldns_buffer_limit(packet);
pend->pkt = memdup(ldns_buffer_begin(packet), pend->pkt_len);
pend->pkt_len = sldns_buffer_limit(packet);
pend->pkt = memdup(sldns_buffer_begin(packet), pend->pkt_len);
if(!pend->pkt) fatal_exit("out of memory");
log_pkt("pending udp pkt: ", pend->pkt, pend->pkt_len);
@@ -983,7 +983,7 @@ pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
}
struct waiting_tcp*
pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet,
struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* callback, void* callback_arg,
int ATTR_UNUSED(ssl_upstream))
@@ -992,11 +992,11 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
struct fake_pending* pend = (struct fake_pending*)calloc(1,
sizeof(struct fake_pending));
log_assert(pend);
pend->buffer = ldns_buffer_new(ldns_buffer_capacity(packet));
pend->buffer = sldns_buffer_new(sldns_buffer_capacity(packet));
log_assert(pend->buffer);
ldns_buffer_write(pend->buffer, ldns_buffer_begin(packet),
ldns_buffer_limit(packet));
ldns_buffer_flip(pend->buffer);
sldns_buffer_write(pend->buffer, sldns_buffer_begin(packet),
sldns_buffer_limit(packet));
sldns_buffer_flip(pend->buffer);
memcpy(&pend->addr, addr, addrlen);
pend->addrlen = addrlen;
pend->callback = callback;
@@ -1007,8 +1007,8 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
pend->zone = NULL;
pend->runtime = runtime;
pend->serviced = 0;
pend->pkt_len = ldns_buffer_limit(packet);
pend->pkt = memdup(ldns_buffer_begin(packet), pend->pkt_len);
pend->pkt_len = sldns_buffer_limit(packet);
pend->pkt = memdup(sldns_buffer_begin(packet), pend->pkt_len);
if(!pend->pkt) fatal_exit("out of memory");
log_pkt("pending tcp pkt: ", pend->pkt, pend->pkt_len);
@@ -1039,7 +1039,7 @@ struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
int ATTR_UNUSED(tcp_upstream), int ATTR_UNUSED(ssl_upstream),
struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
size_t zonelen, comm_point_callback_t* callback, void* callback_arg,
ldns_buffer* ATTR_UNUSED(buff))
sldns_buffer* ATTR_UNUSED(buff))
{
struct replay_runtime* runtime = (struct replay_runtime*)outnet->base;
struct fake_pending* pend = (struct fake_pending*)calloc(1,
@@ -1054,18 +1054,18 @@ struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
(flags&~(BIT_RD|BIT_CD))?" MORE":"", (dnssec)?" DO":"");
/* create packet with EDNS */
pend->buffer = ldns_buffer_new(512);
pend->buffer = sldns_buffer_new(512);
log_assert(pend->buffer);
ldns_buffer_write_u16(pend->buffer, 0); /* id */
ldns_buffer_write_u16(pend->buffer, flags);
ldns_buffer_write_u16(pend->buffer, 1); /* qdcount */
ldns_buffer_write_u16(pend->buffer, 0); /* ancount */
ldns_buffer_write_u16(pend->buffer, 0); /* nscount */
ldns_buffer_write_u16(pend->buffer, 0); /* arcount */
ldns_buffer_write(pend->buffer, qname, qnamelen);
ldns_buffer_write_u16(pend->buffer, qtype);
ldns_buffer_write_u16(pend->buffer, qclass);
ldns_buffer_flip(pend->buffer);
sldns_buffer_write_u16(pend->buffer, 0); /* id */
sldns_buffer_write_u16(pend->buffer, flags);
sldns_buffer_write_u16(pend->buffer, 1); /* qdcount */
sldns_buffer_write_u16(pend->buffer, 0); /* ancount */
sldns_buffer_write_u16(pend->buffer, 0); /* nscount */
sldns_buffer_write_u16(pend->buffer, 0); /* arcount */
sldns_buffer_write(pend->buffer, qname, qnamelen);
sldns_buffer_write_u16(pend->buffer, qtype);
sldns_buffer_write_u16(pend->buffer, qclass);
sldns_buffer_flip(pend->buffer);
if(1) {
/* add edns */
struct edns_data edns;
@@ -1091,8 +1091,8 @@ struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
pend->pkt = NULL;
pend->runtime = runtime;
pend->serviced = 1;
pend->pkt_len = ldns_buffer_limit(pend->buffer);
pend->pkt = memdup(ldns_buffer_begin(pend->buffer), pend->pkt_len);
pend->pkt_len = sldns_buffer_limit(pend->buffer);
pend->pkt = memdup(sldns_buffer_begin(pend->buffer), pend->pkt_len);
if(!pend->pkt) fatal_exit("out of memory");
/*log_pkt("pending serviced query: ", pend->pkt, pend->pkt_len);*/
@@ -1130,7 +1130,7 @@ void outnet_serviced_query_stop(struct serviced_query* sq, void* cb_arg)
if(prev)
prev->next = p->next;
else runtime->pending_list = p->next;
ldns_buffer_free(p->buffer);
sldns_buffer_free(p->buffer);
free(p->pkt);
free(p->zone);
free(p);
testcode/perf.c
+19 -19
View File
@@ -78,7 +78,7 @@ struct perfinfo {
/** need to exit */
volatile int exit;
/** all purpose buffer (for UDP send and receive) */
ldns_buffer* buf;
sldns_buffer* buf;
/** destination */
struct sockaddr_storage dest;
@@ -306,8 +306,8 @@ static void
perfreply(struct perfinfo* info, size_t n, struct timeval* now)
{
ssize_t r;
r = recv(info->io[n].fd, (void*)ldns_buffer_begin(info->buf),
ldns_buffer_capacity(info->buf), 0);
r = recv(info->io[n].fd, (void*)sldns_buffer_begin(info->buf),
sldns_buffer_capacity(info->buf), 0);
if(r == -1) {
#ifndef USE_WINSOCK
log_err("recv: %s", strerror(errno));
@@ -315,11 +315,11 @@ perfreply(struct perfinfo* info, size_t n, struct timeval* now)
log_err("recv: %s", wsa_strerror(WSAGetLastError()));
#endif
} else {
info->by_rcode[LDNS_RCODE_WIRE(ldns_buffer_begin(
info->by_rcode[LDNS_RCODE_WIRE(sldns_buffer_begin(
info->buf))]++;
info->numrecv++;
}
/*ldns_buffer_set_limit(info->buf, r);
/*sldns_buffer_set_limit(info->buf, r);
log_buf(0, "reply", info->buf);*/
perfsend(info, n, now);
}
@@ -438,7 +438,7 @@ perfendstats(struct perfinfo* info)
{
if(info->by_rcode[i] > 0) {
char rc[16];
ldns_wire2str_rcode_buf(i, rc, sizeof(rc));
sldns_wire2str_rcode_buf(i, rc, sizeof(rc));
printf("%d(%5s): %u replies\n",
i, rc, (unsigned)info->by_rcode[i]);
}
@@ -461,7 +461,7 @@ perfmain(struct perfinfo* info)
/** parse a query line to a packet into buffer */
static int
qlist_parse_line(ldns_buffer* buf, char* p)
qlist_parse_line(sldns_buffer* buf, char* p)
{
char nm[1024], cl[1024], tp[1024], fl[1024];
int r;
@@ -473,23 +473,23 @@ qlist_parse_line(ldns_buffer* buf, char* p)
return 0;
/*printf("nm='%s', cl='%s', tp='%s', fl='%s'\n", nm, cl, tp, fl);*/
if(strcmp(tp, "IN") == 0 || strcmp(tp, "CH") == 0) {
qinfo.qtype = ldns_get_rr_type_by_name(cl);
qinfo.qclass = ldns_get_rr_class_by_name(tp);
qinfo.qtype = sldns_get_rr_type_by_name(cl);
qinfo.qclass = sldns_get_rr_class_by_name(tp);
} else {
qinfo.qtype = ldns_get_rr_type_by_name(tp);
qinfo.qclass = ldns_get_rr_class_by_name(cl);
qinfo.qtype = sldns_get_rr_type_by_name(tp);
qinfo.qclass = sldns_get_rr_class_by_name(cl);
}
if(fl[0] == '+') rec = 1;
else if(fl[0] == '-') rec = 0;
else if(fl[0] == 'E') edns = 1;
if((fl[0] == '+' || fl[0] == '-') && fl[1] == 'E')
edns = 1;
qinfo.qname = ldns_str2wire_dname(nm, &qinfo.qname_len);
qinfo.qname = sldns_str2wire_dname(nm, &qinfo.qname_len);
if(!qinfo.qname)
return 0;
qinfo_query_encode(buf, &qinfo);
ldns_buffer_write_u16_at(buf, 0, 0); /* zero ID */
if(rec) LDNS_RD_SET(ldns_buffer_begin(buf));
sldns_buffer_write_u16_at(buf, 0, 0); /* zero ID */
if(rec) LDNS_RD_SET(sldns_buffer_begin(buf));
if(edns) {
struct edns_data ed;
memset(&ed, 0, sizeof(ed));
@@ -531,13 +531,13 @@ qlist_add_line(struct perfinfo* info, char* line, int no)
printf("error parsing query %d: %s\n", no, line);
exit(1);
}
ldns_buffer_write_u16_at(info->buf, 0, (uint16_t)info->qlist_size);
sldns_buffer_write_u16_at(info->buf, 0, (uint16_t)info->qlist_size);
if(info->qlist_size + 1 > info->qlist_capacity) {
qlist_grow_capacity(info);
}
info->qlist_len[info->qlist_size] = ldns_buffer_limit(info->buf);
info->qlist_len[info->qlist_size] = sldns_buffer_limit(info->buf);
info->qlist_data[info->qlist_size] = memdup(
ldns_buffer_begin(info->buf), ldns_buffer_limit(info->buf));
sldns_buffer_begin(info->buf), sldns_buffer_limit(info->buf));
if(!info->qlist_data[info->qlist_size])
fatal_exit("out of memory");
info->qlist_size ++;
@@ -597,7 +597,7 @@ int main(int argc, char* argv[])
fatal_exit("WSAStartup failed: %s", wsa_strerror(r));
#endif
info.buf = ldns_buffer_new(65553);
info.buf = sldns_buffer_new(65553);
if(!info.buf) fatal_exit("out of memory");
/* parse the options */
@@ -644,7 +644,7 @@ int main(int argc, char* argv[])
/* do the performance test */
perfmain(&info);
ldns_buffer_free(info.buf);
sldns_buffer_free(info.buf);
#ifdef USE_WINSOCK
WSACleanup();
#endif
testcode/pktview.c
+37 -37
View File
@@ -57,7 +57,7 @@ static void usage(char* argv[])
}
/** read hex input */
static void read_input(ldns_buffer* pkt, FILE* in)
static void read_input(sldns_buffer* pkt, FILE* in)
{
char buf[102400];
char* np = buf;
@@ -70,22 +70,22 @@ static void read_input(ldns_buffer* pkt, FILE* in)
}
/** analyze domain name in packet, possibly compressed */
static void analyze_dname(ldns_buffer* pkt)
static void analyze_dname(sldns_buffer* pkt)
{
size_t oldpos = ldns_buffer_position(pkt);
size_t oldpos = sldns_buffer_position(pkt);
size_t len;
printf("[pos %d] dname: ", (int)oldpos);
dname_print(stdout, pkt, ldns_buffer_current(pkt));
dname_print(stdout, pkt, sldns_buffer_current(pkt));
len = pkt_dname_len(pkt);
printf(" len=%d", (int)len);
if(ldns_buffer_position(pkt)-oldpos != len)
if(sldns_buffer_position(pkt)-oldpos != len)
printf(" comprlen=%d\n",
(int)(ldns_buffer_position(pkt)-oldpos));
(int)(sldns_buffer_position(pkt)-oldpos));
else printf("\n");
}
/** analyze rdata in packet */
static void analyze_rdata(ldns_buffer*pkt, const ldns_rr_descriptor* desc,
static void analyze_rdata(sldns_buffer*pkt, const sldns_rr_descriptor* desc,
uint16_t rdlen)
{
int rdf = 0;
@@ -94,21 +94,21 @@ static void analyze_rdata(ldns_buffer*pkt, const ldns_rr_descriptor* desc,
while(rdlen > 0 && count) {
switch(desc->_wireformat[rdf]) {
case LDNS_RDF_TYPE_DNAME:
oldpos = ldns_buffer_position(pkt);
oldpos = sldns_buffer_position(pkt);
analyze_dname(pkt);
rdlen -= ldns_buffer_position(pkt)-oldpos;
rdlen -= sldns_buffer_position(pkt)-oldpos;
count --;
len = 0;
break;
case LDNS_RDF_TYPE_STR:
len = ldns_buffer_current(pkt)[0] + 1;
len = sldns_buffer_current(pkt)[0] + 1;
break;
default:
len = get_rdf_size(desc->_wireformat[rdf]);
}
if(len) {
printf(" wf[%d]", (int)len);
ldns_buffer_skip(pkt, (ssize_t)len);
sldns_buffer_skip(pkt, (ssize_t)len);
rdlen -= len;
}
rdf++;
@@ -117,62 +117,62 @@ static void analyze_rdata(ldns_buffer*pkt, const ldns_rr_descriptor* desc,
size_t i;
printf(" remain[%d]\n", (int)rdlen);
for(i=0; i<rdlen; i++)
printf(" %2.2X", (unsigned)ldns_buffer_current(pkt)[i]);
printf(" %2.2X", (unsigned)sldns_buffer_current(pkt)[i]);
printf("\n");
}
else printf("\n");
ldns_buffer_skip(pkt, (ssize_t)rdlen);
sldns_buffer_skip(pkt, (ssize_t)rdlen);
}
/** analyze rr in packet */
static void analyze_rr(ldns_buffer* pkt, int q)
static void analyze_rr(sldns_buffer* pkt, int q)
{
uint16_t type, dclass, len;
uint32_t ttl;
analyze_dname(pkt);
type = ldns_buffer_read_u16(pkt);
dclass = ldns_buffer_read_u16(pkt);
printf("type %s(%d)", ldns_rr_descript(type)?
ldns_rr_descript(type)->_name: "??" , (int)type);
printf(" class %s(%d) ", ldns_lookup_by_id(sldns_rr_classes,
(int)dclass)?ldns_lookup_by_id(sldns_rr_classes,
type = sldns_buffer_read_u16(pkt);
dclass = sldns_buffer_read_u16(pkt);
printf("type %s(%d)", sldns_rr_descript(type)?
sldns_rr_descript(type)->_name: "??" , (int)type);
printf(" class %s(%d) ", sldns_lookup_by_id(sldns_rr_classes,
(int)dclass)?sldns_lookup_by_id(sldns_rr_classes,
(int)dclass)->name:"??", (int)dclass);
if(q) {
printf("\n");
} else {
ttl = ldns_buffer_read_u32(pkt);
ttl = sldns_buffer_read_u32(pkt);
printf(" ttl %d (0x%x)", (int)ttl, (unsigned)ttl);
len = ldns_buffer_read_u16(pkt);
len = sldns_buffer_read_u16(pkt);
printf(" rdata len %d:\n", (int)len);
if(ldns_rr_descript(type))
analyze_rdata(pkt, ldns_rr_descript(type), len);
else ldns_buffer_skip(pkt, (ssize_t)len);
if(sldns_rr_descript(type))
analyze_rdata(pkt, sldns_rr_descript(type), len);
else sldns_buffer_skip(pkt, (ssize_t)len);
}
}
/** analyse pkt */
static void analyze(ldns_buffer* pkt)
static void analyze(sldns_buffer* pkt)
{
uint16_t i, f, qd, an, ns, ar;
int rrnum = 0;
printf("packet length %d\n", (int)ldns_buffer_limit(pkt));
if(ldns_buffer_limit(pkt) < 12) return;
printf("packet length %d\n", (int)sldns_buffer_limit(pkt));
if(sldns_buffer_limit(pkt) < 12) return;
i = ldns_buffer_read_u16(pkt);
i = sldns_buffer_read_u16(pkt);
printf("id (hostorder): %d (0x%x)\n", (int)i, (unsigned)i);
f = ldns_buffer_read_u16(pkt);
f = sldns_buffer_read_u16(pkt);
printf("flags: 0x%x\n", (unsigned)f);
qd = ldns_buffer_read_u16(pkt);
qd = sldns_buffer_read_u16(pkt);
printf("qdcount: %d\n", (int)qd);
an = ldns_buffer_read_u16(pkt);
an = sldns_buffer_read_u16(pkt);
printf("ancount: %d\n", (int)an);
ns = ldns_buffer_read_u16(pkt);
ns = sldns_buffer_read_u16(pkt);
printf("nscount: %d\n", (int)ns);
ar = ldns_buffer_read_u16(pkt);
ar = sldns_buffer_read_u16(pkt);
printf("arcount: %d\n", (int)ar);
printf(";-- query section\n");
while(ldns_buffer_remaining(pkt) > 0) {
while(sldns_buffer_remaining(pkt) > 0) {
if(rrnum == (int)qd)
printf(";-- answer section\n");
if(rrnum == (int)qd+(int)an)
@@ -188,7 +188,7 @@ static void analyze(ldns_buffer* pkt)
/** main program for pktview */
int main(int argc, char* argv[])
{
ldns_buffer* pkt = ldns_buffer_new(65553);
sldns_buffer* pkt = sldns_buffer_new(65553);
if(argc != 1) {
usage(argv);
}
@@ -197,6 +197,6 @@ int main(int argc, char* argv[])
read_input(pkt, stdin);
analyze(pkt);
ldns_buffer_free(pkt);
sldns_buffer_free(pkt);
return 0;
}
testcode/readhex.c
+7 -7
View File
@@ -62,24 +62,24 @@ skip_whites(const char** p)
}
/* takes a hex string and puts into buffer */
void hex_to_buf(ldns_buffer* pkt, const char* hex)
void hex_to_buf(sldns_buffer* pkt, const char* hex)
{
const char* p = hex;
int val;
ldns_buffer_clear(pkt);
sldns_buffer_clear(pkt);
while(*p) {
skip_whites(&p);
if(ldns_buffer_position(pkt) == ldns_buffer_limit(pkt))
if(sldns_buffer_position(pkt) == sldns_buffer_limit(pkt))
fatal_exit("hex_to_buf: buffer too small");
if(!isalnum((int)*p))
break;
val = ldns_hexdigit_to_int(*p++) << 4;
val = sldns_hexdigit_to_int(*p++) << 4;
skip_whites(&p);
log_assert(*p && isalnum((int)*p));
val |= ldns_hexdigit_to_int(*p++);
ldns_buffer_write_u8(pkt, (uint8_t)val);
val |= sldns_hexdigit_to_int(*p++);
sldns_buffer_write_u8(pkt, (uint8_t)val);
skip_whites(&p);
}
ldns_buffer_flip(pkt);
sldns_buffer_flip(pkt);
}
testcode/readhex.h
+2 -2
View File
@@ -40,13 +40,13 @@
#ifndef TESTCODE_READHEX_H
#define TESTCODE_READHEX_H
struct ldns_buffer;
struct sldns_buffer;
/**
* Helper to convert hex string to packet buffer.
* @param pkt: buffer to put result in.
* @param hex: string of hex data. Spaces and ';...' comments are skipped.
*/
void hex_to_buf(struct ldns_buffer* pkt, const char* hex);
void hex_to_buf(struct sldns_buffer* pkt, const char* hex);
#endif /* TESTCODE_READHEX_H */
testcode/replay.c
+3 -3
View File
@@ -149,7 +149,7 @@ strip_end_white(char* p)
*/
static struct replay_range*
replay_range_read(char* remain, FILE* in, const char* name,
struct ldns_file_parse_state* pstate, char* line)
struct sldns_file_parse_state* pstate, char* line)
{
struct replay_range* rng = (struct replay_range*)malloc(
sizeof(struct replay_range));
@@ -266,7 +266,7 @@ read_assign_step(char* remain, struct replay_moment* mom)
*/
static struct replay_moment*
replay_moment_read(char* remain, FILE* in, const char* name,
struct ldns_file_parse_state* pstate)
struct sldns_file_parse_state* pstate)
{
struct replay_moment* mom = (struct replay_moment*)malloc(
sizeof(struct replay_moment));
@@ -432,7 +432,7 @@ replay_scenario_read(FILE* in, const char* name, int* lineno)
char line[MAX_LINE_LEN];
char *parse;
struct replay_scenario* scen = NULL;
struct ldns_file_parse_state pstate;
struct sldns_file_parse_state pstate;
line[MAX_LINE_LEN-1]=0;
memset(&pstate, 0, sizeof(pstate));
pstate.default_ttl = 3600;
testcode/replay.h
+3 -3
View File
@@ -138,7 +138,7 @@ struct fake_pending;
struct fake_timer;
struct replay_var;
struct infra_cache;
struct ldns_buffer;
struct sldns_buffer;
/**
* A replay scenario.
@@ -313,7 +313,7 @@ struct replay_runtime {
*/
struct fake_pending {
/** what is important only that we remember the query, copied here. */
struct ldns_buffer* buffer;
struct sldns_buffer* buffer;
/** and to what address this is sent to. */
struct sockaddr_storage addr;
/** len of addr */
@@ -333,7 +333,7 @@ struct fake_pending {
/** next in pending list */
struct fake_pending* next;
/** the buffer parsed into a ldns_pkt */
/** the buffer parsed into a sldns_pkt */
uint8_t* pkt;
size_t pkt_len;
/** by what transport was the query sent out */
testcode/signit.c
+54 -54
View File
@@ -95,7 +95,7 @@ convert_timeval(const char* str)
if (tm.tm_min < 0 || tm.tm_min > 59) return 0;
if (tm.tm_sec < 0 || tm.tm_sec > 59) return 0;
/* call ldns conversion function */
t = ldns_mktime_from_utc(&tm);
t = sldns_mktime_from_utc(&tm);
return t;
}
@@ -121,14 +121,14 @@ parse_cmdline(char *argv[], struct keysets* s)
}
/** read all key files, exit on error */
static ldns_key_list*
static sldns_key_list*
read_keys(int num, char* names[], struct keysets* set)
{
int i;
ldns_key_list* keys = ldns_key_list_new();
ldns_key* k;
ldns_rdf* rdf;
ldns_status s;
sldns_key_list* keys = sldns_key_list_new();
sldns_key* k;
sldns_rdf* rdf;
sldns_status s;
int b;
FILE* in;
@@ -138,45 +138,45 @@ read_keys(int num, char* names[], struct keysets* set)
in = fopen(names[i], "r");
if(!in) fatal_exit("could not open %s: %s", names[i],
strerror(errno));
s = ldns_key_new_frm_fp(&k, in);
s = sldns_key_new_frm_fp(&k, in);
fclose(in);
if(s != LDNS_STATUS_OK)
fatal_exit("bad keyfile %s: %s", names[i],
ldns_get_errorstr_by_id(s));
ldns_key_set_expiration(k, set->expi);
ldns_key_set_inception(k, set->incep);
s = ldns_str2rdf_dname(&rdf, set->owner);
sldns_get_errorstr_by_id(s));
sldns_key_set_expiration(k, set->expi);
sldns_key_set_inception(k, set->incep);
s = sldns_str2rdf_dname(&rdf, set->owner);
if(s != LDNS_STATUS_OK)
fatal_exit("bad owner name %s: %s", set->owner,
ldns_get_errorstr_by_id(s));
ldns_key_set_pubkey_owner(k, rdf);
ldns_key_set_flags(k, set->flags);
ldns_key_set_keytag(k, set->keytag);
b = ldns_key_list_push_key(keys, k);
sldns_get_errorstr_by_id(s));
sldns_key_set_pubkey_owner(k, rdf);
sldns_key_set_flags(k, set->flags);
sldns_key_set_keytag(k, set->keytag);
b = sldns_key_list_push_key(keys, k);
assert(b);
}
return keys;
}
/** read list of rrs from the file */
static ldns_rr_list*
static sldns_rr_list*
read_rrs(FILE* in)
{
uint32_t my_ttl = 3600;
ldns_rdf *my_origin = NULL;
ldns_rdf *my_prev = NULL;
ldns_status s;
sldns_rdf *my_origin = NULL;
sldns_rdf *my_prev = NULL;
sldns_status s;
int line_nr = 1;
int b;
ldns_rr_list* list;
ldns_rr *rr;
sldns_rr_list* list;
sldns_rr *rr;
list = ldns_rr_list_new();
list = sldns_rr_list_new();
if(!list) fatal_exit("alloc error");
while(!feof(in)) {
s = ldns_rr_new_frm_fp_l(&rr, in, &my_ttl, &my_origin,
s = sldns_rr_new_frm_fp_l(&rr, in, &my_ttl, &my_origin,
&my_prev, &line_nr);
if(s == LDNS_STATUS_SYNTAX_TTL ||
s == LDNS_STATUS_SYNTAX_ORIGIN ||
@@ -184,8 +184,8 @@ read_rrs(FILE* in)
continue;
else if(s != LDNS_STATUS_OK)
fatal_exit("parse error in line %d: %s", line_nr,
ldns_get_errorstr_by_id(s));
b = ldns_rr_list_push_rr(list, rr);
sldns_get_errorstr_by_id(s));
b = sldns_rr_list_push_rr(list, rr);
assert(b);
}
printf("read %d lines\n", line_nr);
@@ -195,21 +195,21 @@ read_rrs(FILE* in)
/** sign the rrs with the keys */
static void
signit(ldns_rr_list* rrs, ldns_key_list* keys)
signit(sldns_rr_list* rrs, sldns_key_list* keys)
{
ldns_rr_list* rrset;
ldns_rr_list* sigs;
sldns_rr_list* rrset;
sldns_rr_list* sigs;
while(ldns_rr_list_rr_count(rrs) > 0) {
rrset = ldns_rr_list_pop_rrset(rrs);
while(sldns_rr_list_rr_count(rrs) > 0) {
rrset = sldns_rr_list_pop_rrset(rrs);
if(!rrset) fatal_exit("copy alloc failure");
sigs = ldns_sign_public(rrset, keys);
sigs = sldns_sign_public(rrset, keys);
if(!sigs) fatal_exit("failed to sign");
ldns_rr_list_print(stdout, rrset);
ldns_rr_list_print(stdout, sigs);
sldns_rr_list_print(stdout, rrset);
sldns_rr_list_print(stdout, sigs);
printf("\n");
ldns_rr_list_free(rrset);
ldns_rr_list_free(sigs);
sldns_rr_list_free(rrset);
sldns_rr_list_free(sigs);
}
}
@@ -217,8 +217,8 @@ signit(ldns_rr_list* rrs, ldns_key_list* keys)
static void
process_keys(int argc, char* argv[])
{
ldns_rr_list* rrs;
ldns_key_list* keys;
sldns_rr_list* rrs;
sldns_key_list* keys;
struct keysets settings;
assert(argc == 6);
@@ -227,8 +227,8 @@ process_keys(int argc, char* argv[])
rrs = read_rrs(stdin);
signit(rrs, keys);
ldns_rr_list_deep_free(rrs);
ldns_key_list_free(keys);
sldns_rr_list_deep_free(rrs);
sldns_key_list_free(keys);
}
/** process nsec3 params and perform hashing */
@@ -236,37 +236,37 @@ static void
process_nsec3(int argc, char* argv[])
{
char line[10240];
ldns_rdf* salt;
ldns_rdf* in, *out;
ldns_status status;
status = ldns_str2rdf_nsec3_salt(&salt, argv[5]);
sldns_rdf* salt;
sldns_rdf* in, *out;
sldns_status status;
status = sldns_str2rdf_nsec3_salt(&salt, argv[5]);
if(status != LDNS_STATUS_OK)
fatal_exit("Could not parse salt %s: %s", argv[5],
ldns_get_errorstr_by_id(status));
sldns_get_errorstr_by_id(status));
assert(argc == 6);
while(fgets(line, (int)sizeof(line), stdin)) {
if(strlen(line) > 0)
line[strlen(line)-1] = 0; /* remove trailing newline */
if(line[0]==0)
continue;
status = ldns_str2rdf_dname(&in, line);
status = sldns_str2rdf_dname(&in, line);
if(status != LDNS_STATUS_OK)
fatal_exit("Could not parse name %s: %s", line,
ldns_get_errorstr_by_id(status));
ldns_rdf_print(stdout, in);
sldns_get_errorstr_by_id(status));
sldns_rdf_print(stdout, in);
printf(" -> ");
/* arg 3 is flags, unused */
out = ldns_nsec3_hash_name(in, (uint8_t)atoi(argv[2]),
out = sldns_nsec3_hash_name(in, (uint8_t)atoi(argv[2]),
(uint16_t)atoi(argv[4]),
ldns_rdf_data(salt)[0], ldns_rdf_data(salt)+1);
sldns_rdf_data(salt)[0], sldns_rdf_data(salt)+1);
if(!out)
fatal_exit("Could not hash %s", line);
ldns_rdf_print(stdout, out);
sldns_rdf_print(stdout, out);
printf("\n");
ldns_rdf_deep_free(in);
ldns_rdf_deep_free(out);
sldns_rdf_deep_free(in);
sldns_rdf_deep_free(out);
}
ldns_rdf_deep_free(salt);
sldns_rdf_deep_free(salt);
}
/** main program */
testcode/streamtcp.c
+24 -24
View File
@@ -112,26 +112,26 @@ open_svr(const char* svr, int udp)
/** write a query over the TCP fd */
static void
write_q(int fd, int udp, SSL* ssl, ldns_buffer* buf, uint16_t id,
write_q(int fd, int udp, SSL* ssl, sldns_buffer* buf, uint16_t id,
const char* strname, const char* strtype, const char* strclass)
{
struct query_info qinfo;
uint16_t len;
/* qname */
qinfo.qname = ldns_str2wire_dname(strname, &qinfo.qname_len);
qinfo.qname = sldns_str2wire_dname(strname, &qinfo.qname_len);
if(!qinfo.qname) {
printf("cannot parse query name: '%s'\n", strname);
exit(1);
}
/* qtype and qclass */
qinfo.qtype = ldns_get_rr_type_by_name(strtype);
qinfo.qclass = ldns_get_rr_class_by_name(strclass);
qinfo.qtype = sldns_get_rr_type_by_name(strtype);
qinfo.qclass = sldns_get_rr_class_by_name(strclass);
/* make query */
qinfo_query_encode(buf, &qinfo);
ldns_buffer_write_u16_at(buf, 0, id);
ldns_buffer_write_u16_at(buf, 2, BIT_RD);
sldns_buffer_write_u16_at(buf, 0, id);
sldns_buffer_write_u16_at(buf, 2, BIT_RD);
if(1) {
/* add EDNS DO */
@@ -145,7 +145,7 @@ write_q(int fd, int udp, SSL* ssl, ldns_buffer* buf, uint16_t id,
/* send it */
if(!udp) {
len = (uint16_t)ldns_buffer_limit(buf);
len = (uint16_t)sldns_buffer_limit(buf);
len = htons(len);
if(ssl) {
if(SSL_write(ssl, (void*)&len, (int)sizeof(len)) <= 0) {
@@ -166,15 +166,15 @@ write_q(int fd, int udp, SSL* ssl, ldns_buffer* buf, uint16_t id,
}
}
if(ssl) {
if(SSL_write(ssl, (void*)ldns_buffer_begin(buf),
(int)ldns_buffer_limit(buf)) <= 0) {
if(SSL_write(ssl, (void*)sldns_buffer_begin(buf),
(int)sldns_buffer_limit(buf)) <= 0) {
log_crypto_err("cannot SSL_write");
exit(1);
}
} else {
if(send(fd, (void*)ldns_buffer_begin(buf),
ldns_buffer_limit(buf), 0) <
(ssize_t)ldns_buffer_limit(buf)) {
if(send(fd, (void*)sldns_buffer_begin(buf),
sldns_buffer_limit(buf), 0) <
(ssize_t)sldns_buffer_limit(buf)) {
#ifndef USE_WINSOCK
perror("send() data failed");
#else
@@ -189,7 +189,7 @@ write_q(int fd, int udp, SSL* ssl, ldns_buffer* buf, uint16_t id,
/** receive DNS datagram over TCP and print it */
static void
recv_one(int fd, int udp, SSL* ssl, ldns_buffer* buf)
recv_one(int fd, int udp, SSL* ssl, sldns_buffer* buf)
{
char* pktstr;
uint16_t len;
@@ -212,10 +212,10 @@ recv_one(int fd, int udp, SSL* ssl, ldns_buffer* buf)
}
}
len = ntohs(len);
ldns_buffer_clear(buf);
ldns_buffer_set_limit(buf, len);
sldns_buffer_clear(buf);
sldns_buffer_set_limit(buf, len);
if(ssl) {
int r = SSL_read(ssl, (void*)ldns_buffer_begin(buf),
int r = SSL_read(ssl, (void*)sldns_buffer_begin(buf),
(int)len);
if(r <= 0) {
log_crypto_err("could not SSL_read");
@@ -224,7 +224,7 @@ recv_one(int fd, int udp, SSL* ssl, ldns_buffer* buf)
if(r != (int)len)
fatal_exit("ssl_read %d of %d", r, len);
} else {
if(recv(fd, (void*)ldns_buffer_begin(buf), len, 0) <
if(recv(fd, (void*)sldns_buffer_begin(buf), len, 0) <
(ssize_t)len) {
#ifndef USE_WINSOCK
perror("read() data failed");
@@ -237,9 +237,9 @@ recv_one(int fd, int udp, SSL* ssl, ldns_buffer* buf)
}
} else {
ssize_t l;
ldns_buffer_clear(buf);
if((l=recv(fd, (void*)ldns_buffer_begin(buf),
ldns_buffer_capacity(buf), 0)) < 0) {
sldns_buffer_clear(buf);
if((l=recv(fd, (void*)sldns_buffer_begin(buf),
sldns_buffer_capacity(buf), 0)) < 0) {
#ifndef USE_WINSOCK
perror("read() data failed");
#else
@@ -248,13 +248,13 @@ recv_one(int fd, int udp, SSL* ssl, ldns_buffer* buf)
#endif
exit(1);
}
ldns_buffer_set_limit(buf, (size_t)l);
sldns_buffer_set_limit(buf, (size_t)l);
len = (size_t)l;
}
printf("\nnext received packet\n");
log_buf(0, "data", buf);
pktstr = ldns_wire2str_pkt(ldns_buffer_begin(buf), len);
pktstr = sldns_wire2str_pkt(sldns_buffer_begin(buf), len);
printf("%s", pktstr);
free(pktstr);
}
@@ -272,7 +272,7 @@ static int get_random(void)
static void
send_em(const char* svr, int udp, int usessl, int noanswer, int num, char** qs)
{
ldns_buffer* buf = ldns_buffer_new(65553);
sldns_buffer* buf = sldns_buffer_new(65553);
int fd = open_svr(svr, udp);
int i;
SSL_CTX* ctx = NULL;
@@ -323,7 +323,7 @@ send_em(const char* svr, int udp, int usessl, int noanswer, int num, char** qs)
#else
closesocket(fd);
#endif
ldns_buffer_free(buf);
sldns_buffer_free(buf);
printf("orderly exit\n");
}
testcode/testbound.c
+1 -1
View File
@@ -302,7 +302,7 @@ main(int argc, char* argv[])
break;
case 'g':
#ifdef USE_GOST
if(ldns_key_EVP_load_gost_id()) {
if(sldns_key_EVP_load_gost_id()) {
printf("GOST supported\n");
exit(0);
} else {
testcode/testpkts.c
+69 -69
View File
@@ -319,10 +319,10 @@ hexstr2bin(char *hexstr, int len, uint8_t *buf, size_t offset, size_t buf_len)
}
/** convert hex buffer to binary buffer */
static ldns_buffer *
hex_buffer2wire(ldns_buffer *data_buffer)
static sldns_buffer *
hex_buffer2wire(sldns_buffer *data_buffer)
{
ldns_buffer *wire_buffer = NULL;
sldns_buffer *wire_buffer = NULL;
int c;
/* stat hack
@@ -335,13 +335,13 @@ hex_buffer2wire(ldns_buffer *data_buffer)
uint8_t *hexbuf;
int hexbufpos = 0;
size_t wirelen;
uint8_t *data_wire = (uint8_t *) ldns_buffer_begin(data_buffer);
uint8_t *data_wire = (uint8_t *) sldns_buffer_begin(data_buffer);
uint8_t *wire = (uint8_t*)malloc(MAX_PACKETLEN);
if(!wire) error("out of memory");
hexbuf = (uint8_t*)malloc(MAX_PACKETLEN);
if(!hexbuf) error("out of memory");
for (data_buf_pos = 0; data_buf_pos < ldns_buffer_position(data_buffer); data_buf_pos++) {
for (data_buf_pos = 0; data_buf_pos < sldns_buffer_position(data_buffer); data_buf_pos++) {
c = (int) data_wire[data_buf_pos];
if (state < 2 && !isascii(c)) {
@@ -402,8 +402,8 @@ hex_buffer2wire(ldns_buffer *data_buffer)
if (state < 2) {
wirelen = hexstr2bin((char *) hexbuf, hexbufpos, wire, 0, MAX_PACKETLEN);
wire_buffer = ldns_buffer_new(wirelen);
ldns_buffer_new_frm_data(wire_buffer, wire, wirelen);
wire_buffer = sldns_buffer_new(wirelen);
sldns_buffer_new_frm_data(wire_buffer, wire, wirelen);
} else {
error("Incomplete hex data, not at byte boundary\n");
}
@@ -414,7 +414,7 @@ hex_buffer2wire(ldns_buffer *data_buffer)
/** parse ORIGIN */
static void
get_origin(const char* name, struct ldns_file_parse_state* pstate, char* parse)
get_origin(const char* name, struct sldns_file_parse_state* pstate, char* parse)
{
/* snip off rest of the text so as to make the parse work in ldns */
char* end;
@@ -427,18 +427,18 @@ get_origin(const char* name, struct ldns_file_parse_state* pstate, char* parse)
store = *end;
*end = 0;
verbose(3, "parsing '%s'\n", parse);
status = ldns_str2wire_dname_buf(parse, pstate->origin,
status = sldns_str2wire_dname_buf(parse, pstate->origin,
&pstate->origin_len);
*end = store;
if(status != 0)
error("%s line %d:\n\t%s: %s", name, pstate->lineno,
ldns_get_errorstr_parse(status), parse);
sldns_get_errorstr_parse(status), parse);
}
/** add RR to packet */
static void add_rr(char* rrstr, uint8_t* pktbuf, size_t pktsize,
size_t* pktlen, struct ldns_file_parse_state* pstate,
ldns_pkt_section add_section, const char* fname)
size_t* pktlen, struct sldns_file_parse_state* pstate,
sldns_pkt_section add_section, const char* fname)
{
/* it must be a RR, parse and add to packet. */
size_t rr_len = pktsize - *pktlen;
@@ -451,27 +451,27 @@ static void add_rr(char* rrstr, uint8_t* pktbuf, size_t pktsize,
/* parse RR */
if(add_section == LDNS_SECTION_QUESTION)
status = ldns_str2wire_rr_question_buf(rrstr, pktbuf+*pktlen,
status = sldns_str2wire_rr_question_buf(rrstr, pktbuf+*pktlen,
&rr_len, &dname_len, origin, pstate->origin_len,
prev, pstate->prev_rr_len);
else status = ldns_str2wire_rr_buf(rrstr, pktbuf+*pktlen, &rr_len,
else status = sldns_str2wire_rr_buf(rrstr, pktbuf+*pktlen, &rr_len,
&dname_len, pstate->default_ttl, origin,
pstate->origin_len, prev, pstate->prev_rr_len);
if(status != 0)
error("%s line %d:%d %s\n\t%s", fname, pstate->lineno,
LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status), rrstr);
sldns_get_errorstr_parse(status), rrstr);
*pktlen += rr_len;
/* increase RR count */
if(add_section == LDNS_SECTION_QUESTION)
ldns_write_uint16(pktbuf+4, LDNS_QDCOUNT(pktbuf)+1);
sldns_write_uint16(pktbuf+4, LDNS_QDCOUNT(pktbuf)+1);
else if(add_section == LDNS_SECTION_ANSWER)
ldns_write_uint16(pktbuf+6, LDNS_ANCOUNT(pktbuf)+1);
sldns_write_uint16(pktbuf+6, LDNS_ANCOUNT(pktbuf)+1);
else if(add_section == LDNS_SECTION_AUTHORITY)
ldns_write_uint16(pktbuf+8, LDNS_NSCOUNT(pktbuf)+1);
sldns_write_uint16(pktbuf+8, LDNS_NSCOUNT(pktbuf)+1);
else if(add_section == LDNS_SECTION_ADDITIONAL)
ldns_write_uint16(pktbuf+10, LDNS_ARCOUNT(pktbuf)+1);
sldns_write_uint16(pktbuf+10, LDNS_ARCOUNT(pktbuf)+1);
else error("internal error bad section %d", (int)add_section);
}
@@ -492,22 +492,22 @@ add_do_flag(uint8_t* pktbuf, size_t pktsize, size_t* pktlen)
if(*pktlen + sizeof(edns) > pktsize)
error("not enough space for EDNS OPT record");
memmove(pktbuf+*pktlen, edns, sizeof(edns));
ldns_write_uint16(pktbuf+10, LDNS_ARCOUNT(pktbuf)+1);
sldns_write_uint16(pktbuf+10, LDNS_ARCOUNT(pktbuf)+1);
*pktlen += sizeof(edns);
}
/* Reads one entry from file. Returns entry or NULL on error. */
struct entry*
read_entry(FILE* in, const char* name, struct ldns_file_parse_state* pstate,
read_entry(FILE* in, const char* name, struct sldns_file_parse_state* pstate,
int skip_whitespace)
{
struct entry* current = NULL;
char line[MAX_LINE];
char* parse;
ldns_pkt_section add_section = LDNS_SECTION_QUESTION;
sldns_pkt_section add_section = LDNS_SECTION_QUESTION;
struct reply_packet *cur_reply = NULL;
int reading_hex = 0;
ldns_buffer* hex_data_buffer = NULL;
sldns_buffer* hex_data_buffer = NULL;
uint8_t pktbuf[MAX_PACKETLEN];
size_t pktlen = LDNS_HEADER_SIZE;
int do_flag = 0; /* DO flag in EDNS */
@@ -564,7 +564,7 @@ read_entry(FILE* in, const char* name, struct ldns_file_parse_state* pstate,
add_section = LDNS_SECTION_ADDITIONAL;
else error("%s line %d: bad section %s", name, pstate->lineno, parse);
} else if(str_keyword(&parse, "HEX_ANSWER_BEGIN")) {
hex_data_buffer = ldns_buffer_new(MAX_PACKETLEN);
hex_data_buffer = sldns_buffer_new(MAX_PACKETLEN);
reading_hex = 1;
} else if(str_keyword(&parse, "HEX_ANSWER_END")) {
if(!reading_hex) {
@@ -572,11 +572,11 @@ read_entry(FILE* in, const char* name, struct ldns_file_parse_state* pstate,
}
reading_hex = 0;
cur_reply->reply_from_hex = hex_buffer2wire(hex_data_buffer);
ldns_buffer_free(hex_data_buffer);
sldns_buffer_free(hex_data_buffer);
hex_data_buffer = NULL;
} else if(str_keyword(&parse, "ENTRY_END")) {
if(hex_data_buffer)
ldns_buffer_free(hex_data_buffer);
sldns_buffer_free(hex_data_buffer);
if(pktlen != 0) {
if(do_flag)
add_do_flag(pktbuf, sizeof(pktbuf),
@@ -588,7 +588,7 @@ read_entry(FILE* in, const char* name, struct ldns_file_parse_state* pstate,
}
return current;
} else if(reading_hex) {
ldns_buffer_printf(hex_data_buffer, "%s", line);
sldns_buffer_printf(hex_data_buffer, "%s", line);
} else {
add_rr(skip_whitespace?parse:line, pktbuf,
sizeof(pktbuf), &pktlen, pstate, add_section,
@@ -615,7 +615,7 @@ read_datafile(const char* name, int skip_whitespace)
struct entry* last = NULL;
struct entry* current = NULL;
FILE *in;
struct ldns_file_parse_state pstate;
struct sldns_file_parse_state pstate;
int entry_num = 0;
memset(&pstate, 0, sizeof(pstate));
@@ -638,7 +638,7 @@ read_datafile(const char* name, int skip_whitespace)
}
/** get qtype from packet */
static ldns_rr_type get_qtype(uint8_t* pkt, size_t pktlen)
static sldns_rr_type get_qtype(uint8_t* pkt, size_t pktlen)
{
uint8_t* d;
size_t dl, sl=0;
@@ -650,10 +650,10 @@ static ldns_rr_type get_qtype(uint8_t* pkt, size_t pktlen)
/* skip over dname with dname-scan routine */
d = pkt+LDNS_HEADER_SIZE;
dl = pktlen-LDNS_HEADER_SIZE;
(void)ldns_wire2str_dname_scan(&d, &dl, &snull, &sl, pkt, pktlen);
(void)sldns_wire2str_dname_scan(&d, &dl, &snull, &sl, pkt, pktlen);
if(dl < 2)
return 0;
return ldns_read_uint16(d);
return sldns_read_uint16(d);
}
/** get qtype from packet */
@@ -669,7 +669,7 @@ static size_t get_qname_len(uint8_t* pkt, size_t pktlen)
/* skip over dname with dname-scan routine */
d = pkt+LDNS_HEADER_SIZE;
dl = pktlen-LDNS_HEADER_SIZE;
(void)ldns_wire2str_dname_scan(&d, &dl, &snull, &sl, pkt, pktlen);
(void)sldns_wire2str_dname_scan(&d, &dl, &snull, &sl, pkt, pktlen);
return pktlen-dl-LDNS_HEADER_SIZE;
}
@@ -706,10 +706,10 @@ static uint32_t get_serial(uint8_t* p, size_t plen)
/* skip other records with wire2str_scan */
for(i=0; i < LDNS_QDCOUNT(p); i++)
(void)ldns_wire2str_rrquestion_scan(&walk, &walk_len,
(void)sldns_wire2str_rrquestion_scan(&walk, &walk_len,
&snull, &sl, p, plen);
for(i=0; i < LDNS_ANCOUNT(p); i++)
(void)ldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl,
(void)sldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl,
p, plen);
/* walk through authority section */
@@ -717,29 +717,29 @@ static uint32_t get_serial(uint8_t* p, size_t plen)
/* if this is SOA then get serial, skip compressed dname */
uint8_t* dstart = walk;
size_t dlen = walk_len;
(void)ldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl,
(void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl,
p, plen);
if(dlen >= 2 && ldns_read_uint16(dstart) == LDNS_RR_TYPE_SOA) {
if(dlen >= 2 && sldns_read_uint16(dstart) == LDNS_RR_TYPE_SOA) {
/* skip type, class, TTL, rdatalen */
if(dlen < 10)
return 0;
if(dlen < 10 + (size_t)ldns_read_uint16(dstart+8))
if(dlen < 10 + (size_t)sldns_read_uint16(dstart+8))
return 0;
dstart += 10;
dlen -= 10;
/* check third rdf */
(void)ldns_wire2str_dname_scan(&dstart, &dlen, &snull,
(void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull,
&sl, p, plen);
(void)ldns_wire2str_dname_scan(&dstart, &dlen, &snull,
(void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull,
&sl, p, plen);
if(dlen < 4)
return 0;
verbose(3, "found serial %u in msg. ",
(int)ldns_read_uint32(dstart));
return ldns_read_uint32(dstart);
(int)sldns_read_uint32(dstart));
return sldns_read_uint32(dstart);
}
/* move to next RR */
(void)ldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl,
(void)sldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl,
p, plen);
}
return 0;
@@ -762,27 +762,27 @@ pkt_find_edns_opt(uint8_t** p, size_t* plen)
/* skip other records with wire2str_scan */
for(i=0; i < LDNS_QDCOUNT(p); i++)
(void)ldns_wire2str_rrquestion_scan(&w, &wlen, &snull, &sl,
(void)sldns_wire2str_rrquestion_scan(&w, &wlen, &snull, &sl,
*p, *plen);
for(i=0; i < LDNS_ANCOUNT(p); i++)
(void)ldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen);
(void)sldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen);
for(i=0; i < LDNS_NSCOUNT(p); i++)
(void)ldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen);
(void)sldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen);
/* walk through additional section */
for(i=0; i < LDNS_ARCOUNT(p); i++) {
/* if this is OPT then done */
uint8_t* dstart = w;
size_t dlen = wlen;
(void)ldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl,
(void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl,
*p, *plen);
if(dlen >= 2 && ldns_read_uint16(dstart) == LDNS_RR_TYPE_OPT) {
if(dlen >= 2 && sldns_read_uint16(dstart) == LDNS_RR_TYPE_OPT) {
*p = dstart+2;
*plen = dlen-2;
return 1;
}
/* move to next RR */
(void)ldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen);
(void)sldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen);
}
return 0;
}
@@ -807,7 +807,7 @@ get_do_flag(uint8_t* pkt, size_t len)
}
if(walk_len < 6)
return 0; /* malformed */
edns_bits = ldns_read_uint16(walk+4);
edns_bits = sldns_read_uint16(walk+4);
return (int)(edns_bits&LDNS_EDNS_MASK_DO_BIT);
}
@@ -825,19 +825,19 @@ zerottls(uint8_t* pkt, size_t pktlen)
walk += LDNS_HEADER_SIZE;
walk_len -= LDNS_HEADER_SIZE;
for(i=0; i < LDNS_QDCOUNT(pkt); i++)
(void)ldns_wire2str_rrquestion_scan(&walk, &walk_len,
(void)sldns_wire2str_rrquestion_scan(&walk, &walk_len,
&snull, &sl, pkt, pktlen);
for(i=0; i < num; i++) {
/* wipe TTL */
uint8_t* dstart = walk;
size_t dlen = walk_len;
(void)ldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl,
(void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl,
pkt, pktlen);
if(dlen < 8)
return;
ldns_write_uint32(dstart+4, 0);
sldns_write_uint32(dstart+4, 0);
/* go to next RR */
(void)ldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl,
(void)sldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl,
pkt, pktlen);
}
}
@@ -1000,7 +1000,7 @@ static void lowercase_dname(uint8_t** p, size_t* remain)
static void lowercase_rdata(uint8_t** p, size_t* remain,
uint16_t rdatalen, uint16_t t)
{
const ldns_rr_descriptor *desc = ldns_rr_descript(t);
const sldns_rr_descriptor *desc = sldns_rr_descript(t);
uint8_t dname_count = 0;
size_t i = 0;
size_t rdataremain = rdatalen;
@@ -1011,7 +1011,7 @@ static void lowercase_rdata(uint8_t** p, size_t* remain,
return;
}
while(dname_count < desc->_dname_count) {
ldns_rdf_type f = ldns_rr_descriptor_field_type(desc, i++);
sldns_rdf_type f = sldns_rr_descriptor_field_type(desc, i++);
if(f == LDNS_RDF_TYPE_DNAME) {
lowercase_dname(p, &rdataremain);
dname_count++;
@@ -1077,8 +1077,8 @@ static void lowercase_pkt(uint8_t* pkt, size_t pktlen)
for(i=0; i<LDNS_ANCOUNT(pkt)+LDNS_NSCOUNT(pkt)+LDNS_ARCOUNT(pkt); i++) {
lowercase_dname(&p, &remain);
if(remain < 10) return;
t = ldns_read_uint16(p);
rdatalen = ldns_read_uint16(p+8);
t = sldns_read_uint16(p);
rdatalen = sldns_read_uint16(p+8);
p += 10;
remain -= 10;
if(remain < rdatalen) return;
@@ -1104,8 +1104,8 @@ match_all(uint8_t* q, size_t qlen, uint8_t* p, size_t plen, int mttl,
}
lowercase_pkt(qb, qlen);
lowercase_pkt(pb, plen);
qstr = ldns_wire2str_pkt(qb, qlen);
pstr = ldns_wire2str_pkt(pb, plen);
qstr = sldns_wire2str_pkt(qb, qlen);
pstr = sldns_wire2str_pkt(pb, plen);
if(!qstr || !pstr) error("cannot pkt2string");
r = (strcmp(qstr, pstr) == 0);
if(!r) {
@@ -1145,8 +1145,8 @@ static int equal_dname(uint8_t* q, size_t qlen, uint8_t* p, size_t plen)
char* qss = qs, *pss = ps;
if(!qn || !pn)
return 0;
(void)ldns_wire2str_dname_scan(&qn, &qlen, &qss, &qslen, q, qlen);
(void)ldns_wire2str_dname_scan(&pn, &plen, &pss, &pslen, p, plen);
(void)sldns_wire2str_dname_scan(&qn, &qlen, &qss, &qslen, q, qlen);
(void)sldns_wire2str_dname_scan(&pn, &plen, &pss, &pslen, p, plen);
return (strcmp(qs, ps) == 0);
}
@@ -1163,8 +1163,8 @@ static int subdomain_dname(uint8_t* q, size_t qlen, uint8_t* p, size_t plen)
if(!qn || !pn)
return 0;
/* decompresses domain names */
(void)ldns_wire2str_dname_scan(&qn, &qlen, &qss, &qslen, q, qlen);
(void)ldns_wire2str_dname_scan(&pn, &plen, &pss, &pslen, p, plen);
(void)sldns_wire2str_dname_scan(&qn, &qlen, &qss, &qslen, q, qlen);
(void)sldns_wire2str_dname_scan(&pn, &plen, &pss, &pslen, p, plen);
/* same: false, (strict subdomain check)??? */
if(strcmp(qs, ps) == 0)
return 1;
@@ -1275,7 +1275,7 @@ adjust_packet(struct entry* match, uint8_t** answer_pkt, size_t *answer_len,
memmove(res+LDNS_HEADER_SIZE+dlen+4, orig+LDNS_HEADER_SIZE,
reslen-(LDNS_HEADER_SIZE+dlen+4));
/* set QDCOUNT */
ldns_write_uint16(res+4, 1);
sldns_write_uint16(res+4, 1);
} else if(match->copy_query && origlen >= LDNS_HEADER_SIZE &&
query_len >= LDNS_HEADER_SIZE && LDNS_QDCOUNT(query_pkt)!=0
&& get_qname_len(orig, origlen) == 0) {
@@ -1347,7 +1347,7 @@ handle_query(uint8_t* inbuf, ssize_t inlen, struct entry* entries, int* count,
(int)(inlen>=2?LDNS_ID_WIRE(inbuf):0),
(transport==transport_tcp)?"TCP":"UDP", (int)inlen);
if(verbose_out) {
char* out = ldns_wire2str_pkt(inbuf, (size_t)inlen);
char* out = sldns_wire2str_pkt(inbuf, (size_t)inlen);
printf("%s\n", out);
free(out);
}
@@ -1366,8 +1366,8 @@ handle_query(uint8_t* inbuf, ssize_t inlen, struct entry* entries, int* count,
* parsed, we can use adjust rules. if not,
* send packet literally */
/* still try to adjust ID if others fail */
outlen = ldns_buffer_limit(p->reply_from_hex);
outbuf = ldns_buffer_begin(p->reply_from_hex);
outlen = sldns_buffer_limit(p->reply_from_hex);
outbuf = sldns_buffer_begin(p->reply_from_hex);
} else {
outbuf = p->reply_pkt;
outlen = p->reply_len;
@@ -1380,7 +1380,7 @@ handle_query(uint8_t* inbuf, ssize_t inlen, struct entry* entries, int* count,
adjust_packet(entry, &outbuf, &outlen, inbuf, (size_t)inlen);
verbose(1, "Answer packet size: %u bytes.\n", (unsigned int)outlen);
if(verbose_out) {
char* out = ldns_wire2str_pkt(outbuf, outlen);
char* out = sldns_wire2str_pkt(outbuf, outlen);
printf("%s\n", out);
free(out);
}
@@ -1409,7 +1409,7 @@ void delete_replylist(struct reply_packet* replist)
while(p) {
np = p->next;
free(p->reply_pkt);
ldns_buffer_free(p->reply_from_hex);
sldns_buffer_free(p->reply_from_hex);
free(p);
p=np;
}
testcode/testpkts.h
+4 -4
View File
@@ -9,8 +9,8 @@
#ifndef TESTPKTS_H
#define TESTPKTS_H
struct ldns_buffer;
struct ldns_file_parse_state;
struct sldns_buffer;
struct sldns_file_parse_state;
/**
* \file
@@ -145,7 +145,7 @@ struct reply_packet {
/** length of reply pkt */
size_t reply_len;
/** or reply pkt in hex if not parsable */
struct ldns_buffer* reply_from_hex;
struct sldns_buffer* reply_from_hex;
/** seconds to sleep before giving packet */
unsigned int packet_sleep;
};
@@ -219,7 +219,7 @@ void delete_entry(struct entry* list);
* @return: The entry read (malloced) or NULL if no entry could be read.
*/
struct entry* read_entry(FILE* in, const char* name,
struct ldns_file_parse_state* pstate, int skip_whitespace);
struct sldns_file_parse_state* pstate, int skip_whitespace);
/**
* finds entry in list, or returns NULL.
testcode/unitanchor.c
+5 -5
View File
@@ -64,7 +64,7 @@ test_anchor_empty(struct val_anchors* a)
/** test set of one anchor */
static void
test_anchor_one(ldns_buffer* buff, struct val_anchors* a)
test_anchor_one(sldns_buffer* buff, struct val_anchors* a)
{
struct trust_anchor* ta;
uint16_t c = LDNS_RR_CLASS_IN;
@@ -92,7 +92,7 @@ test_anchor_one(ldns_buffer* buff, struct val_anchors* a)
/** test with several anchors */
static void
test_anchors(ldns_buffer* buff, struct val_anchors* a)
test_anchors(sldns_buffer* buff, struct val_anchors* a)
{
struct trust_anchor* ta;
uint16_t c = LDNS_RR_CLASS_IN;
@@ -124,14 +124,14 @@ test_anchors(ldns_buffer* buff, struct val_anchors* a)
void anchors_test(void)
{
ldns_buffer* buff = ldns_buffer_new(65800);
sldns_buffer* buff = sldns_buffer_new(65800);
struct val_anchors* a;
unit_show_feature("trust anchor store");
unit_assert(a = anchors_create());
ldns_buffer_flip(buff);
sldns_buffer_flip(buff);
test_anchor_empty(a);
test_anchor_one(buff, a);
test_anchors(buff, a);
anchors_delete(a);
ldns_buffer_free(buff);
sldns_buffer_free(buff);
}
testcode/unitdname.c
+90 -90
View File
@@ -46,24 +46,24 @@
#include "ldns/str2wire.h"
/** put dname into buffer */
static ldns_buffer*
dname_to_buf(ldns_buffer* b, const char* str)
static sldns_buffer*
dname_to_buf(sldns_buffer* b, const char* str)
{
int e;
size_t len = ldns_buffer_capacity(b);
ldns_buffer_clear(b);
e = ldns_str2wire_dname_buf(str, ldns_buffer_begin(b), &len);
size_t len = sldns_buffer_capacity(b);
sldns_buffer_clear(b);
e = sldns_str2wire_dname_buf(str, sldns_buffer_begin(b), &len);
if(e != 0)
fatal_exit("%s ldns: %s", __func__,
ldns_get_errorstr_parse(e));
ldns_buffer_set_position(b, len);
ldns_buffer_flip(b);
sldns_get_errorstr_parse(e));
sldns_buffer_set_position(b, len);
sldns_buffer_flip(b);
return b;
}
/** test query_dname_len function */
static void
dname_test_qdl(ldns_buffer* buff)
dname_test_qdl(sldns_buffer* buff)
{
unit_show_func("util/data/dname.c", "query_dname_len");
unit_assert( query_dname_len(buff) == 0);
@@ -75,26 +75,26 @@ dname_test_qdl(ldns_buffer* buff)
/** test query_dname_tolower */
static void
dname_test_qdtl(ldns_buffer* buff)
dname_test_qdtl(sldns_buffer* buff)
{
unit_show_func("util/data/dname.c", "query_dname_tolower");
ldns_buffer_write_at(buff, 0, "\012abCDeaBCde\003cOm\000", 16);
query_dname_tolower(ldns_buffer_begin(buff));
unit_assert( memcmp(ldns_buffer_begin(buff),
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);
ldns_buffer_write_at(buff, 0, "\001+\012abC{e-ZYXe\003NET\000", 18);
query_dname_tolower(ldns_buffer_begin(buff));
unit_assert( memcmp(ldns_buffer_begin(buff),
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);
ldns_buffer_write_at(buff, 0, "\000", 1);
query_dname_tolower(ldns_buffer_begin(buff));
unit_assert( memcmp(ldns_buffer_begin(buff), "\000", 1) == 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);
ldns_buffer_write_at(buff, 0, "\002NL\000", 4);
query_dname_tolower(ldns_buffer_begin(buff));
unit_assert( memcmp(ldns_buffer_begin(buff), "\002nl\000", 4) == 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);
}
/** test query_dname_compare */
@@ -163,62 +163,62 @@ dname_test_count_size_labels(void)
/** test pkt_dname_len */
static void
dname_test_pkt_dname_len(ldns_buffer* buff)
dname_test_pkt_dname_len(sldns_buffer* buff)
{
unit_show_func("util/data/dname.c", "pkt_dname_len");
ldns_buffer_clear(buff);
ldns_buffer_write(buff, "\000", 1);
ldns_buffer_flip(buff);
sldns_buffer_clear(buff);
sldns_buffer_write(buff, "\000", 1);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 1 );
unit_assert( ldns_buffer_position(buff) == 1);
unit_assert( sldns_buffer_position(buff) == 1);
ldns_buffer_clear(buff);
ldns_buffer_write(buff, "\003org\000", 5);
ldns_buffer_flip(buff);
sldns_buffer_clear(buff);
sldns_buffer_write(buff, "\003org\000", 5);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 5 );
unit_assert( ldns_buffer_position(buff) == 5);
unit_assert( sldns_buffer_position(buff) == 5);
ldns_buffer_clear(buff);
ldns_buffer_write(buff, "\002os\007example\003org\000", 16);
ldns_buffer_flip(buff);
sldns_buffer_clear(buff);
sldns_buffer_write(buff, "\002os\007example\003org\000", 16);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 16 );
unit_assert( ldns_buffer_position(buff) == 16);
unit_assert( sldns_buffer_position(buff) == 16);
/* invalid compression pointer: to self */
ldns_buffer_clear(buff);
ldns_buffer_write(buff, "\300\000os\007example\003org\000", 17);
ldns_buffer_flip(buff);
sldns_buffer_clear(buff);
sldns_buffer_write(buff, "\300\000os\007example\003org\000", 17);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 );
/* valid compression pointer */
ldns_buffer_clear(buff);
ldns_buffer_write(buff, "\003com\000\040\300\000", 8);
ldns_buffer_flip(buff);
ldns_buffer_set_position(buff, 6);
sldns_buffer_clear(buff);
sldns_buffer_write(buff, "\003com\000\040\300\000", 8);
sldns_buffer_flip(buff);
sldns_buffer_set_position(buff, 6);
unit_assert( pkt_dname_len(buff) == 5 );
unit_assert( ldns_buffer_position(buff) == 8);
unit_assert( sldns_buffer_position(buff) == 8);
/* unknown label type */
ldns_buffer_clear(buff);
ldns_buffer_write(buff, "\002os\107example\003org\000", 16);
ldns_buffer_flip(buff);
sldns_buffer_clear(buff);
sldns_buffer_write(buff, "\002os\107example\003org\000", 16);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 );
/* label too long */
ldns_buffer_clear(buff);
ldns_buffer_write(buff, "\002os\047example\003org\000", 16);
ldns_buffer_flip(buff);
sldns_buffer_clear(buff);
sldns_buffer_write(buff, "\002os\047example\003org\000", 16);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 );
/* label exceeds packet */
ldns_buffer_clear(buff);
ldns_buffer_write(buff, "\002os\007example\007org\004", 16);
ldns_buffer_flip(buff);
sldns_buffer_clear(buff);
sldns_buffer_write(buff, "\002os\007example\007org\004", 16);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 );
/* name very long */
ldns_buffer_clear(buff);
ldns_buffer_write(buff,
sldns_buffer_clear(buff);
sldns_buffer_write(buff,
"\020a1cdef5555544444"
"\020a2cdef5555544444"
"\020a3cdef5555544444"
@@ -236,13 +236,13 @@ dname_test_pkt_dname_len(ldns_buffer* buff)
"\007aabbccd" /* 246 up to here */
"\007example\000" /* 255 to here */
, 255);
ldns_buffer_flip(buff);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 255 );
unit_assert( ldns_buffer_position(buff) == 255);
unit_assert( sldns_buffer_position(buff) == 255);
/* name too long */
ldns_buffer_clear(buff);
ldns_buffer_write(buff,
sldns_buffer_clear(buff);
sldns_buffer_write(buff,
"\020a1cdef5555544444"
"\020a2cdef5555544444"
"\020a3cdef5555544444"
@@ -263,7 +263,7 @@ dname_test_pkt_dname_len(ldns_buffer* buff)
"\007aabbccd" /* 246 up to here */
"\007example\000" /* 255 to here */
, 255);
ldns_buffer_flip(buff);
sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 );
}
@@ -796,47 +796,47 @@ dname_test_valid(void)
/** test pkt_dname_tolower */
static void
dname_test_pdtl(ldns_buffer* loopbuf, ldns_buffer* boundbuf)
dname_test_pdtl(sldns_buffer* loopbuf, sldns_buffer* boundbuf)
{
unit_show_func("util/data/dname.c", "pkt_dname_tolower");
pkt_dname_tolower(loopbuf, ldns_buffer_at(loopbuf, 12));
pkt_dname_tolower(boundbuf, ldns_buffer_at(boundbuf, 12));
pkt_dname_tolower(loopbuf, sldns_buffer_at(loopbuf, 12));
pkt_dname_tolower(boundbuf, sldns_buffer_at(boundbuf, 12));
}
/** setup looped dname and out-of-bounds dname ptr */
static void
dname_setup_bufs(ldns_buffer* loopbuf, ldns_buffer* boundbuf)
dname_setup_bufs(sldns_buffer* loopbuf, sldns_buffer* boundbuf)
{
ldns_buffer_write_u16(loopbuf, 0xd54d); /* id */
ldns_buffer_write_u16(loopbuf, 0x12); /* flags */
ldns_buffer_write_u16(loopbuf, 1); /* qdcount */
ldns_buffer_write_u16(loopbuf, 0); /* ancount */
ldns_buffer_write_u16(loopbuf, 0); /* nscount */
ldns_buffer_write_u16(loopbuf, 0); /* arcount */
ldns_buffer_write_u8(loopbuf, 0xc0); /* PTR back at itself */
ldns_buffer_write_u8(loopbuf, 0x0c);
ldns_buffer_flip(loopbuf);
sldns_buffer_write_u16(loopbuf, 0xd54d); /* id */
sldns_buffer_write_u16(loopbuf, 0x12); /* flags */
sldns_buffer_write_u16(loopbuf, 1); /* qdcount */
sldns_buffer_write_u16(loopbuf, 0); /* ancount */
sldns_buffer_write_u16(loopbuf, 0); /* nscount */
sldns_buffer_write_u16(loopbuf, 0); /* arcount */
sldns_buffer_write_u8(loopbuf, 0xc0); /* PTR back at itself */
sldns_buffer_write_u8(loopbuf, 0x0c);
sldns_buffer_flip(loopbuf);
ldns_buffer_write_u16(boundbuf, 0xd54d); /* id */
ldns_buffer_write_u16(boundbuf, 0x12); /* flags */
ldns_buffer_write_u16(boundbuf, 1); /* qdcount */
ldns_buffer_write_u16(boundbuf, 0); /* ancount */
ldns_buffer_write_u16(boundbuf, 0); /* nscount */
ldns_buffer_write_u16(boundbuf, 0); /* arcount */
ldns_buffer_write_u8(boundbuf, 0x01); /* len=1 */
ldns_buffer_write_u8(boundbuf, (uint8_t)'A'); /* A. label */
ldns_buffer_write_u8(boundbuf, 0xc0); /* PTR out of bounds */
ldns_buffer_write_u8(boundbuf, 0xcc);
ldns_buffer_flip(boundbuf);
sldns_buffer_write_u16(boundbuf, 0xd54d); /* id */
sldns_buffer_write_u16(boundbuf, 0x12); /* flags */
sldns_buffer_write_u16(boundbuf, 1); /* qdcount */
sldns_buffer_write_u16(boundbuf, 0); /* ancount */
sldns_buffer_write_u16(boundbuf, 0); /* nscount */
sldns_buffer_write_u16(boundbuf, 0); /* arcount */
sldns_buffer_write_u8(boundbuf, 0x01); /* len=1 */
sldns_buffer_write_u8(boundbuf, (uint8_t)'A'); /* A. label */
sldns_buffer_write_u8(boundbuf, 0xc0); /* PTR out of bounds */
sldns_buffer_write_u8(boundbuf, 0xcc);
sldns_buffer_flip(boundbuf);
}
void dname_test(void)
{
ldns_buffer* loopbuf = ldns_buffer_new(14);
ldns_buffer* boundbuf = ldns_buffer_new(16);
ldns_buffer* buff = ldns_buffer_new(65800);
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);
ldns_buffer_flip(buff);
sldns_buffer_flip(buff);
dname_setup_bufs(loopbuf, boundbuf);
dname_test_qdl(buff);
dname_test_qdtl(buff);
@@ -855,7 +855,7 @@ void dname_test(void)
dname_test_canoncmp();
dname_test_topdomain();
dname_test_valid();
ldns_buffer_free(buff);
ldns_buffer_free(loopbuf);
ldns_buffer_free(boundbuf);
sldns_buffer_free(buff);
sldns_buffer_free(loopbuf);
sldns_buffer_free(boundbuf);
}
testcode/unitmain.c
+2 -2
View File
@@ -568,7 +568,7 @@ main(int argc, char* argv[])
OPENSSL_config("unbound");
# endif
# ifdef USE_GOST
(void)ldns_key_EVP_load_gost_id();
(void)sldns_key_EVP_load_gost_id();
# endif
#elif defined(HAVE_NSS)
if(NSS_NoDB_Init(".") != SECSuccess)
@@ -593,7 +593,7 @@ main(int argc, char* argv[])
printf("%d checks ok.\n", testcount);
#ifdef HAVE_SSL
# if defined(USE_GOST) && defined(HAVE_LDNS_KEY_EVP_UNLOAD_GOST)
ldns_key_EVP_unload_gost();
sldns_key_EVP_unload_gost();
# endif
# ifdef HAVE_OPENSSL_CONFIG
EVP_cleanup();
testcode/unitmsgparse.c
+57 -57
View File
@@ -68,36 +68,36 @@ static int check_nosameness = 0;
/** see if buffers contain the same packet */
static int
test_buffers(ldns_buffer* pkt, ldns_buffer* out)
test_buffers(sldns_buffer* pkt, sldns_buffer* out)
{
/* check binary same */
if(ldns_buffer_limit(pkt) == ldns_buffer_limit(out) &&
memcmp(ldns_buffer_begin(pkt), ldns_buffer_begin(out),
ldns_buffer_limit(pkt)) == 0) {
if(sldns_buffer_limit(pkt) == sldns_buffer_limit(out) &&
memcmp(sldns_buffer_begin(pkt), sldns_buffer_begin(out),
sldns_buffer_limit(pkt)) == 0) {
if(vbmp) printf("binary the same (length=%u)\n",
(unsigned)ldns_buffer_limit(pkt));
(unsigned)sldns_buffer_limit(pkt));
return 1;
}
if(vbmp) {
size_t sz = 16;
size_t count;
size_t lim = ldns_buffer_limit(out);
if(ldns_buffer_limit(pkt) < lim)
lim = ldns_buffer_limit(pkt);
size_t lim = sldns_buffer_limit(out);
if(sldns_buffer_limit(pkt) < lim)
lim = sldns_buffer_limit(pkt);
for(count=0; count<lim; count+=sz) {
size_t rem = sz;
if(lim-count < sz) rem = lim-count;
if(memcmp(ldns_buffer_at(pkt, count),
ldns_buffer_at(out, count), rem) == 0) {
if(memcmp(sldns_buffer_at(pkt, count),
sldns_buffer_at(out, count), rem) == 0) {
log_info("same %d %d", (int)count, (int)rem);
log_hex("same: ", ldns_buffer_at(pkt, count),
log_hex("same: ", sldns_buffer_at(pkt, count),
rem);
} else {
log_info("diff %d %d", (int)count, (int)rem);
log_hex("difp: ", ldns_buffer_at(pkt, count),
log_hex("difp: ", sldns_buffer_at(pkt, count),
rem);
log_hex("difo: ", ldns_buffer_at(out, count),
log_hex("difo: ", sldns_buffer_at(out, count),
rem);
}
}
@@ -109,24 +109,24 @@ test_buffers(ldns_buffer* pkt, ldns_buffer* out)
log_buf(0, "orig in hex", pkt);
log_buf(0, "unbound out in hex", out);
printf("\npacket from unbound (%d):\n",
(int)ldns_buffer_limit(out));
s1 = ldns_wire2str_pkt(ldns_buffer_begin(out),
ldns_buffer_limit(out));
(int)sldns_buffer_limit(out));
s1 = sldns_wire2str_pkt(sldns_buffer_begin(out),
sldns_buffer_limit(out));
printf("%s\n", s1?s1:"null");
free(s1);
printf("\npacket original (%d):\n",
(int)ldns_buffer_limit(pkt));
s2 = ldns_wire2str_pkt(ldns_buffer_begin(pkt),
ldns_buffer_limit(pkt));
(int)sldns_buffer_limit(pkt));
s2 = sldns_wire2str_pkt(sldns_buffer_begin(pkt),
sldns_buffer_limit(pkt));
printf("%s\n", s2?s2:"null");
free(s2);
printf("\n");
}
/* if it had two EDNS sections, skip comparison */
if(1) {
char* s = ldns_wire2str_pkt(ldns_buffer_begin(pkt),
ldns_buffer_limit(pkt));
char* s = sldns_wire2str_pkt(sldns_buffer_begin(pkt),
sldns_buffer_limit(pkt));
char* e1 = strstr(s, "; EDNS:");
if(e1 && strstr(e1+4, "; EDNS:")) {
free(s);
@@ -135,19 +135,19 @@ test_buffers(ldns_buffer* pkt, ldns_buffer* out)
free(s);
}
/* compare packets */
unit_assert(match_all(ldns_buffer_begin(pkt), ldns_buffer_limit(pkt),
ldns_buffer_begin(out), ldns_buffer_limit(out), 1,
unit_assert(match_all(sldns_buffer_begin(pkt), sldns_buffer_limit(pkt),
sldns_buffer_begin(out), sldns_buffer_limit(out), 1,
matches_nolocation));
return 0;
}
/** check if unbound formerr equals ldns formerr */
static void
checkformerr(ldns_buffer* pkt)
checkformerr(sldns_buffer* pkt)
{
int status = 0;
char* s = ldns_wire2str_pkt(ldns_buffer_begin(pkt),
ldns_buffer_limit(pkt));
char* s = sldns_wire2str_pkt(sldns_buffer_begin(pkt),
sldns_buffer_limit(pkt));
if(!s) fatal_exit("out of memory");
if(strstr(s, "Error")) status = 1;
if(strstr(s, "error")) status = 1;
@@ -164,7 +164,7 @@ checkformerr(ldns_buffer* pkt)
/** performance test message encoding */
static void
perf_encode(struct query_info* qi, struct reply_info* rep, uint16_t id,
uint16_t flags, ldns_buffer* out, time_t timenow,
uint16_t flags, sldns_buffer* out, time_t timenow,
struct edns_data* edns)
{
static int num = 0;
@@ -191,13 +191,13 @@ perf_encode(struct query_info* qi, struct reply_info* rep, uint16_t id,
((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)ldns_buffer_limit(out));
(int)sldns_buffer_limit(out));
regional_destroy(r2);
}
/** perf test a packet */
static void
perftestpkt(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
perftestpkt(sldns_buffer* pkt, struct alloc_cache* alloc, sldns_buffer* out,
const char* hex)
{
struct query_info qi;
@@ -210,15 +210,15 @@ perftestpkt(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
struct edns_data edns;
hex_to_buf(pkt, hex);
memmove(&id, ldns_buffer_begin(pkt), sizeof(id));
if(ldns_buffer_limit(pkt) < 2)
memmove(&id, sldns_buffer_begin(pkt), sizeof(id));
if(sldns_buffer_limit(pkt) < 2)
flags = 0;
else memmove(&flags, ldns_buffer_at(pkt, 2), sizeof(flags));
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];
ldns_wire2str_rcode_buf(ret, rbuf, sizeof(rbuf));
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);
@@ -311,7 +311,7 @@ check_the_rrsigs(struct query_info* qinfo, struct reply_info* rep)
/** test a packet */
static void
testpkt(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
testpkt(sldns_buffer* pkt, struct alloc_cache* alloc, sldns_buffer* out,
const char* hex)
{
struct query_info qi;
@@ -324,15 +324,15 @@ testpkt(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
struct edns_data edns;
hex_to_buf(pkt, hex);
memmove(&id, ldns_buffer_begin(pkt), sizeof(id));
if(ldns_buffer_limit(pkt) < 2)
memmove(&id, sldns_buffer_begin(pkt), sizeof(id));
if(sldns_buffer_limit(pkt) < 2)
flags = 0;
else memmove(&flags, ldns_buffer_at(pkt, 2), sizeof(flags));
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];
ldns_wire2str_rcode_buf(ret, rbuf, sizeof(rbuf));
sldns_wire2str_rcode_buf(ret, rbuf, sizeof(rbuf));
if(vbmp) printf("parse code %d: %s\n", ret, rbuf);
if(ret == LDNS_RCODE_FORMERR) {
unit_assert(!check_formerr_gone);
@@ -346,30 +346,30 @@ testpkt(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
unit_assert(ret != 0); /* udp packets should fit */
attach_edns_record(out, &edns);
if(vbmp) printf("inlen %u outlen %u\n",
(unsigned)ldns_buffer_limit(pkt),
(unsigned)ldns_buffer_limit(out));
(unsigned)sldns_buffer_limit(pkt),
(unsigned)sldns_buffer_limit(out));
if(!check_nosameness)
test_buffers(pkt, out);
if(check_rrsigs)
check_the_rrsigs(&qi, rep);
if(ldns_buffer_limit(out) > lim) {
if(sldns_buffer_limit(out) > lim) {
ret = reply_info_encode(&qi, rep, id, flags, out,
timenow, region,
lim - calc_edns_field_size(&edns),
(int)(edns.bits & EDNS_DO));
unit_assert(ret != 0); /* should fit, but with TC */
attach_edns_record(out, &edns);
if( LDNS_QDCOUNT(ldns_buffer_begin(out)) !=
LDNS_QDCOUNT(ldns_buffer_begin(pkt)) ||
LDNS_ANCOUNT(ldns_buffer_begin(out)) !=
LDNS_ANCOUNT(ldns_buffer_begin(pkt)) ||
LDNS_NSCOUNT(ldns_buffer_begin(out)) !=
LDNS_NSCOUNT(ldns_buffer_begin(pkt)))
if( LDNS_QDCOUNT(sldns_buffer_begin(out)) !=
LDNS_QDCOUNT(sldns_buffer_begin(pkt)) ||
LDNS_ANCOUNT(sldns_buffer_begin(out)) !=
LDNS_ANCOUNT(sldns_buffer_begin(pkt)) ||
LDNS_NSCOUNT(sldns_buffer_begin(out)) !=
LDNS_NSCOUNT(sldns_buffer_begin(pkt)))
unit_assert(
LDNS_TC_WIRE(ldns_buffer_begin(out)));
LDNS_TC_WIRE(sldns_buffer_begin(out)));
/* must set TC bit if shortened */
unit_assert(ldns_buffer_limit(out) <= lim);
unit_assert(sldns_buffer_limit(out) <= lim);
}
}
@@ -380,7 +380,7 @@ testpkt(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
/** simple test of parsing */
static void
simpletest(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out)
simpletest(sldns_buffer* pkt, struct alloc_cache* alloc, sldns_buffer* out)
{
/* a root query drill -q - */
testpkt(pkt, alloc, out,
@@ -437,7 +437,7 @@ simpletest(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out)
/** simple test of parsing, pcat file */
static void
testfromfile(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
testfromfile(sldns_buffer* pkt, struct alloc_cache* alloc, sldns_buffer* out,
const char* fname)
{
FILE* in = fopen(fname, "r");
@@ -464,8 +464,8 @@ testfromfile(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
/** simple test of parsing, drill file */
static void
testfromdrillfile(ldns_buffer* pkt, struct alloc_cache* alloc,
ldns_buffer* out, const char* fname)
testfromdrillfile(sldns_buffer* pkt, struct alloc_cache* alloc,
sldns_buffer* out, const char* fname)
{
/* ;-- is used to indicate a new message */
FILE* in = fopen(fname, "r");
@@ -497,8 +497,8 @@ testfromdrillfile(ldns_buffer* pkt, struct alloc_cache* alloc,
void msgparse_test(void)
{
ldns_buffer* pkt = ldns_buffer_new(65553);
ldns_buffer* out = ldns_buffer_new(65553);
sldns_buffer* pkt = sldns_buffer_new(65553);
sldns_buffer* out = sldns_buffer_new(65553);
struct alloc_cache super_a, alloc;
/* init */
alloc_init(&super_a, NULL, 0);
@@ -534,6 +534,6 @@ void msgparse_test(void)
/* cleanup */
alloc_clear(&alloc);
alloc_clear(&super_a);
ldns_buffer_free(pkt);
ldns_buffer_free(out);
sldns_buffer_free(pkt);
sldns_buffer_free(out);
}
testcode/unitverify.c
+21 -21
View File
@@ -66,23 +66,23 @@ static int vsig = 0;
/** entry to packet buffer with wireformat */
static void
entry_to_buf(struct entry* e, ldns_buffer* pkt)
entry_to_buf(struct entry* e, sldns_buffer* pkt)
{
unit_assert(e->reply_list);
if(e->reply_list->reply_from_hex) {
ldns_buffer_copy(pkt, e->reply_list->reply_from_hex);
sldns_buffer_copy(pkt, e->reply_list->reply_from_hex);
} else {
ldns_buffer_clear(pkt);
ldns_buffer_write(pkt, e->reply_list->reply_pkt,
sldns_buffer_clear(pkt);
sldns_buffer_write(pkt, e->reply_list->reply_pkt,
e->reply_list->reply_len);
ldns_buffer_flip(pkt);
sldns_buffer_flip(pkt);
}
}
/** entry to reply info conversion */
static void
entry_to_repinfo(struct entry* e, struct alloc_cache* alloc,
struct regional* region, ldns_buffer* pkt, struct query_info* qi,
struct regional* region, sldns_buffer* pkt, struct query_info* qi,
struct reply_info** rep)
{
int ret;
@@ -97,7 +97,7 @@ entry_to_repinfo(struct entry* e, struct alloc_cache* alloc,
lock_quick_unlock(&alloc->lock);
if(ret != 0) {
char rcode[16];
ldns_wire2str_rcode_buf(ret, rcode, sizeof(rcode));
sldns_wire2str_rcode_buf(ret, rcode, sizeof(rcode));
printf("parse code %d: %s\n", ret, rcode);
unit_assert(ret != 0);
}
@@ -106,7 +106,7 @@ entry_to_repinfo(struct entry* e, struct alloc_cache* alloc,
/** extract DNSKEY rrset from answer and convert it */
static struct ub_packed_rrset_key*
extract_keys(struct entry* e, struct alloc_cache* alloc,
struct regional* region, ldns_buffer* pkt)
struct regional* region, sldns_buffer* pkt)
{
struct ub_packed_rrset_key* dnskey = NULL;
struct query_info qinfo;
@@ -201,7 +201,7 @@ verifytest_rrset(struct module_env* env, struct val_env* ve,
/** verify and test an entry - every rr in the message */
static void
verifytest_entry(struct entry* e, struct alloc_cache* alloc,
struct regional* region, ldns_buffer* pkt,
struct regional* region, sldns_buffer* pkt,
struct ub_packed_rrset_key* dnskey, struct module_env* env,
struct val_env* ve)
{
@@ -211,7 +211,7 @@ verifytest_entry(struct entry* e, struct alloc_cache* alloc,
regional_free_all(region);
if(vsig) {
char* s = ldns_wire2str_pkt(e->reply_list->reply_pkt,
char* s = sldns_wire2str_pkt(e->reply_list->reply_pkt,
e->reply_list->reply_len);
printf("verifying pkt:\n%s\n", s?s:"outofmemory");
free(s);
@@ -241,7 +241,7 @@ find_rrset_type(struct reply_info* rep, uint16_t type)
/** 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, ldns_buffer* pkt, struct module_env* env)
struct regional* region, sldns_buffer* pkt, struct module_env* env)
{
struct query_info qinfo;
struct reply_info* rep = NULL;
@@ -250,7 +250,7 @@ dstest_entry(struct entry* e, struct alloc_cache* alloc,
regional_free_all(region);
if(vsig) {
char* s = ldns_wire2str_pkt(e->reply_list->reply_pkt,
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);
@@ -293,7 +293,7 @@ verifytest_file(const char* fname, const char* at_date)
struct ub_packed_rrset_key* dnskey;
struct regional* region = regional_create();
struct alloc_cache alloc;
ldns_buffer* buf = ldns_buffer_new(65535);
sldns_buffer* buf = sldns_buffer_new(65535);
struct entry* e;
struct entry* list = read_datafile(fname, 1);
struct module_env env;
@@ -323,7 +323,7 @@ verifytest_file(const char* fname, const char* at_date)
delete_entry(list);
regional_destroy(region);
alloc_clear(&alloc);
ldns_buffer_free(buf);
sldns_buffer_free(buf);
}
/** verify DS matches DNSKEY from a file */
@@ -337,7 +337,7 @@ dstest_file(const char* fname)
*/
struct regional* region = regional_create();
struct alloc_cache alloc;
ldns_buffer* buf = ldns_buffer_new(65535);
sldns_buffer* buf = sldns_buffer_new(65535);
struct entry* e;
struct entry* list = read_datafile(fname, 1);
struct module_env env;
@@ -358,7 +358,7 @@ dstest_file(const char* fname)
delete_entry(list);
regional_destroy(region);
alloc_clear(&alloc);
ldns_buffer_free(buf);
sldns_buffer_free(buf);
}
/** helper for unittest of NSEC routines */
@@ -414,7 +414,7 @@ nsectest(void)
static void
nsec3_hash_test_entry(struct entry* e, rbtree_t* ct,
struct alloc_cache* alloc, struct regional* region,
ldns_buffer* buf)
sldns_buffer* buf)
{
struct query_info qinfo;
struct reply_info* rep = NULL;
@@ -424,7 +424,7 @@ nsec3_hash_test_entry(struct entry* e, rbtree_t* ct,
uint8_t* qname;
if(vsig) {
char* s = ldns_wire2str_pkt(e->reply_list->reply_pkt,
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);
@@ -471,7 +471,7 @@ nsec3_hash_test(const char* fname)
rbtree_t ct;
struct regional* region = regional_create();
struct alloc_cache alloc;
ldns_buffer* buf = ldns_buffer_new(65535);
sldns_buffer* buf = sldns_buffer_new(65535);
struct entry* e;
struct entry* list = read_datafile(fname, 1);
@@ -489,7 +489,7 @@ nsec3_hash_test(const char* fname)
delete_entry(list);
regional_destroy(region);
alloc_clear(&alloc);
ldns_buffer_free(buf);
sldns_buffer_free(buf);
}
void
@@ -515,7 +515,7 @@ verify_test(void)
verifytest_file("testdata/test_sigs.hinfo", "20090107100022");
verifytest_file("testdata/test_sigs.revoked", "20080414005004");
#ifdef USE_GOST
if(ldns_key_EVP_load_gost_id())
if(sldns_key_EVP_load_gost_id())
verifytest_file("testdata/test_sigs.gost", "20090807060504");
else printf("Warning: skipped GOST, openssl does not provide gost.\n");
#endif