upstream/unbound
1
0
Fork 0
mirror of https://github.com/NLnetLabs/unbound.git synced 2025-12-23 16:20:26 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

- 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
Show stats Download patch file Download diff file Expand all files Collapse all files

1
config.h.in
View file

@ -692,6 +692,7 @@
/** Use small-ldns codebase */ /** Use small-ldns codebase */
#define USE_SLDNS 1 #define USE_SLDNS 1
#define SLDNS sldns_
#ifdef HAVE_SSL #ifdef HAVE_SSL
# define LDNS_BUILD_CONFIG_HAVE_SSL 1 # define LDNS_BUILD_CONFIG_HAVE_SSL 1
#endif #endif

1
configure.ac
View file

@ -1060,6 +1060,7 @@ dnl includes
/** Use small-ldns codebase */ /** Use small-ldns codebase */
#define USE_SLDNS 1 #define USE_SLDNS 1
#define SLDNS sldns_
#ifdef HAVE_SSL #ifdef HAVE_SSL
# define LDNS_BUILD_CONFIG_HAVE_SSL 1 # define LDNS_BUILD_CONFIG_HAVE_SSL 1
#endif #endif

76
daemon/cachedump.c
View file

@ -139,9 +139,9 @@ static int
dump_msg_ref(SSL* ssl, struct ub_packed_rrset_key* k) dump_msg_ref(SSL* ssl, struct ub_packed_rrset_key* k)
{ {
char* nm, *tp, *cl; char* nm, *tp, *cl;
nm = ldns_wire2str_dname(k->rk.dname, k->rk.dname_len); nm = sldns_wire2str_dname(k->rk.dname, k->rk.dname_len);
tp = ldns_wire2str_type(ntohs(k->rk.type)); tp = sldns_wire2str_type(ntohs(k->rk.type));
cl = ldns_wire2str_class(ntohs(k->rk.rrset_class)); cl = sldns_wire2str_class(ntohs(k->rk.rrset_class));
if(!nm || !cl || !tp) { if(!nm || !cl || !tp) {
free(nm); free(nm);
free(tp); free(tp);
@ -171,9 +171,9 @@ dump_msg(SSL* ssl, struct query_info* k, struct reply_info* d,
if(!k || !d) return 1; if(!k || !d) return 1;
if(d->ttl < now) return 1; /* expired */ if(d->ttl < now) return 1; /* expired */
nm = ldns_wire2str_dname(k->qname, k->qname_len); nm = sldns_wire2str_dname(k->qname, k->qname_len);
tp = ldns_wire2str_type(k->qtype); tp = sldns_wire2str_type(k->qtype);
cl = ldns_wire2str_class(k->qclass); cl = sldns_wire2str_class(k->qclass);
if(!nm || !tp || !cl) { if(!nm || !tp || !cl) {
free(nm); free(nm);
free(tp); free(tp);
@ -299,23 +299,23 @@ dump_cache(SSL* ssl, struct worker* worker)
/** read a line from ssl into buffer */ /** read a line from ssl into buffer */
static int static int
ssl_read_buf(SSL* ssl, ldns_buffer* buf) ssl_read_buf(SSL* ssl, sldns_buffer* buf)
{ {
return ssl_read_line(ssl, (char*)ldns_buffer_begin(buf), return ssl_read_line(ssl, (char*)sldns_buffer_begin(buf),
ldns_buffer_capacity(buf)); sldns_buffer_capacity(buf));
} }
/** check fixed text on line */ /** check fixed text on line */
static int static int
read_fixed(SSL* ssl, ldns_buffer* buf, const char* str) read_fixed(SSL* ssl, sldns_buffer* buf, const char* str)
{ {
if(!ssl_read_buf(ssl, buf)) return 0; if(!ssl_read_buf(ssl, buf)) return 0;
return (strcmp((char*)ldns_buffer_begin(buf), str) == 0); return (strcmp((char*)sldns_buffer_begin(buf), str) == 0);
} }
/** load an RR into rrset */ /** load an RR into rrset */
static int static int
load_rr(SSL* ssl, ldns_buffer* buf, struct regional* region, load_rr(SSL* ssl, sldns_buffer* buf, struct regional* region,
struct ub_packed_rrset_key* rk, struct packed_rrset_data* d, struct ub_packed_rrset_key* rk, struct packed_rrset_data* d,
unsigned int i, int is_rrsig, int* go_on, time_t now) unsigned int i, int is_rrsig, int* go_on, time_t now)
{ {
@ -326,31 +326,31 @@ load_rr(SSL* ssl, ldns_buffer* buf, struct regional* region,
/* read the line */ /* read the line */
if(!ssl_read_buf(ssl, buf)) if(!ssl_read_buf(ssl, buf))
return 0; return 0;
if(strncmp((char*)ldns_buffer_begin(buf), "BADRR\n", 6) == 0) { if(strncmp((char*)sldns_buffer_begin(buf), "BADRR\n", 6) == 0) {
*go_on = 0; *go_on = 0;
return 1; return 1;
} }
status = ldns_str2wire_rr_buf((char*)ldns_buffer_begin(buf), rr, status = sldns_str2wire_rr_buf((char*)sldns_buffer_begin(buf), rr,
&rr_len, &dname_len, 3600, NULL, 0, NULL, 0); &rr_len, &dname_len, 3600, NULL, 0, NULL, 0);
if(status != 0) { if(status != 0) {
log_warn("error cannot parse rr: %s: %s", log_warn("error cannot parse rr: %s: %s",
ldns_get_errorstr_parse(status), sldns_get_errorstr_parse(status),
(char*)ldns_buffer_begin(buf)); (char*)sldns_buffer_begin(buf));
return 0; return 0;
} }
if(is_rrsig && ldns_wirerr_get_type(rr, rr_len, dname_len) if(is_rrsig && sldns_wirerr_get_type(rr, rr_len, dname_len)
!= LDNS_RR_TYPE_RRSIG) { != LDNS_RR_TYPE_RRSIG) {
log_warn("error expected rrsig but got %s", log_warn("error expected rrsig but got %s",
(char*)ldns_buffer_begin(buf)); (char*)sldns_buffer_begin(buf));
return 0; return 0;
} }
/* convert ldns rr into packed_rr */ /* convert ldns rr into packed_rr */
d->rr_ttl[i] = (time_t)ldns_wirerr_get_ttl(rr, rr_len, dname_len) + now; d->rr_ttl[i] = (time_t)sldns_wirerr_get_ttl(rr, rr_len, dname_len) + now;
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
d->rr_len[i] = ldns_wirerr_get_rdatalen(rr, rr_len, dname_len)+2; d->rr_len[i] = sldns_wirerr_get_rdatalen(rr, rr_len, dname_len)+2;
d->rr_data[i] = (uint8_t*)regional_alloc_init(region, d->rr_data[i] = (uint8_t*)regional_alloc_init(region,
ldns_wirerr_get_rdatawl(rr, rr_len, dname_len), d->rr_len[i]); sldns_wirerr_get_rdatawl(rr, rr_len, dname_len), d->rr_len[i]);
if(!d->rr_data[i]) { if(!d->rr_data[i]) {
log_warn("error out of memory"); log_warn("error out of memory");
return 0; return 0;
@ -358,8 +358,8 @@ load_rr(SSL* ssl, ldns_buffer* buf, struct regional* region,
/* if first entry, fill the key structure */ /* if first entry, fill the key structure */
if(i==0) { if(i==0) {
rk->rk.type = htons(ldns_wirerr_get_type(rr, rr_len, dname_len)); rk->rk.type = htons(sldns_wirerr_get_type(rr, rr_len, dname_len));
rk->rk.rrset_class = htons(ldns_wirerr_get_class(rr, rr_len, dname_len)); rk->rk.rrset_class = htons(sldns_wirerr_get_class(rr, rr_len, dname_len));
rk->rk.dname_len = dname_len; rk->rk.dname_len = dname_len;
rk->rk.dname = regional_alloc_init(region, rr, dname_len); rk->rk.dname = regional_alloc_init(region, rr, dname_len);
if(!rk->rk.dname) { if(!rk->rk.dname) {
@ -432,9 +432,9 @@ move_into_cache(struct ub_packed_rrset_key* k,
/** load an rrset entry */ /** load an rrset entry */
static int static int
load_rrset(SSL* ssl, ldns_buffer* buf, struct worker* worker) load_rrset(SSL* ssl, sldns_buffer* buf, struct worker* worker)
{ {
char* s = (char*)ldns_buffer_begin(buf); char* s = (char*)sldns_buffer_begin(buf);
struct regional* region = worker->scratchpad; struct regional* region = worker->scratchpad;
struct ub_packed_rrset_key* rk; struct ub_packed_rrset_key* rk;
struct packed_rrset_data* d; struct packed_rrset_data* d;
@ -514,10 +514,10 @@ load_rrset(SSL* ssl, ldns_buffer* buf, struct worker* worker)
static int static int
load_rrset_cache(SSL* ssl, struct worker* worker) load_rrset_cache(SSL* ssl, struct worker* worker)
{ {
ldns_buffer* buf = worker->env.scratch_buffer; sldns_buffer* buf = worker->env.scratch_buffer;
if(!read_fixed(ssl, buf, "START_RRSET_CACHE")) return 0; if(!read_fixed(ssl, buf, "START_RRSET_CACHE")) return 0;
while(ssl_read_buf(ssl, buf) && while(ssl_read_buf(ssl, buf) &&
strcmp((char*)ldns_buffer_begin(buf), "END_RRSET_CACHE")!=0) { strcmp((char*)sldns_buffer_begin(buf), "END_RRSET_CACHE")!=0) {
if(!load_rrset(ssl, buf, worker)) if(!load_rrset(ssl, buf, worker))
return 0; return 0;
} }
@ -546,15 +546,15 @@ load_qinfo(char* str, struct query_info* qinfo, struct regional* region)
s++; s++;
/* parse them */ /* parse them */
status = ldns_str2wire_rr_question_buf(str, rr, &rr_len, &dname_len, status = sldns_str2wire_rr_question_buf(str, rr, &rr_len, &dname_len,
NULL, 0, NULL, 0); NULL, 0, NULL, 0);
if(status != 0) { if(status != 0) {
log_warn("error cannot parse: %s %s", log_warn("error cannot parse: %s %s",
ldns_get_errorstr_parse(status), str); sldns_get_errorstr_parse(status), str);
return NULL; return NULL;
} }
qinfo->qtype = ldns_wirerr_get_type(rr, rr_len, dname_len); qinfo->qtype = sldns_wirerr_get_type(rr, rr_len, dname_len);
qinfo->qclass = ldns_wirerr_get_class(rr, rr_len, dname_len); qinfo->qclass = sldns_wirerr_get_class(rr, rr_len, dname_len);
qinfo->qname_len = dname_len; qinfo->qname_len = dname_len;
qinfo->qname = (uint8_t*)regional_alloc_init(region, rr, dname_len); qinfo->qname = (uint8_t*)regional_alloc_init(region, rr, dname_len);
if(!qinfo->qname) { if(!qinfo->qname) {
@ -567,11 +567,11 @@ load_qinfo(char* str, struct query_info* qinfo, struct regional* region)
/** load a msg rrset reference */ /** load a msg rrset reference */
static int static int
load_ref(SSL* ssl, ldns_buffer* buf, struct worker* worker, load_ref(SSL* ssl, sldns_buffer* buf, struct worker* worker,
struct regional *region, struct ub_packed_rrset_key** rrset, struct regional *region, struct ub_packed_rrset_key** rrset,
int* go_on) int* go_on)
{ {
char* s = (char*)ldns_buffer_begin(buf); char* s = (char*)sldns_buffer_begin(buf);
struct query_info qinfo; struct query_info qinfo;
unsigned int flags; unsigned int flags;
struct ub_packed_rrset_key* k; struct ub_packed_rrset_key* k;
@ -612,12 +612,12 @@ load_ref(SSL* ssl, ldns_buffer* buf, struct worker* worker,
/** load a msg entry */ /** load a msg entry */
static int static int
load_msg(SSL* ssl, ldns_buffer* buf, struct worker* worker) load_msg(SSL* ssl, sldns_buffer* buf, struct worker* worker)
{ {
struct regional* region = worker->scratchpad; struct regional* region = worker->scratchpad;
struct query_info qinf; struct query_info qinf;
struct reply_info rep; struct reply_info rep;
char* s = (char*)ldns_buffer_begin(buf); char* s = (char*)sldns_buffer_begin(buf);
unsigned int flags, qdcount, security, an, ns, ar; unsigned int flags, qdcount, security, an, ns, ar;
long long ttl; long long ttl;
size_t i; size_t i;
@ -675,10 +675,10 @@ load_msg(SSL* ssl, ldns_buffer* buf, struct worker* worker)
static int static int
load_msg_cache(SSL* ssl, struct worker* worker) load_msg_cache(SSL* ssl, struct worker* worker)
{ {
ldns_buffer* buf = worker->env.scratch_buffer; sldns_buffer* buf = worker->env.scratch_buffer;
if(!read_fixed(ssl, buf, "START_MSG_CACHE")) return 0; if(!read_fixed(ssl, buf, "START_MSG_CACHE")) return 0;
while(ssl_read_buf(ssl, buf) && while(ssl_read_buf(ssl, buf) &&
strcmp((char*)ldns_buffer_begin(buf), "END_MSG_CACHE")!=0) { strcmp((char*)sldns_buffer_begin(buf), "END_MSG_CACHE")!=0) {
if(!load_msg(ssl, buf, worker)) if(!load_msg(ssl, buf, worker))
return 0; return 0;
} }

4
daemon/daemon.c
View file

@ -208,7 +208,7 @@ daemon_init(void)
OPENSSL_config("unbound"); OPENSSL_config("unbound");
# endif # endif
# ifdef USE_GOST # ifdef USE_GOST
(void)ldns_key_EVP_load_gost_id(); (void)sldns_key_EVP_load_gost_id();
# endif # endif
OpenSSL_add_all_algorithms(); OpenSSL_add_all_algorithms();
# if HAVE_DECL_SSL_COMP_GET_COMPRESSION_METHODS # if HAVE_DECL_SSL_COMP_GET_COMPRESSION_METHODS
@ -563,7 +563,7 @@ daemon_delete(struct daemon* daemon)
/* libcrypto cleanup */ /* libcrypto cleanup */
#ifdef HAVE_SSL #ifdef HAVE_SSL
# if defined(USE_GOST) && defined(HAVE_LDNS_KEY_EVP_UNLOAD_GOST) # if defined(USE_GOST) && defined(HAVE_LDNS_KEY_EVP_UNLOAD_GOST)
ldns_key_EVP_unload_gost(); sldns_key_EVP_unload_gost();
# endif # endif
# if HAVE_DECL_SSL_COMP_GET_COMPRESSION_METHODS && HAVE_DECL_SK_SSL_COMP_POP_FREE # if HAVE_DECL_SSL_COMP_GET_COMPRESSION_METHODS && HAVE_DECL_SK_SSL_COMP_POP_FREE
# ifndef S_SPLINT_S # ifndef S_SPLINT_S

32
daemon/remote.c
View file

@ -759,13 +759,13 @@ print_ext(SSL* ssl, struct stats_info* s)
{ {
int i; int i;
char nm[16]; char nm[16];
const ldns_rr_descriptor* desc; const sldns_rr_descriptor* desc;
const ldns_lookup_table* lt; const sldns_lookup_table* lt;
/* TYPE */ /* TYPE */
for(i=0; i<STATS_QTYPE_NUM; i++) { for(i=0; i<STATS_QTYPE_NUM; i++) {
if(inhibit_zero && s->svr.qtype[i] == 0) if(inhibit_zero && s->svr.qtype[i] == 0)
continue; continue;
desc = ldns_rr_descript((uint16_t)i); desc = sldns_rr_descript((uint16_t)i);
if(desc && desc->_name) { if(desc && desc->_name) {
snprintf(nm, sizeof(nm), "%s", desc->_name); snprintf(nm, sizeof(nm), "%s", desc->_name);
} else if (i == LDNS_RR_TYPE_IXFR) { } else if (i == LDNS_RR_TYPE_IXFR) {
@ -792,7 +792,7 @@ print_ext(SSL* ssl, struct stats_info* s)
for(i=0; i<STATS_QCLASS_NUM; i++) { for(i=0; i<STATS_QCLASS_NUM; i++) {
if(inhibit_zero && s->svr.qclass[i] == 0) if(inhibit_zero && s->svr.qclass[i] == 0)
continue; continue;
lt = ldns_lookup_by_id(SLDNS(_rr_classes), i); lt = sldns_lookup_by_id(sldns_rr_classes, i);
if(lt && lt->name) { if(lt && lt->name) {
snprintf(nm, sizeof(nm), "%s", lt->name); snprintf(nm, sizeof(nm), "%s", lt->name);
} else { } else {
@ -809,7 +809,7 @@ print_ext(SSL* ssl, struct stats_info* s)
for(i=0; i<STATS_OPCODE_NUM; i++) { for(i=0; i<STATS_OPCODE_NUM; i++) {
if(inhibit_zero && s->svr.qopcode[i] == 0) if(inhibit_zero && s->svr.qopcode[i] == 0)
continue; continue;
lt = ldns_lookup_by_id(SLDNS(_opcodes), i); lt = sldns_lookup_by_id(sldns_opcodes, i);
if(lt && lt->name) { if(lt && lt->name) {
snprintf(nm, sizeof(nm), "%s", lt->name); snprintf(nm, sizeof(nm), "%s", lt->name);
} else { } else {
@ -849,7 +849,7 @@ print_ext(SSL* ssl, struct stats_info* s)
for(i=0; i<STATS_RCODE_NUM; i++) { for(i=0; i<STATS_RCODE_NUM; i++) {
if(inhibit_zero && s->svr.ans_rcode[i] == 0) if(inhibit_zero && s->svr.ans_rcode[i] == 0)
continue; continue;
lt = ldns_lookup_by_id(SLDNS(_rcodes), i); lt = sldns_lookup_by_id(sldns_rcodes, i);
if(lt && lt->name) { if(lt && lt->name) {
snprintf(nm, sizeof(nm), "%s", lt->name); snprintf(nm, sizeof(nm), "%s", lt->name);
} else { } else {
@ -921,11 +921,11 @@ parse_arg_name(SSL* ssl, char* str, uint8_t** res, size_t* len, int* labs)
*res = NULL; *res = NULL;
*len = 0; *len = 0;
*labs = 0; *labs = 0;
status = ldns_str2wire_dname_buf(str, nm, &nmlen); status = sldns_str2wire_dname_buf(str, nm, &nmlen);
if(status != 0) { if(status != 0) {
ssl_printf(ssl, "error cannot parse name %s at %d: %s\n", str, ssl_printf(ssl, "error cannot parse name %s at %d: %s\n", str,
LDNS_WIREPARSE_OFFSET(status), LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status)); sldns_get_errorstr_parse(status));
return 0; return 0;
} }
*res = memdup(nm, nmlen); *res = memdup(nm, nmlen);
@ -1095,7 +1095,7 @@ do_flush_type(SSL* ssl, struct worker* worker, char* arg)
return; return;
if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs))
return; return;
t = ldns_get_rr_type_by_name(arg2); t = sldns_get_rr_type_by_name(arg2);
do_cache_remove(worker, nm, nmlen, t, LDNS_RR_CLASS_IN); do_cache_remove(worker, nm, nmlen, t, LDNS_RR_CLASS_IN);
free(nm); free(nm);
@ -1393,7 +1393,7 @@ ssl_print_name_dp(SSL* ssl, char* str, uint8_t* nm, uint16_t dclass,
struct delegpt_addr* a; struct delegpt_addr* a;
int f = 0; int f = 0;
if(str) { /* print header for forward, stub */ if(str) { /* print header for forward, stub */
char* c = ldns_wire2str_class(dclass); char* c = sldns_wire2str_class(dclass);
dname_str(nm, buf); dname_str(nm, buf);
if(!ssl_printf(ssl, "%s %s %s: ", buf, (c?c:"CLASS??"), str)) { if(!ssl_printf(ssl, "%s %s %s: ", buf, (c?c:"CLASS??"), str)) {
free(c); free(c);
@ -1785,8 +1785,8 @@ get_mesh_status(struct mesh_area* mesh, struct mesh_state* m,
if(m->sub_set.count == 0) if(m->sub_set.count == 0)
snprintf(buf, len, " (empty_list)"); snprintf(buf, len, " (empty_list)");
RBTREE_FOR(sub, struct mesh_state_ref*, &m->sub_set) { RBTREE_FOR(sub, struct mesh_state_ref*, &m->sub_set) {
char* t = ldns_wire2str_type(sub->s->s.qinfo.qtype); char* t = sldns_wire2str_type(sub->s->s.qinfo.qtype);
char* c = ldns_wire2str_class(sub->s->s.qinfo.qclass); char* c = sldns_wire2str_class(sub->s->s.qinfo.qclass);
dname_str(sub->s->s.qinfo.qname, nm); dname_str(sub->s->s.qinfo.qname, nm);
snprintf(buf, len, " %s %s %s", (t?t:"TYPE??"), snprintf(buf, len, " %s %s %s", (t?t:"TYPE??"),
(c?c:"CLASS??"), nm); (c?c:"CLASS??"), nm);
@ -1818,8 +1818,8 @@ do_dump_requestlist(SSL* ssl, struct worker* worker)
mesh = worker->env.mesh; mesh = worker->env.mesh;
if(!mesh) return; if(!mesh) return;
RBTREE_FOR(m, struct mesh_state*, &mesh->all) { RBTREE_FOR(m, struct mesh_state*, &mesh->all) {
char* t = ldns_wire2str_type(m->s.qinfo.qtype); char* t = sldns_wire2str_type(m->s.qinfo.qtype);
char* c = ldns_wire2str_class(m->s.qinfo.qclass); char* c = sldns_wire2str_class(m->s.qinfo.qclass);
dname_str(m->s.qinfo.qname, buf); dname_str(m->s.qinfo.qname, buf);
get_mesh_age(m, timebuf, sizeof(timebuf), &worker->env); get_mesh_age(m, timebuf, sizeof(timebuf), &worker->env);
get_mesh_status(mesh, m, statbuf, sizeof(statbuf)); get_mesh_status(mesh, m, statbuf, sizeof(statbuf));
@ -1985,8 +1985,8 @@ do_list_local_data(SSL* ssl, struct worker* worker)
struct local_zone* z; struct local_zone* z;
struct local_data* d; struct local_data* d;
struct local_rrset* p; struct local_rrset* p;
char* s = (char*)ldns_buffer_begin(worker->env.scratch_buffer); char* s = (char*)sldns_buffer_begin(worker->env.scratch_buffer);
size_t slen = ldns_buffer_capacity(worker->env.scratch_buffer); size_t slen = sldns_buffer_capacity(worker->env.scratch_buffer);
lock_quick_lock(&zones->lock); lock_quick_lock(&zones->lock);
RBTREE_FOR(z, struct local_zone*, &zones->ztree) { RBTREE_FOR(z, struct local_zone*, &zones->ztree) {
lock_rw_rdlock(&z->lock); lock_rw_rdlock(&z->lock);

12
daemon/stats.c
View file

@ -262,14 +262,14 @@ void server_stats_insquery(struct server_stats* stats, struct comm_point* c,
uint16_t qtype, uint16_t qclass, struct edns_data* edns, uint16_t qtype, uint16_t qclass, struct edns_data* edns,
struct comm_reply* repinfo) struct comm_reply* repinfo)
{ {
uint16_t flags = ldns_buffer_read_u16_at(c->buffer, 2); uint16_t flags = sldns_buffer_read_u16_at(c->buffer, 2);
if(qtype < STATS_QTYPE_NUM) if(qtype < STATS_QTYPE_NUM)
stats->qtype[qtype]++; stats->qtype[qtype]++;
else stats->qtype_big++; else stats->qtype_big++;
if(qclass < STATS_QCLASS_NUM) if(qclass < STATS_QCLASS_NUM)
stats->qclass[qclass]++; stats->qclass[qclass]++;
else stats->qclass_big++; else stats->qclass_big++;
stats->qopcode[ LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) ]++; stats->qopcode[ LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) ]++;
if(c->type != comm_udp) if(c->type != comm_udp)
stats->qtcp++; stats->qtcp++;
if(repinfo && addr_is_ip6(&repinfo->addr, repinfo->addrlen)) if(repinfo && addr_is_ip6(&repinfo->addr, repinfo->addrlen))
@ -297,12 +297,12 @@ void server_stats_insquery(struct server_stats* stats, struct comm_point* c,
} }
} }
void server_stats_insrcode(struct server_stats* stats, ldns_buffer* buf) void server_stats_insrcode(struct server_stats* stats, sldns_buffer* buf)
{ {
if(stats->extended && ldns_buffer_limit(buf) != 0) { if(stats->extended && sldns_buffer_limit(buf) != 0) {
int r = (int)LDNS_RCODE_WIRE( ldns_buffer_begin(buf) ); int r = (int)LDNS_RCODE_WIRE( sldns_buffer_begin(buf) );
stats->ans_rcode[r] ++; stats->ans_rcode[r] ++;
if(r == 0 && LDNS_ANCOUNT( ldns_buffer_begin(buf) ) == 0) if(r == 0 && LDNS_ANCOUNT( sldns_buffer_begin(buf) ) == 0)
stats->ans_rcode_nodata ++; stats->ans_rcode_nodata ++;
} }
} }

4
daemon/stats.h
View file

@ -48,7 +48,7 @@ struct config_file;
struct comm_point; struct comm_point;
struct comm_reply; struct comm_reply;
struct edns_data; struct edns_data;
struct ldns_buffer; struct sldns_buffer;
/** number of qtype that is stored for in array */ /** number of qtype that is stored for in array */
#define STATS_QTYPE_NUM 256 #define STATS_QTYPE_NUM 256
@ -230,6 +230,6 @@ void server_stats_insquery(struct server_stats* stats, struct comm_point* c,
* @param stats: the stats * @param stats: the stats
* @param buf: buffer with rcode. If buffer is length0: not counted. * @param buf: buffer with rcode. If buffer is length0: not counted.
*/ */
void server_stats_insrcode(struct server_stats* stats, struct ldns_buffer* buf); void server_stats_insrcode(struct server_stats* stats, struct sldns_buffer* buf);
#endif /* DAEMON_STATS_H */ #endif /* DAEMON_STATS_H */

182
daemon/worker.c
View file

@ -179,7 +179,7 @@ worker_mem_report(struct worker* ATTR_UNUSED(worker),
+ sizeof(worker->rndstate) + sizeof(worker->rndstate)
+ regional_get_mem(worker->scratchpad) + regional_get_mem(worker->scratchpad)
+ sizeof(*worker->env.scratch_buffer) + sizeof(*worker->env.scratch_buffer)
+ ldns_buffer_capacity(worker->env.scratch_buffer) + sldns_buffer_capacity(worker->env.scratch_buffer)
+ forwards_get_mem(worker->env.fwds) + forwards_get_mem(worker->env.fwds)
+ hints_get_mem(worker->env.hints); + hints_get_mem(worker->env.hints);
if(worker->thread_num == 0) if(worker->thread_num == 0)
@ -241,10 +241,10 @@ worker_handle_reply(struct comm_point* c, void* arg, int error,
return 0; return 0;
} }
/* sanity check. */ /* sanity check. */
if(!LDNS_QR_WIRE(ldns_buffer_begin(c->buffer)) if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) != || LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
LDNS_PACKET_QUERY LDNS_PACKET_QUERY
|| LDNS_QDCOUNT(ldns_buffer_begin(c->buffer)) > 1) { || LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
/* error becomes timeout for the module as if this reply /* error becomes timeout for the module as if this reply
* never arrived. */ * never arrived. */
mesh_report_reply(worker->env.mesh, &e, reply_info, mesh_report_reply(worker->env.mesh, &e, reply_info,
@ -272,10 +272,10 @@ worker_handle_service_reply(struct comm_point* c, void* arg, int error,
return 0; return 0;
} }
/* sanity check. */ /* sanity check. */
if(!LDNS_QR_WIRE(ldns_buffer_begin(c->buffer)) if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) != || LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
LDNS_PACKET_QUERY LDNS_PACKET_QUERY
|| LDNS_QDCOUNT(ldns_buffer_begin(c->buffer)) > 1) { || LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
/* error becomes timeout for the module as if this reply /* error becomes timeout for the module as if this reply
* never arrived. */ * never arrived. */
verbose(VERB_ALGO, "worker: bad reply handled as timeout"); verbose(VERB_ALGO, "worker: bad reply handled as timeout");
@ -295,49 +295,49 @@ worker_handle_service_reply(struct comm_point* c, void* arg, int error,
* @return error code, 0 OK, or -1 discard. * @return error code, 0 OK, or -1 discard.
*/ */
static int static int
worker_check_request(ldns_buffer* pkt, struct worker* worker) worker_check_request(sldns_buffer* pkt, struct worker* worker)
{ {
if(ldns_buffer_limit(pkt) < LDNS_HEADER_SIZE) { if(sldns_buffer_limit(pkt) < LDNS_HEADER_SIZE) {
verbose(VERB_QUERY, "request too short, discarded"); verbose(VERB_QUERY, "request too short, discarded");
return -1; return -1;
} }
if(ldns_buffer_limit(pkt) > NORMAL_UDP_SIZE && if(sldns_buffer_limit(pkt) > NORMAL_UDP_SIZE &&
worker->daemon->cfg->harden_large_queries) { worker->daemon->cfg->harden_large_queries) {
verbose(VERB_QUERY, "request too large, discarded"); verbose(VERB_QUERY, "request too large, discarded");
return -1; return -1;
} }
if(LDNS_QR_WIRE(ldns_buffer_begin(pkt))) { if(LDNS_QR_WIRE(sldns_buffer_begin(pkt))) {
verbose(VERB_QUERY, "request has QR bit on, discarded"); verbose(VERB_QUERY, "request has QR bit on, discarded");
return -1; return -1;
} }
if(LDNS_TC_WIRE(ldns_buffer_begin(pkt))) { if(LDNS_TC_WIRE(sldns_buffer_begin(pkt))) {
LDNS_TC_CLR(ldns_buffer_begin(pkt)); LDNS_TC_CLR(sldns_buffer_begin(pkt));
verbose(VERB_QUERY, "request bad, has TC bit on"); verbose(VERB_QUERY, "request bad, has TC bit on");
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
} }
if(LDNS_OPCODE_WIRE(ldns_buffer_begin(pkt)) != LDNS_PACKET_QUERY) { if(LDNS_OPCODE_WIRE(sldns_buffer_begin(pkt)) != LDNS_PACKET_QUERY) {
verbose(VERB_QUERY, "request unknown opcode %d", verbose(VERB_QUERY, "request unknown opcode %d",
LDNS_OPCODE_WIRE(ldns_buffer_begin(pkt))); LDNS_OPCODE_WIRE(sldns_buffer_begin(pkt)));
return LDNS_RCODE_NOTIMPL; return LDNS_RCODE_NOTIMPL;
} }
if(LDNS_QDCOUNT(ldns_buffer_begin(pkt)) != 1) { if(LDNS_QDCOUNT(sldns_buffer_begin(pkt)) != 1) {
verbose(VERB_QUERY, "request wrong nr qd=%d", verbose(VERB_QUERY, "request wrong nr qd=%d",
LDNS_QDCOUNT(ldns_buffer_begin(pkt))); LDNS_QDCOUNT(sldns_buffer_begin(pkt)));
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
} }
if(LDNS_ANCOUNT(ldns_buffer_begin(pkt)) != 0) { if(LDNS_ANCOUNT(sldns_buffer_begin(pkt)) != 0) {
verbose(VERB_QUERY, "request wrong nr an=%d", verbose(VERB_QUERY, "request wrong nr an=%d",
LDNS_ANCOUNT(ldns_buffer_begin(pkt))); LDNS_ANCOUNT(sldns_buffer_begin(pkt)));
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
} }
if(LDNS_NSCOUNT(ldns_buffer_begin(pkt)) != 0) { if(LDNS_NSCOUNT(sldns_buffer_begin(pkt)) != 0) {
verbose(VERB_QUERY, "request wrong nr ns=%d", verbose(VERB_QUERY, "request wrong nr ns=%d",
LDNS_NSCOUNT(ldns_buffer_begin(pkt))); LDNS_NSCOUNT(sldns_buffer_begin(pkt)));
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
} }
if(LDNS_ARCOUNT(ldns_buffer_begin(pkt)) > 1) { if(LDNS_ARCOUNT(sldns_buffer_begin(pkt)) > 1) {
verbose(VERB_QUERY, "request wrong nr ar=%d", verbose(VERB_QUERY, "request wrong nr ar=%d",
LDNS_ARCOUNT(ldns_buffer_begin(pkt))); LDNS_ARCOUNT(sldns_buffer_begin(pkt)));
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
} }
return 0; return 0;
@ -359,7 +359,7 @@ worker_handle_control_cmd(struct tube* ATTR_UNUSED(tube), uint8_t* msg,
if(len != sizeof(uint32_t)) { if(len != sizeof(uint32_t)) {
fatal_exit("bad control msg length %d", (int)len); fatal_exit("bad control msg length %d", (int)len);
} }
cmd = ldns_read_uint32(msg); cmd = sldns_read_uint32(msg);
free(msg); free(msg);
switch(cmd) { switch(cmd) {
case worker_cmd_quit: case worker_cmd_quit:
@ -636,32 +636,32 @@ reply_and_prefetch(struct worker* worker, struct query_info* qinfo,
* @param edns: edns reply information. * @param edns: edns reply information.
*/ */
static void static void
chaos_replystr(ldns_buffer* pkt, const char* str, struct edns_data* edns) chaos_replystr(sldns_buffer* pkt, const char* str, struct edns_data* edns)
{ {
size_t len = strlen(str); size_t len = strlen(str);
unsigned int rd = LDNS_RD_WIRE(ldns_buffer_begin(pkt)); unsigned int rd = LDNS_RD_WIRE(sldns_buffer_begin(pkt));
unsigned int cd = LDNS_CD_WIRE(ldns_buffer_begin(pkt)); unsigned int cd = LDNS_CD_WIRE(sldns_buffer_begin(pkt));
if(len>255) len=255; /* cap size of TXT record */ if(len>255) len=255; /* cap size of TXT record */
ldns_buffer_clear(pkt); sldns_buffer_clear(pkt);
ldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip id */ sldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip id */
ldns_buffer_write_u16(pkt, (uint16_t)(BIT_QR|BIT_RA)); sldns_buffer_write_u16(pkt, (uint16_t)(BIT_QR|BIT_RA));
if(rd) LDNS_RD_SET(ldns_buffer_begin(pkt)); if(rd) LDNS_RD_SET(sldns_buffer_begin(pkt));
if(cd) LDNS_CD_SET(ldns_buffer_begin(pkt)); if(cd) LDNS_CD_SET(sldns_buffer_begin(pkt));
ldns_buffer_write_u16(pkt, 1); /* qdcount */ sldns_buffer_write_u16(pkt, 1); /* qdcount */
ldns_buffer_write_u16(pkt, 1); /* ancount */ sldns_buffer_write_u16(pkt, 1); /* ancount */
ldns_buffer_write_u16(pkt, 0); /* nscount */ sldns_buffer_write_u16(pkt, 0); /* nscount */
ldns_buffer_write_u16(pkt, 0); /* arcount */ sldns_buffer_write_u16(pkt, 0); /* arcount */
(void)query_dname_len(pkt); /* skip qname */ (void)query_dname_len(pkt); /* skip qname */
ldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip qtype */ sldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip qtype */
ldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip qclass */ sldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip qclass */
ldns_buffer_write_u16(pkt, 0xc00c); /* compr ptr to query */ sldns_buffer_write_u16(pkt, 0xc00c); /* compr ptr to query */
ldns_buffer_write_u16(pkt, LDNS_RR_TYPE_TXT); sldns_buffer_write_u16(pkt, LDNS_RR_TYPE_TXT);
ldns_buffer_write_u16(pkt, LDNS_RR_CLASS_CH); sldns_buffer_write_u16(pkt, LDNS_RR_CLASS_CH);
ldns_buffer_write_u32(pkt, 0); /* TTL */ sldns_buffer_write_u32(pkt, 0); /* TTL */
ldns_buffer_write_u16(pkt, sizeof(uint8_t) + len); sldns_buffer_write_u16(pkt, sizeof(uint8_t) + len);
ldns_buffer_write_u8(pkt, len); sldns_buffer_write_u8(pkt, len);
ldns_buffer_write(pkt, str, len); sldns_buffer_write(pkt, str, len);
ldns_buffer_flip(pkt); sldns_buffer_flip(pkt);
edns->edns_version = EDNS_ADVERTISED_VERSION; edns->edns_version = EDNS_ADVERTISED_VERSION;
edns->udp_size = EDNS_ADVERTISED_SIZE; edns->udp_size = EDNS_ADVERTISED_SIZE;
edns->bits &= EDNS_DO; edns->bits &= EDNS_DO;
@ -678,7 +678,7 @@ chaos_replystr(ldns_buffer* pkt, const char* str, struct edns_data* edns)
*/ */
static int static int
answer_chaos(struct worker* w, struct query_info* qinfo, answer_chaos(struct worker* w, struct query_info* qinfo,
struct edns_data* edns, ldns_buffer* pkt) struct edns_data* edns, sldns_buffer* pkt)
{ {
struct config_file* cfg = w->env.cfg; struct config_file* cfg = w->env.cfg;
if(qinfo->qtype != LDNS_RR_TYPE_ANY && qinfo->qtype != LDNS_RR_TYPE_TXT) if(qinfo->qtype != LDNS_RR_TYPE_ANY && qinfo->qtype != LDNS_RR_TYPE_TXT)
@ -738,11 +738,11 @@ deny_refuse(struct comm_point* c, enum acl_access acl,
comm_point_drop_reply(repinfo); comm_point_drop_reply(repinfo);
return 0; /* discard this */ return 0; /* discard this */
} }
ldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE); sldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE);
ldns_buffer_write_at(c->buffer, 4, sldns_buffer_write_at(c->buffer, 4,
(uint8_t*)"\0\0\0\0\0\0\0\0", 8); (uint8_t*)"\0\0\0\0\0\0\0\0", 8);
LDNS_QR_SET(ldns_buffer_begin(c->buffer)); LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_REFUSED); LDNS_RCODE_REFUSED);
return 1; return 1;
} }
@ -791,8 +791,8 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
verbose(VERB_ALGO, "worker check request: bad query."); verbose(VERB_ALGO, "worker check request: bad query.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen); log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
if(ret != -1) { if(ret != -1) {
LDNS_QR_SET(ldns_buffer_begin(c->buffer)); LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), ret); LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret);
return 1; return 1;
} }
comm_point_drop_reply(repinfo); comm_point_drop_reply(repinfo);
@ -803,9 +803,9 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
if(!query_info_parse(&qinfo, c->buffer)) { if(!query_info_parse(&qinfo, c->buffer)) {
verbose(VERB_ALGO, "worker parse request: formerror."); verbose(VERB_ALGO, "worker parse request: formerror.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen); log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
ldns_buffer_rewind(c->buffer); sldns_buffer_rewind(c->buffer);
LDNS_QR_SET(ldns_buffer_begin(c->buffer)); LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_FORMERR); LDNS_RCODE_FORMERR);
server_stats_insrcode(&worker->stats, c->buffer); server_stats_insrcode(&worker->stats, c->buffer);
return 1; return 1;
@ -819,9 +819,9 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
qinfo.qtype == LDNS_RR_TYPE_IXFR) { qinfo.qtype == LDNS_RR_TYPE_IXFR) {
verbose(VERB_ALGO, "worker request: refused zone transfer."); verbose(VERB_ALGO, "worker request: refused zone transfer.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen); log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
ldns_buffer_rewind(c->buffer); sldns_buffer_rewind(c->buffer);
LDNS_QR_SET(ldns_buffer_begin(c->buffer)); LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_REFUSED); LDNS_RCODE_REFUSED);
if(worker->stats.extended) { if(worker->stats.extended) {
worker->stats.qtype[qinfo.qtype]++; worker->stats.qtype[qinfo.qtype]++;
@ -832,9 +832,9 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
if((ret=parse_edns_from_pkt(c->buffer, &edns)) != 0) { if((ret=parse_edns_from_pkt(c->buffer, &edns)) != 0) {
verbose(VERB_ALGO, "worker parse edns: formerror."); verbose(VERB_ALGO, "worker parse edns: formerror.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen); log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
ldns_buffer_rewind(c->buffer); sldns_buffer_rewind(c->buffer);
LDNS_QR_SET(ldns_buffer_begin(c->buffer)); LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), ret); LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret);
server_stats_insrcode(&worker->stats, c->buffer); server_stats_insrcode(&worker->stats, c->buffer);
return 1; return 1;
} }
@ -846,8 +846,8 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
verbose(VERB_ALGO, "query with bad edns version."); verbose(VERB_ALGO, "query with bad edns version.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen); log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
error_encode(c->buffer, EDNS_RCODE_BADVERS&0xf, &qinfo, error_encode(c->buffer, EDNS_RCODE_BADVERS&0xf, &qinfo,
*(uint16_t*)ldns_buffer_begin(c->buffer), *(uint16_t*)sldns_buffer_begin(c->buffer),
ldns_buffer_read_u16_at(c->buffer, 2), NULL); sldns_buffer_read_u16_at(c->buffer, 2), NULL);
attach_edns_record(c->buffer, &edns); attach_edns_record(c->buffer, &edns);
return 1; return 1;
} }
@ -869,14 +869,14 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
if(edns.udp_size < LDNS_HEADER_SIZE) { if(edns.udp_size < LDNS_HEADER_SIZE) {
verbose(VERB_ALGO, "worker request: edns is too small."); verbose(VERB_ALGO, "worker request: edns is too small.");
log_addr(VERB_CLIENT, "from", &repinfo->addr, repinfo->addrlen); log_addr(VERB_CLIENT, "from", &repinfo->addr, repinfo->addrlen);
LDNS_QR_SET(ldns_buffer_begin(c->buffer)); LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_TC_SET(ldns_buffer_begin(c->buffer)); LDNS_TC_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_SERVFAIL); LDNS_RCODE_SERVFAIL);
ldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE); sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
ldns_buffer_write_at(c->buffer, 4, sldns_buffer_write_at(c->buffer, 4,
(uint8_t*)"\0\0\0\0\0\0\0\0", 8); (uint8_t*)"\0\0\0\0\0\0\0\0", 8);
ldns_buffer_flip(c->buffer); sldns_buffer_flip(c->buffer);
return 1; return 1;
} }
if(worker->stats.extended) if(worker->stats.extended)
@ -892,7 +892,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
if(local_zones_answer(worker->daemon->local_zones, &qinfo, &edns, if(local_zones_answer(worker->daemon->local_zones, &qinfo, &edns,
c->buffer, worker->scratchpad)) { c->buffer, worker->scratchpad)) {
regional_free_all(worker->scratchpad); regional_free_all(worker->scratchpad);
if(ldns_buffer_limit(c->buffer) == 0) { if(sldns_buffer_limit(c->buffer) == 0) {
comm_point_drop_reply(repinfo); comm_point_drop_reply(repinfo);
return 0; return 0;
} }
@ -909,15 +909,15 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
/* If this request does not have the recursion bit set, verify /* If this request does not have the recursion bit set, verify
* ACLs allow the snooping. */ * ACLs allow the snooping. */
if(!(LDNS_RD_WIRE(ldns_buffer_begin(c->buffer))) && if(!(LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) &&
acl != acl_allow_snoop ) { acl != acl_allow_snoop ) {
ldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE); sldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE);
ldns_buffer_write_at(c->buffer, 4, sldns_buffer_write_at(c->buffer, 4,
(uint8_t*)"\0\0\0\0\0\0\0\0", 8); (uint8_t*)"\0\0\0\0\0\0\0\0", 8);
LDNS_QR_SET(ldns_buffer_begin(c->buffer)); LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_REFUSED); LDNS_RCODE_REFUSED);
ldns_buffer_flip(c->buffer); sldns_buffer_flip(c->buffer);
server_stats_insrcode(&worker->stats, c->buffer); server_stats_insrcode(&worker->stats, c->buffer);
log_addr(VERB_ALGO, "refused nonrec (cache snoop) query from", log_addr(VERB_ALGO, "refused nonrec (cache snoop) query from",
&repinfo->addr, repinfo->addrlen); &repinfo->addr, repinfo->addrlen);
@ -928,8 +928,8 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
/* answer from cache - we have acquired a readlock on it */ /* answer from cache - we have acquired a readlock on it */
if(answer_from_cache(worker, &qinfo, if(answer_from_cache(worker, &qinfo,
(struct reply_info*)e->data, (struct reply_info*)e->data,
*(uint16_t*)ldns_buffer_begin(c->buffer), *(uint16_t*)sldns_buffer_begin(c->buffer),
ldns_buffer_read_u16_at(c->buffer, 2), repinfo, sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
&edns)) { &edns)) {
/* prefetch it if the prefetch TTL expired */ /* prefetch it if the prefetch TTL expired */
if(worker->env.cfg->prefetch && *worker->env.now >= if(worker->env.cfg->prefetch && *worker->env.now >=
@ -938,7 +938,7 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
data)->ttl - *worker->env.now; data)->ttl - *worker->env.now;
lock_rw_unlock(&e->lock); lock_rw_unlock(&e->lock);
reply_and_prefetch(worker, &qinfo, reply_and_prefetch(worker, &qinfo,
ldns_buffer_read_u16_at(c->buffer, 2), sldns_buffer_read_u16_at(c->buffer, 2),
repinfo, leeway); repinfo, leeway);
return 0; return 0;
} }
@ -948,17 +948,17 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
verbose(VERB_ALGO, "answer from the cache failed"); verbose(VERB_ALGO, "answer from the cache failed");
lock_rw_unlock(&e->lock); lock_rw_unlock(&e->lock);
} }
if(!LDNS_RD_WIRE(ldns_buffer_begin(c->buffer))) { if(!LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) {
if(answer_norec_from_cache(worker, &qinfo, if(answer_norec_from_cache(worker, &qinfo,
*(uint16_t*)ldns_buffer_begin(c->buffer), *(uint16_t*)sldns_buffer_begin(c->buffer),
ldns_buffer_read_u16_at(c->buffer, 2), repinfo, sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
&edns)) { &edns)) {
return 1; return 1;
} }
verbose(VERB_ALGO, "answer norec from cache -- " verbose(VERB_ALGO, "answer norec from cache -- "
"need to validate or not primed"); "need to validate or not primed");
} }
ldns_buffer_rewind(c->buffer); sldns_buffer_rewind(c->buffer);
server_stats_querymiss(&worker->stats, worker); server_stats_querymiss(&worker->stats, worker);
if(verbosity >= VERB_CLIENT) { if(verbosity >= VERB_CLIENT) {
@ -971,8 +971,8 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
/* grab a work request structure for this new request */ /* grab a work request structure for this new request */
mesh_new_client(worker->env.mesh, &qinfo, mesh_new_client(worker->env.mesh, &qinfo,
ldns_buffer_read_u16_at(c->buffer, 2), sldns_buffer_read_u16_at(c->buffer, 2),
&edns, repinfo, *(uint16_t*)ldns_buffer_begin(c->buffer)); &edns, repinfo, *(uint16_t*)sldns_buffer_begin(c->buffer));
worker_mem_report(worker, NULL); worker_mem_report(worker, NULL);
return 0; return 0;
} }
@ -1202,7 +1202,7 @@ worker_init(struct worker* worker, struct config_file *cfg,
worker->env.attach_sub = &mesh_attach_sub; worker->env.attach_sub = &mesh_attach_sub;
worker->env.kill_sub = &mesh_state_delete; worker->env.kill_sub = &mesh_state_delete;
worker->env.detect_cycle = &mesh_detect_cycle; worker->env.detect_cycle = &mesh_detect_cycle;
worker->env.scratch_buffer = ldns_buffer_new(cfg->msg_buffer_size); worker->env.scratch_buffer = sldns_buffer_new(cfg->msg_buffer_size);
if(!(worker->env.fwds = forwards_create()) || if(!(worker->env.fwds = forwards_create()) ||
!forwards_apply_cfg(worker->env.fwds, cfg)) { !forwards_apply_cfg(worker->env.fwds, cfg)) {
log_err("Could not set forward zones"); log_err("Could not set forward zones");
@ -1265,7 +1265,7 @@ worker_delete(struct worker* worker)
} }
outside_network_quit_prepare(worker->back); outside_network_quit_prepare(worker->back);
mesh_delete(worker->env.mesh); mesh_delete(worker->env.mesh);
ldns_buffer_free(worker->env.scratch_buffer); sldns_buffer_free(worker->env.scratch_buffer);
forwards_delete(worker->env.fwds); forwards_delete(worker->env.fwds);
hints_delete(worker->env.hints); hints_delete(worker->env.hints);
listen_delete(worker->front); listen_delete(worker->front);
@ -1378,21 +1378,21 @@ void libworker_handle_control_cmd(struct tube* ATTR_UNUSED(tube),
} }
void libworker_fg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode), void libworker_fg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s), sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus)) char* ATTR_UNUSED(why_bogus))
{ {
log_assert(0); log_assert(0);
} }
void libworker_bg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode), void libworker_bg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s), sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus)) char* ATTR_UNUSED(why_bogus))
{ {
log_assert(0); log_assert(0);
} }
void libworker_event_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode), void libworker_event_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s), sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus)) char* ATTR_UNUSED(why_bogus))
{ {
log_assert(0); log_assert(0);

3
doc/Changelog
View file

@ -1,3 +1,6 @@
3 Dec 2013: Wouter
- Fix sldns to use sldns_ prefix for all ldns_ variables.
30 Nov 2013: Wouter 30 Nov 2013: Wouter
- Fix sldns to make globals use sldns_ prefix. This fixes - Fix sldns to make globals use sldns_ prefix. This fixes
linking with libldns that uses global variables ldns_ . linking with libldns that uses global variables ldns_ .

2
iterator/iter_delegpt.c
View file

@ -390,7 +390,7 @@ delegpt_rrset_add_ns(struct delegpt* dp, struct regional* region,
for(i=0; i<nsdata->count; i++) { for(i=0; i<nsdata->count; i++) {
if(nsdata->rr_len[i] < 2+1) continue; /* len + root label */ if(nsdata->rr_len[i] < 2+1) continue; /* len + root label */
if(dname_valid(nsdata->rr_data[i]+2, nsdata->rr_len[i]-2) != if(dname_valid(nsdata->rr_data[i]+2, nsdata->rr_len[i]-2) !=
(size_t)ldns_read_uint16(nsdata->rr_data[i])) (size_t)sldns_read_uint16(nsdata->rr_data[i]))
continue; /* bad format */ continue; /* bad format */
/* add rdata of NS (= wirefmt dname), skip rdatalen bytes */ /* add rdata of NS (= wirefmt dname), skip rdatalen bytes */
if(!delegpt_add_ns(dp, region, nsdata->rr_data[i]+2, lame)) if(!delegpt_add_ns(dp, region, nsdata->rr_data[i]+2, lame))

6
iterator/iter_fwd.c
View file

@ -185,7 +185,7 @@ read_fwds_name(struct config_stub* s)
log_err("forward zone without a name (use name \".\" to forward everything)"); log_err("forward zone without a name (use name \".\" to forward everything)");
return NULL; return NULL;
} }
dname = ldns_str2wire_dname(s->name, &dname_len); dname = sldns_str2wire_dname(s->name, &dname_len);
if(!dname) { if(!dname) {
log_err("cannot parse forward zone name %s", s->name); log_err("cannot parse forward zone name %s", s->name);
return NULL; return NULL;
@ -208,7 +208,7 @@ read_fwds_host(struct config_stub* s, struct delegpt* dp)
size_t dname_len; size_t dname_len;
for(p = s->hosts; p; p = p->next) { for(p = s->hosts; p; p = p->next) {
log_assert(p->str); log_assert(p->str);
dname = ldns_str2wire_dname(p->str, &dname_len); dname = sldns_str2wire_dname(p->str, &dname_len);
if(!dname) { if(!dname) {
log_err("cannot parse forward %s server name: '%s'", log_err("cannot parse forward %s server name: '%s'",
s->name, p->str); s->name, p->str);
@ -294,7 +294,7 @@ make_stub_holes(struct iter_forwards* fwd, struct config_file* cfg)
uint8_t* dname; uint8_t* dname;
size_t dname_len; size_t dname_len;
for(s = cfg->stubs; s; s = s->next) { for(s = cfg->stubs; s; s = s->next) {
dname = ldns_str2wire_dname(s->name, &dname_len); dname = sldns_str2wire_dname(s->name, &dname_len);
if(!dname) { if(!dname) {
log_err("cannot parse stub name '%s'", s->name); log_err("cannot parse stub name '%s'", s->name);
return 0; return 0;

32
iterator/iter_hints.c
View file

@ -94,7 +94,7 @@ ah(struct delegpt* dp, const char* sv, const char* ip)
struct sockaddr_storage addr; struct sockaddr_storage addr;
socklen_t addrlen; socklen_t addrlen;
size_t dname_len; size_t dname_len;
uint8_t* dname = ldns_str2wire_dname(sv, &dname_len); uint8_t* dname = sldns_str2wire_dname(sv, &dname_len);
if(!dname) { if(!dname) {
log_err("could not parse %s", sv); log_err("could not parse %s", sv);
return 0; return 0;
@ -194,7 +194,7 @@ read_stubs_name(struct config_stub* s)
log_err("stub zone without a name"); log_err("stub zone without a name");
return NULL; return NULL;
} }
dname = ldns_str2wire_dname(s->name, &dname_len); dname = sldns_str2wire_dname(s->name, &dname_len);
if(!dname) { if(!dname) {
log_err("cannot parse stub zone name %s", s->name); log_err("cannot parse stub zone name %s", s->name);
return NULL; return NULL;
@ -217,7 +217,7 @@ read_stubs_host(struct config_stub* s, struct delegpt* dp)
uint8_t* dname; uint8_t* dname;
for(p = s->hosts; p; p = p->next) { for(p = s->hosts; p; p = p->next) {
log_assert(p->str); log_assert(p->str);
dname = ldns_str2wire_dname(p->str, &dname_len); dname = sldns_str2wire_dname(p->str, &dname_len);
if(!dname) { if(!dname) {
log_err("cannot parse stub %s nameserver name: '%s'", log_err("cannot parse stub %s nameserver name: '%s'",
s->name, p->str); s->name, p->str);
@ -283,7 +283,7 @@ read_stubs(struct iter_hints* hints, struct config_file* cfg)
static int static int
read_root_hints(struct iter_hints* hints, char* fname) read_root_hints(struct iter_hints* hints, char* fname)
{ {
struct ldns_file_parse_state pstate; struct sldns_file_parse_state pstate;
struct delegpt* dp; struct delegpt* dp;
uint8_t rr[LDNS_RR_BUF_SIZE]; uint8_t rr[LDNS_RR_BUF_SIZE];
size_t rr_len, dname_len; size_t rr_len, dname_len;
@ -308,32 +308,32 @@ read_root_hints(struct iter_hints* hints, char* fname)
while(!feof(f)) { while(!feof(f)) {
rr_len = sizeof(rr); rr_len = sizeof(rr);
dname_len = 0; dname_len = 0;
status = ldns_fp2wire_rr_buf(f, rr, &rr_len, &dname_len, status = sldns_fp2wire_rr_buf(f, rr, &rr_len, &dname_len,
&pstate); &pstate);
if(status != 0) { if(status != 0) {
log_err("reading root hints %s %d:%d: %s", fname, log_err("reading root hints %s %d:%d: %s", fname,
pstate.lineno, LDNS_WIREPARSE_OFFSET(status), pstate.lineno, LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status)); sldns_get_errorstr_parse(status));
goto stop_read; goto stop_read;
} }
if(rr_len == 0) if(rr_len == 0)
continue; /* EMPTY line, TTL or ORIGIN */ continue; /* EMPTY line, TTL or ORIGIN */
if(ldns_wirerr_get_type(rr, rr_len, dname_len) if(sldns_wirerr_get_type(rr, rr_len, dname_len)
== LDNS_RR_TYPE_NS) { == LDNS_RR_TYPE_NS) {
if(!delegpt_add_ns_mlc(dp, ldns_wirerr_get_rdata(rr, if(!delegpt_add_ns_mlc(dp, sldns_wirerr_get_rdata(rr,
rr_len, dname_len), 0)) { rr_len, dname_len), 0)) {
log_err("out of memory reading root hints"); log_err("out of memory reading root hints");
goto stop_read; goto stop_read;
} }
c = ldns_wirerr_get_class(rr, rr_len, dname_len); c = sldns_wirerr_get_class(rr, rr_len, dname_len);
if(!dp->name) { if(!dp->name) {
if(!delegpt_set_name_mlc(dp, rr)) { if(!delegpt_set_name_mlc(dp, rr)) {
log_err("out of memory."); log_err("out of memory.");
goto stop_read; goto stop_read;
} }
} }
} else if(ldns_wirerr_get_type(rr, rr_len, dname_len) } else if(sldns_wirerr_get_type(rr, rr_len, dname_len)
== LDNS_RR_TYPE_A && ldns_wirerr_get_rdatalen(rr, == LDNS_RR_TYPE_A && sldns_wirerr_get_rdatalen(rr,
rr_len, dname_len) == INET_SIZE) { rr_len, dname_len) == INET_SIZE) {
struct sockaddr_in sa; struct sockaddr_in sa;
socklen_t len = (socklen_t)sizeof(sa); socklen_t len = (socklen_t)sizeof(sa);
@ -341,7 +341,7 @@ read_root_hints(struct iter_hints* hints, char* fname)
sa.sin_family = AF_INET; sa.sin_family = AF_INET;
sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT); sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT);
memmove(&sa.sin_addr, memmove(&sa.sin_addr,
ldns_wirerr_get_rdata(rr, rr_len, dname_len), sldns_wirerr_get_rdata(rr, rr_len, dname_len),
INET_SIZE); INET_SIZE);
if(!delegpt_add_target_mlc(dp, rr, dname_len, if(!delegpt_add_target_mlc(dp, rr, dname_len,
(struct sockaddr_storage*)&sa, len, (struct sockaddr_storage*)&sa, len,
@ -349,8 +349,8 @@ read_root_hints(struct iter_hints* hints, char* fname)
log_err("out of memory reading root hints"); log_err("out of memory reading root hints");
goto stop_read; goto stop_read;
} }
} else if(ldns_wirerr_get_type(rr, rr_len, dname_len) } else if(sldns_wirerr_get_type(rr, rr_len, dname_len)
== LDNS_RR_TYPE_AAAA && ldns_wirerr_get_rdatalen(rr, == LDNS_RR_TYPE_AAAA && sldns_wirerr_get_rdatalen(rr,
rr_len, dname_len) == INET6_SIZE) { rr_len, dname_len) == INET6_SIZE) {
struct sockaddr_in6 sa; struct sockaddr_in6 sa;
socklen_t len = (socklen_t)sizeof(sa); socklen_t len = (socklen_t)sizeof(sa);
@ -358,7 +358,7 @@ read_root_hints(struct iter_hints* hints, char* fname)
sa.sin6_family = AF_INET6; sa.sin6_family = AF_INET6;
sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT); sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT);
memmove(&sa.sin6_addr, memmove(&sa.sin6_addr,
ldns_wirerr_get_rdata(rr, rr_len, dname_len), sldns_wirerr_get_rdata(rr, rr_len, dname_len),
INET6_SIZE); INET6_SIZE);
if(!delegpt_add_target_mlc(dp, rr, dname_len, if(!delegpt_add_target_mlc(dp, rr, dname_len,
(struct sockaddr_storage*)&sa, len, (struct sockaddr_storage*)&sa, len,
@ -368,7 +368,7 @@ read_root_hints(struct iter_hints* hints, char* fname)
} }
} else { } else {
char buf[17]; char buf[17];
ldns_wire2str_type_buf(ldns_wirerr_get_type(rr, sldns_wire2str_type_buf(sldns_wirerr_get_type(rr,
rr_len, dname_len), buf, sizeof(buf)); rr_len, dname_len), buf, sizeof(buf));
log_warn("root hints %s:%d skipping type %s", log_warn("root hints %s:%d skipping type %s",
fname, pstate.lineno, buf); fname, pstate.lineno, buf);

12
iterator/iter_priv.c
View file

@ -117,7 +117,7 @@ static int read_names(struct iter_priv* priv, struct config_file* cfg)
for(p = cfg->private_domain; p; p = p->next) { for(p = cfg->private_domain; p; p = p->next) {
log_assert(p->str); log_assert(p->str);
nm = ldns_str2wire_dname(p->str, &nm_len); nm = sldns_str2wire_dname(p->str, &nm_len);
if(!nm) { if(!nm) {
log_err("cannot parse private-domain: %s", p->str); log_err("cannot parse private-domain: %s", p->str);
return 0; return 0;
@ -187,7 +187,7 @@ priv_lookup_addr(struct iter_priv* priv, struct sockaddr_storage* addr,
* @return: true if the name is OK. false if unlisted. * @return: true if the name is OK. false if unlisted.
*/ */
static int static int
priv_lookup_name(struct iter_priv* priv, ldns_buffer* pkt, priv_lookup_name(struct iter_priv* priv, sldns_buffer* pkt,
uint8_t* name, size_t name_len, uint16_t dclass) uint8_t* name, size_t name_len, uint16_t dclass)
{ {
size_t len; size_t len;
@ -209,7 +209,7 @@ size_t priv_get_mem(struct iter_priv* priv)
/** remove RR from msgparse RRset, return true if rrset is entirely bad */ /** remove RR from msgparse RRset, return true if rrset is entirely bad */
static int static int
remove_rr(const char* str, ldns_buffer* pkt, struct rrset_parse* rrset, remove_rr(const char* str, sldns_buffer* pkt, struct rrset_parse* rrset,
struct rr_parse* prev, struct rr_parse** rr, struct sockaddr_storage* addr, socklen_t addrlen) struct rr_parse* prev, struct rr_parse** rr, struct sockaddr_storage* addr, socklen_t addrlen)
{ {
if(verbosity >= VERB_QUERY && rrset->dname_len <= LDNS_MAX_DOMAINLEN && str) { if(verbosity >= VERB_QUERY && rrset->dname_len <= LDNS_MAX_DOMAINLEN && str) {
@ -229,7 +229,7 @@ remove_rr(const char* str, ldns_buffer* pkt, struct rrset_parse* rrset,
return rrset->rr_count == 0; return rrset->rr_count == 0;
} }
int priv_rrset_bad(struct iter_priv* priv, ldns_buffer* pkt, int priv_rrset_bad(struct iter_priv* priv, sldns_buffer* pkt,
struct rrset_parse* rrset) struct rrset_parse* rrset)
{ {
if(priv->a.count == 0) if(priv->a.count == 0)
@ -252,7 +252,7 @@ int priv_rrset_bad(struct iter_priv* priv, ldns_buffer* pkt,
sa.sin_family = AF_INET; sa.sin_family = AF_INET;
sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT); sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT);
for(rr = rrset->rr_first; rr; rr = rr->next) { for(rr = rrset->rr_first; rr; rr = rr->next) {
if(ldns_read_uint16(rr->ttl_data+4) if(sldns_read_uint16(rr->ttl_data+4)
!= INET_SIZE) { != INET_SIZE) {
prev = rr; prev = rr;
continue; continue;
@ -275,7 +275,7 @@ int priv_rrset_bad(struct iter_priv* priv, ldns_buffer* pkt,
sa.sin6_family = AF_INET6; sa.sin6_family = AF_INET6;
sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT); sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT);
for(rr = rrset->rr_first; rr; rr = rr->next) { for(rr = rrset->rr_first; rr; rr = rr->next) {
if(ldns_read_uint16(rr->ttl_data+4) if(sldns_read_uint16(rr->ttl_data+4)
!= INET6_SIZE) { != INET6_SIZE) {
prev = rr; prev = rr;
continue; continue;

4
iterator/iter_priv.h
View file

@ -43,7 +43,7 @@
#ifndef ITERATOR_ITER_PRIV_H #ifndef ITERATOR_ITER_PRIV_H
#define ITERATOR_ITER_PRIV_H #define ITERATOR_ITER_PRIV_H
#include "util/rbtree.h" #include "util/rbtree.h"
struct ldns_buffer; struct sldns_buffer;
struct iter_env; struct iter_env;
struct config_file; struct config_file;
struct regional; struct regional;
@ -99,7 +99,7 @@ int priv_apply_cfg(struct iter_priv* priv, struct config_file* cfg);
* @param rrset: the rrset to examine, A or AAAA. * @param rrset: the rrset to examine, A or AAAA.
* @return true if the rrset is bad and should be removed. * @return true if the rrset is bad and should be removed.
*/ */
int priv_rrset_bad(struct iter_priv* priv, struct ldns_buffer* pkt, int priv_rrset_bad(struct iter_priv* priv, struct sldns_buffer* pkt,
struct rrset_parse* rrset); struct rrset_parse* rrset);
/** /**

38
iterator/iter_scrub.c
View file

@ -60,7 +60,7 @@
/** remove rrset, update loop variables */ /** remove rrset, update loop variables */
static void static void
remove_rrset(const char* str, ldns_buffer* pkt, struct msg_parse* msg, remove_rrset(const char* str, sldns_buffer* pkt, struct msg_parse* msg,
struct rrset_parse* prev, struct rrset_parse** rrset) struct rrset_parse* prev, struct rrset_parse** rrset)
{ {
if(verbosity >= VERB_QUERY && str if(verbosity >= VERB_QUERY && str
@ -109,7 +109,7 @@ has_additional(uint16_t t)
/** get additional name from rrset RR, return false if no name present */ /** get additional name from rrset RR, return false if no name present */
static int static int
get_additional_name(struct rrset_parse* rrset, struct rr_parse* rr, get_additional_name(struct rrset_parse* rrset, struct rr_parse* rr,
uint8_t** nm, size_t* nmlen, ldns_buffer* pkt) uint8_t** nm, size_t* nmlen, sldns_buffer* pkt)
{ {
size_t offset = 0; size_t offset = 0;
size_t len, oldpos; size_t len, oldpos;
@ -133,14 +133,14 @@ get_additional_name(struct rrset_parse* rrset, struct rr_parse* rr,
default: default:
return 0; return 0;
} }
len = ldns_read_uint16(rr->ttl_data+sizeof(uint32_t)); len = sldns_read_uint16(rr->ttl_data+sizeof(uint32_t));
if(len < offset+1) if(len < offset+1)
return 0; /* rdata field too small */ return 0; /* rdata field too small */
*nm = rr->ttl_data+sizeof(uint32_t)+sizeof(uint16_t)+offset; *nm = rr->ttl_data+sizeof(uint32_t)+sizeof(uint16_t)+offset;
oldpos = ldns_buffer_position(pkt); oldpos = sldns_buffer_position(pkt);
ldns_buffer_set_position(pkt, (size_t)(*nm - ldns_buffer_begin(pkt))); sldns_buffer_set_position(pkt, (size_t)(*nm - sldns_buffer_begin(pkt)));
*nmlen = pkt_dname_len(pkt); *nmlen = pkt_dname_len(pkt);
ldns_buffer_set_position(pkt, oldpos); sldns_buffer_set_position(pkt, oldpos);
if(*nmlen == 0) if(*nmlen == 0)
return 0; return 0;
return 1; return 1;
@ -148,7 +148,7 @@ get_additional_name(struct rrset_parse* rrset, struct rr_parse* rr,
/** Place mark on rrsets in additional section they are OK */ /** Place mark on rrsets in additional section they are OK */
static void static void
mark_additional_rrset(ldns_buffer* pkt, struct msg_parse* msg, mark_additional_rrset(sldns_buffer* pkt, struct msg_parse* msg,
struct rrset_parse* rrset) struct rrset_parse* rrset)
{ {
/* Mark A and AAAA for NS as appropriate additional section info. */ /* Mark A and AAAA for NS as appropriate additional section info. */
@ -210,7 +210,7 @@ parse_get_cname_target(struct rrset_parse* rrset, uint8_t** sname,
/** Synthesize CNAME from DNAME, false if too long */ /** Synthesize CNAME from DNAME, false if too long */
static int static int
synth_cname(uint8_t* qname, size_t qnamelen, struct rrset_parse* dname_rrset, synth_cname(uint8_t* qname, size_t qnamelen, struct rrset_parse* dname_rrset,
uint8_t* alias, size_t* aliaslen, ldns_buffer* pkt) uint8_t* alias, size_t* aliaslen, sldns_buffer* pkt)
{ {
/* we already know that sname is a strict subdomain of DNAME owner */ /* we already know that sname is a strict subdomain of DNAME owner */
uint8_t* dtarg = NULL; uint8_t* dtarg = NULL;
@ -234,7 +234,7 @@ static struct rrset_parse*
synth_cname_rrset(uint8_t** sname, size_t* snamelen, uint8_t* alias, synth_cname_rrset(uint8_t** sname, size_t* snamelen, uint8_t* alias,
size_t aliaslen, struct regional* region, struct msg_parse* msg, size_t aliaslen, struct regional* region, struct msg_parse* msg,
struct rrset_parse* rrset, struct rrset_parse* prev, struct rrset_parse* rrset, struct rrset_parse* prev,
struct rrset_parse* nx, ldns_buffer* pkt) struct rrset_parse* nx, sldns_buffer* pkt)
{ {
struct rrset_parse* cn = (struct rrset_parse*)regional_alloc(region, struct rrset_parse* cn = (struct rrset_parse*)regional_alloc(region,
sizeof(struct rrset_parse)); sizeof(struct rrset_parse));
@ -265,8 +265,8 @@ synth_cname_rrset(uint8_t** sname, size_t* snamelen, uint8_t* alias,
sizeof(uint32_t)+sizeof(uint16_t)+aliaslen); sizeof(uint32_t)+sizeof(uint16_t)+aliaslen);
if(!cn->rr_first->ttl_data) if(!cn->rr_first->ttl_data)
return NULL; return NULL;
ldns_write_uint32(cn->rr_first->ttl_data, 0); /* TTL = 0 */ sldns_write_uint32(cn->rr_first->ttl_data, 0); /* TTL = 0 */
ldns_write_uint16(cn->rr_first->ttl_data+4, aliaslen); sldns_write_uint16(cn->rr_first->ttl_data+4, aliaslen);
memmove(cn->rr_first->ttl_data+6, alias, aliaslen); memmove(cn->rr_first->ttl_data+6, alias, aliaslen);
cn->rr_first->size = sizeof(uint16_t)+aliaslen; cn->rr_first->size = sizeof(uint16_t)+aliaslen;
@ -288,7 +288,7 @@ synth_cname_rrset(uint8_t** sname, size_t* snamelen, uint8_t* alias,
/** check if DNAME applies to a name */ /** check if DNAME applies to a name */
static int static int
pkt_strict_sub(ldns_buffer* pkt, uint8_t* sname, uint8_t* dr) pkt_strict_sub(sldns_buffer* pkt, uint8_t* sname, uint8_t* dr)
{ {
uint8_t buf1[LDNS_MAX_DOMAINLEN+1]; uint8_t buf1[LDNS_MAX_DOMAINLEN+1];
uint8_t buf2[LDNS_MAX_DOMAINLEN+1]; uint8_t buf2[LDNS_MAX_DOMAINLEN+1];
@ -300,7 +300,7 @@ pkt_strict_sub(ldns_buffer* pkt, uint8_t* sname, uint8_t* dr)
/** check subdomain with decompression */ /** check subdomain with decompression */
static int static int
pkt_sub(ldns_buffer* pkt, uint8_t* comprname, uint8_t* zone) pkt_sub(sldns_buffer* pkt, uint8_t* comprname, uint8_t* zone)
{ {
uint8_t buf[LDNS_MAX_DOMAINLEN+1]; uint8_t buf[LDNS_MAX_DOMAINLEN+1];
dname_pkt_copy(pkt, buf, comprname); dname_pkt_copy(pkt, buf, comprname);
@ -309,7 +309,7 @@ pkt_sub(ldns_buffer* pkt, uint8_t* comprname, uint8_t* zone)
/** check subdomain with decompression, compressed is parent */ /** check subdomain with decompression, compressed is parent */
static int static int
sub_of_pkt(ldns_buffer* pkt, uint8_t* zone, uint8_t* comprname) sub_of_pkt(sldns_buffer* pkt, uint8_t* zone, uint8_t* comprname)
{ {
uint8_t buf[LDNS_MAX_DOMAINLEN+1]; uint8_t buf[LDNS_MAX_DOMAINLEN+1];
dname_pkt_copy(pkt, buf, comprname); dname_pkt_copy(pkt, buf, comprname);
@ -328,7 +328,7 @@ sub_of_pkt(ldns_buffer* pkt, uint8_t* zone, uint8_t* comprname)
* @return 0 on error. * @return 0 on error.
*/ */
static int static int
scrub_normalize(ldns_buffer* pkt, struct msg_parse* msg, scrub_normalize(sldns_buffer* pkt, struct msg_parse* msg,
struct query_info* qinfo, struct regional* region) struct query_info* qinfo, struct regional* region)
{ {
uint8_t* sname = qinfo->qname; uint8_t* sname = qinfo->qname;
@ -515,7 +515,7 @@ scrub_normalize(ldns_buffer* pkt, struct msg_parse* msg,
* @param rrset: to store. * @param rrset: to store.
*/ */
static void static void
store_rrset(ldns_buffer* pkt, struct msg_parse* msg, struct module_env* env, store_rrset(sldns_buffer* pkt, struct msg_parse* msg, struct module_env* env,
struct rrset_parse* rrset) struct rrset_parse* rrset)
{ {
struct ub_packed_rrset_key* k; struct ub_packed_rrset_key* k;
@ -566,7 +566,7 @@ static int sanitize_nsec_is_overreach(struct rrset_parse* rrset,
log_assert(rrset->type == LDNS_RR_TYPE_NSEC); log_assert(rrset->type == LDNS_RR_TYPE_NSEC);
for(rr = rrset->rr_first; rr; rr = rr->next) { for(rr = rrset->rr_first; rr; rr = rr->next) {
rhs = rr->ttl_data+4+2; rhs = rr->ttl_data+4+2;
len = ldns_read_uint16(rr->ttl_data+4); len = sldns_read_uint16(rr->ttl_data+4);
if(!dname_valid(rhs, len)) { if(!dname_valid(rhs, len)) {
/* malformed domain name in rdata */ /* malformed domain name in rdata */
return 1; return 1;
@ -595,7 +595,7 @@ static int sanitize_nsec_is_overreach(struct rrset_parse* rrset,
* @return 0 on error. * @return 0 on error.
*/ */
static int static int
scrub_sanitize(ldns_buffer* pkt, struct msg_parse* msg, scrub_sanitize(sldns_buffer* pkt, struct msg_parse* msg,
struct query_info* qinfo, uint8_t* zonename, struct module_env* env, struct query_info* qinfo, uint8_t* zonename, struct module_env* env,
struct iter_env* ie) struct iter_env* ie)
{ {
@ -714,7 +714,7 @@ scrub_sanitize(ldns_buffer* pkt, struct msg_parse* msg,
} }
int int
scrub_message(ldns_buffer* pkt, struct msg_parse* msg, scrub_message(sldns_buffer* pkt, struct msg_parse* msg,
struct query_info* qinfo, uint8_t* zonename, struct regional* region, struct query_info* qinfo, uint8_t* zonename, struct regional* region,
struct module_env* env, struct iter_env* ie) struct module_env* env, struct iter_env* ie)
{ {

4
iterator/iter_scrub.h
View file

@ -42,7 +42,7 @@
#ifndef ITERATOR_ITER_SCRUB_H #ifndef ITERATOR_ITER_SCRUB_H
#define ITERATOR_ITER_SCRUB_H #define ITERATOR_ITER_SCRUB_H
struct ldns_buffer; struct sldns_buffer;
struct msg_parse; struct msg_parse;
struct query_info; struct query_info;
struct regional; struct regional;
@ -62,7 +62,7 @@ struct iter_env;
* @param ie: iterator module environment data. * @param ie: iterator module environment data.
* @return: false if the message is total waste. true if scrubbed with success. * @return: false if the message is total waste. true if scrubbed with success.
*/ */
int scrub_message(struct ldns_buffer* pkt, struct msg_parse* msg, int scrub_message(struct sldns_buffer* pkt, struct msg_parse* msg,
struct query_info* qinfo, uint8_t* zonename, struct regional* regional, struct query_info* qinfo, uint8_t* zonename, struct regional* regional,
struct module_env* env, struct iter_env* ie); struct module_env* env, struct iter_env* ie);

4
iterator/iter_utils.c
View file

@ -391,7 +391,7 @@ iter_server_selection(struct iter_env* iter_env,
} }
struct dns_msg* struct dns_msg*
dns_alloc_msg(ldns_buffer* pkt, struct msg_parse* msg, dns_alloc_msg(sldns_buffer* pkt, struct msg_parse* msg,
struct regional* region) struct regional* region)
{ {
struct dns_msg* m = (struct dns_msg*)regional_alloc(region, struct dns_msg* m = (struct dns_msg*)regional_alloc(region,
@ -804,7 +804,7 @@ void iter_store_parentside_neg(struct module_env* env,
newd->rr_len[0] = 0 /* zero len rdata */ + sizeof(uint16_t); newd->rr_len[0] = 0 /* zero len rdata */ + sizeof(uint16_t);
packed_rrset_ptr_fixup(newd); packed_rrset_ptr_fixup(newd);
newd->rr_ttl[0] = newd->ttl; newd->rr_ttl[0] = newd->ttl;
ldns_write_uint16(newd->rr_data[0], 0 /* zero len rdata */); sldns_write_uint16(newd->rr_data[0], 0 /* zero len rdata */);
/* store it */ /* store it */
log_rrset_key(VERB_ALGO, "store parent-side negative", neg); log_rrset_key(VERB_ALGO, "store parent-side negative", neg);
iter_store_parentside_rrset(env, neg); iter_store_parentside_rrset(env, neg);

4
iterator/iter_utils.h
View file

@ -43,7 +43,7 @@
#ifndef ITERATOR_ITER_UTILS_H #ifndef ITERATOR_ITER_UTILS_H
#define ITERATOR_ITER_UTILS_H #define ITERATOR_ITER_UTILS_H
#include "iterator/iter_resptype.h" #include "iterator/iter_resptype.h"
struct ldns_buffer; struct sldns_buffer;
struct iter_env; struct iter_env;
struct iter_hints; struct iter_hints;
struct iter_forwards; struct iter_forwards;
@ -102,7 +102,7 @@ struct delegpt_addr* iter_server_selection(struct iter_env* iter_env,
* @param regional: regional to use for allocation. * @param regional: regional to use for allocation.
* @return newly allocated dns_msg, or NULL on memory error. * @return newly allocated dns_msg, or NULL on memory error.
*/ */
struct dns_msg* dns_alloc_msg(struct ldns_buffer* pkt, struct msg_parse* msg, struct dns_msg* dns_alloc_msg(struct sldns_buffer* pkt, struct msg_parse* msg,
struct regional* regional); struct regional* regional);
/** /**

12
iterator/iterator.c
View file

@ -231,8 +231,8 @@ static int
error_response(struct module_qstate* qstate, int id, int rcode) error_response(struct module_qstate* qstate, int id, int rcode)
{ {
verbose(VERB_QUERY, "return error response %s", verbose(VERB_QUERY, "return error response %s",
ldns_lookup_by_id(SLDNS(_rcodes), rcode)? sldns_lookup_by_id(sldns_rcodes, rcode)?
ldns_lookup_by_id(SLDNS(_rcodes), rcode)->name:"??"); sldns_lookup_by_id(sldns_rcodes, rcode)->name:"??");
qstate->return_rcode = rcode; qstate->return_rcode = rcode;
qstate->return_msg = NULL; qstate->return_msg = NULL;
qstate->ext_state[id] = module_finished; qstate->ext_state[id] = module_finished;
@ -543,8 +543,8 @@ prime_root(struct module_qstate* qstate, struct iter_qstate* iq, int id,
struct delegpt* dp; struct delegpt* dp;
struct module_qstate* subq; struct module_qstate* subq;
verbose(VERB_DETAIL, "priming . %s NS", verbose(VERB_DETAIL, "priming . %s NS",
ldns_lookup_by_id(SLDNS(_rr_classes), (int)qclass)? sldns_lookup_by_id(sldns_rr_classes, (int)qclass)?
ldns_lookup_by_id(SLDNS(_rr_classes), (int)qclass)->name:"??"); sldns_lookup_by_id(sldns_rr_classes, (int)qclass)->name:"??");
dp = hints_lookup_root(qstate->env->hints, qclass); dp = hints_lookup_root(qstate->env->hints, qclass);
if(!dp) { if(!dp) {
verbose(VERB_ALGO, "Cannot prime due to lack of hints"); verbose(VERB_ALGO, "Cannot prime due to lack of hints");
@ -2751,7 +2751,7 @@ process_response(struct module_qstate* qstate, struct iter_qstate* iq,
{ {
struct msg_parse* prs; struct msg_parse* prs;
struct edns_data edns; struct edns_data edns;
ldns_buffer* pkt; sldns_buffer* pkt;
verbose(VERB_ALGO, "process_response: new external response event"); verbose(VERB_ALGO, "process_response: new external response event");
iq->response = NULL; iq->response = NULL;
@ -2778,7 +2778,7 @@ process_response(struct module_qstate* qstate, struct iter_qstate* iq,
memset(prs, 0, sizeof(*prs)); memset(prs, 0, sizeof(*prs));
memset(&edns, 0, sizeof(edns)); memset(&edns, 0, sizeof(edns));
pkt = qstate->reply->c->buffer; pkt = qstate->reply->c->buffer;
ldns_buffer_set_position(pkt, 0); sldns_buffer_set_position(pkt, 0);
if(parse_packet(pkt, prs, qstate->env->scratch) != LDNS_RCODE_NOERROR) { if(parse_packet(pkt, prs, qstate->env->scratch) != LDNS_RCODE_NOERROR) {
verbose(VERB_ALGO, "parse error on reply packet"); verbose(VERB_ALGO, "parse error on reply packet");
goto handle_it; goto handle_it;

32
ldns/keyraw.c
View file

@ -26,7 +26,7 @@
#endif /* HAVE_SSL */ #endif /* HAVE_SSL */
size_t size_t
ldns_rr_dnskey_key_size_raw(const unsigned char* keydata, sldns_rr_dnskey_key_size_raw(const unsigned char* keydata,
const size_t len, int alg) const size_t len, int alg)
{ {
/* for DSA keys */ /* for DSA keys */
@ -36,7 +36,7 @@ ldns_rr_dnskey_key_size_raw(const unsigned char* keydata,
uint16_t exp; uint16_t exp;
uint16_t int16; uint16_t int16;
switch ((ldns_algorithm)alg) { switch ((sldns_algorithm)alg) {
case LDNS_DSA: case LDNS_DSA:
case LDNS_DSA_NSEC3: case LDNS_DSA_NSEC3:
if (len > 0) { if (len > 0) {
@ -86,7 +86,7 @@ ldns_rr_dnskey_key_size_raw(const unsigned char* keydata,
} }
} }
uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize) uint16_t sldns_calc_keytag_raw(uint8_t* key, size_t keysize)
{ {
if(keysize < 4) { if(keysize < 4) {
return 0; return 0;
@ -113,10 +113,10 @@ uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize)
#ifdef HAVE_SSL #ifdef HAVE_SSL
#ifdef USE_GOST #ifdef USE_GOST
/** store GOST engine reference loaded into OpenSSL library */ /** store GOST engine reference loaded into OpenSSL library */
ENGINE* ldns_gost_engine = NULL; ENGINE* sldns_gost_engine = NULL;
int int
ldns_key_EVP_load_gost_id(void) sldns_key_EVP_load_gost_id(void)
{ {
static int gost_id = 0; static int gost_id = 0;
const EVP_PKEY_ASN1_METHOD* meth; const EVP_PKEY_ASN1_METHOD* meth;
@ -158,24 +158,24 @@ ldns_key_EVP_load_gost_id(void)
} }
/* Note: do not ENGINE_finish and ENGINE_free the acquired engine /* Note: do not ENGINE_finish and ENGINE_free the acquired engine
* on some platforms this frees up the meth and unloads gost stuff */ * on some platforms this frees up the meth and unloads gost stuff */
ldns_gost_engine = e; sldns_gost_engine = e;
EVP_PKEY_asn1_get0_info(&gost_id, NULL, NULL, NULL, NULL, meth); EVP_PKEY_asn1_get0_info(&gost_id, NULL, NULL, NULL, NULL, meth);
return gost_id; return gost_id;
} }
void ldns_key_EVP_unload_gost(void) void sldns_key_EVP_unload_gost(void)
{ {
if(ldns_gost_engine) { if(sldns_gost_engine) {
ENGINE_finish(ldns_gost_engine); ENGINE_finish(sldns_gost_engine);
ENGINE_free(ldns_gost_engine); ENGINE_free(sldns_gost_engine);
ldns_gost_engine = NULL; sldns_gost_engine = NULL;
} }
} }
#endif /* USE_GOST */ #endif /* USE_GOST */
DSA * DSA *
ldns_key_buf2dsa_raw(unsigned char* key, size_t len) sldns_key_buf2dsa_raw(unsigned char* key, size_t len)
{ {
uint8_t T; uint8_t T;
uint16_t length; uint16_t length;
@ -227,7 +227,7 @@ ldns_key_buf2dsa_raw(unsigned char* key, size_t len)
} }
RSA * RSA *
ldns_key_buf2rsa_raw(unsigned char* key, size_t len) sldns_key_buf2rsa_raw(unsigned char* key, size_t len)
{ {
uint16_t offset; uint16_t offset;
uint16_t exp; uint16_t exp;
@ -284,7 +284,7 @@ ldns_key_buf2rsa_raw(unsigned char* key, size_t len)
#ifdef USE_GOST #ifdef USE_GOST
EVP_PKEY* EVP_PKEY*
ldns_gost2pkey_raw(unsigned char* key, size_t keylen) sldns_gost2pkey_raw(unsigned char* key, size_t keylen)
{ {
/* prefix header for X509 encoding */ /* prefix header for X509 encoding */
uint8_t asn[37] = { 0x30, 0x63, 0x30, 0x1c, 0x06, 0x06, 0x2a, 0x85, uint8_t asn[37] = { 0x30, 0x63, 0x30, 0x1c, 0x06, 0x06, 0x2a, 0x85,
@ -309,7 +309,7 @@ ldns_gost2pkey_raw(unsigned char* key, size_t keylen)
#ifdef USE_ECDSA #ifdef USE_ECDSA
EVP_PKEY* EVP_PKEY*
ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo) sldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo)
{ {
unsigned char buf[256+2]; /* sufficient for 2*384/8+1 */ unsigned char buf[256+2]; /* sufficient for 2*384/8+1 */
const unsigned char* pp = buf; const unsigned char* pp = buf;
@ -349,7 +349,7 @@ ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo)
#endif /* USE_ECDSA */ #endif /* USE_ECDSA */
int int
ldns_digest_evp(unsigned char* data, unsigned int len, unsigned char* dest, sldns_digest_evp(unsigned char* data, unsigned int len, unsigned char* dest,
const EVP_MD* md) const EVP_MD* md)
{ {
EVP_MD_CTX* ctx; EVP_MD_CTX* ctx;

22
ldns/keyraw.h
View file

@ -35,7 +35,7 @@ extern "C" {
* \param[in] alg the cryptographic algorithm this is a key for * \param[in] alg the cryptographic algorithm this is a key for
* \return the keysize in bits, or 0 on error * \return the keysize in bits, or 0 on error
*/ */
size_t ldns_rr_dnskey_key_size_raw(const unsigned char *keydata, size_t sldns_rr_dnskey_key_size_raw(const unsigned char *keydata,
const size_t len, int alg); const size_t len, int alg);
/** /**
@ -44,7 +44,7 @@ size_t ldns_rr_dnskey_key_size_raw(const unsigned char *keydata,
* \param[in] keysize length of key data. * \param[in] keysize length of key data.
* \return the keytag * \return the keytag
*/ */
uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize); uint16_t sldns_calc_keytag_raw(uint8_t* key, size_t keysize);
#if LDNS_BUILD_CONFIG_HAVE_SSL #if LDNS_BUILD_CONFIG_HAVE_SSL
/** /**
@ -52,18 +52,18 @@ uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize);
* Only available if GOST is compiled into the library and openssl. * Only available if GOST is compiled into the library and openssl.
* \return the gost id for EVP_CTX creation. * \return the gost id for EVP_CTX creation.
*/ */
int ldns_key_EVP_load_gost_id(void); int sldns_key_EVP_load_gost_id(void);
/** Release the engine reference held for the GOST engine. */ /** Release the engine reference held for the GOST engine. */
void ldns_key_EVP_unload_gost(void); void sldns_key_EVP_unload_gost(void);
/** /**
* Like ldns_key_buf2dsa, but uses raw buffer. * Like sldns_key_buf2dsa, but uses raw buffer.
* \param[in] key the uncompressed wireformat of the key. * \param[in] key the uncompressed wireformat of the key.
* \param[in] len length of key data * \param[in] len length of key data
* \return a DSA * structure with the key material * \return a DSA * structure with the key material
*/ */
DSA *ldns_key_buf2dsa_raw(unsigned char* key, size_t len); DSA *sldns_key_buf2dsa_raw(unsigned char* key, size_t len);
/** /**
* Converts a holding buffer with key material to EVP PKEY in openssl. * Converts a holding buffer with key material to EVP PKEY in openssl.
@ -72,7 +72,7 @@ DSA *ldns_key_buf2dsa_raw(unsigned char* key, size_t len);
* \param[in] keylen length of the key data * \param[in] keylen length of the key data
* \return the key or NULL on error. * \return the key or NULL on error.
*/ */
EVP_PKEY* ldns_gost2pkey_raw(unsigned char* key, size_t keylen); EVP_PKEY* sldns_gost2pkey_raw(unsigned char* key, size_t keylen);
/** /**
* Converts a holding buffer with key material to EVP PKEY in openssl. * Converts a holding buffer with key material to EVP PKEY in openssl.
@ -82,15 +82,15 @@ EVP_PKEY* ldns_gost2pkey_raw(unsigned char* key, size_t keylen);
* \param[in] algo precise algorithm to initialize ECC group values. * \param[in] algo precise algorithm to initialize ECC group values.
* \return the key or NULL on error. * \return the key or NULL on error.
*/ */
EVP_PKEY* ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo); EVP_PKEY* sldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo);
/** /**
* Like ldns_key_buf2rsa, but uses raw buffer. * Like sldns_key_buf2rsa, but uses raw buffer.
* \param[in] key the uncompressed wireformat of the key. * \param[in] key the uncompressed wireformat of the key.
* \param[in] len length of key data * \param[in] len length of key data
* \return a RSA * structure with the key material * \return a RSA * structure with the key material
*/ */
RSA *ldns_key_buf2rsa_raw(unsigned char* key, size_t len); RSA *sldns_key_buf2rsa_raw(unsigned char* key, size_t len);
/** /**
* Utility function to calculate hash using generic EVP_MD pointer. * Utility function to calculate hash using generic EVP_MD pointer.
@ -100,7 +100,7 @@ RSA *ldns_key_buf2rsa_raw(unsigned char* key, size_t len);
* \param[in] md the message digest to use. * \param[in] md the message digest to use.
* \return true if worked, false on failure. * \return true if worked, false on failure.
*/ */
int ldns_digest_evp(unsigned char* data, unsigned int len, int sldns_digest_evp(unsigned char* data, unsigned int len,
unsigned char* dest, const EVP_MD* md); unsigned char* dest, const EVP_MD* md);
#endif /* LDNS_BUILD_CONFIG_HAVE_SSL */ #endif /* LDNS_BUILD_CONFIG_HAVE_SSL */

48
ldns/parse.c
View file

@ -15,7 +15,7 @@
#include <limits.h> #include <limits.h>
#include <strings.h> #include <strings.h>
ldns_lookup_table ldns_directive_types[] = { sldns_lookup_table sldns_directive_types[] = {
{ LDNS_DIR_TTL, "$TTL" }, { LDNS_DIR_TTL, "$TTL" },
{ LDNS_DIR_ORIGIN, "$ORIGIN" }, { LDNS_DIR_ORIGIN, "$ORIGIN" },
{ LDNS_DIR_INCLUDE, "$INCLUDE" }, { LDNS_DIR_INCLUDE, "$INCLUDE" },
@ -24,13 +24,13 @@ ldns_lookup_table ldns_directive_types[] = {
/* add max_limit here? */ /* add max_limit here? */
ssize_t ssize_t
ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit) sldns_fget_token(FILE *f, char *token, const char *delim, size_t limit)
{ {
return ldns_fget_token_l(f, token, delim, limit, NULL); return sldns_fget_token_l(f, token, delim, limit, NULL);
} }
ssize_t ssize_t
ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr) sldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr)
{ {
int c, prev_c; int c, prev_c;
int p; /* 0 -> no parenthese seen, >0 nr of ( seen */ int p; /* 0 -> no parenthese seen, >0 nr of ( seen */
@ -163,7 +163,7 @@ ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *li
return (ssize_t)i; return (ssize_t)i;
tokenread: tokenread:
ldns_fskipcs_l(f, del, line_nr); sldns_fskipcs_l(f, del, line_nr);
*t = '\0'; *t = '\0';
if (p != 0) { if (p != 0) {
return -1; return -1;
@ -173,15 +173,15 @@ tokenread:
} }
ssize_t ssize_t
ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data, sldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data,
const char *d_del, size_t data_limit) const char *d_del, size_t data_limit)
{ {
return ldns_fget_keyword_data_l(f, keyword, k_del, data, d_del, return sldns_fget_keyword_data_l(f, keyword, k_del, data, d_del,
data_limit, NULL); data_limit, NULL);
} }
ssize_t ssize_t
ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data, sldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data,
const char *d_del, size_t data_limit, int *line_nr) const char *d_del, size_t data_limit, int *line_nr)
{ {
/* we assume: keyword|sep|data */ /* we assume: keyword|sep|data */
@ -194,7 +194,7 @@ ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *
if(!fkeyword) if(!fkeyword)
return -1; return -1;
i = ldns_fget_token(f, fkeyword, k_del, LDNS_MAX_KEYWORDLEN); i = sldns_fget_token(f, fkeyword, k_del, LDNS_MAX_KEYWORDLEN);
if(i==0 || i==-1) { if(i==0 || i==-1) {
free(fkeyword); free(fkeyword);
return -1; return -1;
@ -204,7 +204,7 @@ ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *
if (strncmp(fkeyword, keyword, LDNS_MAX_KEYWORDLEN - 1) == 0) { if (strncmp(fkeyword, keyword, LDNS_MAX_KEYWORDLEN - 1) == 0) {
/* whee! */ /* whee! */
/* printf("%s\n%s\n", "Matching keyword", fkeyword); */ /* printf("%s\n%s\n", "Matching keyword", fkeyword); */
i = ldns_fget_token_l(f, data, d_del, data_limit, line_nr); i = sldns_fget_token_l(f, data, d_del, data_limit, line_nr);
free(fkeyword); free(fkeyword);
return i; return i;
} else { } else {
@ -215,13 +215,13 @@ ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *
} }
ssize_t ssize_t
ldns_bget_token(ldns_buffer *b, char *token, const char *delim, size_t limit) sldns_bget_token(sldns_buffer *b, char *token, const char *delim, size_t limit)
{ {
return ldns_bget_token_par(b, token, delim, limit, NULL, NULL); return sldns_bget_token_par(b, token, delim, limit, NULL, NULL);
} }
ssize_t ssize_t
ldns_bget_token_par(ldns_buffer *b, char *token, const char *delim, sldns_bget_token_par(sldns_buffer *b, char *token, const char *delim,
size_t limit, int* par, const char* skipw) size_t limit, int* par, const char* skipw)
{ {
int c, lc; int c, lc;
@ -250,7 +250,7 @@ ldns_bget_token_par(ldns_buffer *b, char *token, const char *delim,
quoted = 1; quoted = 1;
} }
while ((c = ldns_bgetc(b)) != EOF) { while ((c = sldns_bgetc(b)) != EOF) {
if (c == '\r') /* carriage return */ if (c == '\r') /* carriage return */
c = ' '; c = ' ';
if (c == '(' && lc != '\\' && !quoted) { if (c == '(' && lc != '\\' && !quoted) {
@ -352,7 +352,7 @@ ldns_bget_token_par(ldns_buffer *b, char *token, const char *delim,
return (ssize_t)i; return (ssize_t)i;
tokenread: tokenread:
ldns_bskipcs(b, del); sldns_bskipcs(b, del);
*t = '\0'; *t = '\0';
if (!par && p != 0) { if (!par && p != 0) {
@ -363,14 +363,14 @@ tokenread:
void void
ldns_bskipcs(ldns_buffer *buffer, const char *s) sldns_bskipcs(sldns_buffer *buffer, const char *s)
{ {
int found; int found;
char c; char c;
const char *d; const char *d;
while(ldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) { while(sldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) {
c = (char) ldns_buffer_read_u8_at(buffer, buffer->_position); c = (char) sldns_buffer_read_u8_at(buffer, buffer->_position);
found = 0; found = 0;
for (d = s; *d; d++) { for (d = s; *d; d++) {
if (*d == c) { if (*d == c) {
@ -386,13 +386,13 @@ ldns_bskipcs(ldns_buffer *buffer, const char *s)
} }
void void
ldns_fskipcs(FILE *fp, const char *s) sldns_fskipcs(FILE *fp, const char *s)
{ {
ldns_fskipcs_l(fp, s, NULL); sldns_fskipcs_l(fp, s, NULL);
} }
void void
ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr) sldns_fskipcs_l(FILE *fp, const char *s, int *line_nr)
{ {
int found; int found;
int c; int c;
@ -417,7 +417,7 @@ ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr)
} }
ssize_t ssize_t
ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, char sldns_bget_keyword_data(sldns_buffer *b, const char *keyword, const char *k_del, char
*data, const char *d_del, size_t data_limit) *data, const char *d_del, size_t data_limit)
{ {
/* we assume: keyword|sep|data */ /* we assume: keyword|sep|data */
@ -430,7 +430,7 @@ ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, c
if(!fkeyword) if(!fkeyword)
return -1; /* out of memory */ return -1; /* out of memory */
i = ldns_bget_token(b, fkeyword, k_del, data_limit); i = sldns_bget_token(b, fkeyword, k_del, data_limit);
if(i==0 || i==-1) { if(i==0 || i==-1) {
free(fkeyword); free(fkeyword);
return -1; /* nothing read */ return -1; /* nothing read */
@ -441,7 +441,7 @@ ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, c
free(fkeyword); free(fkeyword);
/* whee, the match! */ /* whee, the match! */
/* retrieve it's data */ /* retrieve it's data */
i = ldns_bget_token(b, data, d_del, 0); i = sldns_bget_token(b, data, d_del, 0);
return i; return i;
} else { } else {
free(fkeyword); free(fkeyword);

28
ldns/parse.h
View file

@ -10,7 +10,7 @@
#ifndef LDNS_PARSE_H #ifndef LDNS_PARSE_H
#define LDNS_PARSE_H #define LDNS_PARSE_H
struct ldns_buffer; struct sldns_buffer;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -35,13 +35,13 @@ extern "C" {
* We now deal with $TTL, $ORIGIN and $INCLUDE. * We now deal with $TTL, $ORIGIN and $INCLUDE.
* The latter is not implemented in ldns (yet) * The latter is not implemented in ldns (yet)
*/ */
enum ldns_enum_directive enum sldns_enum_directive
{ {
LDNS_DIR_TTL, LDNS_DIR_TTL,
LDNS_DIR_ORIGIN, LDNS_DIR_ORIGIN,
LDNS_DIR_INCLUDE LDNS_DIR_INCLUDE
}; };
typedef enum ldns_enum_directive ldns_directive; typedef enum sldns_enum_directive sldns_directive;
/** /**
* returns a token/char from the stream F. * returns a token/char from the stream F.
@ -53,7 +53,7 @@ typedef enum ldns_enum_directive ldns_directive;
* \param[in] *limit how much to read. If 0 the builtin maximum is used * \param[in] *limit how much to read. If 0 the builtin maximum is used
* \return 0 on error of EOF of the stream F. Otherwise return the length of what is read * \return 0 on error of EOF of the stream F. Otherwise return the length of what is read
*/ */
ssize_t ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit); ssize_t sldns_fget_token(FILE *f, char *token, const char *delim, size_t limit);
/** /**
* returns a token/char from the stream F. * returns a token/char from the stream F.
@ -66,7 +66,7 @@ ssize_t ldns_fget_token(FILE *f, char *token, const char *delim, size_t limit);
* \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes)
* \return 0 on error of EOF of F otherwise return the length of what is read * \return 0 on error of EOF of F otherwise return the length of what is read
*/ */
ssize_t ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr); ssize_t sldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit, int *line_nr);
/** /**
* returns a token/char from the buffer b. * returns a token/char from the buffer b.
@ -84,7 +84,7 @@ ssize_t ldns_fget_token_l(FILE *f, char *token, const char *delim, size_t limit,
* token, like " ", or " \t", or NULL for none. * token, like " ", or " \t", or NULL for none.
* \returns 0 on error of EOF of b. Otherwise return the length of what is read * \returns 0 on error of EOF of b. Otherwise return the length of what is read
*/ */
ssize_t ldns_bget_token_par(struct ldns_buffer *b, char *token, const char *delim, size_t limit, int* par, const char* skipw); ssize_t sldns_bget_token_par(struct sldns_buffer *b, char *token, const char *delim, size_t limit, int* par, const char* skipw);
/** /**
* returns a token/char from the buffer b. * returns a token/char from the buffer b.
@ -96,7 +96,7 @@ ssize_t ldns_bget_token_par(struct ldns_buffer *b, char *token, const char *deli
* \param[in] *limit how much to read. If 0 the builtin maximum is used * \param[in] *limit how much to read. If 0 the builtin maximum is used
* \returns 0 on error of EOF of b. Otherwise return the length of what is read * \returns 0 on error of EOF of b. Otherwise return the length of what is read
*/ */
ssize_t ldns_bget_token(struct ldns_buffer *b, char *token, const char *delim, size_t limit); ssize_t sldns_bget_token(struct sldns_buffer *b, char *token, const char *delim, size_t limit);
/* /*
* searches for keyword and delim in a file. Gives everything back * searches for keyword and delim in a file. Gives everything back
@ -109,7 +109,7 @@ ssize_t ldns_bget_token(struct ldns_buffer *b, char *token, const char *delim, s
* \param[in] data_limit maximum size the the data buffer * \param[in] data_limit maximum size the the data buffer
* \return the number of character read * \return the number of character read
*/ */
ssize_t ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit); ssize_t sldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit);
/* /*
* searches for keyword and delim. Gives everything back * searches for keyword and delim. Gives everything back
@ -124,7 +124,7 @@ ssize_t ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del,
debugging purposes) debugging purposes)
* \return the number of character read * \return the number of character read
*/ */
ssize_t ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit, int *line_nr); ssize_t sldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit, int *line_nr);
/* /*
* searches for keyword and delim in a buffer. Gives everything back * searches for keyword and delim in a buffer. Gives everything back
@ -137,7 +137,7 @@ ssize_t ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del
* \param[in] data_limit maximum size the the data buffer * \param[in] data_limit maximum size the the data buffer
* \return the number of character read * \return the number of character read
*/ */
ssize_t ldns_bget_keyword_data(struct ldns_buffer *b, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit); ssize_t sldns_bget_keyword_data(struct sldns_buffer *b, const char *keyword, const char *k_del, char *data, const char *d_del, size_t data_limit);
/** /**
* returns the next character from a buffer. Advances the position pointer with 1. * returns the next character from a buffer. Advances the position pointer with 1.
@ -146,7 +146,7 @@ ssize_t ldns_bget_keyword_data(struct ldns_buffer *b, const char *keyword, const
* \param[in] *buffer buffer to read from * \param[in] *buffer buffer to read from
* \return EOF on failure otherwise return the character * \return EOF on failure otherwise return the character
*/ */
int ldns_bgetc(struct ldns_buffer *buffer); int sldns_bgetc(struct sldns_buffer *buffer);
/** /**
* skips all of the characters in the given string in the buffer, moving * skips all of the characters in the given string in the buffer, moving
@ -155,7 +155,7 @@ int ldns_bgetc(struct ldns_buffer *buffer);
* \param[in] *s characters to skip * \param[in] *s characters to skip
* \return void * \return void
*/ */
void ldns_bskipcs(struct ldns_buffer *buffer, const char *s); void sldns_bskipcs(struct sldns_buffer *buffer, const char *s);
/** /**
* skips all of the characters in the given string in the fp, moving * skips all of the characters in the given string in the fp, moving
@ -164,7 +164,7 @@ void ldns_bskipcs(struct ldns_buffer *buffer, const char *s);
* \param[in] *s characters to skip * \param[in] *s characters to skip
* \return void * \return void
*/ */
void ldns_fskipcs(FILE *fp, const char *s); void sldns_fskipcs(FILE *fp, const char *s);
/** /**
@ -175,7 +175,7 @@ void ldns_fskipcs(FILE *fp, const char *s);
* \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes) * \param[in] line_nr pointer to an integer containing the current line number (for debugging purposes)
* \return void * \return void
*/ */
void ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr); void sldns_fskipcs_l(FILE *fp, const char *s, int *line_nr);
#ifdef __cplusplus #ifdef __cplusplus
} }

84
ldns/parseutil.c
View file

@ -18,8 +18,8 @@
#include <time.h> #include <time.h>
#include <ctype.h> #include <ctype.h>
ldns_lookup_table * sldns_lookup_table *
ldns_lookup_by_name(ldns_lookup_table *table, const char *name) sldns_lookup_by_name(sldns_lookup_table *table, const char *name)
{ {
while (table->name != NULL) { while (table->name != NULL) {
if (strcasecmp(name, table->name) == 0) if (strcasecmp(name, table->name) == 0)
@ -29,8 +29,8 @@ ldns_lookup_by_name(ldns_lookup_table *table, const char *name)
return NULL; return NULL;
} }
ldns_lookup_table * sldns_lookup_table *
ldns_lookup_by_id(ldns_lookup_table *table, int id) sldns_lookup_by_id(sldns_lookup_table *table, int id)
{ {
while (table->name != NULL) { while (table->name != NULL) {
if (table->id == id) if (table->id == id)
@ -69,7 +69,7 @@ leap_days(int y1, int y2)
* Code adapted from Python 2.4.1 sources (Lib/calendar.py). * Code adapted from Python 2.4.1 sources (Lib/calendar.py).
*/ */
time_t time_t
ldns_mktime_from_utc(const struct tm *tm) sldns_mktime_from_utc(const struct tm *tm)
{ {
int year = 1900 + tm->tm_year; int year = 1900 + tm->tm_year;
time_t days = 365 * ((time_t) year - 1970) + leap_days(1970, year); time_t days = 365 * ((time_t) year - 1970) + leap_days(1970, year);
@ -96,7 +96,7 @@ ldns_mktime_from_utc(const struct tm *tm)
#if SIZEOF_TIME_T <= 4 #if SIZEOF_TIME_T <= 4
static void static void
ldns_year_and_yday_from_days_since_epoch(int64_t days, struct tm *result) sldns_year_and_yday_from_days_since_epoch(int64_t days, struct tm *result)
{ {
int year = 1970; int year = 1970;
int new_year; int new_year;
@ -117,7 +117,7 @@ static const int leap_year_mdays[] = {
}; };
static void static void
ldns_mon_and_mday_from_year_and_yday(struct tm *result) sldns_mon_and_mday_from_year_and_yday(struct tm *result)
{ {
int idays = result->tm_yday; int idays = result->tm_yday;
const int *mon_lengths = is_leap_year(result->tm_year) ? const int *mon_lengths = is_leap_year(result->tm_year) ?
@ -131,7 +131,7 @@ ldns_mon_and_mday_from_year_and_yday(struct tm *result)
} }
static void static void
ldns_wday_from_year_and_yday(struct tm *result) sldns_wday_from_year_and_yday(struct tm *result)
{ {
result->tm_wday = 4 /* 1-1-1970 was a thursday */ result->tm_wday = 4 /* 1-1-1970 was a thursday */
+ LDNS_MOD((result->tm_year - 1970), 7) * LDNS_MOD(365, 7) + LDNS_MOD((result->tm_year - 1970), 7) * LDNS_MOD(365, 7)
@ -144,7 +144,7 @@ ldns_wday_from_year_and_yday(struct tm *result)
} }
static struct tm * static struct tm *
ldns_gmtime64_r(int64_t clock, struct tm *result) sldns_gmtime64_r(int64_t clock, struct tm *result)
{ {
result->tm_isdst = 0; result->tm_isdst = 0;
result->tm_sec = (int) LDNS_MOD(clock, 60); result->tm_sec = (int) LDNS_MOD(clock, 60);
@ -154,9 +154,9 @@ ldns_gmtime64_r(int64_t clock, struct tm *result)
result->tm_hour = (int) LDNS_MOD(clock, 24); result->tm_hour = (int) LDNS_MOD(clock, 24);
clock = LDNS_DIV(clock, 24); clock = LDNS_DIV(clock, 24);
ldns_year_and_yday_from_days_since_epoch(clock, result); sldns_year_and_yday_from_days_since_epoch(clock, result);
ldns_mon_and_mday_from_year_and_yday(result); sldns_mon_and_mday_from_year_and_yday(result);
ldns_wday_from_year_and_yday(result); sldns_wday_from_year_and_yday(result);
result->tm_year -= 1900; result->tm_year -= 1900;
return result; return result;
@ -165,26 +165,26 @@ ldns_gmtime64_r(int64_t clock, struct tm *result)
#endif /* SIZEOF_TIME_T <= 4 */ #endif /* SIZEOF_TIME_T <= 4 */
static int64_t static int64_t
ldns_serial_arithmitics_time(int32_t time, time_t now) sldns_serial_arithmitics_time(int32_t time, time_t now)
{ {
int32_t offset = time - (int32_t) now; int32_t offset = time - (int32_t) now;
return (int64_t) now + offset; return (int64_t) now + offset;
} }
struct tm * struct tm *
ldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result) sldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result)
{ {
#if SIZEOF_TIME_T <= 4 #if SIZEOF_TIME_T <= 4
int64_t secs_since_epoch = ldns_serial_arithmitics_time(time, now); int64_t secs_since_epoch = sldns_serial_arithmitics_time(time, now);
return ldns_gmtime64_r(secs_since_epoch, result); return sldns_gmtime64_r(secs_since_epoch, result);
#else #else
time_t secs_since_epoch = ldns_serial_arithmitics_time(time, now); time_t secs_since_epoch = sldns_serial_arithmitics_time(time, now);
return gmtime_r(&secs_since_epoch, result); return gmtime_r(&secs_since_epoch, result);
#endif #endif
} }
int int
ldns_hexdigit_to_int(char ch) sldns_hexdigit_to_int(char ch)
{ {
switch (ch) { switch (ch) {
case '0': return 0; case '0': return 0;
@ -209,7 +209,7 @@ ldns_hexdigit_to_int(char ch)
} }
uint32_t uint32_t
ldns_str2period(const char *nptr, const char **endptr) sldns_str2period(const char *nptr, const char **endptr)
{ {
int sign = 0; int sign = 0;
uint32_t i = 0; uint32_t i = 0;
@ -284,7 +284,7 @@ ldns_str2period(const char *nptr, const char **endptr)
} }
int int
ldns_parse_escape(uint8_t *ch_p, const char** str_p) sldns_parse_escape(uint8_t *ch_p, const char** str_p)
{ {
uint16_t val; uint16_t val;
@ -315,32 +315,32 @@ error:
/** parse one character, with escape codes */ /** parse one character, with escape codes */
int int
ldns_parse_char(uint8_t *ch_p, const char** str_p) sldns_parse_char(uint8_t *ch_p, const char** str_p)
{ {
switch (**str_p) { switch (**str_p) {
case '\0': return 0; case '\0': return 0;
case '\\': *str_p += 1; case '\\': *str_p += 1;
return ldns_parse_escape(ch_p, str_p); return sldns_parse_escape(ch_p, str_p);
default: *ch_p = (uint8_t)*(*str_p)++; default: *ch_p = (uint8_t)*(*str_p)++;
return 1; return 1;
} }
} }
size_t ldns_b32_ntop_calculate_size(size_t src_data_length) size_t sldns_b32_ntop_calculate_size(size_t src_data_length)
{ {
return src_data_length == 0 ? 0 : ((src_data_length - 1) / 5 + 1) * 8; return src_data_length == 0 ? 0 : ((src_data_length - 1) / 5 + 1) * 8;
} }
size_t ldns_b32_ntop_calculate_size_no_padding(size_t src_data_length) size_t sldns_b32_ntop_calculate_size_no_padding(size_t src_data_length)
{ {
return ((src_data_length + 3) * 8 / 5) - 4; return ((src_data_length + 3) * 8 / 5) - 4;
} }
static int static int
ldns_b32_ntop_base(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz, sldns_b32_ntop_base(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz,
int extended_hex, int add_padding) int extended_hex, int add_padding)
{ {
size_t ret_sz; size_t ret_sz;
@ -352,8 +352,8 @@ ldns_b32_ntop_base(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz,
* (i.e. src_sz % 5 != 0) * (i.e. src_sz % 5 != 0)
*/ */
ret_sz = add_padding ? ldns_b32_ntop_calculate_size(src_sz) ret_sz = add_padding ? sldns_b32_ntop_calculate_size(src_sz)
: ldns_b32_ntop_calculate_size_no_padding(src_sz); : sldns_b32_ntop_calculate_size_no_padding(src_sz);
/* Do we have enough space? */ /* Do we have enough space? */
if (dst_sz < ret_sz + 1) if (dst_sz < ret_sz + 1)
@ -433,25 +433,25 @@ ldns_b32_ntop_base(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz,
} }
int int
ldns_b32_ntop(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz) sldns_b32_ntop(const uint8_t* src, size_t src_sz, char* dst, size_t dst_sz)
{ {
return ldns_b32_ntop_base(src, src_sz, dst, dst_sz, 0, 1); return sldns_b32_ntop_base(src, src_sz, dst, dst_sz, 0, 1);
} }
int int
ldns_b32_ntop_extended_hex(const uint8_t* src, size_t src_sz, sldns_b32_ntop_extended_hex(const uint8_t* src, size_t src_sz,
char* dst, size_t dst_sz) char* dst, size_t dst_sz)
{ {
return ldns_b32_ntop_base(src, src_sz, dst, dst_sz, 1, 1); return sldns_b32_ntop_base(src, src_sz, dst, dst_sz, 1, 1);
} }
size_t ldns_b32_pton_calculate_size(size_t src_text_length) size_t sldns_b32_pton_calculate_size(size_t src_text_length)
{ {
return src_text_length * 5 / 8; return src_text_length * 5 / 8;
} }
static int static int
ldns_b32_pton_base(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz, sldns_b32_pton_base(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz,
int extended_hex, int check_padding) int extended_hex, int check_padding)
{ {
size_t i = 0; size_t i = 0;
@ -583,19 +583,19 @@ ldns_b32_pton_base(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz,
} }
int int
ldns_b32_pton(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz) sldns_b32_pton(const char* src, size_t src_sz, uint8_t* dst, size_t dst_sz)
{ {
return ldns_b32_pton_base(src, src_sz, dst, dst_sz, 0, 1); return sldns_b32_pton_base(src, src_sz, dst, dst_sz, 0, 1);
} }
int int
ldns_b32_pton_extended_hex(const char* src, size_t src_sz, sldns_b32_pton_extended_hex(const char* src, size_t src_sz,
uint8_t* dst, size_t dst_sz) uint8_t* dst, size_t dst_sz)
{ {
return ldns_b32_pton_base(src, src_sz, dst, dst_sz, 1, 1); return sldns_b32_pton_base(src, src_sz, dst, dst_sz, 1, 1);
} }
size_t ldns_b64_ntop_calculate_size(size_t srcsize) size_t sldns_b64_ntop_calculate_size(size_t srcsize)
{ {
return ((((srcsize + 2) / 3) * 4) + 1); return ((((srcsize + 2) / 3) * 4) + 1);
} }
@ -610,14 +610,14 @@ size_t ldns_b64_ntop_calculate_size(size_t srcsize)
* *
* This routine does not insert spaces or linebreaks after 76 characters. * This routine does not insert spaces or linebreaks after 76 characters.
*/ */
int ldns_b64_ntop(uint8_t const *src, size_t srclength, int sldns_b64_ntop(uint8_t const *src, size_t srclength,
char *target, size_t targsize) char *target, size_t targsize)
{ {
const char* b64 = const char* b64 =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const char pad64 = '='; const char pad64 = '=';
size_t i = 0, o = 0; size_t i = 0, o = 0;
if(targsize < ldns_b64_ntop_calculate_size(srclength)) if(targsize < sldns_b64_ntop_calculate_size(srclength))
return -1; return -1;
/* whole chunks: xxxxxxyy yyyyzzzz zzwwwwww */ /* whole chunks: xxxxxxyy yyyyzzzz zzwwwwww */
while(i+3 <= srclength) { while(i+3 <= srclength) {
@ -660,12 +660,12 @@ int ldns_b64_ntop(uint8_t const *src, size_t srclength,
return (int)o; return (int)o;
} }
size_t ldns_b64_pton_calculate_size(size_t srcsize) size_t sldns_b64_pton_calculate_size(size_t srcsize)
{ {
return (((((srcsize + 3) / 4) * 3)) + 1); return (((((srcsize + 3) / 4) * 3)) + 1);
} }
int ldns_b64_pton(char const *src, uint8_t *target, size_t targsize) int sldns_b64_pton(char const *src, uint8_t *target, size_t targsize)
{ {
const uint8_t pad64 = 64; /* is 64th in the b64 array */ const uint8_t pad64 = 64; /* is 64th in the b64 array */
const char* s = src; const char* s = src;

44
ldns/parseutil.h
View file

@ -24,11 +24,11 @@ struct tm;
* and vice versa. The lookup tables themselves are defined wherever needed, * and vice versa. The lookup tables themselves are defined wherever needed,
* for instance in host2str.c * for instance in host2str.c
*/ */
struct ldns_struct_lookup_table { struct sldns_struct_lookup_table {
int id; int id;
const char *name; const char *name;
}; };
typedef struct ldns_struct_lookup_table ldns_lookup_table; typedef struct sldns_struct_lookup_table sldns_lookup_table;
/** /**
* Looks up the table entry by name, returns NULL if not found. * Looks up the table entry by name, returns NULL if not found.
@ -36,7 +36,7 @@ typedef struct ldns_struct_lookup_table ldns_lookup_table;
* \param[in] name what to search for * \param[in] name what to search for
* \return the item found * \return the item found
*/ */
ldns_lookup_table *ldns_lookup_by_name(ldns_lookup_table table[], sldns_lookup_table *sldns_lookup_by_name(sldns_lookup_table table[],
const char *name); const char *name);
/** /**
* Looks up the table entry by id, returns NULL if not found. * Looks up the table entry by id, returns NULL if not found.
@ -44,7 +44,7 @@ ldns_lookup_table *ldns_lookup_by_name(ldns_lookup_table table[],
* \param[in] id what to search for * \param[in] id what to search for
* \return the item found * \return the item found
*/ */
ldns_lookup_table *ldns_lookup_by_id(ldns_lookup_table table[], int id); sldns_lookup_table *sldns_lookup_by_id(sldns_lookup_table table[], int id);
/** /**
* Convert TM to seconds since epoch (midnight, January 1st, 1970). * Convert TM to seconds since epoch (midnight, January 1st, 1970).
@ -52,7 +52,7 @@ ldns_lookup_table *ldns_lookup_by_id(ldns_lookup_table table[], int id);
* \param[in] tm a struct tm* with the date * \param[in] tm a struct tm* with the date
* \return the seconds since epoch * \return the seconds since epoch
*/ */
time_t ldns_mktime_from_utc(const struct tm *tm); time_t sldns_mktime_from_utc(const struct tm *tm);
/** /**
* The function interprets time as the number of seconds since epoch * The function interprets time as the number of seconds since epoch
@ -68,7 +68,7 @@ time_t ldns_mktime_from_utc(const struct tm *tm);
* \param[out] result the struct with the broken-out time information * \param[out] result the struct with the broken-out time information
* \return result on success or NULL on error * \return result on success or NULL on error
*/ */
struct tm * ldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result); struct tm * sldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result);
/** /**
* converts a ttl value (like 5d2h) to a long. * converts a ttl value (like 5d2h) to a long.
@ -76,52 +76,52 @@ struct tm * ldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm
* \param[out] endptr points to the last char in case of error * \param[out] endptr points to the last char in case of error
* \return the convert duration value * \return the convert duration value
*/ */
uint32_t ldns_str2period(const char *nptr, const char **endptr); uint32_t sldns_str2period(const char *nptr, const char **endptr);
/** /**
* Returns the int value of the given (hex) digit * Returns the int value of the given (hex) digit
* \param[in] ch the hex char to convert * \param[in] ch the hex char to convert
* \return the converted decimal value * \return the converted decimal value
*/ */
int ldns_hexdigit_to_int(char ch); int sldns_hexdigit_to_int(char ch);
/** /**
* calculates the size needed to store the result of b64_ntop * calculates the size needed to store the result of b64_ntop
*/ */
size_t ldns_b64_ntop_calculate_size(size_t srcsize); size_t sldns_b64_ntop_calculate_size(size_t srcsize);
int ldns_b64_ntop(uint8_t const *src, size_t srclength, int sldns_b64_ntop(uint8_t const *src, size_t srclength,
char *target, size_t targsize); char *target, size_t targsize);
/** /**
* calculates the size needed to store the result of ldns_b64_pton * calculates the size needed to store the result of sldns_b64_pton
*/ */
size_t ldns_b64_pton_calculate_size(size_t srcsize); size_t sldns_b64_pton_calculate_size(size_t srcsize);
int ldns_b64_pton(char const *src, uint8_t *target, size_t targsize); int sldns_b64_pton(char const *src, uint8_t *target, size_t targsize);
/** /**
* calculates the size needed to store the result of b32_ntop * calculates the size needed to store the result of b32_ntop
*/ */
size_t ldns_b32_ntop_calculate_size(size_t src_data_length); size_t sldns_b32_ntop_calculate_size(size_t src_data_length);
size_t ldns_b32_ntop_calculate_size_no_padding(size_t src_data_length); size_t sldns_b32_ntop_calculate_size_no_padding(size_t src_data_length);
int ldns_b32_ntop(const uint8_t* src_data, size_t src_data_length, int sldns_b32_ntop(const uint8_t* src_data, size_t src_data_length,
char* target_text_buffer, size_t target_text_buffer_size); char* target_text_buffer, size_t target_text_buffer_size);
int ldns_b32_ntop_extended_hex(const uint8_t* src_data, size_t src_data_length, int sldns_b32_ntop_extended_hex(const uint8_t* src_data, size_t src_data_length,
char* target_text_buffer, size_t target_text_buffer_size); char* target_text_buffer, size_t target_text_buffer_size);
/** /**
* calculates the size needed to store the result of b32_pton * calculates the size needed to store the result of b32_pton
*/ */
size_t ldns_b32_pton_calculate_size(size_t src_text_length); size_t sldns_b32_pton_calculate_size(size_t src_text_length);
int ldns_b32_pton(const char* src_text, size_t src_text_length, int sldns_b32_pton(const char* src_text, size_t src_text_length,
uint8_t* target_data_buffer, size_t target_data_buffer_size); uint8_t* target_data_buffer, size_t target_data_buffer_size);
int ldns_b32_pton_extended_hex(const char* src_text, size_t src_text_length, int sldns_b32_pton_extended_hex(const char* src_text, size_t src_text_length,
uint8_t* target_data_buffer, size_t target_data_buffer_size); uint8_t* target_data_buffer, size_t target_data_buffer_size);
/* /*
@ -135,7 +135,7 @@ int ldns_b32_pton_extended_hex(const char* src_text, size_t src_text_length,
* *
* @return 0 on error * @return 0 on error
*/ */
int ldns_parse_escape(uint8_t *ch_p, const char** str_p); int sldns_parse_escape(uint8_t *ch_p, const char** str_p);
/** /**
* Parse one character, with escape codes, * Parse one character, with escape codes,
@ -143,6 +143,6 @@ int ldns_parse_escape(uint8_t *ch_p, const char** str_p);
* @param str_p: the string. moved along for characters read. * @param str_p: the string. moved along for characters read.
* @return 0 on error * @return 0 on error
*/ */
int ldns_parse_char(uint8_t *ch_p, const char** str_p); int sldns_parse_char(uint8_t *ch_p, const char** str_p);
#endif /* LDNS_PARSEUTIL_H */ #endif /* LDNS_PARSEUTIL_H */

24
ldns/pkthdr.h
View file

@ -88,32 +88,32 @@ extern "C" {
#define LDNS_RA_CLR(wirebuf) (*(wirebuf+3) &= ~LDNS_RA_MASK) #define LDNS_RA_CLR(wirebuf) (*(wirebuf+3) &= ~LDNS_RA_MASK)
/* Query ID */ /* Query ID */
#define LDNS_ID_WIRE(wirebuf) (ldns_read_uint16(wirebuf)) #define LDNS_ID_WIRE(wirebuf) (sldns_read_uint16(wirebuf))
#define LDNS_ID_SET(wirebuf, id) (ldns_write_uint16(wirebuf, id)) #define LDNS_ID_SET(wirebuf, id) (sldns_write_uint16(wirebuf, id))
/* Counter of the question section */ /* Counter of the question section */
#define LDNS_QDCOUNT_OFF 4 #define LDNS_QDCOUNT_OFF 4
/* /*
#define QDCOUNT(wirebuf) (ntohs(*(uint16_t *)(wirebuf+QDCOUNT_OFF))) #define QDCOUNT(wirebuf) (ntohs(*(uint16_t *)(wirebuf+QDCOUNT_OFF)))
*/ */
#define LDNS_QDCOUNT(wirebuf) (ldns_read_uint16(wirebuf+LDNS_QDCOUNT_OFF)) #define LDNS_QDCOUNT(wirebuf) (sldns_read_uint16(wirebuf+LDNS_QDCOUNT_OFF))
/* Counter of the answer section */ /* Counter of the answer section */
#define LDNS_ANCOUNT_OFF 6 #define LDNS_ANCOUNT_OFF 6
#define LDNS_ANCOUNT(wirebuf) (ldns_read_uint16(wirebuf+LDNS_ANCOUNT_OFF)) #define LDNS_ANCOUNT(wirebuf) (sldns_read_uint16(wirebuf+LDNS_ANCOUNT_OFF))
/* Counter of the authority section */ /* Counter of the authority section */
#define LDNS_NSCOUNT_OFF 8 #define LDNS_NSCOUNT_OFF 8
#define LDNS_NSCOUNT(wirebuf) (ldns_read_uint16(wirebuf+LDNS_NSCOUNT_OFF)) #define LDNS_NSCOUNT(wirebuf) (sldns_read_uint16(wirebuf+LDNS_NSCOUNT_OFF))
/* Counter of the additional section */ /* Counter of the additional section */
#define LDNS_ARCOUNT_OFF 10 #define LDNS_ARCOUNT_OFF 10
#define LDNS_ARCOUNT(wirebuf) (ldns_read_uint16(wirebuf+LDNS_ARCOUNT_OFF)) #define LDNS_ARCOUNT(wirebuf) (sldns_read_uint16(wirebuf+LDNS_ARCOUNT_OFF))
/** /**
* The sections of a packet * The sections of a packet
*/ */
enum ldns_enum_pkt_section { enum sldns_enum_pkt_section {
LDNS_SECTION_QUESTION = 0, LDNS_SECTION_QUESTION = 0,
LDNS_SECTION_ANSWER = 1, LDNS_SECTION_ANSWER = 1,
LDNS_SECTION_AUTHORITY = 2, LDNS_SECTION_AUTHORITY = 2,
@ -123,20 +123,20 @@ enum ldns_enum_pkt_section {
/** used to get all non-question rrs from a packet */ /** used to get all non-question rrs from a packet */
LDNS_SECTION_ANY_NOQUESTION = 5 LDNS_SECTION_ANY_NOQUESTION = 5
}; };
typedef enum ldns_enum_pkt_section ldns_pkt_section; typedef enum sldns_enum_pkt_section sldns_pkt_section;
/* opcodes for pkt's */ /* opcodes for pkt's */
enum ldns_enum_pkt_opcode { enum sldns_enum_pkt_opcode {
LDNS_PACKET_QUERY = 0, LDNS_PACKET_QUERY = 0,
LDNS_PACKET_IQUERY = 1, LDNS_PACKET_IQUERY = 1,
LDNS_PACKET_STATUS = 2, /* there is no 3?? DNS is weird */ LDNS_PACKET_STATUS = 2, /* there is no 3?? DNS is weird */
LDNS_PACKET_NOTIFY = 4, LDNS_PACKET_NOTIFY = 4,
LDNS_PACKET_UPDATE = 5 LDNS_PACKET_UPDATE = 5
}; };
typedef enum ldns_enum_pkt_opcode ldns_pkt_opcode; typedef enum sldns_enum_pkt_opcode sldns_pkt_opcode;
/* rcodes for pkts */ /* rcodes for pkts */
enum ldns_enum_pkt_rcode { enum sldns_enum_pkt_rcode {
LDNS_RCODE_NOERROR = 0, LDNS_RCODE_NOERROR = 0,
LDNS_RCODE_FORMERR = 1, LDNS_RCODE_FORMERR = 1,
LDNS_RCODE_SERVFAIL = 2, LDNS_RCODE_SERVFAIL = 2,
@ -149,7 +149,7 @@ enum ldns_enum_pkt_rcode {
LDNS_RCODE_NOTAUTH = 9, LDNS_RCODE_NOTAUTH = 9,
LDNS_RCODE_NOTZONE = 10 LDNS_RCODE_NOTZONE = 10
}; };
typedef enum ldns_enum_pkt_rcode ldns_pkt_rcode; typedef enum sldns_enum_pkt_rcode sldns_pkt_rcode;
#ifdef __cplusplus #ifdef __cplusplus
} }

169
ldns/rrdef.c
View file

@ -17,11 +17,7 @@
#include "ldns/parseutil.h" #include "ldns/parseutil.h"
/* classes */ /* classes */
#ifdef USE_SLDNS static sldns_lookup_table sldns_rr_classes_data[] = {
static ldns_lookup_table sldns_rr_classes_data[] = {
#else
static ldns_lookup_table ldns_rr_classes_data[] = {
#endif
{ LDNS_RR_CLASS_IN, "IN" }, { LDNS_RR_CLASS_IN, "IN" },
{ LDNS_RR_CLASS_CH, "CH" }, { LDNS_RR_CLASS_CH, "CH" },
{ LDNS_RR_CLASS_HS, "HS" }, { LDNS_RR_CLASS_HS, "HS" },
@ -29,136 +25,132 @@ static ldns_lookup_table ldns_rr_classes_data[] = {
{ LDNS_RR_CLASS_ANY, "ANY" }, { LDNS_RR_CLASS_ANY, "ANY" },
{ 0, NULL } { 0, NULL }
}; };
#ifdef USE_SLDNS sldns_lookup_table* sldns_rr_classes = sldns_rr_classes_data;
ldns_lookup_table* sldns_rr_classes = sldns_rr_classes_data;
#else
ldns_lookup_table* ldns_rr_classes = ldns_rr_classes_data;
#endif
/* types */ /* types */
static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN }; static const sldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A }; static const sldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };
static const ldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_soa_wireformat[] = { static const sldns_rdf_type type_soa_wireformat[] = {
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_INT32,
LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD,
LDNS_RDF_TYPE_PERIOD LDNS_RDF_TYPE_PERIOD
}; };
static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_wks_wireformat[] = { static const sldns_rdf_type type_wks_wireformat[] = {
LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_WKS LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_WKS
}; };
static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_hinfo_wireformat[] = { static const sldns_rdf_type type_hinfo_wireformat[] = {
LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
}; };
static const ldns_rdf_type type_minfo_wireformat[] = { static const sldns_rdf_type type_minfo_wireformat[] = {
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_mx_wireformat[] = { static const sldns_rdf_type type_mx_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_rp_wireformat[] = { static const sldns_rdf_type type_rp_wireformat[] = {
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_afsdb_wireformat[] = { static const sldns_rdf_type type_afsdb_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR }; static const sldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR };
static const ldns_rdf_type type_isdn_wireformat[] = { static const sldns_rdf_type type_isdn_wireformat[] = {
LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
}; };
static const ldns_rdf_type type_rt_wireformat[] = { static const sldns_rdf_type type_rt_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_nsap_wireformat[] = { static const sldns_rdf_type type_nsap_wireformat[] = {
LDNS_RDF_TYPE_NSAP LDNS_RDF_TYPE_NSAP
}; };
static const ldns_rdf_type type_nsap_ptr_wireformat[] = { static const sldns_rdf_type type_nsap_ptr_wireformat[] = {
LDNS_RDF_TYPE_STR LDNS_RDF_TYPE_STR
}; };
static const ldns_rdf_type type_sig_wireformat[] = { static const sldns_rdf_type type_sig_wireformat[] = {
LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32,
LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64
}; };
static const ldns_rdf_type type_key_wireformat[] = { static const sldns_rdf_type type_key_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64
}; };
static const ldns_rdf_type type_px_wireformat[] = { static const sldns_rdf_type type_px_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_gpos_wireformat[] = { static const sldns_rdf_type type_gpos_wireformat[] = {
LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
}; };
static const ldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA }; static const sldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA };
static const ldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC }; static const sldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC };
static const ldns_rdf_type type_nxt_wireformat[] = { static const sldns_rdf_type type_nxt_wireformat[] = {
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_UNKNOWN LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_UNKNOWN
}; };
static const ldns_rdf_type type_eid_wireformat[] = { static const sldns_rdf_type type_eid_wireformat[] = {
LDNS_RDF_TYPE_HEX LDNS_RDF_TYPE_HEX
}; };
static const ldns_rdf_type type_nimloc_wireformat[] = { static const sldns_rdf_type type_nimloc_wireformat[] = {
LDNS_RDF_TYPE_HEX LDNS_RDF_TYPE_HEX
}; };
static const ldns_rdf_type type_srv_wireformat[] = { static const sldns_rdf_type type_srv_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_atma_wireformat[] = { static const sldns_rdf_type type_atma_wireformat[] = {
LDNS_RDF_TYPE_ATMA LDNS_RDF_TYPE_ATMA
}; };
static const ldns_rdf_type type_naptr_wireformat[] = { static const sldns_rdf_type type_naptr_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_kx_wireformat[] = { static const sldns_rdf_type type_kx_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
}; };
static const ldns_rdf_type type_cert_wireformat[] = { static const sldns_rdf_type type_cert_wireformat[] = {
LDNS_RDF_TYPE_CERT_ALG, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_CERT_ALG, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_B64
}; };
static const ldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN }; static const sldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
static const ldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME }; static const sldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8, static const sldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8,
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64
}; };
static const ldns_rdf_type type_apl_wireformat[] = { static const sldns_rdf_type type_apl_wireformat[] = {
LDNS_RDF_TYPE_APL LDNS_RDF_TYPE_APL
}; };
static const ldns_rdf_type type_ds_wireformat[] = { static const sldns_rdf_type type_ds_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
}; };
static const ldns_rdf_type type_sshfp_wireformat[] = { static const sldns_rdf_type type_sshfp_wireformat[] = {
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
}; };
static const ldns_rdf_type type_ipseckey_wireformat[] = { static const sldns_rdf_type type_ipseckey_wireformat[] = {
LDNS_RDF_TYPE_IPSECKEY LDNS_RDF_TYPE_IPSECKEY
}; };
static const ldns_rdf_type type_rrsig_wireformat[] = { static const sldns_rdf_type type_rrsig_wireformat[] = {
LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32,
LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64
}; };
static const ldns_rdf_type type_nsec_wireformat[] = { static const sldns_rdf_type type_nsec_wireformat[] = {
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_NSEC LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_NSEC
}; };
static const ldns_rdf_type type_dhcid_wireformat[] = { static const sldns_rdf_type type_dhcid_wireformat[] = {
LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_B64
}; };
static const ldns_rdf_type type_talink_wireformat[] = { static const sldns_rdf_type type_talink_wireformat[] = {
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
}; };
/* nsec3 is some vars, followed by same type of data of nsec */ /* nsec3 is some vars, followed by same type of data of nsec */
static const ldns_rdf_type type_nsec3_wireformat[] = { static const sldns_rdf_type type_nsec3_wireformat[] = {
/* LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/ /* LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC3_SALT, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC3_SALT, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC
}; };
static const ldns_rdf_type type_nsec3param_wireformat[] = { static const sldns_rdf_type type_nsec3param_wireformat[] = {
/* LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/ /* LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8,
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8,
@ -166,13 +158,13 @@ static const ldns_rdf_type type_nsec3param_wireformat[] = {
LDNS_RDF_TYPE_NSEC3_SALT LDNS_RDF_TYPE_NSEC3_SALT
}; };
static const ldns_rdf_type type_dnskey_wireformat[] = { static const sldns_rdf_type type_dnskey_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8,
LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_ALG,
LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_B64
}; };
static const ldns_rdf_type type_tkey_wireformat[] = { static const sldns_rdf_type type_tkey_wireformat[] = {
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME,
LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME,
LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME,
@ -181,7 +173,7 @@ static const ldns_rdf_type type_tkey_wireformat[] = {
LDNS_RDF_TYPE_INT16_DATA, LDNS_RDF_TYPE_INT16_DATA,
LDNS_RDF_TYPE_INT16_DATA, LDNS_RDF_TYPE_INT16_DATA,
}; };
static const ldns_rdf_type type_tsig_wireformat[] = { static const sldns_rdf_type type_tsig_wireformat[] = {
LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME,
LDNS_RDF_TYPE_TSIGTIME, LDNS_RDF_TYPE_TSIGTIME,
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
@ -190,7 +182,7 @@ static const ldns_rdf_type type_tsig_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_INT16_DATA LDNS_RDF_TYPE_INT16_DATA
}; };
static const ldns_rdf_type type_tlsa_wireformat[] = { static const sldns_rdf_type type_tlsa_wireformat[] = {
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8,
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8,
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8,
@ -221,42 +213,42 @@ static const ldns_rdf_type type_tlsa_wireformat[] = {
* follow the RDF types enumerated in the array pointed to by _wireformat in * follow the RDF types enumerated in the array pointed to by _wireformat in
* its descriptor record. * its descriptor record.
*/ */
static const ldns_rdf_type type_hip_hostformat[] = { static const sldns_rdf_type type_hip_hostformat[] = {
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8,
LDNS_RDF_TYPE_HEX, LDNS_RDF_TYPE_HEX,
LDNS_RDF_TYPE_B64 LDNS_RDF_TYPE_B64
}; };
static const ldns_rdf_type type_nid_wireformat[] = { static const sldns_rdf_type type_nid_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_ILNP64 LDNS_RDF_TYPE_ILNP64
}; };
static const ldns_rdf_type type_l32_wireformat[] = { static const sldns_rdf_type type_l32_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_A LDNS_RDF_TYPE_A
}; };
static const ldns_rdf_type type_l64_wireformat[] = { static const sldns_rdf_type type_l64_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_ILNP64 LDNS_RDF_TYPE_ILNP64
}; };
static const ldns_rdf_type type_lp_wireformat[] = { static const sldns_rdf_type type_lp_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_DNAME LDNS_RDF_TYPE_DNAME
}; };
#ifdef DRAFT_RRTYPES #ifdef DRAFT_RRTYPES
static const ldns_rdf_type type_eui48_wireformat[] = { static const sldns_rdf_type type_eui48_wireformat[] = {
LDNS_RDF_TYPE_EUI48 LDNS_RDF_TYPE_EUI48
}; };
static const ldns_rdf_type type_eui64_wireformat[] = { static const sldns_rdf_type type_eui64_wireformat[] = {
LDNS_RDF_TYPE_EUI64 LDNS_RDF_TYPE_EUI64
}; };
static const ldns_rdf_type type_uri_wireformat[] = { static const sldns_rdf_type type_uri_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_LONG_STR LDNS_RDF_TYPE_LONG_STR
}; };
#endif #endif
static const ldns_rdf_type type_caa_wireformat[] = { static const sldns_rdf_type type_caa_wireformat[] = {
LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8,
LDNS_RDF_TYPE_TAG, LDNS_RDF_TYPE_TAG,
LDNS_RDF_TYPE_LONG_STR LDNS_RDF_TYPE_LONG_STR
@ -266,7 +258,7 @@ static const ldns_rdf_type type_caa_wireformat[] = {
* be compressed. See RFC3597. These RR's are: * be compressed. See RFC3597. These RR's are:
* CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT * CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT
*/ */
static ldns_rr_descriptor rdata_field_descriptors[] = { static sldns_rr_descriptor rdata_field_descriptors[] = {
/* 0 */ /* 0 */
{ 0, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }, { 0, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
/* 1 */ /* 1 */
@ -668,8 +660,8 @@ static ldns_rr_descriptor rdata_field_descriptors[] = {
#define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \ #define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \
(sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0])) (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0]))
const ldns_rr_descriptor * const sldns_rr_descriptor *
ldns_rr_descript(uint16_t type) sldns_rr_descript(uint16_t type)
{ {
size_t i; size_t i;
if (type < LDNS_RDATA_FIELD_DESCRIPTORS_COMMON) { if (type < LDNS_RDATA_FIELD_DESCRIPTORS_COMMON) {
@ -688,7 +680,7 @@ ldns_rr_descript(uint16_t type)
} }
size_t size_t
ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor) sldns_rr_descriptor_minimum(const sldns_rr_descriptor *descriptor)
{ {
if (descriptor) { if (descriptor) {
return descriptor->_minimum; return descriptor->_minimum;
@ -698,7 +690,7 @@ ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor)
} }
size_t size_t
ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor) sldns_rr_descriptor_maximum(const sldns_rr_descriptor *descriptor)
{ {
if (descriptor) { if (descriptor) {
if (descriptor->_variable != LDNS_RDF_TYPE_NONE) { if (descriptor->_variable != LDNS_RDF_TYPE_NONE) {
@ -711,8 +703,8 @@ ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor)
} }
} }
ldns_rdf_type sldns_rdf_type
ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor, sldns_rr_descriptor_field_type(const sldns_rr_descriptor *descriptor,
size_t index) size_t index)
{ {
assert(descriptor != NULL); assert(descriptor != NULL);
@ -725,12 +717,12 @@ ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor,
} }
} }
ldns_rr_type sldns_rr_type
ldns_get_rr_type_by_name(const char *name) sldns_get_rr_type_by_name(const char *name)
{ {
unsigned int i; unsigned int i;
const char *desc_name; const char *desc_name;
const ldns_rr_descriptor *desc; const sldns_rr_descriptor *desc;
/* TYPEXX representation */ /* TYPEXX representation */
if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) { if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) {
@ -765,10 +757,10 @@ ldns_get_rr_type_by_name(const char *name)
return 0; return 0;
} }
ldns_rr_class sldns_rr_class
ldns_get_rr_class_by_name(const char *name) sldns_get_rr_class_by_name(const char *name)
{ {
ldns_lookup_table *lt; sldns_lookup_table *lt;
/* CLASSXX representation */ /* CLASSXX representation */
if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) { if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) {
@ -776,12 +768,7 @@ ldns_get_rr_class_by_name(const char *name)
} }
/* Normal types */ /* Normal types */
#ifdef USE_SLDNS lt = sldns_lookup_by_name(sldns_rr_classes, name);
lt = ldns_lookup_by_name(sldns_rr_classes, name);
#else
lt = ldns_lookup_by_name(ldns_rr_classes, name);
#endif
if (lt) { if (lt) {
return lt->id; return lt->id;
} }

64
ldns/rrdef.h
View file

@ -41,16 +41,12 @@ extern "C" {
#define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON 258 #define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON 258
/** lookuptable for rr classes */ /** lookuptable for rr classes */
#ifdef USE_SLDNS extern struct sldns_struct_lookup_table* sldns_rr_classes;
extern struct ldns_struct_lookup_table* sldns_rr_classes;
#else
extern struct ldns_struct_lookup_table* ldns_rr_classes;
#endif
/** /**
* The different RR classes. * The different RR classes.
*/ */
enum ldns_enum_rr_class enum sldns_enum_rr_class
{ {
/** the Internet */ /** the Internet */
LDNS_RR_CLASS_IN = 1, LDNS_RR_CLASS_IN = 1,
@ -67,23 +63,23 @@ enum ldns_enum_rr_class
LDNS_RR_CLASS_LAST = 65535, LDNS_RR_CLASS_LAST = 65535,
LDNS_RR_CLASS_COUNT = LDNS_RR_CLASS_LAST - LDNS_RR_CLASS_FIRST + 1 LDNS_RR_CLASS_COUNT = LDNS_RR_CLASS_LAST - LDNS_RR_CLASS_FIRST + 1
}; };
typedef enum ldns_enum_rr_class ldns_rr_class; typedef enum sldns_enum_rr_class sldns_rr_class;
/** /**
* Used to specify whether compression is allowed. * Used to specify whether compression is allowed.
*/ */
enum ldns_enum_rr_compress enum sldns_enum_rr_compress
{ {
/** compression is allowed */ /** compression is allowed */
LDNS_RR_COMPRESS, LDNS_RR_COMPRESS,
LDNS_RR_NO_COMPRESS LDNS_RR_NO_COMPRESS
}; };
typedef enum ldns_enum_rr_compress ldns_rr_compress; typedef enum sldns_enum_rr_compress sldns_rr_compress;
/** /**
* The different RR types. * The different RR types.
*/ */
enum ldns_enum_rr_type enum sldns_enum_rr_type
{ {
/** a host address */ /** a host address */
LDNS_RR_TYPE_A = 1, LDNS_RR_TYPE_A = 1,
@ -240,7 +236,7 @@ enum ldns_enum_rr_type
LDNS_RR_TYPE_LAST = 65535, LDNS_RR_TYPE_LAST = 65535,
LDNS_RR_TYPE_COUNT = LDNS_RR_TYPE_LAST - LDNS_RR_TYPE_FIRST + 1 LDNS_RR_TYPE_COUNT = LDNS_RR_TYPE_LAST - LDNS_RR_TYPE_FIRST + 1
}; };
typedef enum ldns_enum_rr_type ldns_rr_type; typedef enum sldns_enum_rr_type sldns_rr_type;
/* RDATA */ /* RDATA */
#define LDNS_MAX_RDFLEN 65535 #define LDNS_MAX_RDFLEN 65535
@ -262,7 +258,7 @@ typedef enum ldns_enum_rr_type ldns_rr_type;
/** /**
* The different types of RDATA fields. * The different types of RDATA fields.
*/ */
enum ldns_enum_rdf_type enum sldns_enum_rdf_type
{ {
/** none */ /** none */
LDNS_RDF_TYPE_NONE, LDNS_RDF_TYPE_NONE,
@ -351,12 +347,12 @@ enum ldns_enum_rdf_type
/* Aliases */ /* Aliases */
LDNS_RDF_TYPE_BITMAP = LDNS_RDF_TYPE_NSEC LDNS_RDF_TYPE_BITMAP = LDNS_RDF_TYPE_NSEC
}; };
typedef enum ldns_enum_rdf_type ldns_rdf_type; typedef enum sldns_enum_rdf_type sldns_rdf_type;
/** /**
* Algorithms used in dns * Algorithms used in dns
*/ */
enum ldns_enum_algorithm enum sldns_enum_algorithm
{ {
LDNS_RSAMD5 = 1, /* RFC 4034,4035 */ LDNS_RSAMD5 = 1, /* RFC 4034,4035 */
LDNS_DH = 2, LDNS_DH = 2,
@ -374,24 +370,24 @@ enum ldns_enum_algorithm
LDNS_PRIVATEDNS = 253, LDNS_PRIVATEDNS = 253,
LDNS_PRIVATEOID = 254 LDNS_PRIVATEOID = 254
}; };
typedef enum ldns_enum_algorithm ldns_algorithm; typedef enum sldns_enum_algorithm sldns_algorithm;
/** /**
* Hashing algorithms used in the DS record * Hashing algorithms used in the DS record
*/ */
enum ldns_enum_hash enum sldns_enum_hash
{ {
LDNS_SHA1 = 1, /* RFC 4034 */ LDNS_SHA1 = 1, /* RFC 4034 */
LDNS_SHA256 = 2, /* RFC 4509 */ LDNS_SHA256 = 2, /* RFC 4509 */
LDNS_HASH_GOST = 3, /* RFC 5933 */ LDNS_HASH_GOST = 3, /* RFC 5933 */
LDNS_SHA384 = 4 /* RFC 6605 */ LDNS_SHA384 = 4 /* RFC 6605 */
}; };
typedef enum ldns_enum_hash ldns_hash; typedef enum sldns_enum_hash sldns_hash;
/** /**
* algorithms used in CERT rrs * algorithms used in CERT rrs
*/ */
enum ldns_enum_cert_algorithm enum sldns_enum_cert_algorithm
{ {
LDNS_CERT_PKIX = 1, LDNS_CERT_PKIX = 1,
LDNS_CERT_SPKI = 2, LDNS_CERT_SPKI = 2,
@ -404,12 +400,12 @@ enum ldns_enum_cert_algorithm
LDNS_CERT_URI = 253, LDNS_CERT_URI = 253,
LDNS_CERT_OID = 254 LDNS_CERT_OID = 254
}; };
typedef enum ldns_enum_cert_algorithm ldns_cert_algorithm; typedef enum sldns_enum_cert_algorithm sldns_cert_algorithm;
/** /**
* EDNS option codes * EDNS option codes
*/ */
enum ldns_enum_edns_option enum sldns_enum_edns_option
{ {
LDNS_EDNS_LLQ = 1, /* http://files.dns-sd.org/draft-sekar-dns-llq.txt */ LDNS_EDNS_LLQ = 1, /* http://files.dns-sd.org/draft-sekar-dns-llq.txt */
LDNS_EDNS_UL = 2, /* http://files.dns-sd.org/draft-sekar-dns-ul.txt */ LDNS_EDNS_UL = 2, /* http://files.dns-sd.org/draft-sekar-dns-ul.txt */
@ -420,7 +416,7 @@ enum ldns_enum_edns_option
LDNS_EDNS_N3U = 7, /* RFC6975 */ LDNS_EDNS_N3U = 7, /* RFC6975 */
LDNS_EDNS_CLIENT_SUBNET = 8 /* draft-vandergaast-edns-client-subnet */ LDNS_EDNS_CLIENT_SUBNET = 8 /* draft-vandergaast-edns-client-subnet */
}; };
typedef enum ldns_edns_option ldns_edns_option; typedef enum sldns_edns_option sldns_edns_option;
#define LDNS_EDNS_MASK_DO_BIT 0x8000 #define LDNS_EDNS_MASK_DO_BIT 0x8000
@ -429,10 +425,10 @@ typedef enum ldns_edns_option ldns_edns_option;
* *
* This structure contains, for all rr types, the rdata fields that are defined. * This structure contains, for all rr types, the rdata fields that are defined.
*/ */
struct ldns_struct_rr_descriptor struct sldns_struct_rr_descriptor
{ {
/** Type of the RR that is described here */ /** Type of the RR that is described here */
ldns_rr_type _type; sldns_rr_type _type;
/** Textual name of the RR type. */ /** Textual name of the RR type. */
const char *_name; const char *_name;
/** Minimum number of rdata fields in the RRs of this type. */ /** Minimum number of rdata fields in the RRs of this type. */
@ -440,23 +436,23 @@ struct ldns_struct_rr_descriptor
/** Maximum number of rdata fields in the RRs of this type. */ /** Maximum number of rdata fields in the RRs of this type. */
uint8_t _maximum; uint8_t _maximum;
/** Wireformat specification for the rr, i.e. the types of rdata fields in their respective order. */ /** Wireformat specification for the rr, i.e. the types of rdata fields in their respective order. */
const ldns_rdf_type *_wireformat; const sldns_rdf_type *_wireformat;
/** Special rdf types */ /** Special rdf types */
ldns_rdf_type _variable; sldns_rdf_type _variable;
/** Specifies whether compression can be used for dnames in this RR type. */ /** Specifies whether compression can be used for dnames in this RR type. */
ldns_rr_compress _compress; sldns_rr_compress _compress;
/** The number of DNAMEs in the _wireformat string, for parsing. */ /** The number of DNAMEs in the _wireformat string, for parsing. */
uint8_t _dname_count; uint8_t _dname_count;
}; };
typedef struct ldns_struct_rr_descriptor ldns_rr_descriptor; typedef struct sldns_struct_rr_descriptor sldns_rr_descriptor;
/** /**
* returns the resource record descriptor for the given rr type. * returns the resource record descriptor for the given rr type.
* *
* \param[in] type the type value of the rr type * \param[in] type the type value of the rr type
*\return the ldns_rr_descriptor for this type *\return the sldns_rr_descriptor for this type
*/ */
const ldns_rr_descriptor *ldns_rr_descript(uint16_t type); const sldns_rr_descriptor *sldns_rr_descript(uint16_t type);
/** /**
* returns the minimum number of rdata fields of the rr type this descriptor describes. * returns the minimum number of rdata fields of the rr type this descriptor describes.
@ -464,7 +460,7 @@ const ldns_rr_descriptor *ldns_rr_descript(uint16_t type);
* \param[in] descriptor for an rr type * \param[in] descriptor for an rr type
* \return the minimum number of rdata fields * \return the minimum number of rdata fields
*/ */
size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor); size_t sldns_rr_descriptor_minimum(const sldns_rr_descriptor *descriptor);
/** /**
* returns the maximum number of rdata fields of the rr type this descriptor describes. * returns the maximum number of rdata fields of the rr type this descriptor describes.
@ -472,7 +468,7 @@ size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor);
* \param[in] descriptor for an rr type * \param[in] descriptor for an rr type
* \return the maximum number of rdata fields * \return the maximum number of rdata fields
*/ */
size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor); size_t sldns_rr_descriptor_maximum(const sldns_rr_descriptor *descriptor);
/** /**
* returns the rdf type for the given rdata field number of the rr type for the given descriptor. * returns the rdf type for the given rdata field number of the rr type for the given descriptor.
@ -481,21 +477,21 @@ size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor);
* \param[in] field the field number * \param[in] field the field number
* \return the rdf type for the field * \return the rdf type for the field
*/ */
ldns_rdf_type ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor, size_t field); sldns_rdf_type sldns_rr_descriptor_field_type(const sldns_rr_descriptor *descriptor, size_t field);
/** /**
* retrieves a rrtype by looking up its name. * retrieves a rrtype by looking up its name.
* \param[in] name a string with the name * \param[in] name a string with the name
* \return the type which corresponds with the name * \return the type which corresponds with the name
*/ */
ldns_rr_type ldns_get_rr_type_by_name(const char *name); sldns_rr_type sldns_get_rr_type_by_name(const char *name);
/** /**
* retrieves a class by looking up its name. * retrieves a class by looking up its name.
* \param[in] name string with the name * \param[in] name string with the name
* \return the cass which corresponds with the name * \return the cass which corresponds with the name
*/ */
ldns_rr_class ldns_get_rr_class_by_name(const char *name); sldns_rr_class sldns_get_rr_class_by_name(const char *name);
#ifdef __cplusplus #ifdef __cplusplus
} }

70
ldns/sbuffer.c
View file

@ -9,16 +9,16 @@
/** /**
* \file * \file
* *
* This file contains the definition of ldns_buffer, and functions to manipulate those. * This file contains the definition of sldns_buffer, and functions to manipulate those.
*/ */
#include "config.h" #include "config.h"
#include "ldns/sbuffer.h" #include "ldns/sbuffer.h"
#include <stdarg.h> #include <stdarg.h>
ldns_buffer * sldns_buffer *
ldns_buffer_new(size_t capacity) sldns_buffer_new(size_t capacity)
{ {
ldns_buffer *buffer = (ldns_buffer*)malloc(sizeof(ldns_buffer)); sldns_buffer *buffer = (sldns_buffer*)malloc(sizeof(sldns_buffer));
if (!buffer) { if (!buffer) {
return NULL; return NULL;
@ -35,13 +35,13 @@ ldns_buffer_new(size_t capacity)
buffer->_fixed = 0; buffer->_fixed = 0;
buffer->_status_err = 0; buffer->_status_err = 0;
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
return buffer; return buffer;
} }
void void
ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size) sldns_buffer_new_frm_data(sldns_buffer *buffer, void *data, size_t size)
{ {
assert(data != NULL); assert(data != NULL);
@ -56,11 +56,11 @@ ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size)
memcpy(buffer->_data, data, size); memcpy(buffer->_data, data, size);
buffer->_status_err = 0; buffer->_status_err = 0;
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
} }
void void
ldns_buffer_init_frm_data(ldns_buffer *buffer, void *data, size_t size) sldns_buffer_init_frm_data(sldns_buffer *buffer, void *data, size_t size)
{ {
memset(buffer, 0, sizeof(*buffer)); memset(buffer, 0, sizeof(*buffer));
buffer->_data = data; buffer->_data = data;
@ -69,11 +69,11 @@ ldns_buffer_init_frm_data(ldns_buffer *buffer, void *data, size_t size)
} }
int int
ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity) sldns_buffer_set_capacity(sldns_buffer *buffer, size_t capacity)
{ {
void *data; void *data;
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
assert(buffer->_position <= capacity); assert(buffer->_position <= capacity);
data = (uint8_t *) realloc(buffer->_data, capacity); data = (uint8_t *) realloc(buffer->_data, capacity);
@ -88,9 +88,9 @@ ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity)
} }
int int
ldns_buffer_reserve(ldns_buffer *buffer, size_t amount) sldns_buffer_reserve(sldns_buffer *buffer, size_t amount)
{ {
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
assert(!buffer->_fixed); assert(!buffer->_fixed);
if (buffer->_capacity < buffer->_position + amount) { if (buffer->_capacity < buffer->_position + amount) {
size_t new_capacity = buffer->_capacity * 3 / 2; size_t new_capacity = buffer->_capacity * 3 / 2;
@ -98,7 +98,7 @@ ldns_buffer_reserve(ldns_buffer *buffer, size_t amount)
if (new_capacity < buffer->_position + amount) { if (new_capacity < buffer->_position + amount) {
new_capacity = buffer->_position + amount; new_capacity = buffer->_position + amount;
} }
if (!ldns_buffer_set_capacity(buffer, new_capacity)) { if (!sldns_buffer_set_capacity(buffer, new_capacity)) {
buffer->_status_err = 1; buffer->_status_err = 1;
return 0; return 0;
} }
@ -108,32 +108,32 @@ ldns_buffer_reserve(ldns_buffer *buffer, size_t amount)
} }
int int
ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...) sldns_buffer_printf(sldns_buffer *buffer, const char *format, ...)
{ {
va_list args; va_list args;
int written = 0; int written = 0;
size_t remaining; size_t remaining;
if (ldns_buffer_status_ok(buffer)) { if (sldns_buffer_status_ok(buffer)) {
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
assert(buffer->_limit == buffer->_capacity); assert(buffer->_limit == buffer->_capacity);
remaining = ldns_buffer_remaining(buffer); remaining = sldns_buffer_remaining(buffer);
va_start(args, format); va_start(args, format);
written = vsnprintf((char *) ldns_buffer_current(buffer), remaining, written = vsnprintf((char *) sldns_buffer_current(buffer), remaining,
format, args); format, args);
va_end(args); va_end(args);
if (written == -1) { if (written == -1) {
buffer->_status_err = 1; buffer->_status_err = 1;
return -1; return -1;
} else if ((size_t) written >= remaining) { } else if ((size_t) written >= remaining) {
if (!ldns_buffer_reserve(buffer, (size_t) written + 1)) { if (!sldns_buffer_reserve(buffer, (size_t) written + 1)) {
buffer->_status_err = 1; buffer->_status_err = 1;
return -1; return -1;
} }
va_start(args, format); va_start(args, format);
written = vsnprintf((char *) ldns_buffer_current(buffer), written = vsnprintf((char *) sldns_buffer_current(buffer),
ldns_buffer_remaining(buffer), format, args); sldns_buffer_remaining(buffer), format, args);
va_end(args); va_end(args);
if (written == -1) { if (written == -1) {
buffer->_status_err = 1; buffer->_status_err = 1;
@ -146,7 +146,7 @@ ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...)
} }
void void
ldns_buffer_free(ldns_buffer *buffer) sldns_buffer_free(sldns_buffer *buffer)
{ {
if (!buffer) { if (!buffer) {
return; return;
@ -159,31 +159,31 @@ ldns_buffer_free(ldns_buffer *buffer)
} }
void * void *
ldns_buffer_export(ldns_buffer *buffer) sldns_buffer_export(sldns_buffer *buffer)
{ {
buffer->_fixed = 1; buffer->_fixed = 1;
return buffer->_data; return buffer->_data;
} }
int int
ldns_bgetc(ldns_buffer *buffer) sldns_bgetc(sldns_buffer *buffer)
{ {
if (!ldns_buffer_available_at(buffer, buffer->_position, sizeof(uint8_t))) { if (!sldns_buffer_available_at(buffer, buffer->_position, sizeof(uint8_t))) {
ldns_buffer_set_position(buffer, ldns_buffer_limit(buffer)); sldns_buffer_set_position(buffer, sldns_buffer_limit(buffer));
/* ldns_buffer_rewind(buffer);*/ /* sldns_buffer_rewind(buffer);*/
return EOF; return EOF;
} }
return (int)ldns_buffer_read_u8(buffer); return (int)sldns_buffer_read_u8(buffer);
} }
void void
ldns_buffer_copy(ldns_buffer* result, ldns_buffer* from) sldns_buffer_copy(sldns_buffer* result, sldns_buffer* from)
{ {
size_t tocopy = ldns_buffer_limit(from); size_t tocopy = sldns_buffer_limit(from);
if(tocopy > ldns_buffer_capacity(result)) if(tocopy > sldns_buffer_capacity(result))
tocopy = ldns_buffer_capacity(result); tocopy = sldns_buffer_capacity(result);
ldns_buffer_clear(result); sldns_buffer_clear(result);
ldns_buffer_write(result, ldns_buffer_begin(from), tocopy); sldns_buffer_write(result, sldns_buffer_begin(from), tocopy);
ldns_buffer_flip(result); sldns_buffer_flip(result);
} }

178
ldns/sbuffer.h
View file

@ -32,7 +32,7 @@ extern "C" {
* (big endian). * (big endian).
*/ */
INLINE uint16_t INLINE uint16_t
ldns_read_uint16(const void *src) sldns_read_uint16(const void *src)
{ {
#ifdef ALLOW_UNALIGNED_ACCESSES #ifdef ALLOW_UNALIGNED_ACCESSES
return ntohs(*(uint16_t *) src); return ntohs(*(uint16_t *) src);
@ -43,7 +43,7 @@ ldns_read_uint16(const void *src)
} }
INLINE uint32_t INLINE uint32_t
ldns_read_uint32(const void *src) sldns_read_uint32(const void *src)
{ {
#ifdef ALLOW_UNALIGNED_ACCESSES #ifdef ALLOW_UNALIGNED_ACCESSES
return ntohl(*(uint32_t *) src); return ntohl(*(uint32_t *) src);
@ -61,7 +61,7 @@ ldns_read_uint32(const void *src)
* (big endian). * (big endian).
*/ */
INLINE void INLINE void
ldns_write_uint16(void *dst, uint16_t data) sldns_write_uint16(void *dst, uint16_t data)
{ {
#ifdef ALLOW_UNALIGNED_ACCESSES #ifdef ALLOW_UNALIGNED_ACCESSES
* (uint16_t *) dst = htons(data); * (uint16_t *) dst = htons(data);
@ -73,7 +73,7 @@ ldns_write_uint16(void *dst, uint16_t data)
} }
INLINE void INLINE void
ldns_write_uint32(void *dst, uint32_t data) sldns_write_uint32(void *dst, uint32_t data)
{ {
#ifdef ALLOW_UNALIGNED_ACCESSES #ifdef ALLOW_UNALIGNED_ACCESSES
* (uint32_t *) dst = htonl(data); * (uint32_t *) dst = htonl(data);
@ -90,17 +90,17 @@ ldns_write_uint32(void *dst, uint32_t data)
/** /**
* \file sbuffer.h * \file sbuffer.h
* *
* This file contains the definition of ldns_buffer, and functions to manipulate those. * This file contains the definition of sldns_buffer, and functions to manipulate those.
*/ */
/** /**
* implementation of buffers to ease operations * implementation of buffers to ease operations
* *
* ldns_buffers can contain arbitrary information, per octet. You can write * sldns_buffers can contain arbitrary information, per octet. You can write
* to the current end of a buffer, read from the current position, and * to the current end of a buffer, read from the current position, and
* access any data within it. * access any data within it.
*/ */
struct ldns_buffer struct sldns_buffer
{ {
/** The current position used for reading/writing */ /** The current position used for reading/writing */
size_t _position; size_t _position;
@ -122,16 +122,16 @@ struct ldns_buffer
* multiple writes in sequence and check for success afterwards. */ * multiple writes in sequence and check for success afterwards. */
unsigned _status_err : 1; unsigned _status_err : 1;
}; };
typedef struct ldns_buffer ldns_buffer; typedef struct sldns_buffer sldns_buffer;
#ifdef NDEBUG #ifdef NDEBUG
INLINE void INLINE void
ldns_buffer_invariant(ldns_buffer *ATTR_UNUSED(buffer)) sldns_buffer_invariant(sldns_buffer *ATTR_UNUSED(buffer))
{ {
} }
#else #else
INLINE void INLINE void
ldns_buffer_invariant(ldns_buffer *buffer) sldns_buffer_invariant(sldns_buffer *buffer)
{ {
assert(buffer != NULL); assert(buffer != NULL);
assert(buffer->_position <= buffer->_limit); assert(buffer->_position <= buffer->_limit);
@ -146,7 +146,7 @@ ldns_buffer_invariant(ldns_buffer *buffer)
* \param[in] capacity the size (in bytes) to allocate for the buffer * \param[in] capacity the size (in bytes) to allocate for the buffer
* \return the created buffer * \return the created buffer
*/ */
ldns_buffer *ldns_buffer_new(size_t capacity); sldns_buffer *sldns_buffer_new(size_t capacity);
/** /**
* creates a buffer with the specified data. The data IS copied * creates a buffer with the specified data. The data IS copied
@ -157,7 +157,7 @@ ldns_buffer *ldns_buffer_new(size_t capacity);
* \param[in] data the data to encapsulate in the buffer * \param[in] data the data to encapsulate in the buffer
* \param[in] size the size of the data * \param[in] size the size of the data
*/ */
void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size); void sldns_buffer_new_frm_data(sldns_buffer *buffer, void *data, size_t size);
/** /**
* Setup a buffer with the data pointed to. No data copied, no memory allocs. * Setup a buffer with the data pointed to. No data copied, no memory allocs.
@ -166,16 +166,16 @@ void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size);
* \param[in] data the data to encapsulate in the buffer * \param[in] data the data to encapsulate in the buffer
* \param[in] size the size of the data * \param[in] size the size of the data
*/ */
void ldns_buffer_init_frm_data(ldns_buffer *buffer, void *data, size_t size); void sldns_buffer_init_frm_data(sldns_buffer *buffer, void *data, size_t size);
/** /**
* clears the buffer and make it ready for writing. The buffer's limit * clears the buffer and make it ready for writing. The buffer's limit
* is set to the capacity and the position is set to 0. * is set to the capacity and the position is set to 0.
* \param[in] buffer the buffer to clear * \param[in] buffer the buffer to clear
*/ */
INLINE void ldns_buffer_clear(ldns_buffer *buffer) INLINE void sldns_buffer_clear(sldns_buffer *buffer)
{ {
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
/* reset status here? */ /* reset status here? */
@ -191,9 +191,9 @@ INLINE void ldns_buffer_clear(ldns_buffer *buffer)
* \param[in] buffer the buffer to flip * \param[in] buffer the buffer to flip
* \return void * \return void
*/ */
INLINE void ldns_buffer_flip(ldns_buffer *buffer) INLINE void sldns_buffer_flip(sldns_buffer *buffer)
{ {
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
buffer->_limit = buffer->_position; buffer->_limit = buffer->_position;
buffer->_position = 0; buffer->_position = 0;
@ -204,9 +204,9 @@ INLINE void ldns_buffer_flip(ldns_buffer *buffer)
* position is reset to 0. * position is reset to 0.
* \param[in] buffer the buffer to rewind * \param[in] buffer the buffer to rewind
*/ */
INLINE void ldns_buffer_rewind(ldns_buffer *buffer) INLINE void sldns_buffer_rewind(sldns_buffer *buffer)
{ {
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
buffer->_position = 0; buffer->_position = 0;
} }
@ -217,7 +217,7 @@ INLINE void ldns_buffer_rewind(ldns_buffer *buffer)
* \return the current position * \return the current position
*/ */
INLINE size_t INLINE size_t
ldns_buffer_position(ldns_buffer *buffer) sldns_buffer_position(sldns_buffer *buffer)
{ {
return buffer->_position; return buffer->_position;
} }
@ -229,7 +229,7 @@ ldns_buffer_position(ldns_buffer *buffer)
* \param[in] mark the mark to use * \param[in] mark the mark to use
*/ */
INLINE void INLINE void
ldns_buffer_set_position(ldns_buffer *buffer, size_t mark) sldns_buffer_set_position(sldns_buffer *buffer, size_t mark)
{ {
assert(mark <= buffer->_limit); assert(mark <= buffer->_limit);
buffer->_position = mark; buffer->_position = mark;
@ -243,7 +243,7 @@ ldns_buffer_set_position(ldns_buffer *buffer, size_t mark)
* \param[in] count the count to use * \param[in] count the count to use
*/ */
INLINE void INLINE void
ldns_buffer_skip(ldns_buffer *buffer, ssize_t count) sldns_buffer_skip(sldns_buffer *buffer, ssize_t count)
{ {
assert(buffer->_position + count <= buffer->_limit); assert(buffer->_position + count <= buffer->_limit);
buffer->_position += count; buffer->_position += count;
@ -255,7 +255,7 @@ ldns_buffer_skip(ldns_buffer *buffer, ssize_t count)
* \return the size * \return the size
*/ */
INLINE size_t INLINE size_t
ldns_buffer_limit(ldns_buffer *buffer) sldns_buffer_limit(sldns_buffer *buffer)
{ {
return buffer->_limit; return buffer->_limit;
} }
@ -267,7 +267,7 @@ ldns_buffer_limit(ldns_buffer *buffer)
* \param[in] limit the new limit * \param[in] limit the new limit
*/ */
INLINE void INLINE void
ldns_buffer_set_limit(ldns_buffer *buffer, size_t limit) sldns_buffer_set_limit(sldns_buffer *buffer, size_t limit)
{ {
assert(limit <= buffer->_capacity); assert(limit <= buffer->_capacity);
buffer->_limit = limit; buffer->_limit = limit;
@ -281,7 +281,7 @@ ldns_buffer_set_limit(ldns_buffer *buffer, size_t limit)
* \return the number of bytes * \return the number of bytes
*/ */
INLINE size_t INLINE size_t
ldns_buffer_capacity(ldns_buffer *buffer) sldns_buffer_capacity(sldns_buffer *buffer)
{ {
return buffer->_capacity; return buffer->_capacity;
} }
@ -294,7 +294,7 @@ ldns_buffer_capacity(ldns_buffer *buffer)
* \param[in] capacity the capacity to use * \param[in] capacity the capacity to use
* \return whether this failed or succeeded * \return whether this failed or succeeded
*/ */
int ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity); int sldns_buffer_set_capacity(sldns_buffer *buffer, size_t capacity);
/** /**
* ensures BUFFER can contain at least AMOUNT more bytes. The buffer's * ensures BUFFER can contain at least AMOUNT more bytes. The buffer's
@ -306,7 +306,7 @@ int ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity);
* \param[in] amount amount to use * \param[in] amount amount to use
* \return whether this failed or succeeded * \return whether this failed or succeeded
*/ */
int ldns_buffer_reserve(ldns_buffer *buffer, size_t amount); int sldns_buffer_reserve(sldns_buffer *buffer, size_t amount);
/** /**
* returns a pointer to the data at the indicated position. * returns a pointer to the data at the indicated position.
@ -315,7 +315,7 @@ int ldns_buffer_reserve(ldns_buffer *buffer, size_t amount);
* \return the pointer to the data * \return the pointer to the data
*/ */
INLINE uint8_t * INLINE uint8_t *
ldns_buffer_at(const ldns_buffer *buffer, size_t at) sldns_buffer_at(const sldns_buffer *buffer, size_t at)
{ {
assert(at <= buffer->_limit); assert(at <= buffer->_limit);
return buffer->_data + at; return buffer->_data + at;
@ -328,9 +328,9 @@ ldns_buffer_at(const ldns_buffer *buffer, size_t at)
* \return the pointer * \return the pointer
*/ */
INLINE uint8_t * INLINE uint8_t *
ldns_buffer_begin(const ldns_buffer *buffer) sldns_buffer_begin(const sldns_buffer *buffer)
{ {
return ldns_buffer_at(buffer, 0); return sldns_buffer_at(buffer, 0);
} }
/** /**
@ -340,9 +340,9 @@ ldns_buffer_begin(const ldns_buffer *buffer)
* \return the pointer * \return the pointer
*/ */
INLINE uint8_t * INLINE uint8_t *
ldns_buffer_end(ldns_buffer *buffer) sldns_buffer_end(sldns_buffer *buffer)
{ {
return ldns_buffer_at(buffer, buffer->_limit); return sldns_buffer_at(buffer, buffer->_limit);
} }
/** /**
@ -351,9 +351,9 @@ ldns_buffer_end(ldns_buffer *buffer)
* \return the pointer * \return the pointer
*/ */
INLINE uint8_t * INLINE uint8_t *
ldns_buffer_current(ldns_buffer *buffer) sldns_buffer_current(sldns_buffer *buffer)
{ {
return ldns_buffer_at(buffer, buffer->_position); return sldns_buffer_at(buffer, buffer->_position);
} }
/** /**
@ -364,9 +364,9 @@ ldns_buffer_current(ldns_buffer *buffer)
* \return number of bytes * \return number of bytes
*/ */
INLINE size_t INLINE size_t
ldns_buffer_remaining_at(ldns_buffer *buffer, size_t at) sldns_buffer_remaining_at(sldns_buffer *buffer, size_t at)
{ {
ldns_buffer_invariant(buffer); sldns_buffer_invariant(buffer);
assert(at <= buffer->_limit); assert(at <= buffer->_limit);
return buffer->_limit - at; return buffer->_limit - at;
} }
@ -378,9 +378,9 @@ ldns_buffer_remaining_at(ldns_buffer *buffer, size_t at)
* \return the number of bytes * \return the number of bytes
*/ */
INLINE size_t INLINE size_t
ldns_buffer_remaining(ldns_buffer *buffer) sldns_buffer_remaining(sldns_buffer *buffer)
{ {
return ldns_buffer_remaining_at(buffer, buffer->_position); return sldns_buffer_remaining_at(buffer, buffer->_position);
} }
/** /**
@ -393,9 +393,9 @@ ldns_buffer_remaining(ldns_buffer *buffer)
* \return true or false (as int?) * \return true or false (as int?)
*/ */
INLINE int INLINE int
ldns_buffer_available_at(ldns_buffer *buffer, size_t at, size_t count) sldns_buffer_available_at(sldns_buffer *buffer, size_t at, size_t count)
{ {
return count <= ldns_buffer_remaining_at(buffer, at); return count <= sldns_buffer_remaining_at(buffer, at);
} }
/** /**
@ -405,9 +405,9 @@ ldns_buffer_available_at(ldns_buffer *buffer, size_t at, size_t count)
* \return true or false (as int?) * \return true or false (as int?)
*/ */
INLINE int INLINE int
ldns_buffer_available(ldns_buffer *buffer, size_t count) sldns_buffer_available(sldns_buffer *buffer, size_t count)
{ {
return ldns_buffer_available_at(buffer, buffer->_position, count); return sldns_buffer_available_at(buffer, buffer->_position, count);
} }
/** /**
@ -418,9 +418,9 @@ ldns_buffer_available(ldns_buffer *buffer, size_t count)
* \param[in] count the number of bytes of data to write * \param[in] count the number of bytes of data to write
*/ */
INLINE void INLINE void
ldns_buffer_write_at(ldns_buffer *buffer, size_t at, const void *data, size_t count) sldns_buffer_write_at(sldns_buffer *buffer, size_t at, const void *data, size_t count)
{ {
assert(ldns_buffer_available_at(buffer, at, count)); assert(sldns_buffer_available_at(buffer, at, count));
memcpy(buffer->_data + at, data, count); memcpy(buffer->_data + at, data, count);
} }
@ -431,9 +431,9 @@ ldns_buffer_write_at(ldns_buffer *buffer, size_t at, const void *data, size_t co
* \param[in] count the lenght of the data to write * \param[in] count the lenght of the data to write
*/ */
INLINE void INLINE void
ldns_buffer_write(ldns_buffer *buffer, const void *data, size_t count) sldns_buffer_write(sldns_buffer *buffer, const void *data, size_t count)
{ {
ldns_buffer_write_at(buffer, buffer->_position, data, count); sldns_buffer_write_at(buffer, buffer->_position, data, count);
buffer->_position += count; buffer->_position += count;
} }
@ -444,9 +444,9 @@ ldns_buffer_write(ldns_buffer *buffer, const void *data, size_t count)
* \param[in] str the string to write * \param[in] str the string to write
*/ */
INLINE void INLINE void
ldns_buffer_write_string_at(ldns_buffer *buffer, size_t at, const char *str) sldns_buffer_write_string_at(sldns_buffer *buffer, size_t at, const char *str)
{ {
ldns_buffer_write_at(buffer, at, str, strlen(str)); sldns_buffer_write_at(buffer, at, str, strlen(str));
} }
/** /**
@ -455,9 +455,9 @@ ldns_buffer_write_string_at(ldns_buffer *buffer, size_t at, const char *str)
* \param[in] str the string to write * \param[in] str the string to write
*/ */
INLINE void INLINE void
ldns_buffer_write_string(ldns_buffer *buffer, const char *str) sldns_buffer_write_string(sldns_buffer *buffer, const char *str)
{ {
ldns_buffer_write(buffer, str, strlen(str)); sldns_buffer_write(buffer, str, strlen(str));
} }
/** /**
@ -467,9 +467,9 @@ ldns_buffer_write_string(ldns_buffer *buffer, const char *str)
* \param[in] data the 8 bits to write * \param[in] data the 8 bits to write
*/ */
INLINE void INLINE void
ldns_buffer_write_u8_at(ldns_buffer *buffer, size_t at, uint8_t data) sldns_buffer_write_u8_at(sldns_buffer *buffer, size_t at, uint8_t data)
{ {
assert(ldns_buffer_available_at(buffer, at, sizeof(data))); assert(sldns_buffer_available_at(buffer, at, sizeof(data)));
buffer->_data[at] = data; buffer->_data[at] = data;
} }
@ -479,9 +479,9 @@ ldns_buffer_write_u8_at(ldns_buffer *buffer, size_t at, uint8_t data)
* \param[in] data the 8 bits to write * \param[in] data the 8 bits to write
*/ */
INLINE void INLINE void
ldns_buffer_write_u8(ldns_buffer *buffer, uint8_t data) sldns_buffer_write_u8(sldns_buffer *buffer, uint8_t data)
{ {
ldns_buffer_write_u8_at(buffer, buffer->_position, data); sldns_buffer_write_u8_at(buffer, buffer->_position, data);
buffer->_position += sizeof(data); buffer->_position += sizeof(data);
} }
@ -492,10 +492,10 @@ ldns_buffer_write_u8(ldns_buffer *buffer, uint8_t data)
* \param[in] data the 16 bits to write * \param[in] data the 16 bits to write
*/ */
INLINE void INLINE void
ldns_buffer_write_u16_at(ldns_buffer *buffer, size_t at, uint16_t data) sldns_buffer_write_u16_at(sldns_buffer *buffer, size_t at, uint16_t data)
{ {
assert(ldns_buffer_available_at(buffer, at, sizeof(data))); assert(sldns_buffer_available_at(buffer, at, sizeof(data)));
ldns_write_uint16(buffer->_data + at, data); sldns_write_uint16(buffer->_data + at, data);
} }
/** /**
@ -504,9 +504,9 @@ ldns_buffer_write_u16_at(ldns_buffer *buffer, size_t at, uint16_t data)
* \param[in] data the 16 bits to write * \param[in] data the 16 bits to write
*/ */
INLINE void INLINE void
ldns_buffer_write_u16(ldns_buffer *buffer, uint16_t data) sldns_buffer_write_u16(sldns_buffer *buffer, uint16_t data)
{ {
ldns_buffer_write_u16_at(buffer, buffer->_position, data); sldns_buffer_write_u16_at(buffer, buffer->_position, data);
buffer->_position += sizeof(data); buffer->_position += sizeof(data);
} }
@ -517,10 +517,10 @@ ldns_buffer_write_u16(ldns_buffer *buffer, uint16_t data)
* \param[in] data the 32 bits to write * \param[in] data the 32 bits to write
*/ */
INLINE void INLINE void
ldns_buffer_write_u32_at(ldns_buffer *buffer, size_t at, uint32_t data) sldns_buffer_write_u32_at(sldns_buffer *buffer, size_t at, uint32_t data)
{ {
assert(ldns_buffer_available_at(buffer, at, sizeof(data))); assert(sldns_buffer_available_at(buffer, at, sizeof(data)));
ldns_write_uint32(buffer->_data + at, data); sldns_write_uint32(buffer->_data + at, data);
} }
/** /**
@ -529,9 +529,9 @@ ldns_buffer_write_u32_at(ldns_buffer *buffer, size_t at, uint32_t data)
* \param[in] data the 32 bits to write * \param[in] data the 32 bits to write
*/ */
INLINE void INLINE void
ldns_buffer_write_u32(ldns_buffer *buffer, uint32_t data) sldns_buffer_write_u32(sldns_buffer *buffer, uint32_t data)
{ {
ldns_buffer_write_u32_at(buffer, buffer->_position, data); sldns_buffer_write_u32_at(buffer, buffer->_position, data);
buffer->_position += sizeof(data); buffer->_position += sizeof(data);
} }
@ -543,9 +543,9 @@ ldns_buffer_write_u32(ldns_buffer *buffer, uint32_t data)
* \param[in] count the length of the data to copy * \param[in] count the length of the data to copy
*/ */
INLINE void INLINE void
ldns_buffer_read_at(ldns_buffer *buffer, size_t at, void *data, size_t count) sldns_buffer_read_at(sldns_buffer *buffer, size_t at, void *data, size_t count)
{ {
assert(ldns_buffer_available_at(buffer, at, count)); assert(sldns_buffer_available_at(buffer, at, count));
memcpy(data, buffer->_data + at, count); memcpy(data, buffer->_data + at, count);
} }
@ -556,9 +556,9 @@ ldns_buffer_read_at(ldns_buffer *buffer, size_t at, void *data, size_t count)
* \param[in] count the length of the data to copy * \param[in] count the length of the data to copy
*/ */
INLINE void INLINE void
ldns_buffer_read(ldns_buffer *buffer, void *data, size_t count) sldns_buffer_read(sldns_buffer *buffer, void *data, size_t count)
{ {
ldns_buffer_read_at(buffer, buffer->_position, data, count); sldns_buffer_read_at(buffer, buffer->_position, data, count);
buffer->_position += count; buffer->_position += count;
} }
@ -569,9 +569,9 @@ ldns_buffer_read(ldns_buffer *buffer, void *data, size_t count)
* \return 1 byte integer * \return 1 byte integer
*/ */
INLINE uint8_t INLINE uint8_t
ldns_buffer_read_u8_at(ldns_buffer *buffer, size_t at) sldns_buffer_read_u8_at(sldns_buffer *buffer, size_t at)
{ {
assert(ldns_buffer_available_at(buffer, at, sizeof(uint8_t))); assert(sldns_buffer_available_at(buffer, at, sizeof(uint8_t)));
return buffer->_data[at]; return buffer->_data[at];
} }
@ -581,9 +581,9 @@ ldns_buffer_read_u8_at(ldns_buffer *buffer, size_t at)
* \return 1 byte integer * \return 1 byte integer
*/ */
INLINE uint8_t INLINE uint8_t
ldns_buffer_read_u8(ldns_buffer *buffer) sldns_buffer_read_u8(sldns_buffer *buffer)
{ {
uint8_t result = ldns_buffer_read_u8_at(buffer, buffer->_position); uint8_t result = sldns_buffer_read_u8_at(buffer, buffer->_position);
buffer->_position += sizeof(uint8_t); buffer->_position += sizeof(uint8_t);
return result; return result;
} }
@ -595,10 +595,10 @@ ldns_buffer_read_u8(ldns_buffer *buffer)
* \return 2 byte integer * \return 2 byte integer
*/ */
INLINE uint16_t INLINE uint16_t
ldns_buffer_read_u16_at(ldns_buffer *buffer, size_t at) sldns_buffer_read_u16_at(sldns_buffer *buffer, size_t at)
{ {
assert(ldns_buffer_available_at(buffer, at, sizeof(uint16_t))); assert(sldns_buffer_available_at(buffer, at, sizeof(uint16_t)));
return ldns_read_uint16(buffer->_data + at); return sldns_read_uint16(buffer->_data + at);
} }
/** /**
@ -607,9 +607,9 @@ ldns_buffer_read_u16_at(ldns_buffer *buffer, size_t at)
* \return 2 byte integer * \return 2 byte integer
*/ */
INLINE uint16_t INLINE uint16_t
ldns_buffer_read_u16(ldns_buffer *buffer) sldns_buffer_read_u16(sldns_buffer *buffer)
{ {
uint16_t result = ldns_buffer_read_u16_at(buffer, buffer->_position); uint16_t result = sldns_buffer_read_u16_at(buffer, buffer->_position);
buffer->_position += sizeof(uint16_t); buffer->_position += sizeof(uint16_t);
return result; return result;
} }
@ -621,10 +621,10 @@ ldns_buffer_read_u16(ldns_buffer *buffer)
* \return 4 byte integer * \return 4 byte integer
*/ */
INLINE uint32_t INLINE uint32_t
ldns_buffer_read_u32_at(ldns_buffer *buffer, size_t at) sldns_buffer_read_u32_at(sldns_buffer *buffer, size_t at)
{ {
assert(ldns_buffer_available_at(buffer, at, sizeof(uint32_t))); assert(sldns_buffer_available_at(buffer, at, sizeof(uint32_t)));
return ldns_read_uint32(buffer->_data + at); return sldns_read_uint32(buffer->_data + at);
} }
/** /**
@ -633,9 +633,9 @@ ldns_buffer_read_u32_at(ldns_buffer *buffer, size_t at)
* \return 4 byte integer * \return 4 byte integer
*/ */
INLINE uint32_t INLINE uint32_t
ldns_buffer_read_u32(ldns_buffer *buffer) sldns_buffer_read_u32(sldns_buffer *buffer)
{ {
uint32_t result = ldns_buffer_read_u32_at(buffer, buffer->_position); uint32_t result = sldns_buffer_read_u32_at(buffer, buffer->_position);
buffer->_position += sizeof(uint32_t); buffer->_position += sizeof(uint32_t);
return result; return result;
} }
@ -646,7 +646,7 @@ ldns_buffer_read_u32(ldns_buffer *buffer)
* \return the status * \return the status
*/ */
INLINE int INLINE int
ldns_buffer_status(ldns_buffer *buffer) sldns_buffer_status(sldns_buffer *buffer)
{ {
return (int)buffer->_status_err; return (int)buffer->_status_err;
} }
@ -657,10 +657,10 @@ ldns_buffer_status(ldns_buffer *buffer)
* \return true or false * \return true or false
*/ */
INLINE int INLINE int
ldns_buffer_status_ok(ldns_buffer *buffer) sldns_buffer_status_ok(sldns_buffer *buffer)
{ {
if (buffer) { if (buffer) {
return ldns_buffer_status(buffer) == 0; return sldns_buffer_status(buffer) == 0;
} else { } else {
return 0; return 0;
} }
@ -672,7 +672,7 @@ ldns_buffer_status_ok(ldns_buffer *buffer)
* Returns the number of characters written (not including the * Returns the number of characters written (not including the
* terminating '\\0') or -1 on failure. * terminating '\\0') or -1 on failure.
*/ */
int ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...) int sldns_buffer_printf(sldns_buffer *buffer, const char *format, ...)
ATTR_FORMAT(printf, 2, 3); ATTR_FORMAT(printf, 2, 3);
/** /**
@ -680,7 +680,7 @@ int ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...)
* \param[in] *buffer the buffer to be freed * \param[in] *buffer the buffer to be freed
* \return void * \return void
*/ */
void ldns_buffer_free(ldns_buffer *buffer); void sldns_buffer_free(sldns_buffer *buffer);
/** /**
* Makes the buffer fixed and returns a pointer to the data. The * Makes the buffer fixed and returns a pointer to the data. The
@ -688,7 +688,7 @@ void ldns_buffer_free(ldns_buffer *buffer);
* \param[in] *buffer the buffer to be exported * \param[in] *buffer the buffer to be exported
* \return void * \return void
*/ */
void *ldns_buffer_export(ldns_buffer *buffer); void *sldns_buffer_export(sldns_buffer *buffer);
/** /**
* Copy contents of the from buffer to the result buffer and then flips * Copy contents of the from buffer to the result buffer and then flips
@ -697,7 +697,7 @@ void *ldns_buffer_export(ldns_buffer *buffer);
* \param[out] *result resulting buffer which is copied to. * \param[out] *result resulting buffer which is copied to.
* \param[in] *from what to copy to result. * \param[in] *from what to copy to result.
*/ */
void ldns_buffer_copy(ldns_buffer* result, ldns_buffer* from); void sldns_buffer_copy(sldns_buffer* result, sldns_buffer* from);
#ifdef __cplusplus #ifdef __cplusplus
} }

492
ldns/str2wire.c
View file

File diff suppressed because it is too large Load diff

110
ldns/str2wire.h
View file

@ -21,7 +21,7 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct ldns_struct_lookup_table; struct sldns_struct_lookup_table;
/** buffer to read an RR, cannot be larger than 64K because of packet size */ /** buffer to read an RR, cannot be larger than 64K because of packet size */
#define LDNS_RR_BUF_SIZE 65535 /* bytes */ #define LDNS_RR_BUF_SIZE 65535 /* bytes */
@ -29,8 +29,8 @@ struct ldns_struct_lookup_table;
/* /*
* To convert class and type to string see * To convert class and type to string see
* ldns_get_rr_class_by_name(str) * sldns_get_rr_class_by_name(str)
* ldns_get_rr_type_by_name(str) * sldns_get_rr_type_by_name(str)
* from rrdef.h * from rrdef.h
*/ */
@ -41,10 +41,10 @@ struct ldns_struct_lookup_table;
* @param len: length of the buffer on input, length of the result on output. * @param len: length of the buffer on input, length of the result on output.
* @return 0 on success, otherwise an error. * @return 0 on success, otherwise an error.
*/ */
int ldns_str2wire_dname_buf(const char* str, uint8_t* buf, size_t* len); int sldns_str2wire_dname_buf(const char* str, uint8_t* buf, size_t* len);
/** /**
* Same as ldns_str2wire_dname_buf, but concatenates origin if the domain * Same as sldns_str2wire_dname_buf, but concatenates origin if the domain
* name is relative (does not end in '.'). * name is relative (does not end in '.').
* @param str: the text string with the domain name. * @param str: the text string with the domain name.
* @param buf: the result buffer, suggested size LDNS_MAX_DOMAINLEN+1 * @param buf: the result buffer, suggested size LDNS_MAX_DOMAINLEN+1
@ -53,7 +53,7 @@ int ldns_str2wire_dname_buf(const char* str, uint8_t* buf, size_t* len);
* @param origin_len: length of origin. * @param origin_len: length of origin.
* @return 0 on success, otherwise an error. * @return 0 on success, otherwise an error.
*/ */
int ldns_str2wire_dname_buf_origin(const char* str, uint8_t* buf, size_t* len, int sldns_str2wire_dname_buf_origin(const char* str, uint8_t* buf, size_t* len,
uint8_t* origin, size_t origin_len); uint8_t* origin, size_t origin_len);
/** /**
@ -62,7 +62,7 @@ int ldns_str2wire_dname_buf_origin(const char* str, uint8_t* buf, size_t* len,
* @param len: returned length of wireformat. * @param len: returned length of wireformat.
* @return wireformat dname (malloced) or NULL on failure. * @return wireformat dname (malloced) or NULL on failure.
*/ */
uint8_t* ldns_str2wire_dname(const char* str, size_t* len); uint8_t* sldns_str2wire_dname(const char* str, size_t* len);
/** /**
* Convert text RR to wireformat, with user buffer. * Convert text RR to wireformat, with user buffer.
@ -70,7 +70,7 @@ uint8_t* ldns_str2wire_dname(const char* str, size_t* len);
* @param rr: the buffer where the result is stored into. This buffer has * @param rr: the buffer where the result is stored into. This buffer has
* the wire-dname(uncompressed), type, class, ttl, rdatalen, rdata. * the wire-dname(uncompressed), type, class, ttl, rdatalen, rdata.
* These values are probably not aligned, and in network format. * These values are probably not aligned, and in network format.
* Use the ldns_wirerr_get_xxx functions to access them safely. * Use the sldns_wirerr_get_xxx functions to access them safely.
* buffer size LDNS_RR_BUF_SIZE is suggested. * buffer size LDNS_RR_BUF_SIZE is suggested.
* @param len: on input the length of the buffer, on output the amount of * @param len: on input the length of the buffer, on output the amount of
* the buffer used for the rr. * the buffer used for the rr.
@ -83,14 +83,14 @@ uint8_t* ldns_str2wire_dname(const char* str, size_t* len);
* @param prev_len: length of prev. * @param prev_len: length of prev.
* @return 0 on success, an error on failure. * @return 0 on success, an error on failure.
*/ */
int ldns_str2wire_rr_buf(const char* str, uint8_t* rr, size_t* len, int sldns_str2wire_rr_buf(const char* str, uint8_t* rr, size_t* len,
size_t* dname_len, uint32_t default_ttl, uint8_t* origin, size_t* dname_len, uint32_t default_ttl, uint8_t* origin,
size_t origin_len, uint8_t* prev, size_t prev_len); size_t origin_len, uint8_t* prev, size_t prev_len);
/** /**
* Same as ldns_str2wire_rr_buf, but there is no rdata, it returns an RR * Same as sldns_str2wire_rr_buf, but there is no rdata, it returns an RR
* with zero rdata and no ttl. It has name, type, class. * with zero rdata and no ttl. It has name, type, class.
* You can access those with the ldns_wirerr_get_type and class functions. * You can access those with the sldns_wirerr_get_type and class functions.
* @param str: the RR data in text presentation format. * @param str: the RR data in text presentation format.
* @param rr: the buffer where the result is stored into. * @param rr: the buffer where the result is stored into.
* @param len: on input the length of the buffer, on output the amount of * @param len: on input the length of the buffer, on output the amount of
@ -103,7 +103,7 @@ int ldns_str2wire_rr_buf(const char* str, uint8_t* rr, size_t* len,
* @param prev_len: length of prev. * @param prev_len: length of prev.
* @return 0 on success, an error on failure. * @return 0 on success, an error on failure.
*/ */
int ldns_str2wire_rr_question_buf(const char* str, uint8_t* rr, size_t* len, int sldns_str2wire_rr_question_buf(const char* str, uint8_t* rr, size_t* len,
size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev, size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev,
size_t prev_len); size_t prev_len);
@ -114,7 +114,7 @@ int ldns_str2wire_rr_question_buf(const char* str, uint8_t* rr, size_t* len,
* @param dname_len: dname length to skip. * @param dname_len: dname length to skip.
* @return type in host byteorder * @return type in host byteorder
*/ */
uint16_t ldns_wirerr_get_type(uint8_t* rr, size_t len, size_t dname_len); uint16_t sldns_wirerr_get_type(uint8_t* rr, size_t len, size_t dname_len);
/** /**
* Get the class of the RR. * Get the class of the RR.
@ -123,7 +123,7 @@ uint16_t ldns_wirerr_get_type(uint8_t* rr, size_t len, size_t dname_len);
* @param dname_len: dname length to skip. * @param dname_len: dname length to skip.
* @return class in host byteorder * @return class in host byteorder
*/ */
uint16_t ldns_wirerr_get_class(uint8_t* rr, size_t len, size_t dname_len); uint16_t sldns_wirerr_get_class(uint8_t* rr, size_t len, size_t dname_len);
/** /**
* Get the ttl of the RR. * Get the ttl of the RR.
@ -132,7 +132,7 @@ uint16_t ldns_wirerr_get_class(uint8_t* rr, size_t len, size_t dname_len);
* @param dname_len: dname length to skip. * @param dname_len: dname length to skip.
* @return ttl in host byteorder * @return ttl in host byteorder
*/ */
uint32_t ldns_wirerr_get_ttl(uint8_t* rr, size_t len, size_t dname_len); uint32_t sldns_wirerr_get_ttl(uint8_t* rr, size_t len, size_t dname_len);
/** /**
* Get the rdata length of the RR. * Get the rdata length of the RR.
@ -142,9 +142,9 @@ uint32_t ldns_wirerr_get_ttl(uint8_t* rr, size_t len, size_t dname_len);
* @return rdata length in host byteorder * @return rdata length in host byteorder
* If the rdata length is larger than the rr-len allows, it is truncated. * If the rdata length is larger than the rr-len allows, it is truncated.
* So, that it is safe to read the data length returned * So, that it is safe to read the data length returned
* from this function from the rdata pointer of ldns_wirerr_get_rdata. * from this function from the rdata pointer of sldns_wirerr_get_rdata.
*/ */
uint16_t ldns_wirerr_get_rdatalen(uint8_t* rr, size_t len, size_t dname_len); uint16_t sldns_wirerr_get_rdatalen(uint8_t* rr, size_t len, size_t dname_len);
/** /**
* Get the rdata pointer of the RR. * Get the rdata pointer of the RR.
@ -153,7 +153,7 @@ uint16_t ldns_wirerr_get_rdatalen(uint8_t* rr, size_t len, size_t dname_len);
* @param dname_len: dname length to skip. * @param dname_len: dname length to skip.
* @return rdata pointer * @return rdata pointer
*/ */
uint8_t* ldns_wirerr_get_rdata(uint8_t* rr, size_t len, size_t dname_len); uint8_t* sldns_wirerr_get_rdata(uint8_t* rr, size_t len, size_t dname_len);
/** /**
* Get the rdata pointer of the RR. prefixed with rdata length. * Get the rdata pointer of the RR. prefixed with rdata length.
@ -162,7 +162,7 @@ uint8_t* ldns_wirerr_get_rdata(uint8_t* rr, size_t len, size_t dname_len);
* @param dname_len: dname length to skip. * @param dname_len: dname length to skip.
* @return pointer to rdatalength, followed by the rdata. * @return pointer to rdatalength, followed by the rdata.
*/ */
uint8_t* ldns_wirerr_get_rdatawl(uint8_t* rr, size_t len, size_t dname_len); uint8_t* sldns_wirerr_get_rdatawl(uint8_t* rr, size_t len, size_t dname_len);
/** /**
* Parse result codes * Parse result codes
@ -171,7 +171,7 @@ uint8_t* ldns_wirerr_get_rdatawl(uint8_t* rr, size_t len, size_t dname_len);
#define LDNS_WIREPARSE_SHIFT 12 #define LDNS_WIREPARSE_SHIFT 12
#define LDNS_WIREPARSE_ERROR(e) ((e)&LDNS_WIREPARSE_MASK) #define LDNS_WIREPARSE_ERROR(e) ((e)&LDNS_WIREPARSE_MASK)
#define LDNS_WIREPARSE_OFFSET(e) (((e)&~LDNS_WIREPARSE_MASK)>>LDNS_WIREPARSE_SHIFT) #define LDNS_WIREPARSE_OFFSET(e) (((e)&~LDNS_WIREPARSE_MASK)>>LDNS_WIREPARSE_SHIFT)
/* use lookuptable to get error string, ldns_wireparse_errors */ /* use lookuptable to get error string, sldns_wireparse_errors */
#define LDNS_WIREPARSE_ERR_OK 0 #define LDNS_WIREPARSE_ERR_OK 0
#define LDNS_WIREPARSE_ERR_GENERAL 342 #define LDNS_WIREPARSE_ERR_GENERAL 342
#define LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW 343 #define LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW 343
@ -210,12 +210,12 @@ uint8_t* ldns_wirerr_get_rdatawl(uint8_t* rr, size_t len, size_t dname_len);
* @param e: error return value * @param e: error return value
* @return string. * @return string.
*/ */
const char* ldns_get_errorstr_parse(int e); const char* sldns_get_errorstr_parse(int e);
/** /**
* wire parse state for parsing files * wire parse state for parsing files
*/ */
struct ldns_file_parse_state { struct sldns_file_parse_state {
/** the origin domain name, if len!=0. uncompressed wireformat */ /** the origin domain name, if len!=0. uncompressed wireformat */
uint8_t origin[LDNS_MAX_DOMAINLEN+1]; uint8_t origin[LDNS_MAX_DOMAINLEN+1];
/** length of origin domain name, in bytes. 0 if not set. */ /** length of origin domain name, in bytes. 0 if not set. */
@ -249,8 +249,8 @@ struct ldns_file_parse_state {
* you should initialize it at 1 at the start of the file. * you should initialize it at 1 at the start of the file.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len, int sldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len,
struct ldns_file_parse_state* parse_state); struct sldns_file_parse_state* parse_state);
/** /**
* Convert one rdf in rdata to wireformat and parse from string. * Convert one rdf in rdata to wireformat and parse from string.
@ -260,8 +260,8 @@ int ldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len,
* @param rdftype: the type of the rdf. * @param rdftype: the type of the rdf.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len, int sldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len,
ldns_rdf_type rdftype); sldns_rdf_type rdftype);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_INT8 from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_INT8 from string to wireformat.
@ -270,7 +270,7 @@ int ldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len,
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_int8_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_int8_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_INT16 from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_INT16 from string to wireformat.
@ -279,7 +279,7 @@ int ldns_str2wire_int8_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_int16_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_int16_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_INT32 from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_INT32 from string to wireformat.
@ -288,7 +288,7 @@ int ldns_str2wire_int16_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_int32_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_int32_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_A from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_A from string to wireformat.
@ -297,7 +297,7 @@ int ldns_str2wire_int32_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_a_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_a_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_AAAA from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_AAAA from string to wireformat.
@ -306,7 +306,7 @@ int ldns_str2wire_a_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_aaaa_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_aaaa_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_STR from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_STR from string to wireformat.
@ -315,7 +315,7 @@ int ldns_str2wire_aaaa_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_str_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_str_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_APL from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_APL from string to wireformat.
@ -324,7 +324,7 @@ int ldns_str2wire_str_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_apl_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_apl_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_B64 from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_B64 from string to wireformat.
@ -333,7 +333,7 @@ int ldns_str2wire_apl_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_b64_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_b64_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_B32_EXT from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_B32_EXT from string to wireformat.
@ -343,7 +343,7 @@ int ldns_str2wire_b64_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_b32_ext_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_b32_ext_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_HEX from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_HEX from string to wireformat.
@ -352,7 +352,7 @@ int ldns_str2wire_b32_ext_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_hex_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_hex_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_NSEC from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_NSEC from string to wireformat.
@ -361,7 +361,7 @@ int ldns_str2wire_hex_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_nsec_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_nsec_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_TYPE from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_TYPE from string to wireformat.
@ -370,7 +370,7 @@ int ldns_str2wire_nsec_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_type_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_type_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_CLASS from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_CLASS from string to wireformat.
@ -379,7 +379,7 @@ int ldns_str2wire_type_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_class_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_class_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_CERT_ALG from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_CERT_ALG from string to wireformat.
@ -388,7 +388,7 @@ int ldns_str2wire_class_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_ALG from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_ALG from string to wireformat.
@ -397,7 +397,7 @@ int ldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_alg_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_alg_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_TIME from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_TIME from string to wireformat.
@ -406,7 +406,7 @@ int ldns_str2wire_alg_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_time_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_time_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_PERIOD from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_PERIOD from string to wireformat.
@ -415,7 +415,7 @@ int ldns_str2wire_time_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_period_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_period_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_LOC from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_LOC from string to wireformat.
@ -424,7 +424,7 @@ int ldns_str2wire_period_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_loc_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_loc_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_WKS from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_WKS from string to wireformat.
@ -433,7 +433,7 @@ int ldns_str2wire_loc_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_wks_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_wks_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_NSAP from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_NSAP from string to wireformat.
@ -442,7 +442,7 @@ int ldns_str2wire_wks_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_nsap_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_nsap_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_ATMA from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_ATMA from string to wireformat.
@ -451,7 +451,7 @@ int ldns_str2wire_nsap_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_atma_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_atma_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_IPSECKEY from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_IPSECKEY from string to wireformat.
@ -460,7 +460,7 @@ int ldns_str2wire_atma_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_ipseckey_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_ipseckey_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_NSEC3_SALT from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_NSEC3_SALT from string to wireformat.
@ -469,7 +469,7 @@ int ldns_str2wire_ipseckey_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_nsec3_salt_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_nsec3_salt_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_ILNP64 from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_ILNP64 from string to wireformat.
@ -478,7 +478,7 @@ int ldns_str2wire_nsec3_salt_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_ilnp64_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_ilnp64_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_EUI48 from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_EUI48 from string to wireformat.
@ -487,7 +487,7 @@ int ldns_str2wire_ilnp64_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_eui48_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_eui48_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_EUI64 from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_EUI64 from string to wireformat.
@ -496,7 +496,7 @@ int ldns_str2wire_eui48_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_eui64_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_eui64_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_TAG from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_TAG from string to wireformat.
@ -505,7 +505,7 @@ int ldns_str2wire_eui64_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_tag_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_tag_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_LONG_STR from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_LONG_STR from string to wireformat.
@ -514,7 +514,7 @@ int ldns_str2wire_tag_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_long_str_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_long_str_buf(const char* str, uint8_t* rd, size_t* len);
/** /**
* Convert rdf of type LDNS_RDF_TYPE_INT16_DATA from string to wireformat. * Convert rdf of type LDNS_RDF_TYPE_INT16_DATA from string to wireformat.
@ -523,7 +523,7 @@ int ldns_str2wire_long_str_buf(const char* str, uint8_t* rd, size_t* len);
* @param len: length of rd buffer on input, used length on output. * @param len: length of rd buffer on input, used length on output.
* @return 0 on success, error on failure. * @return 0 on success, error on failure.
*/ */
int ldns_str2wire_int16_data_buf(const char* str, uint8_t* rd, size_t* len); int sldns_str2wire_int16_data_buf(const char* str, uint8_t* rd, size_t* len);
#ifdef __cplusplus #ifdef __cplusplus
} }

896
ldns/wire2str.c
View file

File diff suppressed because it is too large Load diff

260
ldns/wire2str.h
View file

@ -19,33 +19,25 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct ldns_struct_lookup_table; struct sldns_struct_lookup_table;
#ifndef SLDNS
# ifdef USE_SLDNS
# define SLDNS(x) sldns##x
# else
# define SLDNS(x) ldns##x
# endif
#endif
/* lookup tables for standard DNS stuff */ /* lookup tables for standard DNS stuff */
/** Taken from RFC 2535, section 7. */ /** Taken from RFC 2535, section 7. */
extern struct ldns_struct_lookup_table* SLDNS(_algorithms); extern struct sldns_struct_lookup_table* sldns_algorithms;
/** DS record hash algorithms */ /** DS record hash algorithms */
extern struct ldns_struct_lookup_table* SLDNS(_hashes); extern struct sldns_struct_lookup_table* sldns_hashes;
/** Taken from RFC 2538, section 2.1. */ /** Taken from RFC 2538, section 2.1. */
extern struct ldns_struct_lookup_table* SLDNS(_cert_algorithms); extern struct sldns_struct_lookup_table* sldns_cert_algorithms;
/** Response codes */ /** Response codes */
extern struct ldns_struct_lookup_table* SLDNS(_rcodes); extern struct sldns_struct_lookup_table* sldns_rcodes;
/** Operation codes */ /** Operation codes */
extern struct ldns_struct_lookup_table* SLDNS(_opcodes); extern struct sldns_struct_lookup_table* sldns_opcodes;
/** EDNS flags */ /** EDNS flags */
extern struct ldns_struct_lookup_table* SLDNS(_edns_flags); extern struct sldns_struct_lookup_table* sldns_edns_flags;
/** EDNS option codes */ /** EDNS option codes */
extern struct ldns_struct_lookup_table* SLDNS(_edns_options); extern struct sldns_struct_lookup_table* sldns_edns_options;
/** error string from wireparse */ /** error string from wireparse */
extern struct ldns_struct_lookup_table* SLDNS(_wireparse_errors); extern struct sldns_struct_lookup_table* sldns_wireparse_errors;
/** /**
* Convert wireformat packet to a string representation * Convert wireformat packet to a string representation
@ -53,7 +45,7 @@ extern struct ldns_struct_lookup_table* SLDNS(_wireparse_errors);
* @param len: length of packet. * @param len: length of packet.
* @return string(malloced) or NULL on failure. * @return string(malloced) or NULL on failure.
*/ */
char* ldns_wire2str_pkt(uint8_t* data, size_t len); char* sldns_wire2str_pkt(uint8_t* data, size_t len);
/** /**
* Convert wireformat RR to a string representation. * Convert wireformat RR to a string representation.
@ -62,7 +54,7 @@ char* ldns_wire2str_pkt(uint8_t* data, size_t len);
* @param len: length of the rr wireformat. * @param len: length of the rr wireformat.
* @return string(malloced) or NULL on failure. * @return string(malloced) or NULL on failure.
*/ */
char* ldns_wire2str_rr(uint8_t* rr, size_t len); char* sldns_wire2str_rr(uint8_t* rr, size_t len);
/** /**
* Conver wire dname to a string. * Conver wire dname to a string.
@ -70,28 +62,28 @@ char* ldns_wire2str_rr(uint8_t* rr, size_t len);
* @param dname_len: length of the dname. * @param dname_len: length of the dname.
* @return string or NULL on failure. * @return string or NULL on failure.
*/ */
char* ldns_wire2str_dname(uint8_t* dname, size_t dname_len); char* sldns_wire2str_dname(uint8_t* dname, size_t dname_len);
/** /**
* Convert wire RR type to a string, 'MX', 'TYPE1234'... * Convert wire RR type to a string, 'MX', 'TYPE1234'...
* @param rrtype: the RR type in host order. * @param rrtype: the RR type in host order.
* @return malloced string with the RR type or NULL on malloc failure. * @return malloced string with the RR type or NULL on malloc failure.
*/ */
char* ldns_wire2str_type(uint16_t rrtype); char* sldns_wire2str_type(uint16_t rrtype);
/** /**
* Convert wire RR class to a string, 'IN', 'CLASS1'. * Convert wire RR class to a string, 'IN', 'CLASS1'.
* @param rrclass: the RR class in host order. * @param rrclass: the RR class in host order.
* @return malloced string with the RR class or NULL on malloc failure. * @return malloced string with the RR class or NULL on malloc failure.
*/ */
char* ldns_wire2str_class(uint16_t rrclass); char* sldns_wire2str_class(uint16_t rrclass);
/** /**
* Convert wire packet rcode to a string, 'NOERROR', 'NXDOMAIN'... * Convert wire packet rcode to a string, 'NOERROR', 'NXDOMAIN'...
* @param rcode: as integer, host order * @param rcode: as integer, host order
* @return malloced string with the rcode or NULL on malloc failure. * @return malloced string with the rcode or NULL on malloc failure.
*/ */
char* ldns_wire2str_rcode(int rcode); char* sldns_wire2str_rcode(int rcode);
/** /**
* Print to string, move string along for next content. With va_list. * Print to string, move string along for next content. With va_list.
@ -101,7 +93,7 @@ char* ldns_wire2str_rcode(int rcode);
* @param args: arguments for printf. * @param args: arguments for printf.
* @return number of characters needed. Can be larger than slen. * @return number of characters needed. Can be larger than slen.
*/ */
int ldns_str_vprint(char** str, size_t* slen, const char* format, va_list args); int sldns_str_vprint(char** str, size_t* slen, const char* format, va_list args);
/** /**
* Print to string, move string along for next content. * Print to string, move string along for next content.
@ -110,7 +102,7 @@ int ldns_str_vprint(char** str, size_t* slen, const char* format, va_list args);
* @param format: printf format string and arguments for it. * @param format: printf format string and arguments for it.
* @return number of characters needed. Can be larger than slen. * @return number of characters needed. Can be larger than slen.
*/ */
int ldns_str_print(char** str, size_t* slen, const char* format, ...) int sldns_str_print(char** str, size_t* slen, const char* format, ...)
ATTR_FORMAT(printf, 3, 4); ATTR_FORMAT(printf, 3, 4);
/** /**
@ -128,7 +120,7 @@ int ldns_str_print(char** str, size_t* slen, const char* format, ...)
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_pkt_buf(uint8_t* data, size_t data_len, char* str, int sldns_wire2str_pkt_buf(uint8_t* data, size_t data_len, char* str,
size_t str_len); size_t str_len);
/** /**
@ -150,12 +142,12 @@ int ldns_wire2str_pkt_buf(uint8_t* data, size_t data_len, char* str,
* terminated (shortening the output if necessary). If the end of the input * terminated (shortening the output if necessary). If the end of the input
* is reached *data_len is set to 0. * is reached *data_len is set to 0.
*/ */
int ldns_wire2str_pkt_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_pkt_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat rr to string, with user buffers. It shifts the arguments * Scan wireformat rr to string, with user buffers. It shifts the arguments
* to move along (see ldns_wire2str_pkt_scan). * to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -164,12 +156,12 @@ int ldns_wire2str_pkt_scan(uint8_t** data, size_t* data_len, char** str,
* @param pktlen: length of packet buffer. * @param pktlen: length of packet buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_rr_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_rr_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len, uint8_t* pkt, size_t pktlen); size_t* str_len, uint8_t* pkt, size_t pktlen);
/** /**
* Scan wireformat question rr to string, with user buffers. * Scan wireformat question rr to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -178,12 +170,12 @@ int ldns_wire2str_rr_scan(uint8_t** data, size_t* data_len, char** str,
* @param pktlen: length of packet buffer. * @param pktlen: length of packet buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_rrquestion_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_rrquestion_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len, uint8_t* pkt, size_t pktlen); size_t* str_len, uint8_t* pkt, size_t pktlen);
/** /**
* Scan wireformat RR to string in unknown RR format, with user buffers. * Scan wireformat RR to string in unknown RR format, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -192,7 +184,7 @@ int ldns_wire2str_rrquestion_scan(uint8_t** data, size_t* data_len, char** str,
* @param pktlen: length of packet buffer. * @param pktlen: length of packet buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_rr_unknown_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_rr_unknown_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len, uint8_t* pkt, size_t pktlen); size_t* str_len, uint8_t* pkt, size_t pktlen);
/** /**
@ -207,24 +199,24 @@ int ldns_wire2str_rr_unknown_scan(uint8_t** data, size_t* data_len, char** str,
* @param rrtype: type of the RR, host format. * @param rrtype: type of the RR, host format.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_rr_comment_print(char** str, size_t* str_len, uint8_t* rr, int sldns_wire2str_rr_comment_print(char** str, size_t* str_len, uint8_t* rr,
size_t rrlen, size_t dname_off, uint16_t rrtype); size_t rrlen, size_t dname_off, uint16_t rrtype);
/** /**
* Scan wireformat packet header to string, with user buffers. * Scan wireformat packet header to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
* @param str_len: length of string buffer. * @param str_len: length of string buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_header_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_header_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat rdata to string, with user buffers. * Scan wireformat rdata to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. The length of the rdata in the * @param data_len: length of data buffer. The length of the rdata in the
* buffer. The rdatalen itself has already been scanned, the data * buffer. The rdatalen itself has already been scanned, the data
@ -236,24 +228,24 @@ int ldns_wire2str_header_scan(uint8_t** data, size_t* data_len, char** str,
* @param pktlen: length of packet buffer. * @param pktlen: length of packet buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_rdata_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_rdata_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len, uint16_t rrtype, uint8_t* pkt, size_t pktlen); size_t* str_len, uint16_t rrtype, uint8_t* pkt, size_t pktlen);
/** /**
* Scan wireformat rdata to string in unknown format, with user buffers. * Scan wireformat rdata to string in unknown format, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer, the length of the rdata in buffer. * @param data_len: length of data buffer, the length of the rdata in buffer.
* @param str: string buffer. * @param str: string buffer.
* @param str_len: length of string buffer. * @param str_len: length of string buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_rdata_unknown_scan(uint8_t** data, size_t* data_len, int sldns_wire2str_rdata_unknown_scan(uint8_t** data, size_t* data_len,
char** str, size_t* str_len); char** str, size_t* str_len);
/** /**
* Scan wireformat domain name to string, with user buffers. * Scan wireformat domain name to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -262,43 +254,43 @@ int ldns_wire2str_rdata_unknown_scan(uint8_t** data, size_t* data_len,
* @param pktlen: length of packet buffer. * @param pktlen: length of packet buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_dname_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_dname_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len, uint8_t* pkt, size_t pktlen); size_t* str_len, uint8_t* pkt, size_t pktlen);
/** /**
* Scan wireformat rr type to string, with user buffers. * Scan wireformat rr type to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
* @param str_len: length of string buffer. * @param str_len: length of string buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_type_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_type_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat rr class to string, with user buffers. * Scan wireformat rr class to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
* @param str_len: length of string buffer. * @param str_len: length of string buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_class_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_class_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat rr ttl to string, with user buffers. * Scan wireformat rr ttl to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
* @param str_len: length of string buffer. * @param str_len: length of string buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_ttl_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_ttl_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
@ -309,7 +301,7 @@ int ldns_wire2str_ttl_scan(uint8_t** data, size_t* data_len, char** str,
* @param rrtype: host format rr type. * @param rrtype: host format rr type.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_type_print(char** str, size_t* str_len, uint16_t rrtype); int sldns_wire2str_type_print(char** str, size_t* str_len, uint16_t rrtype);
/** /**
* Print host format rr class to string. Moves string along, user buffers. * Print host format rr class to string. Moves string along, user buffers.
@ -318,7 +310,7 @@ int ldns_wire2str_type_print(char** str, size_t* str_len, uint16_t rrtype);
* @param rrclass: host format rr class. * @param rrclass: host format rr class.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_class_print(char** str, size_t* str_len, uint16_t rrclass); int sldns_wire2str_class_print(char** str, size_t* str_len, uint16_t rrclass);
/** /**
* Print host format rcode to string. Moves string along, user buffers. * Print host format rcode to string. Moves string along, user buffers.
@ -327,7 +319,7 @@ int ldns_wire2str_class_print(char** str, size_t* str_len, uint16_t rrclass);
* @param rcode: host format rcode number. * @param rcode: host format rcode number.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_rcode_print(char** str, size_t* str_len, int rcode); int sldns_wire2str_rcode_print(char** str, size_t* str_len, int rcode);
/** /**
* Print host format opcode to string. Moves string along, user buffers. * Print host format opcode to string. Moves string along, user buffers.
@ -336,7 +328,7 @@ int ldns_wire2str_rcode_print(char** str, size_t* str_len, int rcode);
* @param opcode: host format opcode number. * @param opcode: host format opcode number.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_opcode_print(char** str, size_t* str_len, int opcode); int sldns_wire2str_opcode_print(char** str, size_t* str_len, int opcode);
/** /**
* Print host format EDNS0 option to string. Moves string along, user buffers. * Print host format EDNS0 option to string. Moves string along, user buffers.
@ -345,7 +337,7 @@ int ldns_wire2str_opcode_print(char** str, size_t* str_len, int opcode);
* @param opcode: host format option number. * @param opcode: host format option number.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_option_code_print(char** str, size_t* str_len, int sldns_wire2str_edns_option_code_print(char** str, size_t* str_len,
uint16_t opcode); uint16_t opcode);
/** /**
@ -361,7 +353,7 @@ int ldns_wire2str_edns_option_code_print(char** str, size_t* str_len,
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_rr_buf(uint8_t* rr, size_t rr_len, char* str, int sldns_wire2str_rr_buf(uint8_t* rr, size_t rr_len, char* str,
size_t str_len); size_t str_len);
/** /**
@ -379,7 +371,7 @@ int ldns_wire2str_rr_buf(uint8_t* rr, size_t rr_len, char* str,
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_rr_unknown_buf(uint8_t* rr, size_t rr_len, char* str, int sldns_wire2str_rr_unknown_buf(uint8_t* rr, size_t rr_len, char* str,
size_t str_len); size_t str_len);
/** /**
@ -399,7 +391,7 @@ int ldns_wire2str_rr_unknown_buf(uint8_t* rr, size_t rr_len, char* str,
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_rr_comment_buf(uint8_t* rr, size_t rr_len, size_t dname_len, int sldns_wire2str_rr_comment_buf(uint8_t* rr, size_t rr_len, size_t dname_len,
char* str, size_t str_len); char* str, size_t str_len);
/** /**
@ -416,7 +408,7 @@ int ldns_wire2str_rr_comment_buf(uint8_t* rr, size_t rr_len, size_t dname_len,
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_rdata_buf(uint8_t* rdata, size_t rdata_len, char* str, int sldns_wire2str_rdata_buf(uint8_t* rdata, size_t rdata_len, char* str,
size_t str_len, uint16_t rrtype); size_t str_len, uint16_t rrtype);
/** /**
@ -427,7 +419,7 @@ int ldns_wire2str_rdata_buf(uint8_t* rdata, size_t rdata_len, char* str,
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_type_buf(uint16_t rrtype, char* str, size_t len); int sldns_wire2str_type_buf(uint16_t rrtype, char* str, size_t len);
/** /**
* Convert wire RR class to a string, 'IN', 'CLASS12'. With user buffer. * Convert wire RR class to a string, 'IN', 'CLASS12'. With user buffer.
@ -437,7 +429,7 @@ int ldns_wire2str_type_buf(uint16_t rrtype, char* str, size_t len);
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_class_buf(uint16_t rrclass, char* str, size_t len); int sldns_wire2str_class_buf(uint16_t rrclass, char* str, size_t len);
/** /**
* Convert wire RR rcode to a string, 'NOERROR', 'NXDOMAIN'. With user buffer. * Convert wire RR rcode to a string, 'NOERROR', 'NXDOMAIN'. With user buffer.
@ -447,7 +439,7 @@ int ldns_wire2str_class_buf(uint16_t rrclass, char* str, size_t len);
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_rcode_buf(int rcode, char* str, size_t len); int sldns_wire2str_rcode_buf(int rcode, char* str, size_t len);
/** /**
* Convert wire dname to a string, "example.com.". With user buffer. * Convert wire dname to a string, "example.com.". With user buffer.
@ -458,28 +450,28 @@ int ldns_wire2str_rcode_buf(int rcode, char* str, size_t len);
* @return the number of characters for this element, excluding zerobyte. * @return the number of characters for this element, excluding zerobyte.
* Is larger than str_len if output was truncated. * Is larger than str_len if output was truncated.
*/ */
int ldns_wire2str_dname_buf(uint8_t* dname, size_t dname_len, char* str, int sldns_wire2str_dname_buf(uint8_t* dname, size_t dname_len, char* str,
size_t len); size_t len);
/** /**
* Scan wireformat rdf field to string, with user buffers. * Scan wireformat rdf field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
* @param str_len: length of string buffer. * @param str_len: length of string buffer.
* @param rdftype: the type of the rdata field, enum ldns_rdf_type. * @param rdftype: the type of the rdata field, enum sldns_rdf_type.
* @param pkt: packet for decompression, if NULL no decompression. * @param pkt: packet for decompression, if NULL no decompression.
* @param pktlen: length of packet buffer. * @param pktlen: length of packet buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_rdf_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_rdf_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len, int rdftype, uint8_t* pkt, size_t pktlen); size_t* str_len, int rdftype, uint8_t* pkt, size_t pktlen);
/** /**
* Scan wireformat int8 field to string, with user buffers. * Scan wireformat int8 field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -487,12 +479,12 @@ int ldns_wire2str_rdf_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_int8_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_int8_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat int16 field to string, with user buffers. * Scan wireformat int16 field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -500,12 +492,12 @@ int ldns_wire2str_int8_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_int16_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_int16_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat int32 field to string, with user buffers. * Scan wireformat int32 field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -513,12 +505,12 @@ int ldns_wire2str_int16_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_int32_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_int32_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat period field to string, with user buffers. * Scan wireformat period field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -526,12 +518,12 @@ int ldns_wire2str_int32_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_period_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_period_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat tsigtime field to string, with user buffers. * Scan wireformat tsigtime field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -539,12 +531,12 @@ int ldns_wire2str_period_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_tsigtime_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_tsigtime_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat ip4 A field to string, with user buffers. * Scan wireformat ip4 A field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -552,12 +544,12 @@ int ldns_wire2str_tsigtime_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_a_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_a_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat ip6 AAAA field to string, with user buffers. * Scan wireformat ip6 AAAA field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -565,12 +557,12 @@ int ldns_wire2str_a_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_aaaa_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_aaaa_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat str field to string, with user buffers. * Scan wireformat str field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -578,12 +570,12 @@ int ldns_wire2str_aaaa_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_str_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_str_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat apl field to string, with user buffers. * Scan wireformat apl field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -591,12 +583,12 @@ int ldns_wire2str_str_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_apl_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_apl_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat b32_ext field to string, with user buffers. * Scan wireformat b32_ext field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -604,12 +596,12 @@ int ldns_wire2str_apl_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_b32_ext_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_b32_ext_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat b64 field to string, with user buffers. * Scan wireformat b64 field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -617,12 +609,12 @@ int ldns_wire2str_b32_ext_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_b64_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_b64_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat hex field to string, with user buffers. * Scan wireformat hex field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -630,12 +622,12 @@ int ldns_wire2str_b64_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_hex_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_hex_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat nsec bitmap field to string, with user buffers. * Scan wireformat nsec bitmap field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -643,12 +635,12 @@ int ldns_wire2str_hex_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_nsec_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_nsec_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat nsec3_salt field to string, with user buffers. * Scan wireformat nsec3_salt field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -656,12 +648,12 @@ int ldns_wire2str_nsec_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_nsec3_salt_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_nsec3_salt_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat cert_alg field to string, with user buffers. * Scan wireformat cert_alg field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -669,12 +661,12 @@ int ldns_wire2str_nsec3_salt_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_cert_alg_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_cert_alg_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat alg field to string, with user buffers. * Scan wireformat alg field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -682,12 +674,12 @@ int ldns_wire2str_cert_alg_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_alg_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_alg_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat type unknown field to string, with user buffers. * Scan wireformat type unknown field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -695,12 +687,12 @@ int ldns_wire2str_alg_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_unknown_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_unknown_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat time field to string, with user buffers. * Scan wireformat time field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -708,12 +700,12 @@ int ldns_wire2str_unknown_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_time_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_time_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat LOC field to string, with user buffers. * Scan wireformat LOC field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -721,12 +713,12 @@ int ldns_wire2str_time_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_loc_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_loc_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat WKS field to string, with user buffers. * Scan wireformat WKS field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -734,12 +726,12 @@ int ldns_wire2str_loc_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_wks_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_wks_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat NSAP field to string, with user buffers. * Scan wireformat NSAP field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -747,12 +739,12 @@ int ldns_wire2str_wks_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_nsap_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_nsap_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat ATMA field to string, with user buffers. * Scan wireformat ATMA field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -760,12 +752,12 @@ int ldns_wire2str_nsap_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_atma_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_atma_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat IPSECKEY field to string, with user buffers. * Scan wireformat IPSECKEY field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -775,12 +767,12 @@ int ldns_wire2str_atma_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_ipseckey_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_ipseckey_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len, uint8_t* pkt, size_t pktlen); size_t* str_len, uint8_t* pkt, size_t pktlen);
/** /**
* Scan wireformat int16_data field to string, with user buffers. * Scan wireformat int16_data field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -788,12 +780,12 @@ int ldns_wire2str_ipseckey_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_int16_data_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_int16_data_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat nsec3_next_owner field to string, with user buffers. * Scan wireformat nsec3_next_owner field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -801,12 +793,12 @@ int ldns_wire2str_int16_data_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_nsec3_next_owner_scan(uint8_t** data, size_t* data_len, int sldns_wire2str_nsec3_next_owner_scan(uint8_t** data, size_t* data_len,
char** str, size_t* str_len); char** str, size_t* str_len);
/** /**
* Scan wireformat ILNP64 field to string, with user buffers. * Scan wireformat ILNP64 field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -814,12 +806,12 @@ int ldns_wire2str_nsec3_next_owner_scan(uint8_t** data, size_t* data_len,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_ilnp64_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_ilnp64_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat EUI48 field to string, with user buffers. * Scan wireformat EUI48 field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -827,12 +819,12 @@ int ldns_wire2str_ilnp64_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_eui48_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_eui48_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat EUI64 field to string, with user buffers. * Scan wireformat EUI64 field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -840,12 +832,12 @@ int ldns_wire2str_eui48_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_eui64_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_eui64_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat TAG field to string, with user buffers. * Scan wireformat TAG field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -853,12 +845,12 @@ int ldns_wire2str_eui64_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_tag_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_tag_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
* Scan wireformat long_str field to string, with user buffers. * Scan wireformat long_str field to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -866,7 +858,7 @@ int ldns_wire2str_tag_scan(uint8_t** data, size_t* data_len, char** str,
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
* Can return -1 on failure. * Can return -1 on failure.
*/ */
int ldns_wire2str_long_str_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_long_str_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len); size_t* str_len);
/** /**
@ -877,7 +869,7 @@ int ldns_wire2str_long_str_scan(uint8_t** data, size_t* data_len, char** str,
* @param option_len: length of the data for this option. * @param option_len: length of the data for this option.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_llq_print(char** str, size_t* str_len, int sldns_wire2str_edns_llq_print(char** str, size_t* str_len,
uint8_t* option_data, size_t option_len); uint8_t* option_data, size_t option_len);
/** /**
@ -888,7 +880,7 @@ int ldns_wire2str_edns_llq_print(char** str, size_t* str_len,
* @param option_len: length of the data for this option. * @param option_len: length of the data for this option.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_ul_print(char** str, size_t* str_len, int sldns_wire2str_edns_ul_print(char** str, size_t* str_len,
uint8_t* option_data, size_t option_len); uint8_t* option_data, size_t option_len);
/** /**
@ -899,7 +891,7 @@ int ldns_wire2str_edns_ul_print(char** str, size_t* str_len,
* @param option_len: length of the data for this option. * @param option_len: length of the data for this option.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_nsid_print(char** str, size_t* str_len, int sldns_wire2str_edns_nsid_print(char** str, size_t* str_len,
uint8_t* option_data, size_t option_len); uint8_t* option_data, size_t option_len);
/** /**
@ -910,7 +902,7 @@ int ldns_wire2str_edns_nsid_print(char** str, size_t* str_len,
* @param option_len: length of the data for this option. * @param option_len: length of the data for this option.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_dau_print(char** str, size_t* str_len, int sldns_wire2str_edns_dau_print(char** str, size_t* str_len,
uint8_t* option_data, size_t option_len); uint8_t* option_data, size_t option_len);
/** /**
@ -921,7 +913,7 @@ int ldns_wire2str_edns_dau_print(char** str, size_t* str_len,
* @param option_len: length of the data for this option. * @param option_len: length of the data for this option.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_dhu_print(char** str, size_t* str_len, int sldns_wire2str_edns_dhu_print(char** str, size_t* str_len,
uint8_t* option_data, size_t option_len); uint8_t* option_data, size_t option_len);
/** /**
@ -932,7 +924,7 @@ int ldns_wire2str_edns_dhu_print(char** str, size_t* str_len,
* @param option_len: length of the data for this option. * @param option_len: length of the data for this option.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_n3u_print(char** str, size_t* str_len, int sldns_wire2str_edns_n3u_print(char** str, size_t* str_len,
uint8_t* option_data, size_t option_len); uint8_t* option_data, size_t option_len);
/** /**
@ -943,7 +935,7 @@ int ldns_wire2str_edns_n3u_print(char** str, size_t* str_len,
* @param option_len: length of the data for this option. * @param option_len: length of the data for this option.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_subnet_print(char** str, size_t* str_len, int sldns_wire2str_edns_subnet_print(char** str, size_t* str_len,
uint8_t* option_data, size_t option_len); uint8_t* option_data, size_t option_len);
/** /**
@ -955,12 +947,12 @@ int ldns_wire2str_edns_subnet_print(char** str, size_t* str_len,
* @param option_len: length of the data for this option. * @param option_len: length of the data for this option.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_option_print(char** str, size_t* str_len, int sldns_wire2str_edns_option_print(char** str, size_t* str_len,
uint16_t option_code, uint8_t* option_data, size_t option_len); uint16_t option_code, uint8_t* option_data, size_t option_len);
/** /**
* Scan wireformat EDNS OPT to string, with user buffers. * Scan wireformat EDNS OPT to string, with user buffers.
* It shifts the arguments to move along (see ldns_wire2str_pkt_scan). * It shifts the arguments to move along (see sldns_wire2str_pkt_scan).
* @param data: wireformat data. * @param data: wireformat data.
* @param data_len: length of data buffer. * @param data_len: length of data buffer.
* @param str: string buffer. * @param str: string buffer.
@ -969,7 +961,7 @@ int ldns_wire2str_edns_option_print(char** str, size_t* str_len,
* @param pktlen: length of packet buffer. * @param pktlen: length of packet buffer.
* @return number of characters (except null) needed to print. * @return number of characters (except null) needed to print.
*/ */
int ldns_wire2str_edns_scan(uint8_t** data, size_t* data_len, char** str, int sldns_wire2str_edns_scan(uint8_t** data, size_t* data_len, char** str,
size_t* str_len, uint8_t* pkt, size_t pktlen); size_t* str_len, uint8_t* pkt, size_t pktlen);
#ifdef __cplusplus #ifdef __cplusplus

58
libunbound/context.c
View file

@ -221,10 +221,10 @@ context_serialize_new_query(struct ctx_query* q, uint32_t* len)
*len = sizeof(uint32_t)*4 + slen; *len = sizeof(uint32_t)*4 + slen;
p = (uint8_t*)malloc(*len); p = (uint8_t*)malloc(*len);
if(!p) return NULL; if(!p) return NULL;
ldns_write_uint32(p, UB_LIBCMD_NEWQUERY); sldns_write_uint32(p, UB_LIBCMD_NEWQUERY);
ldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum); sldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
ldns_write_uint32(p+2*sizeof(uint32_t), (uint32_t)q->res->qtype); sldns_write_uint32(p+2*sizeof(uint32_t), (uint32_t)q->res->qtype);
ldns_write_uint32(p+3*sizeof(uint32_t), (uint32_t)q->res->qclass); sldns_write_uint32(p+3*sizeof(uint32_t), (uint32_t)q->res->qclass);
memmove(p+4*sizeof(uint32_t), q->res->qname, slen); memmove(p+4*sizeof(uint32_t), q->res->qname, slen);
return p; return p;
} }
@ -238,8 +238,8 @@ context_deserialize_new_query(struct ub_ctx* ctx, uint8_t* p, uint32_t len)
free(q); free(q);
return NULL; return NULL;
} }
log_assert( ldns_read_uint32(p) == UB_LIBCMD_NEWQUERY); log_assert( sldns_read_uint32(p) == UB_LIBCMD_NEWQUERY);
q->querynum = (int)ldns_read_uint32(p+sizeof(uint32_t)); q->querynum = (int)sldns_read_uint32(p+sizeof(uint32_t));
q->node.key = &q->querynum; q->node.key = &q->querynum;
q->async = 1; q->async = 1;
q->res = (struct ub_result*)calloc(1, sizeof(*q->res)); q->res = (struct ub_result*)calloc(1, sizeof(*q->res));
@ -247,8 +247,8 @@ context_deserialize_new_query(struct ub_ctx* ctx, uint8_t* p, uint32_t len)
free(q); free(q);
return NULL; return NULL;
} }
q->res->qtype = (int)ldns_read_uint32(p+2*sizeof(uint32_t)); q->res->qtype = (int)sldns_read_uint32(p+2*sizeof(uint32_t));
q->res->qclass = (int)ldns_read_uint32(p+3*sizeof(uint32_t)); q->res->qclass = (int)sldns_read_uint32(p+3*sizeof(uint32_t));
q->res->qname = strdup((char*)(p+4*sizeof(uint32_t))); q->res->qname = strdup((char*)(p+4*sizeof(uint32_t)));
if(!q->res->qname) { if(!q->res->qname) {
free(q->res); free(q->res);
@ -270,8 +270,8 @@ context_lookup_new_query(struct ub_ctx* ctx, uint8_t* p, uint32_t len)
if(len < 4*sizeof(uint32_t)+1) { if(len < 4*sizeof(uint32_t)+1) {
return NULL; return NULL;
} }
log_assert( ldns_read_uint32(p) == UB_LIBCMD_NEWQUERY); log_assert( sldns_read_uint32(p) == UB_LIBCMD_NEWQUERY);
querynum = (int)ldns_read_uint32(p+sizeof(uint32_t)); querynum = (int)sldns_read_uint32(p+sizeof(uint32_t));
q = (struct ctx_query*)rbtree_search(&ctx->queries, &querynum); q = (struct ctx_query*)rbtree_search(&ctx->queries, &querynum);
if(!q) { if(!q) {
return NULL; return NULL;
@ -281,7 +281,7 @@ context_lookup_new_query(struct ub_ctx* ctx, uint8_t* p, uint32_t len)
} }
uint8_t* uint8_t*
context_serialize_answer(struct ctx_query* q, int err, ldns_buffer* pkt, context_serialize_answer(struct ctx_query* q, int err, sldns_buffer* pkt,
uint32_t* len) uint32_t* len)
{ {
/* answer format /* answer format
@ -294,22 +294,22 @@ context_serialize_answer(struct ctx_query* q, int err, ldns_buffer* pkt,
* o the remainder is the answer msg from resolver lookup. * o the remainder is the answer msg from resolver lookup.
* remainder can be length 0. * remainder can be length 0.
*/ */
size_t pkt_len = pkt?ldns_buffer_remaining(pkt):0; size_t pkt_len = pkt?sldns_buffer_remaining(pkt):0;
size_t wlen = (pkt&&q->res->why_bogus)?strlen(q->res->why_bogus)+1:0; size_t wlen = (pkt&&q->res->why_bogus)?strlen(q->res->why_bogus)+1:0;
uint8_t* p; uint8_t* p;
*len = sizeof(uint32_t)*5 + pkt_len + wlen; *len = sizeof(uint32_t)*5 + pkt_len + wlen;
p = (uint8_t*)malloc(*len); p = (uint8_t*)malloc(*len);
if(!p) return NULL; if(!p) return NULL;
ldns_write_uint32(p, UB_LIBCMD_ANSWER); sldns_write_uint32(p, UB_LIBCMD_ANSWER);
ldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum); sldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
ldns_write_uint32(p+2*sizeof(uint32_t), (uint32_t)err); sldns_write_uint32(p+2*sizeof(uint32_t), (uint32_t)err);
ldns_write_uint32(p+3*sizeof(uint32_t), (uint32_t)q->msg_security); sldns_write_uint32(p+3*sizeof(uint32_t), (uint32_t)q->msg_security);
ldns_write_uint32(p+4*sizeof(uint32_t), (uint32_t)wlen); sldns_write_uint32(p+4*sizeof(uint32_t), (uint32_t)wlen);
if(wlen > 0) if(wlen > 0)
memmove(p+5*sizeof(uint32_t), q->res->why_bogus, wlen); memmove(p+5*sizeof(uint32_t), q->res->why_bogus, wlen);
if(pkt_len > 0) if(pkt_len > 0)
memmove(p+5*sizeof(uint32_t)+wlen, memmove(p+5*sizeof(uint32_t)+wlen,
ldns_buffer_begin(pkt), pkt_len); sldns_buffer_begin(pkt), pkt_len);
return p; return p;
} }
@ -321,13 +321,13 @@ context_deserialize_answer(struct ub_ctx* ctx,
int id; int id;
size_t wlen; size_t wlen;
if(len < 5*sizeof(uint32_t)) return NULL; if(len < 5*sizeof(uint32_t)) return NULL;
log_assert( ldns_read_uint32(p) == UB_LIBCMD_ANSWER); log_assert( sldns_read_uint32(p) == UB_LIBCMD_ANSWER);
id = (int)ldns_read_uint32(p+sizeof(uint32_t)); id = (int)sldns_read_uint32(p+sizeof(uint32_t));
q = (struct ctx_query*)rbtree_search(&ctx->queries, &id); q = (struct ctx_query*)rbtree_search(&ctx->queries, &id);
if(!q) return NULL; if(!q) return NULL;
*err = (int)ldns_read_uint32(p+2*sizeof(uint32_t)); *err = (int)sldns_read_uint32(p+2*sizeof(uint32_t));
q->msg_security = ldns_read_uint32(p+3*sizeof(uint32_t)); q->msg_security = sldns_read_uint32(p+3*sizeof(uint32_t));
wlen = (size_t)ldns_read_uint32(p+4*sizeof(uint32_t)); wlen = (size_t)sldns_read_uint32(p+4*sizeof(uint32_t));
if(len > 5*sizeof(uint32_t) && wlen > 0) { if(len > 5*sizeof(uint32_t) && wlen > 0) {
if(len >= 5*sizeof(uint32_t)+wlen) if(len >= 5*sizeof(uint32_t)+wlen)
q->res->why_bogus = (char*)memdup( q->res->why_bogus = (char*)memdup(
@ -363,8 +363,8 @@ context_serialize_cancel(struct ctx_query* q, uint32_t* len)
uint8_t* p = (uint8_t*)malloc(2*sizeof(uint32_t)); uint8_t* p = (uint8_t*)malloc(2*sizeof(uint32_t));
if(!p) return NULL; if(!p) return NULL;
*len = 2*sizeof(uint32_t); *len = 2*sizeof(uint32_t);
ldns_write_uint32(p, UB_LIBCMD_CANCEL); sldns_write_uint32(p, UB_LIBCMD_CANCEL);
ldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum); sldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
return p; return p;
} }
@ -374,8 +374,8 @@ struct ctx_query* context_deserialize_cancel(struct ub_ctx* ctx,
struct ctx_query* q; struct ctx_query* q;
int id; int id;
if(len != 2*sizeof(uint32_t)) return NULL; if(len != 2*sizeof(uint32_t)) return NULL;
log_assert( ldns_read_uint32(p) == UB_LIBCMD_CANCEL); log_assert( sldns_read_uint32(p) == UB_LIBCMD_CANCEL);
id = (int)ldns_read_uint32(p+sizeof(uint32_t)); id = (int)sldns_read_uint32(p+sizeof(uint32_t));
q = (struct ctx_query*)rbtree_search(&ctx->queries, &id); q = (struct ctx_query*)rbtree_search(&ctx->queries, &id);
return q; return q;
} }
@ -387,7 +387,7 @@ context_serialize_quit(uint32_t* len)
if(!p) if(!p)
return NULL; return NULL;
*len = sizeof(uint32_t); *len = sizeof(uint32_t);
ldns_write_uint32(p, UB_LIBCMD_QUIT); sldns_write_uint32(p, UB_LIBCMD_QUIT);
return p; return p;
} }
@ -396,6 +396,6 @@ enum ub_ctx_cmd context_serial_getcmd(uint8_t* p, uint32_t len)
uint32_t v; uint32_t v;
if((size_t)len < sizeof(v)) if((size_t)len < sizeof(v))
return UB_LIBCMD_QUIT; return UB_LIBCMD_QUIT;
v = ldns_read_uint32(p); v = sldns_read_uint32(p);
return v; return v;
} }

4
libunbound/context.h
View file

@ -48,7 +48,7 @@
#include "util/data/packed_rrset.h" #include "util/data/packed_rrset.h"
struct libworker; struct libworker;
struct tube; struct tube;
struct ldns_buffer; struct sldns_buffer;
struct event_base; struct event_base;
/** /**
@ -282,7 +282,7 @@ uint8_t* context_serialize_new_query(struct ctx_query* q, uint32_t* len);
* @return: an alloc, or NULL on mem error. * @return: an alloc, or NULL on mem error.
*/ */
uint8_t* context_serialize_answer(struct ctx_query* q, int err, uint8_t* context_serialize_answer(struct ctx_query* q, int err,
struct ldns_buffer* pkt, uint32_t* len); struct sldns_buffer* pkt, uint32_t* len);
/** /**
* Serialize a query cancellation. Serializes query async id * Serialize a query cancellation. Serializes query async id

10
libunbound/libunbound.c
View file

@ -469,21 +469,21 @@ process_answer_detail(struct ub_ctx* ctx, uint8_t* msg, uint32_t len,
ub_resolve_free(q->res); ub_resolve_free(q->res);
} else { } else {
/* parse the message, extract rcode, fill result */ /* parse the message, extract rcode, fill result */
ldns_buffer* buf = ldns_buffer_new(q->msg_len); sldns_buffer* buf = sldns_buffer_new(q->msg_len);
struct regional* region = regional_create(); struct regional* region = regional_create();
*res = q->res; *res = q->res;
(*res)->rcode = LDNS_RCODE_SERVFAIL; (*res)->rcode = LDNS_RCODE_SERVFAIL;
if(region && buf) { if(region && buf) {
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
ldns_buffer_write(buf, q->msg, q->msg_len); sldns_buffer_write(buf, q->msg, q->msg_len);
ldns_buffer_flip(buf); sldns_buffer_flip(buf);
libworker_enter_result(*res, buf, region, libworker_enter_result(*res, buf, region,
q->msg_security); q->msg_security);
} }
(*res)->answer_packet = q->msg; (*res)->answer_packet = q->msg;
(*res)->answer_len = (int)q->msg_len; (*res)->answer_len = (int)q->msg_len;
q->msg = NULL; q->msg = NULL;
ldns_buffer_free(buf); sldns_buffer_free(buf);
regional_destroy(region); regional_destroy(region);
} }
q->res = NULL; q->res = NULL;

58
libunbound/libworker.c
View file

@ -83,7 +83,7 @@ libworker_delete_env(struct libworker* w)
mesh_delete(w->env->mesh); mesh_delete(w->env->mesh);
context_release_alloc(w->ctx, w->env->alloc, context_release_alloc(w->ctx, w->env->alloc,
!w->is_bg || w->is_bg_thread); !w->is_bg || w->is_bg_thread);
ldns_buffer_free(w->env->scratch_buffer); sldns_buffer_free(w->env->scratch_buffer);
regional_destroy(w->env->scratch); regional_destroy(w->env->scratch);
forwards_delete(w->env->fwds); forwards_delete(w->env->fwds);
hints_delete(w->env->hints); hints_delete(w->env->hints);
@ -144,7 +144,7 @@ libworker_setup(struct ub_ctx* ctx, int is_bg, struct event_base* eb)
lock_basic_lock(&ctx->cfglock); lock_basic_lock(&ctx->cfglock);
} }
w->env->scratch = regional_create_custom(cfg->msg_buffer_size); w->env->scratch = regional_create_custom(cfg->msg_buffer_size);
w->env->scratch_buffer = ldns_buffer_new(cfg->msg_buffer_size); w->env->scratch_buffer = sldns_buffer_new(cfg->msg_buffer_size);
w->env->fwds = forwards_create(); w->env->fwds = forwards_create();
if(w->env->fwds && !forwards_apply_cfg(w->env->fwds, cfg)) { if(w->env->fwds && !forwards_apply_cfg(w->env->fwds, cfg)) {
forwards_delete(w->env->fwds); forwards_delete(w->env->fwds);
@ -414,7 +414,7 @@ int libworker_bg(struct ub_ctx* ctx)
/** get msg reply struct (in temp region) */ /** get msg reply struct (in temp region) */
static struct reply_info* static struct reply_info*
parse_reply(ldns_buffer* pkt, struct regional* region, struct query_info* qi) parse_reply(sldns_buffer* pkt, struct regional* region, struct query_info* qi)
{ {
struct reply_info* rep; struct reply_info* rep;
struct msg_parse* msg; struct msg_parse* msg;
@ -422,7 +422,7 @@ parse_reply(ldns_buffer* pkt, struct regional* region, struct query_info* qi)
return NULL; return NULL;
} }
memset(msg, 0, sizeof(*msg)); memset(msg, 0, sizeof(*msg));
ldns_buffer_set_position(pkt, 0); sldns_buffer_set_position(pkt, 0);
if(parse_packet(pkt, msg, region) != 0) if(parse_packet(pkt, msg, region) != 0)
return 0; return 0;
if(!parse_create_msg(pkt, msg, NULL, qi, &rep, region)) { if(!parse_create_msg(pkt, msg, NULL, qi, &rep, region)) {
@ -498,7 +498,7 @@ fill_res(struct ub_result* res, struct ub_packed_rrset_key* answer,
/** fill result from parsed message, on error fills servfail */ /** fill result from parsed message, on error fills servfail */
void void
libworker_enter_result(struct ub_result* res, ldns_buffer* buf, libworker_enter_result(struct ub_result* res, sldns_buffer* buf,
struct regional* temp, enum sec_status msg_security) struct regional* temp, enum sec_status msg_security)
{ {
struct query_info rq; struct query_info rq;
@ -526,7 +526,7 @@ libworker_enter_result(struct ub_result* res, ldns_buffer* buf,
/** fillup fg results */ /** fillup fg results */
static void static void
libworker_fillup_fg(struct ctx_query* q, int rcode, ldns_buffer* buf, libworker_fillup_fg(struct ctx_query* q, int rcode, sldns_buffer* buf,
enum sec_status s, char* why_bogus) enum sec_status s, char* why_bogus)
{ {
if(why_bogus) if(why_bogus)
@ -539,8 +539,8 @@ libworker_fillup_fg(struct ctx_query* q, int rcode, ldns_buffer* buf,
q->res->rcode = LDNS_RCODE_SERVFAIL; q->res->rcode = LDNS_RCODE_SERVFAIL;
q->msg_security = 0; q->msg_security = 0;
q->msg = memdup(ldns_buffer_begin(buf), ldns_buffer_limit(buf)); q->msg = memdup(sldns_buffer_begin(buf), sldns_buffer_limit(buf));
q->msg_len = ldns_buffer_limit(buf); q->msg_len = sldns_buffer_limit(buf);
if(!q->msg) { if(!q->msg) {
return; /* the error is in the rcode */ return; /* the error is in the rcode */
} }
@ -551,7 +551,7 @@ libworker_fillup_fg(struct ctx_query* q, int rcode, ldns_buffer* buf,
} }
void void
libworker_fg_done_cb(void* arg, int rcode, ldns_buffer* buf, enum sec_status s, libworker_fg_done_cb(void* arg, int rcode, sldns_buffer* buf, enum sec_status s,
char* why_bogus) char* why_bogus)
{ {
struct ctx_query* q = (struct ctx_query*)arg; struct ctx_query* q = (struct ctx_query*)arg;
@ -568,7 +568,7 @@ setup_qinfo_edns(struct libworker* w, struct ctx_query* q,
{ {
qinfo->qtype = (uint16_t)q->res->qtype; qinfo->qtype = (uint16_t)q->res->qtype;
qinfo->qclass = (uint16_t)q->res->qclass; qinfo->qclass = (uint16_t)q->res->qclass;
qinfo->qname = ldns_str2wire_dname(q->res->qname, &qinfo->qname_len); qinfo->qname = sldns_str2wire_dname(q->res->qname, &qinfo->qname_len);
if(!qinfo->qname) { if(!qinfo->qname) {
return 0; return 0;
} }
@ -576,8 +576,8 @@ setup_qinfo_edns(struct libworker* w, struct ctx_query* q,
edns->ext_rcode = 0; edns->ext_rcode = 0;
edns->edns_version = 0; edns->edns_version = 0;
edns->bits = EDNS_DO; edns->bits = EDNS_DO;
if(ldns_buffer_capacity(w->back->udp_buff) < 65535) if(sldns_buffer_capacity(w->back->udp_buff) < 65535)
edns->udp_size = (uint16_t)ldns_buffer_capacity( edns->udp_size = (uint16_t)sldns_buffer_capacity(
w->back->udp_buff); w->back->udp_buff);
else edns->udp_size = 65535; else edns->udp_size = 65535;
return 1; return 1;
@ -599,8 +599,8 @@ int libworker_fg(struct ub_ctx* ctx, struct ctx_query* q)
qflags = BIT_RD; qflags = BIT_RD;
q->w = w; q->w = w;
/* see if there is a fixed answer */ /* see if there is a fixed answer */
ldns_buffer_write_u16_at(w->back->udp_buff, 0, qid); sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
ldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags); sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
if(local_zones_answer(ctx->local_zones, &qinfo, &edns, if(local_zones_answer(ctx->local_zones, &qinfo, &edns,
w->back->udp_buff, w->env->scratch)) { w->back->udp_buff, w->env->scratch)) {
regional_free_all(w->env->scratch); regional_free_all(w->env->scratch);
@ -626,7 +626,7 @@ int libworker_fg(struct ub_ctx* ctx, struct ctx_query* q)
} }
void void
libworker_event_done_cb(void* arg, int rcode, ldns_buffer* buf, libworker_event_done_cb(void* arg, int rcode, sldns_buffer* buf,
enum sec_status s, char* why_bogus) enum sec_status s, char* why_bogus)
{ {
struct ctx_query* q = (struct ctx_query*)arg; struct ctx_query* q = (struct ctx_query*)arg;
@ -668,8 +668,8 @@ int libworker_attach_mesh(struct ub_ctx* ctx, struct ctx_query* q,
qflags = BIT_RD; qflags = BIT_RD;
q->w = w; q->w = w;
/* see if there is a fixed answer */ /* see if there is a fixed answer */
ldns_buffer_write_u16_at(w->back->udp_buff, 0, qid); sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
ldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags); sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
if(local_zones_answer(ctx->local_zones, &qinfo, &edns, if(local_zones_answer(ctx->local_zones, &qinfo, &edns,
w->back->udp_buff, w->env->scratch)) { w->back->udp_buff, w->env->scratch)) {
regional_free_all(w->env->scratch); regional_free_all(w->env->scratch);
@ -692,7 +692,7 @@ int libworker_attach_mesh(struct ub_ctx* ctx, struct ctx_query* q,
/** add result to the bg worker result queue */ /** add result to the bg worker result queue */
static void static void
add_bg_result(struct libworker* w, struct ctx_query* q, ldns_buffer* pkt, add_bg_result(struct libworker* w, struct ctx_query* q, sldns_buffer* pkt,
int err, char* reason) int err, char* reason)
{ {
uint8_t* msg = NULL; uint8_t* msg = NULL;
@ -704,8 +704,8 @@ add_bg_result(struct libworker* w, struct ctx_query* q, ldns_buffer* pkt,
if(reason) if(reason)
q->res->why_bogus = strdup(reason); q->res->why_bogus = strdup(reason);
if(pkt) { if(pkt) {
q->msg_len = ldns_buffer_remaining(pkt); q->msg_len = sldns_buffer_remaining(pkt);
q->msg = memdup(ldns_buffer_begin(pkt), q->msg_len); q->msg = memdup(sldns_buffer_begin(pkt), q->msg_len);
if(!q->msg) if(!q->msg)
msg = context_serialize_answer(q, UB_NOMEM, msg = context_serialize_answer(q, UB_NOMEM,
NULL, &len); NULL, &len);
@ -733,7 +733,7 @@ add_bg_result(struct libworker* w, struct ctx_query* q, ldns_buffer* pkt,
} }
void void
libworker_bg_done_cb(void* arg, int rcode, ldns_buffer* buf, enum sec_status s, libworker_bg_done_cb(void* arg, int rcode, sldns_buffer* buf, enum sec_status s,
char* why_bogus) char* why_bogus)
{ {
struct ctx_query* q = (struct ctx_query*)arg; struct ctx_query* q = (struct ctx_query*)arg;
@ -788,8 +788,8 @@ handle_newq(struct libworker* w, uint8_t* buf, uint32_t len)
qid = 0; qid = 0;
qflags = BIT_RD; qflags = BIT_RD;
/* see if there is a fixed answer */ /* see if there is a fixed answer */
ldns_buffer_write_u16_at(w->back->udp_buff, 0, qid); sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
ldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags); sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
if(local_zones_answer(w->ctx->local_zones, &qinfo, &edns, if(local_zones_answer(w->ctx->local_zones, &qinfo, &edns,
w->back->udp_buff, w->env->scratch)) { w->back->udp_buff, w->env->scratch)) {
regional_free_all(w->env->scratch); regional_free_all(w->env->scratch);
@ -851,10 +851,10 @@ libworker_handle_reply(struct comm_point* c, void* arg, int error,
return 0; return 0;
} }
/* sanity check. */ /* sanity check. */
if(!LDNS_QR_WIRE(ldns_buffer_begin(c->buffer)) if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) != || LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
LDNS_PACKET_QUERY LDNS_PACKET_QUERY
|| LDNS_QDCOUNT(ldns_buffer_begin(c->buffer)) > 1) { || LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
/* error becomes timeout for the module as if this reply /* error becomes timeout for the module as if this reply
* never arrived. */ * never arrived. */
mesh_report_reply(lw->env->mesh, &e, reply_info, mesh_report_reply(lw->env->mesh, &e, reply_info,
@ -877,10 +877,10 @@ libworker_handle_service_reply(struct comm_point* c, void* arg, int error,
return 0; return 0;
} }
/* sanity check. */ /* sanity check. */
if(!LDNS_QR_WIRE(ldns_buffer_begin(c->buffer)) if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) != || LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
LDNS_PACKET_QUERY LDNS_PACKET_QUERY
|| LDNS_QDCOUNT(ldns_buffer_begin(c->buffer)) > 1) { || LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
/* error becomes timeout for the module as if this reply /* error becomes timeout for the module as if this reply
* never arrived. */ * never arrived. */
mesh_report_reply(lw->env->mesh, e, reply_info, mesh_report_reply(lw->env->mesh, e, reply_info,

10
libunbound/libworker.h
View file

@ -57,7 +57,7 @@ struct comm_point;
struct comm_reply; struct comm_reply;
struct regional; struct regional;
struct tube; struct tube;
struct ldns_buffer; struct sldns_buffer;
struct event_base; struct event_base;
/** /**
@ -175,15 +175,15 @@ void libworker_handle_result_write(struct tube* tube, uint8_t* msg, size_t len,
int err, void* arg); int err, void* arg);
/** mesh callback with fg results */ /** mesh callback with fg results */
void libworker_fg_done_cb(void* arg, int rcode, struct ldns_buffer* buf, void libworker_fg_done_cb(void* arg, int rcode, struct sldns_buffer* buf,
enum sec_status s, char* why_bogus); enum sec_status s, char* why_bogus);
/** mesh callback with bg results */ /** mesh callback with bg results */
void libworker_bg_done_cb(void* arg, int rcode, struct ldns_buffer* buf, void libworker_bg_done_cb(void* arg, int rcode, struct sldns_buffer* buf,
enum sec_status s, char* why_bogus); enum sec_status s, char* why_bogus);
/** mesh callback with event results */ /** mesh callback with event results */
void libworker_event_done_cb(void* arg, int rcode, struct ldns_buffer* buf, void libworker_event_done_cb(void* arg, int rcode, struct sldns_buffer* buf,
enum sec_status s, char* why_bogus); enum sec_status s, char* why_bogus);
/** /**
@ -195,7 +195,7 @@ void libworker_event_done_cb(void* arg, int rcode, struct ldns_buffer* buf,
* On error, the res may contain a different status * On error, the res may contain a different status
* (out of memory is not secure, not bogus). * (out of memory is not secure, not bogus).
*/ */
void libworker_enter_result(struct ub_result* res, struct ldns_buffer* buf, void libworker_enter_result(struct ub_result* res, struct sldns_buffer* buf,
struct regional* temp, enum sec_status msg_security); struct regional* temp, enum sec_status msg_security);
#endif /* LIBUNBOUND_WORKER_H */ #endif /* LIBUNBOUND_WORKER_H */

4
pythonmod/pythonmod_utils.c
View file

@ -107,7 +107,7 @@ void invalidateQueryInCache(struct module_qstate* qstate, struct query_info* qin
} }
/* Create response according to the ldns packet content */ /* Create response according to the ldns packet content */
int createResponse(struct module_qstate* qstate, ldns_buffer* pkt) int createResponse(struct module_qstate* qstate, sldns_buffer* pkt)
{ {
struct msg_parse* prs; struct msg_parse* prs;
struct edns_data edns; struct edns_data edns;
@ -122,7 +122,7 @@ int createResponse(struct module_qstate* qstate, ldns_buffer* pkt)
memset(prs, 0, sizeof(*prs)); memset(prs, 0, sizeof(*prs));
memset(&edns, 0, sizeof(edns)); memset(&edns, 0, sizeof(edns));
ldns_buffer_set_position(pkt, 0); sldns_buffer_set_position(pkt, 0);
if (parse_packet(pkt, prs, qstate->env->scratch) != LDNS_RCODE_NOERROR) { if (parse_packet(pkt, prs, qstate->env->scratch) != LDNS_RCODE_NOERROR) {
verbose(VERB_ALGO, "storeResponse: parse error on reply packet"); verbose(VERB_ALGO, "storeResponse: parse error on reply packet");
return 0; return 0;

4
pythonmod/pythonmod_utils.h
View file

@ -73,10 +73,10 @@ void invalidateQueryInCache(struct module_qstate* qstate, struct query_info* qin
* This function fills qstate.return_msg up with data of a given packet * This function fills qstate.return_msg up with data of a given packet
* *
* @param qstate: module environment * @param qstate: module environment
* @param pkt: a ldns_buffer which contains ldns_packet data * @param pkt: a sldns_buffer which contains sldns_packet data
* @return 0 on failure, out of memory or parse error. * @return 0 on failure, out of memory or parse error.
*/ */
int createResponse(struct module_qstate* qstate, ldns_buffer* pkt); int createResponse(struct module_qstate* qstate, sldns_buffer* pkt);
/** /**
* Convert reply->addr to string * Convert reply->addr to string

2
services/cache/dns.c vendored
View file

@ -616,7 +616,7 @@ synth_dname_msg(struct ub_packed_rrset_key* rrset, struct regional* region,
newd->rr_ttl[0] = newd->ttl; newd->rr_ttl[0] = newd->ttl;
msg->rep->ttl = newd->ttl; msg->rep->ttl = newd->ttl;
msg->rep->prefetch_ttl = PREFETCH_TTL_CALC(newd->ttl); msg->rep->prefetch_ttl = PREFETCH_TTL_CALC(newd->ttl);
ldns_write_uint16(newd->rr_data[0], newlen); sldns_write_uint16(newd->rr_data[0], newlen);
memmove(newd->rr_data[0] + sizeof(uint16_t), newname, newlen); memmove(newd->rr_data[0] + sizeof(uint16_t), newname, newlen);
msg->rep->an_numrrsets ++; msg->rep->an_numrrsets ++;
msg->rep->rrset_count ++; msg->rep->rrset_count ++;

6
services/listen_dnsport.c
View file

@ -792,7 +792,7 @@ listen_create(struct comm_base* base, struct listen_port* ports,
if(!front) if(!front)
return NULL; return NULL;
front->cps = NULL; front->cps = NULL;
front->udp_buff = ldns_buffer_new(bufsize); front->udp_buff = sldns_buffer_new(bufsize);
if(!front->udp_buff) { if(!front->udp_buff) {
free(front); free(front);
return NULL; return NULL;
@ -855,7 +855,7 @@ listen_delete(struct listen_dnsport* front)
if(!front) if(!front)
return; return;
listen_list_delete(front->cps); listen_list_delete(front->cps);
ldns_buffer_free(front->udp_buff); sldns_buffer_free(front->udp_buff);
free(front); free(front);
} }
@ -961,7 +961,7 @@ size_t listen_get_mem(struct listen_dnsport* listen)
{ {
size_t s = sizeof(*listen) + sizeof(*listen->base) + size_t s = sizeof(*listen) + sizeof(*listen->base) +
sizeof(*listen->udp_buff) + sizeof(*listen->udp_buff) +
ldns_buffer_capacity(listen->udp_buff); sldns_buffer_capacity(listen->udp_buff);
struct listen_list* p; struct listen_list* p;
for(p = listen->cps; p; p = p->next) { for(p = listen->cps; p; p = p->next) {
s += sizeof(*p); s += sizeof(*p);

4
services/listen_dnsport.h
View file

@ -46,7 +46,7 @@
struct listen_list; struct listen_list;
struct config_file; struct config_file;
struct addrinfo; struct addrinfo;
struct ldns_buffer; struct sldns_buffer;
/** /**
* Listening for queries structure. * Listening for queries structure.
@ -58,7 +58,7 @@ struct listen_dnsport {
/** buffer shared by UDP connections, since there is only one /** buffer shared by UDP connections, since there is only one
datagram at any time. */ datagram at any time. */
struct ldns_buffer* udp_buff; struct sldns_buffer* udp_buff;
/** list of comm points used to get incoming events */ /** list of comm points used to get incoming events */
struct listen_list* cps; struct listen_list* cps;

54
services/localzone.c
View file

@ -125,7 +125,7 @@ local_data_cmp(const void* d1, const void* d2)
int int
parse_dname(const char* str, uint8_t** res, size_t* len, int* labs) parse_dname(const char* str, uint8_t** res, size_t* len, int* labs)
{ {
*res = ldns_str2wire_dname(str, len); *res = sldns_str2wire_dname(str, len);
*labs = 0; *labs = 0;
if(!*res) { if(!*res) {
log_err("cannot parse name %s", str); log_err("cannot parse name %s", str);
@ -220,12 +220,12 @@ get_rr_content(const char* str, uint8_t** nm, uint16_t* type,
uint8_t** rdata, size_t* rdata_len) uint8_t** rdata, size_t* rdata_len)
{ {
size_t dname_len = 0; size_t dname_len = 0;
int e = ldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600, int e = sldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600,
NULL, 0, NULL, 0); NULL, 0, NULL, 0);
if(e) { if(e) {
log_err("error parsing local-data at %d: '%s': %s", log_err("error parsing local-data at %d: '%s': %s",
LDNS_WIREPARSE_OFFSET(e), str, LDNS_WIREPARSE_OFFSET(e), str,
ldns_get_errorstr_parse(e)); sldns_get_errorstr_parse(e));
return 0; return 0;
} }
*nm = memdup(rr, dname_len); *nm = memdup(rr, dname_len);
@ -233,11 +233,11 @@ get_rr_content(const char* str, uint8_t** nm, uint16_t* type,
log_err("out of memory"); log_err("out of memory");
return 0; return 0;
} }
*dclass = ldns_wirerr_get_class(rr, len, dname_len); *dclass = sldns_wirerr_get_class(rr, len, dname_len);
*type = ldns_wirerr_get_type(rr, len, dname_len); *type = sldns_wirerr_get_type(rr, len, dname_len);
*ttl = (time_t)ldns_wirerr_get_ttl(rr, len, dname_len); *ttl = (time_t)sldns_wirerr_get_ttl(rr, len, dname_len);
*rdata = ldns_wirerr_get_rdatawl(rr, len, dname_len); *rdata = sldns_wirerr_get_rdatawl(rr, len, dname_len);
*rdata_len = ldns_wirerr_get_rdatalen(rr, len, dname_len)+2; *rdata_len = sldns_wirerr_get_rdatalen(rr, len, dname_len)+2;
return 1; return 1;
} }
@ -247,16 +247,16 @@ get_rr_nameclass(const char* str, uint8_t** nm, uint16_t* dclass)
{ {
uint8_t rr[LDNS_RR_BUF_SIZE]; uint8_t rr[LDNS_RR_BUF_SIZE];
size_t len = sizeof(rr), dname_len = 0; size_t len = sizeof(rr), dname_len = 0;
int s = ldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600, int s = sldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600,
NULL, 0, NULL, 0); NULL, 0, NULL, 0);
if(s != 0) { if(s != 0) {
log_err("error parsing local-data at %d '%s': %s", log_err("error parsing local-data at %d '%s': %s",
LDNS_WIREPARSE_OFFSET(s), str, LDNS_WIREPARSE_OFFSET(s), str,
ldns_get_errorstr_parse(s)); sldns_get_errorstr_parse(s));
return 0; return 0;
} }
*nm = memdup(rr, dname_len); *nm = memdup(rr, dname_len);
*dclass = ldns_wirerr_get_class(rr, len, dname_len); *dclass = sldns_wirerr_get_class(rr, len, dname_len);
if(!*nm) { if(!*nm) {
log_err("out of memory"); log_err("out of memory");
return 0; return 0;
@ -962,7 +962,7 @@ void local_zones_print(struct local_zones* zones)
/** encode answer consisting of 1 rrset */ /** encode answer consisting of 1 rrset */
static int static int
local_encode(struct query_info* qinfo, struct edns_data* edns, local_encode(struct query_info* qinfo, struct edns_data* edns,
ldns_buffer* buf, struct regional* temp, sldns_buffer* buf, struct regional* temp,
struct ub_packed_rrset_key* rrset, int ansec, int rcode) struct ub_packed_rrset_key* rrset, int ansec, int rcode)
{ {
struct reply_info rep; struct reply_info rep;
@ -982,20 +982,20 @@ local_encode(struct query_info* qinfo, struct edns_data* edns,
edns->ext_rcode = 0; edns->ext_rcode = 0;
edns->bits &= EDNS_DO; edns->bits &= EDNS_DO;
if(!reply_info_answer_encode(qinfo, &rep, if(!reply_info_answer_encode(qinfo, &rep,
*(uint16_t*)ldns_buffer_begin(buf), *(uint16_t*)sldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), sldns_buffer_read_u16_at(buf, 2),
buf, 0, 0, temp, udpsize, edns, buf, 0, 0, temp, udpsize, edns,
(int)(edns->bits&EDNS_DO), 0)) (int)(edns->bits&EDNS_DO), 0))
error_encode(buf, (LDNS_RCODE_SERVFAIL|BIT_AA), qinfo, error_encode(buf, (LDNS_RCODE_SERVFAIL|BIT_AA), qinfo,
*(uint16_t*)ldns_buffer_begin(buf), *(uint16_t*)sldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), edns); sldns_buffer_read_u16_at(buf, 2), edns);
return 1; return 1;
} }
/** answer local data match */ /** answer local data match */
static int static int
local_data_answer(struct local_zone* z, struct query_info* qinfo, local_data_answer(struct local_zone* z, struct query_info* qinfo,
struct edns_data* edns, ldns_buffer* buf, struct regional* temp, struct edns_data* edns, sldns_buffer* buf, struct regional* temp,
int labs, struct local_data** ldp) int labs, struct local_data** ldp)
{ {
struct local_data key; struct local_data key;
@ -1042,18 +1042,18 @@ local_data_answer(struct local_zone* z, struct query_info* qinfo,
*/ */
static int static int
lz_zone_answer(struct local_zone* z, struct query_info* qinfo, lz_zone_answer(struct local_zone* z, struct query_info* qinfo,
struct edns_data* edns, ldns_buffer* buf, struct regional* temp, struct edns_data* edns, sldns_buffer* buf, struct regional* temp,
struct local_data* ld) struct local_data* ld)
{ {
if(z->type == local_zone_deny) { if(z->type == local_zone_deny) {
/** no reply at all, signal caller by clearing buffer. */ /** no reply at all, signal caller by clearing buffer. */
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
ldns_buffer_flip(buf); sldns_buffer_flip(buf);
return 1; return 1;
} else if(z->type == local_zone_refuse) { } else if(z->type == local_zone_refuse) {
error_encode(buf, (LDNS_RCODE_REFUSED|BIT_AA), qinfo, error_encode(buf, (LDNS_RCODE_REFUSED|BIT_AA), qinfo,
*(uint16_t*)ldns_buffer_begin(buf), *(uint16_t*)sldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), edns); sldns_buffer_read_u16_at(buf, 2), edns);
return 1; return 1;
} else if(z->type == local_zone_static || } else if(z->type == local_zone_static ||
z->type == local_zone_redirect) { z->type == local_zone_redirect) {
@ -1069,8 +1069,8 @@ lz_zone_answer(struct local_zone* z, struct query_info* qinfo,
return local_encode(qinfo, edns, buf, temp, return local_encode(qinfo, edns, buf, temp,
z->soa, 0, rcode); z->soa, 0, rcode);
error_encode(buf, (rcode|BIT_AA), qinfo, error_encode(buf, (rcode|BIT_AA), qinfo,
*(uint16_t*)ldns_buffer_begin(buf), *(uint16_t*)sldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), edns); sldns_buffer_read_u16_at(buf, 2), edns);
return 1; return 1;
} else if(z->type == local_zone_typetransparent) { } else if(z->type == local_zone_typetransparent) {
/* no NODATA or NXDOMAINS for this zone type */ /* no NODATA or NXDOMAINS for this zone type */
@ -1086,8 +1086,8 @@ lz_zone_answer(struct local_zone* z, struct query_info* qinfo,
return local_encode(qinfo, edns, buf, temp, return local_encode(qinfo, edns, buf, temp,
z->soa, 0, rcode); z->soa, 0, rcode);
error_encode(buf, (rcode|BIT_AA), qinfo, error_encode(buf, (rcode|BIT_AA), qinfo,
*(uint16_t*)ldns_buffer_begin(buf), *(uint16_t*)sldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), edns); sldns_buffer_read_u16_at(buf, 2), edns);
return 1; return 1;
} }
@ -1097,7 +1097,7 @@ lz_zone_answer(struct local_zone* z, struct query_info* qinfo,
int int
local_zones_answer(struct local_zones* zones, struct query_info* qinfo, local_zones_answer(struct local_zones* zones, struct query_info* qinfo,
struct edns_data* edns, ldns_buffer* buf, struct regional* temp) struct edns_data* edns, sldns_buffer* buf, struct regional* temp)
{ {
/* see if query is covered by a zone, /* see if query is covered by a zone,
* if so: - try to match (exact) local data * if so: - try to match (exact) local data

4
services/localzone.h
View file

@ -48,7 +48,7 @@ struct regional;
struct config_file; struct config_file;
struct edns_data; struct edns_data;
struct query_info; struct query_info;
struct ldns_buffer; struct sldns_buffer;
/** /**
* Local zone type * Local zone type
@ -225,7 +225,7 @@ void local_zones_print(struct local_zones* zones);
* value is true, but the buffer is cleared (empty). * value is true, but the buffer is cleared (empty).
*/ */
int local_zones_answer(struct local_zones* zones, struct query_info* qinfo, int local_zones_answer(struct local_zones* zones, struct query_info* qinfo,
struct edns_data* edns, struct ldns_buffer* buf, struct regional* temp); struct edns_data* edns, struct sldns_buffer* buf, struct regional* temp);
/** /**
* Parse the string into localzone type. * Parse the string into localzone type.

28
services/mesh.c
View file

@ -162,7 +162,7 @@ mesh_create(struct module_stack* stack, struct module_env* env)
return NULL; return NULL;
} }
mesh->histogram = timehist_setup(); mesh->histogram = timehist_setup();
mesh->qbuf_bak = ldns_buffer_new(env->cfg->msg_buffer_size); mesh->qbuf_bak = sldns_buffer_new(env->cfg->msg_buffer_size);
if(!mesh->histogram || !mesh->qbuf_bak) { if(!mesh->histogram || !mesh->qbuf_bak) {
free(mesh); free(mesh);
log_err("mesh area alloc: out of memory"); log_err("mesh area alloc: out of memory");
@ -210,7 +210,7 @@ mesh_delete(struct mesh_area* mesh)
while(mesh->all.count) while(mesh->all.count)
mesh_delete_helper(mesh->all.root); mesh_delete_helper(mesh->all.root);
timehist_delete(mesh->histogram); timehist_delete(mesh->histogram);
ldns_buffer_free(mesh->qbuf_bak); sldns_buffer_free(mesh->qbuf_bak);
free(mesh); free(mesh);
} }
@ -234,7 +234,7 @@ mesh_delete_all(struct mesh_area* mesh)
mesh->jostle_last = NULL; mesh->jostle_last = NULL;
} }
int mesh_make_new_space(struct mesh_area* mesh, ldns_buffer* qbuf) int mesh_make_new_space(struct mesh_area* mesh, sldns_buffer* qbuf)
{ {
struct mesh_state* m = mesh->jostle_first; struct mesh_state* m = mesh->jostle_first;
/* free space is available */ /* free space is available */
@ -253,7 +253,7 @@ int mesh_make_new_space(struct mesh_area* mesh, ldns_buffer* qbuf)
m->s.qinfo.qname, m->s.qinfo.qtype, m->s.qinfo.qname, m->s.qinfo.qtype,
m->s.qinfo.qclass); m->s.qinfo.qclass);
/* backup the query */ /* backup the query */
if(qbuf) ldns_buffer_copy(mesh->qbuf_bak, qbuf); if(qbuf) sldns_buffer_copy(mesh->qbuf_bak, qbuf);
/* notify supers */ /* notify supers */
if(m->super_set.count > 0) { if(m->super_set.count > 0) {
verbose(VERB_ALGO, "notify supers of failure"); verbose(VERB_ALGO, "notify supers of failure");
@ -265,7 +265,7 @@ int mesh_make_new_space(struct mesh_area* mesh, ldns_buffer* qbuf)
mesh_state_delete(&m->s); mesh_state_delete(&m->s);
/* restore the query - note that the qinfo ptr to /* restore the query - note that the qinfo ptr to
* the querybuffer is then correct again. */ * the querybuffer is then correct again. */
if(qbuf) ldns_buffer_copy(qbuf, mesh->qbuf_bak); if(qbuf) sldns_buffer_copy(qbuf, mesh->qbuf_bak);
return 1; return 1;
} }
} }
@ -372,7 +372,7 @@ void mesh_new_client(struct mesh_area* mesh, struct query_info* qinfo,
int int
mesh_new_callback(struct mesh_area* mesh, struct query_info* qinfo, mesh_new_callback(struct mesh_area* mesh, struct query_info* qinfo,
uint16_t qflags, struct edns_data* edns, ldns_buffer* buf, uint16_t qflags, struct edns_data* edns, sldns_buffer* buf,
uint16_t qid, mesh_cb_func_t cb, void* cb_arg) uint16_t qid, mesh_cb_func_t cb, void* cb_arg)
{ {
struct mesh_state* s = mesh_area_find(mesh, qinfo, qflags&BIT_RD, 0); struct mesh_state* s = mesh_area_find(mesh, qinfo, qflags&BIT_RD, 0);
@ -800,7 +800,7 @@ mesh_do_callback(struct mesh_state* m, int rcode, struct reply_info* rep,
(*r->cb)(r->cb_arg, rcode, r->buf, sec_status_unchecked, NULL); (*r->cb)(r->cb_arg, rcode, r->buf, sec_status_unchecked, NULL);
} else { } else {
size_t udp_size = r->edns.udp_size; size_t udp_size = r->edns.udp_size;
ldns_buffer_clear(r->buf); sldns_buffer_clear(r->buf);
r->edns.edns_version = EDNS_ADVERTISED_VERSION; r->edns.edns_version = EDNS_ADVERTISED_VERSION;
r->edns.udp_size = EDNS_ADVERTISED_SIZE; r->edns.udp_size = EDNS_ADVERTISED_SIZE;
r->edns.ext_rcode = 0; r->edns.ext_rcode = 0;
@ -858,11 +858,11 @@ mesh_send_reply(struct mesh_state* m, int rcode, struct reply_info* rep,
prev->edns.udp_size == r->edns.udp_size) { prev->edns.udp_size == r->edns.udp_size) {
/* if the previous reply is identical to this one, fix ID */ /* if the previous reply is identical to this one, fix ID */
if(prev->query_reply.c->buffer != r->query_reply.c->buffer) if(prev->query_reply.c->buffer != r->query_reply.c->buffer)
ldns_buffer_copy(r->query_reply.c->buffer, sldns_buffer_copy(r->query_reply.c->buffer,
prev->query_reply.c->buffer); prev->query_reply.c->buffer);
ldns_buffer_write_at(r->query_reply.c->buffer, 0, sldns_buffer_write_at(r->query_reply.c->buffer, 0,
&r->qid, sizeof(uint16_t)); &r->qid, sizeof(uint16_t));
ldns_buffer_write_at(r->query_reply.c->buffer, 12, sldns_buffer_write_at(r->query_reply.c->buffer, 12,
r->qname, m->s.qinfo.qname_len); r->qname, m->s.qinfo.qname_len);
comm_point_send_reply(&r->query_reply); comm_point_send_reply(&r->query_reply);
} else if(rcode) { } else if(rcode) {
@ -898,11 +898,11 @@ mesh_send_reply(struct mesh_state* m, int rcode, struct reply_info* rep,
timeval_add(&m->s.env->mesh->replies_sum_wait, &duration); timeval_add(&m->s.env->mesh->replies_sum_wait, &duration);
timehist_insert(m->s.env->mesh->histogram, &duration); timehist_insert(m->s.env->mesh->histogram, &duration);
if(m->s.env->cfg->stat_extended) { if(m->s.env->cfg->stat_extended) {
uint16_t rc = FLAGS_GET_RCODE(ldns_buffer_read_u16_at(r-> uint16_t rc = FLAGS_GET_RCODE(sldns_buffer_read_u16_at(r->
query_reply.c->buffer, 2)); query_reply.c->buffer, 2));
if(secure) m->s.env->mesh->ans_secure++; if(secure) m->s.env->mesh->ans_secure++;
m->s.env->mesh->ans_rcode[ rc ] ++; m->s.env->mesh->ans_rcode[ rc ] ++;
if(rc == 0 && LDNS_ANCOUNT(ldns_buffer_begin(r-> if(rc == 0 && LDNS_ANCOUNT(sldns_buffer_begin(r->
query_reply.c->buffer)) == 0) query_reply.c->buffer)) == 0)
m->s.env->mesh->ans_nodata++; m->s.env->mesh->ans_nodata++;
} }
@ -956,7 +956,7 @@ struct mesh_state* mesh_area_find(struct mesh_area* mesh,
} }
int mesh_state_add_cb(struct mesh_state* s, struct edns_data* edns, int mesh_state_add_cb(struct mesh_state* s, struct edns_data* edns,
ldns_buffer* buf, mesh_cb_func_t cb, void* cb_arg, sldns_buffer* buf, mesh_cb_func_t cb, void* cb_arg,
uint16_t qid, uint16_t qflags) uint16_t qid, uint16_t qflags)
{ {
struct mesh_cb* r = regional_alloc(s->s.region, struct mesh_cb* r = regional_alloc(s->s.region,
@ -1167,7 +1167,7 @@ mesh_get_mem(struct mesh_area* mesh)
struct mesh_state* m; struct mesh_state* m;
size_t s = sizeof(*mesh) + sizeof(struct timehist) + size_t s = sizeof(*mesh) + sizeof(struct timehist) +
sizeof(struct th_buck)*mesh->histogram->num + sizeof(struct th_buck)*mesh->histogram->num +
sizeof(ldns_buffer) + ldns_buffer_capacity(mesh->qbuf_bak); sizeof(sldns_buffer) + sldns_buffer_capacity(mesh->qbuf_bak);
RBTREE_FOR(m, struct mesh_state*, &mesh->all) { RBTREE_FOR(m, struct mesh_state*, &mesh->all) {
/* all, including m itself allocated in qstate region */ /* all, including m itself allocated in qstate region */
s += regional_get_mem(m->s.region); s += regional_get_mem(m->s.region);

14
services/mesh.h
View file

@ -51,7 +51,7 @@
#include "util/data/msgparse.h" #include "util/data/msgparse.h"
#include "util/module.h" #include "util/module.h"
#include "services/modstack.h" #include "services/modstack.h"
struct ldns_buffer; struct sldns_buffer;
struct mesh_state; struct mesh_state;
struct mesh_reply; struct mesh_reply;
struct mesh_cb; struct mesh_cb;
@ -126,7 +126,7 @@ struct mesh_area {
/** backup of query if other operations recurse and need the /** backup of query if other operations recurse and need the
* network buffers */ * network buffers */
struct ldns_buffer* qbuf_bak; struct sldns_buffer* qbuf_bak;
/** double linked list of the run-to-completion query states. /** double linked list of the run-to-completion query states.
* These are query states with a reply */ * These are query states with a reply */
@ -220,7 +220,7 @@ struct mesh_reply {
* Mesh result callback func. * Mesh result callback func.
* called as func(cb_arg, rcode, buffer_with_reply, security, why_bogus); * called as func(cb_arg, rcode, buffer_with_reply, security, why_bogus);
*/ */
typedef void (*mesh_cb_func_t)(void*, int, struct ldns_buffer*, enum sec_status, typedef void (*mesh_cb_func_t)(void*, int, struct sldns_buffer*, enum sec_status,
char*); char*);
/** /**
@ -236,7 +236,7 @@ struct mesh_cb {
/** flags of query, for reply flags */ /** flags of query, for reply flags */
uint16_t qflags; uint16_t qflags;
/** buffer for reply */ /** buffer for reply */
struct ldns_buffer* buf; struct sldns_buffer* buf;
/** callback routine for results. if rcode != 0 buf has message. /** callback routine for results. if rcode != 0 buf has message.
* called as cb(cb_arg, rcode, buf, sec_state); * called as cb(cb_arg, rcode, buf, sec_state);
@ -295,7 +295,7 @@ void mesh_new_client(struct mesh_area* mesh, struct query_info* qinfo,
* @return 0 on error. * @return 0 on error.
*/ */
int mesh_new_callback(struct mesh_area* mesh, struct query_info* qinfo, int mesh_new_callback(struct mesh_area* mesh, struct query_info* qinfo,
uint16_t qflags, struct edns_data* edns, struct ldns_buffer* buf, uint16_t qflags, struct edns_data* edns, struct sldns_buffer* buf,
uint16_t qid, mesh_cb_func_t cb, void* cb_arg); uint16_t qid, mesh_cb_func_t cb, void* cb_arg);
/** /**
@ -474,7 +474,7 @@ int mesh_state_add_reply(struct mesh_state* s, struct edns_data* edns,
* @return: 0 on alloc error. * @return: 0 on alloc error.
*/ */
int mesh_state_add_cb(struct mesh_state* s, struct edns_data* edns, int mesh_state_add_cb(struct mesh_state* s, struct edns_data* edns,
struct ldns_buffer* buf, mesh_cb_func_t cb, void* cb_arg, uint16_t qid, struct sldns_buffer* buf, mesh_cb_func_t cb, void* cb_arg, uint16_t qid,
uint16_t qflags); uint16_t qflags);
/** /**
@ -549,7 +549,7 @@ int mesh_state_ref_compare(const void* ap, const void* bp);
* You can pass NULL if there is no buffer that must be backed up. * You can pass NULL if there is no buffer that must be backed up.
* @return false if no space is available. * @return false if no space is available.
*/ */
int mesh_make_new_space(struct mesh_area* mesh, struct ldns_buffer* qbuf); int mesh_make_new_space(struct mesh_area* mesh, struct sldns_buffer* qbuf);
/** /**
* Insert mesh state into a double linked list. Inserted at end. * Insert mesh state into a double linked list. Inserted at end.

166
services/outside_network.c
View file

@ -76,10 +76,10 @@
/** initiate TCP transaction for serviced query */ /** initiate TCP transaction for serviced query */
static void serviced_tcp_initiate(struct outside_network* outnet, static void serviced_tcp_initiate(struct outside_network* outnet,
struct serviced_query* sq, ldns_buffer* buff); struct serviced_query* sq, sldns_buffer* buff);
/** with a fd available, randomize and send UDP */ /** with a fd available, randomize and send UDP */
static int randomize_and_send_udp(struct outside_network* outnet, static int randomize_and_send_udp(struct outside_network* outnet,
struct pending* pend, ldns_buffer* packet, int timeout); struct pending* pend, sldns_buffer* packet, int timeout);
int int
pending_cmp(const void* key1, const void* key2) pending_cmp(const void* key1, const void* key2)
@ -263,9 +263,9 @@ outnet_tcp_take_into_use(struct waiting_tcp* w, uint8_t* pkt, size_t pkt_len)
pend->query = w; pend->query = w;
pend->c->repinfo.addrlen = w->addrlen; pend->c->repinfo.addrlen = w->addrlen;
memcpy(&pend->c->repinfo.addr, &w->addr, w->addrlen); memcpy(&pend->c->repinfo.addr, &w->addr, w->addrlen);
ldns_buffer_clear(pend->c->buffer); sldns_buffer_clear(pend->c->buffer);
ldns_buffer_write(pend->c->buffer, pkt, pkt_len); sldns_buffer_write(pend->c->buffer, pkt, pkt_len);
ldns_buffer_flip(pend->c->buffer); sldns_buffer_flip(pend->c->buffer);
pend->c->tcp_is_reading = 0; pend->c->tcp_is_reading = 0;
pend->c->tcp_byte_count = 0; pend->c->tcp_byte_count = 0;
comm_point_start_listening(pend->c, s, -1); comm_point_start_listening(pend->c, s, -1);
@ -325,8 +325,8 @@ outnet_tcp_cb(struct comm_point* c, void* arg, int error,
/* pass error below and exit */ /* pass error below and exit */
} else { } else {
/* check ID */ /* check ID */
if(ldns_buffer_limit(c->buffer) < sizeof(uint16_t) || if(sldns_buffer_limit(c->buffer) < sizeof(uint16_t) ||
LDNS_ID_WIRE(ldns_buffer_begin(c->buffer))!=pend->id) { LDNS_ID_WIRE(sldns_buffer_begin(c->buffer))!=pend->id) {
log_addr(VERB_QUERY, log_addr(VERB_QUERY,
"outnettcp: bad ID in reply, from:", "outnettcp: bad ID in reply, from:",
&pend->query->addr, pend->query->addrlen); &pend->query->addr, pend->query->addrlen);
@ -372,9 +372,9 @@ outnet_send_wait_udp(struct outside_network* outnet)
pend = outnet->udp_wait_first; pend = outnet->udp_wait_first;
outnet->udp_wait_first = pend->next_waiting; outnet->udp_wait_first = pend->next_waiting;
if(!pend->next_waiting) outnet->udp_wait_last = NULL; if(!pend->next_waiting) outnet->udp_wait_last = NULL;
ldns_buffer_clear(outnet->udp_buff); sldns_buffer_clear(outnet->udp_buff);
ldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len); sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
ldns_buffer_flip(outnet->udp_buff); sldns_buffer_flip(outnet->udp_buff);
free(pend->pkt); /* freeing now makes get_mem correct */ free(pend->pkt); /* freeing now makes get_mem correct */
pend->pkt = NULL; pend->pkt = NULL;
pend->pkt_len = 0; pend->pkt_len = 0;
@ -402,14 +402,14 @@ outnet_udp_cb(struct comm_point* c, void* arg, int error,
verbose(VERB_QUERY, "outnetudp got udp error %d", error); verbose(VERB_QUERY, "outnetudp got udp error %d", error);
return 0; return 0;
} }
if(ldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) { if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
verbose(VERB_QUERY, "outnetudp udp too short"); verbose(VERB_QUERY, "outnetudp udp too short");
return 0; return 0;
} }
log_assert(reply_info); log_assert(reply_info);
/* setup lookup key */ /* setup lookup key */
key.id = (unsigned)LDNS_ID_WIRE(ldns_buffer_begin(c->buffer)); key.id = (unsigned)LDNS_ID_WIRE(sldns_buffer_begin(c->buffer));
memcpy(&key.addr, &reply_info->addr, reply_info->addrlen); memcpy(&key.addr, &reply_info->addr, reply_info->addrlen);
key.addrlen = reply_info->addrlen; key.addrlen = reply_info->addrlen;
verbose(VERB_ALGO, "Incoming reply id = %4.4x", key.id); verbose(VERB_ALGO, "Incoming reply id = %4.4x", key.id);
@ -609,7 +609,7 @@ outside_network_create(struct comm_base *base, size_t bufsize,
return NULL; return NULL;
} }
} }
if( !(outnet->udp_buff = ldns_buffer_new(bufsize)) || if( !(outnet->udp_buff = sldns_buffer_new(bufsize)) ||
!(outnet->pending = rbtree_create(pending_cmp)) || !(outnet->pending = rbtree_create(pending_cmp)) ||
!(outnet->serviced = rbtree_create(serviced_cmp)) || !(outnet->serviced = rbtree_create(serviced_cmp)) ||
!create_pending_tcp(outnet, bufsize)) { !create_pending_tcp(outnet, bufsize)) {
@ -731,7 +731,7 @@ outside_network_delete(struct outside_network* outnet)
free(outnet->serviced); free(outnet->serviced);
} }
if(outnet->udp_buff) if(outnet->udp_buff)
ldns_buffer_free(outnet->udp_buff); sldns_buffer_free(outnet->udp_buff);
if(outnet->unused_fds) { if(outnet->unused_fds) {
struct port_comm* p = outnet->unused_fds, *np; struct port_comm* p = outnet->unused_fds, *np;
while(p) { while(p) {
@ -863,18 +863,18 @@ udp_sockport(struct sockaddr_storage* addr, socklen_t addrlen, int port,
/** Select random ID */ /** Select random ID */
static int static int
select_id(struct outside_network* outnet, struct pending* pend, select_id(struct outside_network* outnet, struct pending* pend,
ldns_buffer* packet) sldns_buffer* packet)
{ {
int id_tries = 0; int id_tries = 0;
pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff; pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
LDNS_ID_SET(ldns_buffer_begin(packet), pend->id); LDNS_ID_SET(sldns_buffer_begin(packet), pend->id);
/* insert in tree */ /* insert in tree */
pend->node.key = pend; pend->node.key = pend;
while(!rbtree_insert(outnet->pending, &pend->node)) { while(!rbtree_insert(outnet->pending, &pend->node)) {
/* change ID to avoid collision */ /* change ID to avoid collision */
pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff; pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
LDNS_ID_SET(ldns_buffer_begin(packet), pend->id); LDNS_ID_SET(sldns_buffer_begin(packet), pend->id);
id_tries++; id_tries++;
if(id_tries == MAX_ID_RETRY) { if(id_tries == MAX_ID_RETRY) {
pend->id=99999; /* non existant ID */ pend->id=99999; /* non existant ID */
@ -958,7 +958,7 @@ select_ifport(struct outside_network* outnet, struct pending* pend,
static int static int
randomize_and_send_udp(struct outside_network* outnet, struct pending* pend, randomize_and_send_udp(struct outside_network* outnet, struct pending* pend,
ldns_buffer* packet, int timeout) sldns_buffer* packet, int timeout)
{ {
struct timeval tv; struct timeval tv;
@ -997,7 +997,7 @@ randomize_and_send_udp(struct outside_network* outnet, struct pending* pend,
} }
struct pending* 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, struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* cb, void* cb_arg) comm_point_callback_t* cb, void* cb_arg)
{ {
@ -1020,8 +1020,8 @@ pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
/* no unused fd, cannot create a new port (randomly) */ /* no unused fd, cannot create a new port (randomly) */
verbose(VERB_ALGO, "no fds available, udp query waiting"); verbose(VERB_ALGO, "no fds available, udp query waiting");
pend->timeout = timeout; pend->timeout = timeout;
pend->pkt_len = ldns_buffer_limit(packet); pend->pkt_len = sldns_buffer_limit(packet);
pend->pkt = (uint8_t*)memdup(ldns_buffer_begin(packet), pend->pkt = (uint8_t*)memdup(sldns_buffer_begin(packet),
pend->pkt_len); pend->pkt_len);
if(!pend->pkt) { if(!pend->pkt) {
comm_timer_delete(pend->timer); comm_timer_delete(pend->timer);
@ -1080,7 +1080,7 @@ outnet_tcptimer(void* arg)
} }
struct waiting_tcp* 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, struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* callback, void* callback_arg, int ssl_upstream) comm_point_callback_t* callback, void* callback_arg, int ssl_upstream)
{ {
@ -1090,7 +1090,7 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
uint16_t id; uint16_t id;
/* if no buffer is free allocate space to store query */ /* if no buffer is free allocate space to store query */
w = (struct waiting_tcp*)malloc(sizeof(struct waiting_tcp) w = (struct waiting_tcp*)malloc(sizeof(struct waiting_tcp)
+ (pend?0:ldns_buffer_limit(packet))); + (pend?0:sldns_buffer_limit(packet)));
if(!w) { if(!w) {
return NULL; return NULL;
} }
@ -1101,7 +1101,7 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
w->pkt = NULL; w->pkt = NULL;
w->pkt_len = 0; w->pkt_len = 0;
id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff; id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
LDNS_ID_SET(ldns_buffer_begin(packet), id); LDNS_ID_SET(sldns_buffer_begin(packet), id);
memcpy(&w->addr, addr, addrlen); memcpy(&w->addr, addr, addrlen);
w->addrlen = addrlen; w->addrlen = addrlen;
w->outnet = outnet; w->outnet = outnet;
@ -1115,16 +1115,16 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
comm_timer_set(w->timer, &tv); comm_timer_set(w->timer, &tv);
if(pend) { if(pend) {
/* we have a buffer available right now */ /* we have a buffer available right now */
if(!outnet_tcp_take_into_use(w, ldns_buffer_begin(packet), if(!outnet_tcp_take_into_use(w, sldns_buffer_begin(packet),
ldns_buffer_limit(packet))) { sldns_buffer_limit(packet))) {
waiting_tcp_delete(w); waiting_tcp_delete(w);
return NULL; return NULL;
} }
} else { } else {
/* queue up */ /* queue up */
w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp); w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp);
w->pkt_len = ldns_buffer_limit(packet); w->pkt_len = sldns_buffer_limit(packet);
memmove(w->pkt, ldns_buffer_begin(packet), w->pkt_len); memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len);
w->next_waiting = NULL; w->next_waiting = NULL;
if(outnet->tcp_wait_last) if(outnet->tcp_wait_last)
outnet->tcp_wait_last->next_waiting = w; outnet->tcp_wait_last->next_waiting = w;
@ -1136,31 +1136,31 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
/** create query for serviced queries */ /** create query for serviced queries */
static void static void
serviced_gen_query(ldns_buffer* buff, uint8_t* qname, size_t qnamelen, serviced_gen_query(sldns_buffer* buff, uint8_t* qname, size_t qnamelen,
uint16_t qtype, uint16_t qclass, uint16_t flags) uint16_t qtype, uint16_t qclass, uint16_t flags)
{ {
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
/* skip id */ /* skip id */
ldns_buffer_write_u16(buff, flags); sldns_buffer_write_u16(buff, flags);
ldns_buffer_write_u16(buff, 1); /* qdcount */ sldns_buffer_write_u16(buff, 1); /* qdcount */
ldns_buffer_write_u16(buff, 0); /* ancount */ sldns_buffer_write_u16(buff, 0); /* ancount */
ldns_buffer_write_u16(buff, 0); /* nscount */ sldns_buffer_write_u16(buff, 0); /* nscount */
ldns_buffer_write_u16(buff, 0); /* arcount */ sldns_buffer_write_u16(buff, 0); /* arcount */
ldns_buffer_write(buff, qname, qnamelen); sldns_buffer_write(buff, qname, qnamelen);
ldns_buffer_write_u16(buff, qtype); sldns_buffer_write_u16(buff, qtype);
ldns_buffer_write_u16(buff, qclass); sldns_buffer_write_u16(buff, qclass);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
} }
/** lookup serviced query in serviced query rbtree */ /** lookup serviced query in serviced query rbtree */
static struct serviced_query* static struct serviced_query*
lookup_serviced(struct outside_network* outnet, ldns_buffer* buff, int dnssec, lookup_serviced(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
struct sockaddr_storage* addr, socklen_t addrlen) struct sockaddr_storage* addr, socklen_t addrlen)
{ {
struct serviced_query key; struct serviced_query key;
key.node.key = &key; key.node.key = &key;
key.qbuf = ldns_buffer_begin(buff); key.qbuf = sldns_buffer_begin(buff);
key.qbuflen = ldns_buffer_limit(buff); key.qbuflen = sldns_buffer_limit(buff);
key.dnssec = dnssec; key.dnssec = dnssec;
memcpy(&key.addr, addr, addrlen); memcpy(&key.addr, addr, addrlen);
key.addrlen = addrlen; key.addrlen = addrlen;
@ -1170,7 +1170,7 @@ lookup_serviced(struct outside_network* outnet, ldns_buffer* buff, int dnssec,
/** Create new serviced entry */ /** Create new serviced entry */
static struct serviced_query* static struct serviced_query*
serviced_create(struct outside_network* outnet, ldns_buffer* buff, int dnssec, serviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
int want_dnssec, int tcp_upstream, int ssl_upstream, int want_dnssec, int tcp_upstream, int ssl_upstream,
struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone, struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
size_t zonelen, int qtype) size_t zonelen, int qtype)
@ -1182,12 +1182,12 @@ serviced_create(struct outside_network* outnet, ldns_buffer* buff, int dnssec,
if(!sq) if(!sq)
return NULL; return NULL;
sq->node.key = sq; sq->node.key = sq;
sq->qbuf = memdup(ldns_buffer_begin(buff), ldns_buffer_limit(buff)); sq->qbuf = memdup(sldns_buffer_begin(buff), sldns_buffer_limit(buff));
if(!sq->qbuf) { if(!sq->qbuf) {
free(sq); free(sq);
return NULL; return NULL;
} }
sq->qbuflen = ldns_buffer_limit(buff); sq->qbuflen = sldns_buffer_limit(buff);
sq->zone = memdup(zone, zonelen); sq->zone = memdup(zone, zonelen);
if(!sq->zone) { if(!sq->zone) {
free(sq->qbuf); free(sq->qbuf);
@ -1312,17 +1312,17 @@ serviced_perturb_qname(struct ub_randstate* rnd, uint8_t* qbuf, size_t len)
/** put serviced query into a buffer */ /** put serviced query into a buffer */
static void static void
serviced_encode(struct serviced_query* sq, ldns_buffer* buff, int with_edns) serviced_encode(struct serviced_query* sq, sldns_buffer* buff, int with_edns)
{ {
/* if we are using 0x20 bits for ID randomness, perturb them */ /* if we are using 0x20 bits for ID randomness, perturb them */
if(sq->outnet->use_caps_for_id) { if(sq->outnet->use_caps_for_id) {
serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen); serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
} }
/* generate query */ /* generate query */
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write_u16(buff, 0); /* id placeholder */ sldns_buffer_write_u16(buff, 0); /* id placeholder */
ldns_buffer_write(buff, sq->qbuf, sq->qbuflen); sldns_buffer_write(buff, sq->qbuf, sq->qbuflen);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
if(with_edns) { if(with_edns) {
/* add edns section */ /* add edns section */
struct edns_data edns; struct edns_data edns;
@ -1346,7 +1346,7 @@ serviced_encode(struct serviced_query* sq, ldns_buffer* buff, int with_edns)
if(sq->dnssec & EDNS_DO) if(sq->dnssec & EDNS_DO)
edns.bits = EDNS_DO; edns.bits = EDNS_DO;
if(sq->dnssec & BIT_CD) if(sq->dnssec & BIT_CD)
LDNS_CD_SET(ldns_buffer_begin(buff)); LDNS_CD_SET(sldns_buffer_begin(buff));
attach_edns_record(buff, &edns); attach_edns_record(buff, &edns);
} }
} }
@ -1359,7 +1359,7 @@ serviced_encode(struct serviced_query* sq, ldns_buffer* buff, int with_edns)
* @return 0 on error. * @return 0 on error.
*/ */
static int static int
serviced_udp_send(struct serviced_query* sq, ldns_buffer* buff) serviced_udp_send(struct serviced_query* sq, sldns_buffer* buff)
{ {
int rtt, vs; int rtt, vs;
uint8_t edns_lame_known; uint8_t edns_lame_known;
@ -1399,21 +1399,21 @@ serviced_udp_send(struct serviced_query* sq, ldns_buffer* buff)
/** check that perturbed qname is identical */ /** check that perturbed qname is identical */
static int static int
serviced_check_qname(ldns_buffer* pkt, uint8_t* qbuf, size_t qbuflen) serviced_check_qname(sldns_buffer* pkt, uint8_t* qbuf, size_t qbuflen)
{ {
uint8_t* d1 = ldns_buffer_at(pkt, 12); uint8_t* d1 = sldns_buffer_at(pkt, 12);
uint8_t* d2 = qbuf+10; uint8_t* d2 = qbuf+10;
uint8_t len1, len2; uint8_t len1, len2;
int count = 0; int count = 0;
log_assert(qbuflen >= 15 /* 10 header, root, type, class */); log_assert(qbuflen >= 15 /* 10 header, root, type, class */);
len1 = *d1++; len1 = *d1++;
len2 = *d2++; len2 = *d2++;
if(ldns_buffer_limit(pkt) < 12+1+4) /* packet too small for qname */ if(sldns_buffer_limit(pkt) < 12+1+4) /* packet too small for qname */
return 0; return 0;
while(len1 != 0 || len2 != 0) { while(len1 != 0 || len2 != 0) {
if(LABEL_IS_PTR(len1)) { if(LABEL_IS_PTR(len1)) {
d1 = ldns_buffer_at(pkt, PTR_OFFSET(len1, *d1)); d1 = sldns_buffer_at(pkt, PTR_OFFSET(len1, *d1));
if(d1 >= ldns_buffer_at(pkt, ldns_buffer_limit(pkt))) if(d1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt)))
return 0; return 0;
len1 = *d1++; len1 = *d1++;
if(count++ > MAX_COMPRESS_PTRS) if(count++ > MAX_COMPRESS_PTRS)
@ -1463,10 +1463,10 @@ serviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c,
verbose(VERB_ALGO, "svcd callbacks start"); verbose(VERB_ALGO, "svcd callbacks start");
if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c) { if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c) {
/* noerror and nxdomain must have a qname in reply */ /* noerror and nxdomain must have a qname in reply */
if(ldns_buffer_read_u16_at(c->buffer, 4) == 0 && if(sldns_buffer_read_u16_at(c->buffer, 4) == 0 &&
(LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
== LDNS_RCODE_NOERROR || == LDNS_RCODE_NOERROR ||
LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
== LDNS_RCODE_NXDOMAIN)) { == LDNS_RCODE_NXDOMAIN)) {
verbose(VERB_DETAIL, "no qname in reply to check 0x20ID"); verbose(VERB_DETAIL, "no qname in reply to check 0x20ID");
log_addr(VERB_DETAIL, "from server", log_addr(VERB_DETAIL, "from server",
@ -1474,7 +1474,7 @@ serviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c,
log_buf(VERB_DETAIL, "for packet", c->buffer); log_buf(VERB_DETAIL, "for packet", c->buffer);
error = NETEVENT_CLOSED; error = NETEVENT_CLOSED;
c = NULL; c = NULL;
} else if(ldns_buffer_read_u16_at(c->buffer, 4) > 0 && } else if(sldns_buffer_read_u16_at(c->buffer, 4) > 0 &&
!serviced_check_qname(c->buffer, sq->qbuf, !serviced_check_qname(c->buffer, sq->qbuf,
sq->qbuflen)) { sq->qbuflen)) {
verbose(VERB_DETAIL, "wrong 0x20-ID in reply qname"); verbose(VERB_DETAIL, "wrong 0x20-ID in reply qname");
@ -1484,12 +1484,12 @@ serviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c,
error = NETEVENT_CAPSFAIL; error = NETEVENT_CAPSFAIL;
/* and cleanup too */ /* and cleanup too */
pkt_dname_tolower(c->buffer, pkt_dname_tolower(c->buffer,
ldns_buffer_at(c->buffer, 12)); sldns_buffer_at(c->buffer, 12));
} else { } else {
verbose(VERB_ALGO, "good 0x20-ID in reply qname"); verbose(VERB_ALGO, "good 0x20-ID in reply qname");
/* cleanup caps, prettier cache contents. */ /* cleanup caps, prettier cache contents. */
pkt_dname_tolower(c->buffer, pkt_dname_tolower(c->buffer,
ldns_buffer_at(c->buffer, 12)); sldns_buffer_at(c->buffer, 12));
} }
} }
if(dobackup && c) { if(dobackup && c) {
@ -1497,8 +1497,8 @@ serviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c,
* may send outgoing queries that overwrite the buffer. * may send outgoing queries that overwrite the buffer.
* use secondary buffer to store the query. * use secondary buffer to store the query.
* This is a data copy, but faster than packet to server */ * This is a data copy, but faster than packet to server */
backlen = ldns_buffer_limit(c->buffer); backlen = sldns_buffer_limit(c->buffer);
backup_p = memdup(ldns_buffer_begin(c->buffer), backlen); backup_p = memdup(sldns_buffer_begin(c->buffer), backlen);
if(!backup_p) { if(!backup_p) {
log_err("malloc failure in serviced query callbacks"); log_err("malloc failure in serviced query callbacks");
error = NETEVENT_CLOSED; error = NETEVENT_CLOSED;
@ -1510,9 +1510,9 @@ serviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c,
while((p=sq->cblist) != NULL) { while((p=sq->cblist) != NULL) {
sq->cblist = p->next; /* remove this element */ sq->cblist = p->next; /* remove this element */
if(dobackup && c) { if(dobackup && c) {
ldns_buffer_clear(c->buffer); sldns_buffer_clear(c->buffer);
ldns_buffer_write(c->buffer, backup_p, backlen); sldns_buffer_write(c->buffer, backup_p, backlen);
ldns_buffer_flip(c->buffer); sldns_buffer_flip(c->buffer);
} }
fptr_ok(fptr_whitelist_serviced_query(p->cb)); fptr_ok(fptr_whitelist_serviced_query(p->cb));
(void)(*p->cb)(c, p->cb_arg, error, rep); (void)(*p->cb)(c, p->cb_arg, error, rep);
@ -1541,8 +1541,8 @@ serviced_tcp_callback(struct comm_point* c, void* arg, int error,
infra_update_tcp_works(sq->outnet->infra, &sq->addr, infra_update_tcp_works(sq->outnet->infra, &sq->addr,
sq->addrlen, sq->zone, sq->zonelen); sq->addrlen, sq->zone, sq->zonelen);
if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS && if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS &&
(LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) == (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(ldns_buffer_begin( LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(sldns_buffer_begin(
c->buffer)) == LDNS_RCODE_NOTIMPL) ) { c->buffer)) == LDNS_RCODE_NOTIMPL) ) {
/* attempt to fallback to nonEDNS */ /* attempt to fallback to nonEDNS */
sq->status = serviced_query_TCP_EDNS_fallback; sq->status = serviced_query_TCP_EDNS_fallback;
@ -1550,10 +1550,10 @@ serviced_tcp_callback(struct comm_point* c, void* arg, int error,
return 0; return 0;
} else if(error==NETEVENT_NOERROR && } else if(error==NETEVENT_NOERROR &&
sq->status == serviced_query_TCP_EDNS_fallback && sq->status == serviced_query_TCP_EDNS_fallback &&
(LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) == (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
LDNS_RCODE_NOERROR || LDNS_RCODE_WIRE( LDNS_RCODE_NOERROR || LDNS_RCODE_WIRE(
ldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN
|| LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) || LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
== LDNS_RCODE_YXDOMAIN)) { == LDNS_RCODE_YXDOMAIN)) {
/* the fallback produced a result that looks promising, note /* the fallback produced a result that looks promising, note
* that this server should be approached without EDNS */ * that this server should be approached without EDNS */
@ -1599,7 +1599,7 @@ serviced_tcp_callback(struct comm_point* c, void* arg, int error,
static void static void
serviced_tcp_initiate(struct outside_network* outnet, serviced_tcp_initiate(struct outside_network* outnet,
struct serviced_query* sq, ldns_buffer* buff) struct serviced_query* sq, sldns_buffer* buff)
{ {
verbose(VERB_ALGO, "initiate TCP query %s", verbose(VERB_ALGO, "initiate TCP query %s",
sq->status==serviced_query_TCP_EDNS?"EDNS":""); sq->status==serviced_query_TCP_EDNS?"EDNS":"");
@ -1618,7 +1618,7 @@ serviced_tcp_initiate(struct outside_network* outnet,
/** Send serviced query over TCP return false on initial failure */ /** Send serviced query over TCP return false on initial failure */
static int static int
serviced_tcp_send(struct serviced_query* sq, ldns_buffer* buff) serviced_tcp_send(struct serviced_query* sq, sldns_buffer* buff)
{ {
int vs, rtt; int vs, rtt;
uint8_t edns_lame_known; uint8_t edns_lame_known;
@ -1697,9 +1697,9 @@ serviced_udp_callback(struct comm_point* c, void* arg, int error,
if(!fallback_tcp) { if(!fallback_tcp) {
if( (sq->status == serviced_query_UDP_EDNS if( (sq->status == serviced_query_UDP_EDNS
||sq->status == serviced_query_UDP_EDNS_FRAG) ||sq->status == serviced_query_UDP_EDNS_FRAG)
&& (LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) && (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
== LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE( == LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(
ldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOTIMPL)) { sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOTIMPL)) {
/* try to get an answer by falling back without EDNS */ /* try to get an answer by falling back without EDNS */
verbose(VERB_ALGO, "serviced query: attempt without EDNS"); verbose(VERB_ALGO, "serviced query: attempt without EDNS");
sq->status = serviced_query_UDP_EDNS_fallback; sq->status = serviced_query_UDP_EDNS_fallback;
@ -1732,9 +1732,9 @@ serviced_udp_callback(struct comm_point* c, void* arg, int error,
sq->edns_lame_known = 1; sq->edns_lame_known = 1;
} else if(sq->status == serviced_query_UDP_EDNS_fallback && } else if(sq->status == serviced_query_UDP_EDNS_fallback &&
!sq->edns_lame_known && (LDNS_RCODE_WIRE( !sq->edns_lame_known && (LDNS_RCODE_WIRE(
ldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOERROR || sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOERROR ||
LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) == LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
LDNS_RCODE_NXDOMAIN || LDNS_RCODE_WIRE(ldns_buffer_begin( LDNS_RCODE_NXDOMAIN || LDNS_RCODE_WIRE(sldns_buffer_begin(
c->buffer)) == LDNS_RCODE_YXDOMAIN)) { c->buffer)) == LDNS_RCODE_YXDOMAIN)) {
/* the fallback produced a result that looks promising, note /* the fallback produced a result that looks promising, note
* that this server should be approached without EDNS */ * that this server should be approached without EDNS */
@ -1773,7 +1773,7 @@ serviced_udp_callback(struct comm_point* c, void* arg, int error,
} /* end of if_!fallback_tcp */ } /* end of if_!fallback_tcp */
/* perform TC flag check and TCP fallback after updating our /* perform TC flag check and TCP fallback after updating our
* cache entries for EDNS status and RTT times */ * cache entries for EDNS status and RTT times */
if(LDNS_TC_WIRE(ldns_buffer_begin(c->buffer)) || fallback_tcp) { if(LDNS_TC_WIRE(sldns_buffer_begin(c->buffer)) || fallback_tcp) {
/* fallback to TCP */ /* fallback to TCP */
/* this discards partial UDP contents */ /* this discards partial UDP contents */
if(sq->status == serviced_query_UDP_EDNS || if(sq->status == serviced_query_UDP_EDNS ||
@ -1796,7 +1796,7 @@ outnet_serviced_query(struct outside_network* outnet,
uint16_t flags, int dnssec, int want_dnssec, int tcp_upstream, uint16_t flags, int dnssec, int want_dnssec, int tcp_upstream,
int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen, int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen,
uint8_t* zone, size_t zonelen, comm_point_callback_t* callback, uint8_t* zone, size_t zonelen, comm_point_callback_t* callback,
void* callback_arg, ldns_buffer* buff) void* callback_arg, sldns_buffer* buff)
{ {
struct serviced_query* sq; struct serviced_query* sq;
struct service_callback* cb; struct service_callback* cb;
@ -1925,7 +1925,7 @@ size_t outnet_get_mem(struct outside_network* outnet)
struct port_comm* pc; struct port_comm* pc;
size_t s = sizeof(*outnet) + sizeof(*outnet->base) + size_t s = sizeof(*outnet) + sizeof(*outnet->base) +
sizeof(*outnet->udp_buff) + sizeof(*outnet->udp_buff) +
ldns_buffer_capacity(outnet->udp_buff); sldns_buffer_capacity(outnet->udp_buff);
/* second buffer is not ours */ /* second buffer is not ours */
for(pc = outnet->unused_fds; pc; pc = pc->next) { for(pc = outnet->unused_fds; pc; pc = pc->next) {
s += sizeof(*pc) + comm_point_get_mem(pc->cp); s += sizeof(*pc) + comm_point_get_mem(pc->cp);

10
services/outside_network.h
View file

@ -54,7 +54,7 @@ struct waiting_udp;
struct infra_cache; struct infra_cache;
struct port_comm; struct port_comm;
struct port_if; struct port_if;
struct ldns_buffer; struct sldns_buffer;
/** /**
* Send queries to outside servers and wait for answers from servers. * Send queries to outside servers and wait for answers from servers.
@ -70,7 +70,7 @@ struct outside_network {
/** buffer shared by UDP connections, since there is only one /** buffer shared by UDP connections, since there is only one
datagram at any time. */ datagram at any time. */
struct ldns_buffer* udp_buff; struct sldns_buffer* udp_buff;
/** serviced_callbacks malloc overhead when processing multiple /** serviced_callbacks malloc overhead when processing multiple
* identical serviced queries to the same server. */ * identical serviced queries to the same server. */
size_t svcd_overhead; size_t svcd_overhead;
@ -412,7 +412,7 @@ void outside_network_quit_prepare(struct outside_network* outnet);
* @return: NULL on error for malloc or socket. Else the pending query object. * @return: NULL on error for malloc or socket. Else the pending query object.
*/ */
struct pending* pending_udp_query(struct outside_network* outnet, struct pending* pending_udp_query(struct outside_network* outnet,
struct ldns_buffer* packet, struct sockaddr_storage* addr, struct sldns_buffer* packet, struct sockaddr_storage* addr,
socklen_t addrlen, int timeout, comm_point_callback_t* callback, socklen_t addrlen, int timeout, comm_point_callback_t* callback,
void* callback_arg); void* callback_arg);
@ -432,7 +432,7 @@ struct pending* pending_udp_query(struct outside_network* outnet,
* @return: false on error for malloc or socket. Else the pending TCP object. * @return: false on error for malloc or socket. Else the pending TCP object.
*/ */
struct waiting_tcp* pending_tcp_query(struct outside_network* outnet, struct waiting_tcp* pending_tcp_query(struct outside_network* outnet,
struct ldns_buffer* packet, struct sockaddr_storage* addr, struct sldns_buffer* packet, struct sockaddr_storage* addr,
socklen_t addrlen, int timeout, comm_point_callback_t* callback, socklen_t addrlen, int timeout, comm_point_callback_t* callback,
void* callback_arg, int ssl_upstream); void* callback_arg, int ssl_upstream);
@ -477,7 +477,7 @@ struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
uint16_t flags, int dnssec, int want_dnssec, int tcp_upstream, uint16_t flags, int dnssec, int want_dnssec, int tcp_upstream,
int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen, int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen,
uint8_t* zone, size_t zonelen, comm_point_callback_t* callback, uint8_t* zone, size_t zonelen, comm_point_callback_t* callback,
void* callback_arg, struct ldns_buffer* buff); void* callback_arg, struct sldns_buffer* buff);
/** /**
* Remove service query callback. * Remove service query callback.

4
smallapp/unbound-checkconf.c
View file

@ -106,14 +106,14 @@ check_mod(struct config_file* cfg, struct module_func_block* fb)
memset(&env, 0, sizeof(env)); memset(&env, 0, sizeof(env));
env.cfg = cfg; env.cfg = cfg;
env.scratch = regional_create(); env.scratch = regional_create();
env.scratch_buffer = ldns_buffer_new(BUFSIZ); env.scratch_buffer = sldns_buffer_new(BUFSIZ);
if(!env.scratch || !env.scratch_buffer) if(!env.scratch || !env.scratch_buffer)
fatal_exit("out of memory"); fatal_exit("out of memory");
if(!(*fb->init)(&env, 0)) { if(!(*fb->init)(&env, 0)) {
fatal_exit("bad config for %s module", fb->name); fatal_exit("bad config for %s module", fb->name);
} }
(*fb->deinit)(&env, 0); (*fb->deinit)(&env, 0);
ldns_buffer_free(env.scratch_buffer); sldns_buffer_free(env.scratch_buffer);
regional_destroy(env.scratch); regional_destroy(env.scratch);
} }

14
smallapp/unbound-host.c
View file

@ -173,7 +173,7 @@ static int
massage_type(const char* t, int reverse, int* multi) massage_type(const char* t, int reverse, int* multi)
{ {
if(t) { if(t) {
int r = ldns_get_rr_type_by_name(t); int r = sldns_get_rr_type_by_name(t);
if(r == 0 && strcasecmp(t, "TYPE0") != 0 && if(r == 0 && strcasecmp(t, "TYPE0") != 0 &&
strcmp(t, "") != 0) { strcmp(t, "") != 0) {
fprintf(stderr, "error unknown type %s\n", t); fprintf(stderr, "error unknown type %s\n", t);
@ -192,7 +192,7 @@ static int
massage_class(const char* c) massage_class(const char* c)
{ {
if(c) { if(c) {
int r = ldns_get_rr_class_by_name(c); int r = sldns_get_rr_class_by_name(c);
if(r == 0 && strcasecmp(c, "CLASS0") != 0 && if(r == 0 && strcasecmp(c, "CLASS0") != 0 &&
strcmp(c, "") != 0) { strcmp(c, "") != 0) {
fprintf(stderr, "error unknown class %s\n", c); fprintf(stderr, "error unknown class %s\n", c);
@ -217,7 +217,7 @@ static void
pretty_type(char* s, size_t len, int t) pretty_type(char* s, size_t len, int t)
{ {
char d[16]; char d[16];
ldns_wire2str_type_buf((uint16_t)t, d, sizeof(d)); sldns_wire2str_type_buf((uint16_t)t, d, sizeof(d));
snprintf(s, len, "%s", d); snprintf(s, len, "%s", d);
} }
@ -226,7 +226,7 @@ static void
pretty_class(char* s, size_t len, int c) pretty_class(char* s, size_t len, int c)
{ {
char d[16]; char d[16];
ldns_wire2str_class_buf((uint16_t)c, d, sizeof(d)); sldns_wire2str_class_buf((uint16_t)c, d, sizeof(d));
snprintf(s, len, "%s", d); snprintf(s, len, "%s", d);
} }
@ -235,7 +235,7 @@ static void
pretty_rcode(char* s, size_t len, int r) pretty_rcode(char* s, size_t len, int r)
{ {
char d[16]; char d[16];
ldns_wire2str_rcode_buf(r, d, sizeof(d)); sldns_wire2str_rcode_buf(r, d, sizeof(d));
snprintf(s, len, "%s", d); snprintf(s, len, "%s", d);
} }
@ -244,7 +244,7 @@ static void
print_rd(int t, char* data, size_t len) print_rd(int t, char* data, size_t len)
{ {
char s[65535]; char s[65535];
ldns_wire2str_rdata_buf((uint8_t*)data, len, s, sizeof(s), (uint16_t)t); sldns_wire2str_rdata_buf((uint8_t*)data, len, s, sizeof(s), (uint16_t)t);
printf(" %s", s); printf(" %s", s);
} }
@ -320,7 +320,7 @@ pretty_output(char* q, int t, int c, struct ub_result* result, int docname)
else if(t == LDNS_RR_TYPE_MX) else if(t == LDNS_RR_TYPE_MX)
printf(" has no mail handler record"); printf(" has no mail handler record");
else if(t == LDNS_RR_TYPE_ANY) { else if(t == LDNS_RR_TYPE_ANY) {
char* s = ldns_wire2str_pkt( char* s = sldns_wire2str_pkt(
result->answer_packet, result->answer_packet,
(size_t)result->answer_len); (size_t)result->answer_len);
if(!s) { if(!s) {

6
smallapp/worker_cb.c
View file

@ -166,21 +166,21 @@ void libworker_handle_control_cmd(struct tube* ATTR_UNUSED(tube),
} }
void libworker_fg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode), void libworker_fg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
struct ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s), struct sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus)) char* ATTR_UNUSED(why_bogus))
{ {
log_assert(0); log_assert(0);
} }
void libworker_bg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode), void libworker_bg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
struct ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s), struct sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus)) char* ATTR_UNUSED(why_bogus))
{ {
log_assert(0); log_assert(0);
} }
void libworker_event_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode), void libworker_event_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
struct ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s), struct sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus)) char* ATTR_UNUSED(why_bogus))
{ {
log_assert(0); log_assert(0);

60
testcode/delayer.c
View file

@ -222,15 +222,15 @@ ring_delete(struct ringbuf* r)
/** add entry to ringbuffer */ /** add entry to ringbuffer */
static void 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) struct timeval* delay, struct proxy* p)
{ {
/* time -- proxy* -- 16bitlen -- message */ /* 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; struct timeval when;
size_t needed; size_t needed;
uint8_t* where = NULL; 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; needed = sizeof(when) + sizeof(p) + sizeof(len) + len;
/* put item into ringbuffer */ /* put item into ringbuffer */
if(r->low < r->high) { 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), &p, sizeof(p));
memmove(where+sizeof(when)+sizeof(p), &len, sizeof(len)); memmove(where+sizeof(when)+sizeof(p), &len, sizeof(len));
memmove(where+sizeof(when)+sizeof(p)+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 */ /** see if the ringbuffer is empty */
@ -300,7 +300,7 @@ ring_peek_time(struct ringbuf* r)
/** get entry from ringbuffer */ /** get entry from ringbuffer */
static int 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) struct proxy** p)
{ {
/* time -- proxy* -- 16bitlen -- message */ /* 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(tv, where, sizeof(*tv));
memmove(p, where+sizeof(*tv), sizeof(*p)); memmove(p, where+sizeof(*tv), sizeof(*p));
memmove(&len, where+sizeof(*tv)+sizeof(*p), sizeof(len)); 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); 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; done = sizeof(*tv)+sizeof(*p)+sizeof(len)+len;
/* move lowmark */ /* move lowmark */
if(r->low < r->high) { if(r->low < r->high) {
@ -353,7 +353,7 @@ static RETSIGTYPE delayer_sigh(int sig)
/** send out waiting packets */ /** send out waiting packets */
static void 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 sockaddr_storage* srv_addr, socklen_t srv_len)
{ {
struct proxy* p; 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); (unsigned)tv.tv_sec, (unsigned)tv.tv_usec);
log_addr(1, "from client", &p->addr, p->addr_len); log_addr(1, "from client", &p->addr, p->addr_len);
/* send it */ /* send it */
sent = sendto(p->s, (void*)ldns_buffer_begin(pkt), sent = sendto(p->s, (void*)sldns_buffer_begin(pkt),
ldns_buffer_limit(pkt), 0, sldns_buffer_limit(pkt), 0,
(struct sockaddr*)srv_addr, srv_len); (struct sockaddr*)srv_addr, srv_len);
if(sent == -1) { if(sent == -1) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
@ -377,7 +377,7 @@ service_send(struct ringbuf* ring, struct timeval* now, ldns_buffer* pkt,
#else #else
log_err("sendto: %s", wsa_strerror(WSAGetLastError())); log_err("sendto: %s", wsa_strerror(WSAGetLastError()));
#endif #endif
} else if(sent != (ssize_t)ldns_buffer_limit(pkt)) { } else if(sent != (ssize_t)sldns_buffer_limit(pkt)) {
log_err("sendto: partial send"); log_err("sendto: partial send");
} }
p->lastuse = *now; p->lastuse = *now;
@ -387,13 +387,13 @@ service_send(struct ringbuf* ring, struct timeval* now, ldns_buffer* pkt,
/** do proxy for one readable client */ /** do proxy for one readable client */
static void static void
do_proxy(struct proxy* p, int retsock, ldns_buffer* pkt) do_proxy(struct proxy* p, int retsock, sldns_buffer* pkt)
{ {
int i; int i;
ssize_t r; ssize_t r;
for(i=0; i<TRIES_PER_SELECT; i++) { for(i=0; i<TRIES_PER_SELECT; i++) {
r = recv(p->s, (void*)ldns_buffer_begin(pkt), r = recv(p->s, (void*)sldns_buffer_begin(pkt),
ldns_buffer_capacity(pkt), 0); sldns_buffer_capacity(pkt), 0);
if(r == -1) { if(r == -1) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
if(errno == EAGAIN || errno == EINTR) if(errno == EAGAIN || errno == EINTR)
@ -407,11 +407,11 @@ do_proxy(struct proxy* p, int retsock, ldns_buffer* pkt)
#endif #endif
return; 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); log_addr(1, "return reply to client", &p->addr, p->addr_len);
/* send reply back to the real client */ /* send reply back to the real client */
p->numreturn++; 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); 0, (struct sockaddr*)&p->addr, p->addr_len);
if(r == -1) { if(r == -1) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
@ -426,7 +426,7 @@ do_proxy(struct proxy* p, int retsock, ldns_buffer* pkt)
/** proxy return replies to clients */ /** proxy return replies to clients */
static void static void
service_proxy(fd_set* rset, int retsock, struct proxy* proxies, 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; struct proxy* p;
for(p = proxies; p; p = p->next) { 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 */ /** recv new waiting packets */
static void 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, fd_set* rorig, int* max, struct proxy** proxies,
struct sockaddr_storage* srv_addr, socklen_t srv_len, struct sockaddr_storage* srv_addr, socklen_t srv_len,
struct timeval* now, struct timeval* delay, struct timeval* reuse) 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; struct proxy* p;
for(i=0; i<TRIES_PER_SELECT; i++) { for(i=0; i<TRIES_PER_SELECT; i++) {
from_len = (socklen_t)sizeof(from); from_len = (socklen_t)sizeof(from);
len = recvfrom(s, (void*)ldns_buffer_begin(pkt), len = recvfrom(s, (void*)sldns_buffer_begin(pkt),
ldns_buffer_capacity(pkt), 0, sldns_buffer_capacity(pkt), 0,
(struct sockaddr*)&from, &from_len); (struct sockaddr*)&from, &from_len);
if(len < 0) { if(len < 0) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
@ -516,7 +516,7 @@ service_recv(int s, struct ringbuf* ring, ldns_buffer* pkt,
wsa_strerror(WSAGetLastError())); wsa_strerror(WSAGetLastError()));
#endif #endif
} }
ldns_buffer_set_limit(pkt, (size_t)len); sldns_buffer_set_limit(pkt, (size_t)len);
/* find its proxy element */ /* find its proxy element */
p = find_create_proxy(&from, from_len, rorig, max, proxies, p = find_create_proxy(&from, from_len, rorig, max, proxies,
addr_is_ip6(srv_addr, srv_len), now, reuse); 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 static int
tcp_relay_read(int s, struct tcp_send_list** first, tcp_relay_read(int s, struct tcp_send_list** first,
struct tcp_send_list** last, struct timeval* now, 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; struct tcp_send_list* item;
ssize_t r = recv(s, (void*)ldns_buffer_begin(pkt), ssize_t r = recv(s, (void*)sldns_buffer_begin(pkt),
ldns_buffer_capacity(pkt), 0); sldns_buffer_capacity(pkt), 0);
if(r == -1) { if(r == -1) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
if(errno == EINTR || errno == EAGAIN) 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); verbose(1, "read item len %d", (int)r);
item->len = (size_t)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) { if(!item->item) {
free(item); free(item);
log_err("out of memory"); log_err("out of memory");
@ -741,7 +741,7 @@ tcp_relay_write(int s, struct tcp_send_list** first,
/** perform TCP relaying */ /** perform TCP relaying */
static void static void
service_tcp_relay(struct tcp_proxy** tcp_proxies, struct timeval* now, 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) fd_set* rset, fd_set* rorig, fd_set* worig)
{ {
struct tcp_proxy* p, **prev; struct tcp_proxy* p, **prev;
@ -928,7 +928,7 @@ static void
service_loop(int udp_s, int listen_s, struct ringbuf* ring, service_loop(int udp_s, int listen_s, struct ringbuf* ring,
struct timeval* delay, struct timeval* reuse, struct timeval* delay, struct timeval* reuse,
struct sockaddr_storage* srv_addr, socklen_t srv_len, struct sockaddr_storage* srv_addr, socklen_t srv_len,
ldns_buffer* pkt) sldns_buffer* pkt)
{ {
fd_set rset, rorig; fd_set rset, rorig;
fd_set wset, worig; 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; socklen_t bind_len, srv_len;
struct ringbuf* ring = ring_create(memsize); struct ringbuf* ring = ring_create(memsize);
struct timeval delay, reuse; struct timeval delay, reuse;
ldns_buffer* pkt; sldns_buffer* pkt;
int i, s, listen_s; int i, s, listen_s;
#ifndef S_SPLINT_S #ifndef S_SPLINT_S
delay.tv_sec = delay_msec / 1000; 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); printf("cannot parse forward address: %s\n", serv_str);
exit(1); exit(1);
} }
pkt = ldns_buffer_new(65535); pkt = sldns_buffer_new(65535);
if(!pkt) if(!pkt)
fatal_exit("out of memory"); fatal_exit("out of memory");
if( signal(SIGINT, delayer_sigh) == SIG_ERR || 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(s);
closesocket(listen_s); closesocket(listen_s);
#endif #endif
ldns_buffer_free(pkt); sldns_buffer_free(pkt);
ring_delete(ring); ring_delete(ring);
} }

106
testcode/fake_event.c
View file

@ -109,11 +109,11 @@ fake_event_cleanup(void)
saved_scenario = NULL; 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 static void
log_pkt(const char* desc, uint8_t* pkt, size_t len) 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) if(!str)
fatal_exit("%s: (failed out of memory wire2str_pkt)", desc); fatal_exit("%s: (failed out of memory wire2str_pkt)", desc);
else { else {
@ -152,7 +152,7 @@ delete_fake_pending(struct fake_pending* pend)
if(!pend) if(!pend)
return; return;
free(pend->zone); free(pend->zone);
ldns_buffer_free(pend->buffer); sldns_buffer_free(pend->buffer);
free(pend->pkt); free(pend->pkt);
free(pend); free(pend);
} }
@ -164,7 +164,7 @@ delete_replay_answer(struct replay_answer* a)
if(!a) if(!a)
return; return;
if(a->repinfo.c) { if(a->repinfo.c) {
ldns_buffer_free(a->repinfo.c->buffer); sldns_buffer_free(a->repinfo.c->buffer);
free(a->repinfo.c); free(a->repinfo.c);
} }
free(a->pkt); 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. * Fill buffer with reply from the entry.
*/ */
static void 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) size_t qlen)
{ {
uint8_t* c; uint8_t* c;
size_t clen; size_t clen;
log_assert(entry && entry->reply_list); log_assert(entry && entry->reply_list);
ldns_buffer_clear(buffer); sldns_buffer_clear(buffer);
if(entry->reply_list->reply_from_hex) { if(entry->reply_list->reply_from_hex) {
c = ldns_buffer_begin(entry->reply_list->reply_from_hex); c = sldns_buffer_begin(entry->reply_list->reply_from_hex);
clen = ldns_buffer_limit(entry->reply_list->reply_from_hex); clen = sldns_buffer_limit(entry->reply_list->reply_from_hex);
if(!c) fatal_exit("out of memory"); if(!c) fatal_exit("out of memory");
} else { } else {
c = entry->reply_list->reply_pkt; 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(c) {
if(q) adjust_packet(entry, &c, &clen, q, qlen); 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); 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)); memset(&c, 0, sizeof(c));
c.fd = -1; c.fd = -1;
c.buffer = ldns_buffer_new(runtime->bufsize); c.buffer = sldns_buffer_new(runtime->bufsize);
c.type = comm_udp; c.type = comm_udp;
if(pend->transport == transport_tcp) if(pend->transport == transport_tcp)
c.type = comm_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)) { if((*cb)(&c, cb_arg, NETEVENT_NOERROR, &repinfo)) {
fatal_exit("testbound: unexpected: callback returned 1"); fatal_exit("testbound: unexpected: callback returned 1");
} }
ldns_buffer_free(c.buffer); sldns_buffer_free(c.buffer);
} }
/** Check the now moment answer check event */ /** 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->fd = -1;
repinfo.c->ev = (struct internal_event*)runtime; 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) if(todo->match->match_transport == transport_tcp)
repinfo.c->type = comm_tcp; repinfo.c->type = comm_tcp;
else repinfo.c->type = comm_udp; else repinfo.c->type = comm_udp;
@ -428,7 +428,7 @@ fake_pending_callback(struct replay_runtime* runtime,
if(!p) fatal_exit("No pending queries."); if(!p) fatal_exit("No pending queries.");
cb_arg = p->cb_arg; cb_arg = p->cb_arg;
cb = p->callback; cb = p->callback;
c.buffer = ldns_buffer_new(runtime->bufsize); c.buffer = sldns_buffer_new(runtime->bufsize);
c.type = comm_udp; c.type = comm_udp;
if(p->transport == transport_tcp) if(p->transport == transport_tcp)
c.type = comm_tcp; c.type = comm_tcp;
@ -445,7 +445,7 @@ fake_pending_callback(struct replay_runtime* runtime,
fatal_exit("unexpected: pending callback returned 1"); fatal_exit("unexpected: pending callback returned 1");
} }
/* delete the pending item. */ /* delete the pending item. */
ldns_buffer_free(c.buffer); sldns_buffer_free(c.buffer);
} }
/** pass time */ /** pass time */
@ -557,7 +557,7 @@ do_infra_rtt(struct replay_runtime* runtime)
struct replay_moment* now = runtime->now; struct replay_moment* now = runtime->now;
int rto; int rto;
size_t dplen = 0; 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); if(!dp) fatal_exit("cannot parse %s", now->variable);
rto = infra_rtt_update(runtime->infra, &now->addr, now->addrlen, rto = infra_rtt_update(runtime->infra, &now->addr, now->addrlen,
dp, dplen, LDNS_RR_TYPE_A, atoi(now->string), 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) if(!l)
return NULL; return NULL;
l->base = base; l->base = base;
l->udp_buff = ldns_buffer_new(bufsize); l->udp_buff = sldns_buffer_new(bufsize);
if(!l->udp_buff) { if(!l->udp_buff) {
free(l); free(l);
return NULL; return NULL;
@ -757,7 +757,7 @@ listen_delete(struct listen_dnsport* listen)
{ {
if(!listen) if(!listen)
return; return;
ldns_buffer_free(listen->udp_buff); sldns_buffer_free(listen->udp_buff);
free(listen); free(listen);
} }
@ -873,9 +873,9 @@ comm_point_send_reply(struct comm_reply* repinfo)
runtime->answer_last = ans; runtime->answer_last = ans;
/* try to parse packet */ /* try to parse packet */
ans->pkt = memdup(ldns_buffer_begin(ans->repinfo.c->buffer), ans->pkt = memdup(sldns_buffer_begin(ans->repinfo.c->buffer),
ldns_buffer_limit(ans->repinfo.c->buffer)); sldns_buffer_limit(ans->repinfo.c->buffer));
ans->pkt_len = ldns_buffer_limit(ans->repinfo.c->buffer); ans->pkt_len = sldns_buffer_limit(ans->repinfo.c->buffer);
if(!ans->pkt) fatal_exit("out of memory"); if(!ans->pkt) fatal_exit("out of memory");
log_pkt("reply pkt: ", ans->pkt, ans->pkt_len); 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"); log_info("comm_point_drop_reply fake");
if(repinfo->c) { if(repinfo->c) {
ldns_buffer_free(repinfo->c->buffer); sldns_buffer_free(repinfo->c->buffer);
free(repinfo->c); free(repinfo->c);
} }
} }
@ -910,7 +910,7 @@ outside_network_create(struct comm_base* base, size_t bufsize,
return NULL; return NULL;
runtime->infra = infra; runtime->infra = infra;
outnet->base = base; outnet->base = base;
outnet->udp_buff = ldns_buffer_new(bufsize); outnet->udp_buff = sldns_buffer_new(bufsize);
if(!outnet->udp_buff) { if(!outnet->udp_buff) {
free(outnet); free(outnet);
return NULL; return NULL;
@ -923,7 +923,7 @@ outside_network_delete(struct outside_network* outnet)
{ {
if(!outnet) if(!outnet)
return; return;
ldns_buffer_free(outnet->udp_buff); sldns_buffer_free(outnet->udp_buff);
free(outnet); free(outnet);
} }
@ -933,7 +933,7 @@ outside_network_quit_prepare(struct outside_network* ATTR_UNUSED(outnet))
} }
struct pending* 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, struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* callback, void* callback_arg) 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, struct fake_pending* pend = (struct fake_pending*)calloc(1,
sizeof(struct fake_pending)); sizeof(struct fake_pending));
log_assert(pend); 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); log_assert(pend->buffer);
ldns_buffer_write(pend->buffer, ldns_buffer_begin(packet), sldns_buffer_write(pend->buffer, sldns_buffer_begin(packet),
ldns_buffer_limit(packet)); sldns_buffer_limit(packet));
ldns_buffer_flip(pend->buffer); sldns_buffer_flip(pend->buffer);
memcpy(&pend->addr, addr, addrlen); memcpy(&pend->addr, addr, addrlen);
pend->addrlen = addrlen; pend->addrlen = addrlen;
pend->callback = callback; pend->callback = callback;
@ -956,8 +956,8 @@ pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
pend->zone = NULL; pend->zone = NULL;
pend->serviced = 0; pend->serviced = 0;
pend->runtime = runtime; pend->runtime = runtime;
pend->pkt_len = ldns_buffer_limit(packet); pend->pkt_len = sldns_buffer_limit(packet);
pend->pkt = memdup(ldns_buffer_begin(packet), pend->pkt_len); pend->pkt = memdup(sldns_buffer_begin(packet), pend->pkt_len);
if(!pend->pkt) fatal_exit("out of memory"); if(!pend->pkt) fatal_exit("out of memory");
log_pkt("pending udp pkt: ", pend->pkt, pend->pkt_len); 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* 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, struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* callback, void* callback_arg, comm_point_callback_t* callback, void* callback_arg,
int ATTR_UNUSED(ssl_upstream)) 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, struct fake_pending* pend = (struct fake_pending*)calloc(1,
sizeof(struct fake_pending)); sizeof(struct fake_pending));
log_assert(pend); 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); log_assert(pend->buffer);
ldns_buffer_write(pend->buffer, ldns_buffer_begin(packet), sldns_buffer_write(pend->buffer, sldns_buffer_begin(packet),
ldns_buffer_limit(packet)); sldns_buffer_limit(packet));
ldns_buffer_flip(pend->buffer); sldns_buffer_flip(pend->buffer);
memcpy(&pend->addr, addr, addrlen); memcpy(&pend->addr, addr, addrlen);
pend->addrlen = addrlen; pend->addrlen = addrlen;
pend->callback = callback; pend->callback = callback;
@ -1007,8 +1007,8 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
pend->zone = NULL; pend->zone = NULL;
pend->runtime = runtime; pend->runtime = runtime;
pend->serviced = 0; pend->serviced = 0;
pend->pkt_len = ldns_buffer_limit(packet); pend->pkt_len = sldns_buffer_limit(packet);
pend->pkt = memdup(ldns_buffer_begin(packet), pend->pkt_len); pend->pkt = memdup(sldns_buffer_begin(packet), pend->pkt_len);
if(!pend->pkt) fatal_exit("out of memory"); if(!pend->pkt) fatal_exit("out of memory");
log_pkt("pending tcp pkt: ", pend->pkt, pend->pkt_len); 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), int ATTR_UNUSED(tcp_upstream), int ATTR_UNUSED(ssl_upstream),
struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone, struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
size_t zonelen, comm_point_callback_t* callback, void* callback_arg, 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 replay_runtime* runtime = (struct replay_runtime*)outnet->base;
struct fake_pending* pend = (struct fake_pending*)calloc(1, 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":""); (flags&~(BIT_RD|BIT_CD))?" MORE":"", (dnssec)?" DO":"");
/* create packet with EDNS */ /* create packet with EDNS */
pend->buffer = ldns_buffer_new(512); pend->buffer = sldns_buffer_new(512);
log_assert(pend->buffer); log_assert(pend->buffer);
ldns_buffer_write_u16(pend->buffer, 0); /* id */ sldns_buffer_write_u16(pend->buffer, 0); /* id */
ldns_buffer_write_u16(pend->buffer, flags); sldns_buffer_write_u16(pend->buffer, flags);
ldns_buffer_write_u16(pend->buffer, 1); /* qdcount */ sldns_buffer_write_u16(pend->buffer, 1); /* qdcount */
ldns_buffer_write_u16(pend->buffer, 0); /* ancount */ sldns_buffer_write_u16(pend->buffer, 0); /* ancount */
ldns_buffer_write_u16(pend->buffer, 0); /* nscount */ sldns_buffer_write_u16(pend->buffer, 0); /* nscount */
ldns_buffer_write_u16(pend->buffer, 0); /* arcount */ sldns_buffer_write_u16(pend->buffer, 0); /* arcount */
ldns_buffer_write(pend->buffer, qname, qnamelen); sldns_buffer_write(pend->buffer, qname, qnamelen);
ldns_buffer_write_u16(pend->buffer, qtype); sldns_buffer_write_u16(pend->buffer, qtype);
ldns_buffer_write_u16(pend->buffer, qclass); sldns_buffer_write_u16(pend->buffer, qclass);
ldns_buffer_flip(pend->buffer); sldns_buffer_flip(pend->buffer);
if(1) { if(1) {
/* add edns */ /* add edns */
struct edns_data edns; struct edns_data edns;
@ -1091,8 +1091,8 @@ struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
pend->pkt = NULL; pend->pkt = NULL;
pend->runtime = runtime; pend->runtime = runtime;
pend->serviced = 1; pend->serviced = 1;
pend->pkt_len = ldns_buffer_limit(pend->buffer); pend->pkt_len = sldns_buffer_limit(pend->buffer);
pend->pkt = memdup(ldns_buffer_begin(pend->buffer), pend->pkt_len); pend->pkt = memdup(sldns_buffer_begin(pend->buffer), pend->pkt_len);
if(!pend->pkt) fatal_exit("out of memory"); if(!pend->pkt) fatal_exit("out of memory");
/*log_pkt("pending serviced query: ", pend->pkt, pend->pkt_len);*/ /*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) if(prev)
prev->next = p->next; prev->next = p->next;
else runtime->pending_list = p->next; else runtime->pending_list = p->next;
ldns_buffer_free(p->buffer); sldns_buffer_free(p->buffer);
free(p->pkt); free(p->pkt);
free(p->zone); free(p->zone);
free(p); free(p);

38
testcode/perf.c
View file

@ -78,7 +78,7 @@ struct perfinfo {
/** need to exit */ /** need to exit */
volatile int exit; volatile int exit;
/** all purpose buffer (for UDP send and receive) */ /** all purpose buffer (for UDP send and receive) */
ldns_buffer* buf; sldns_buffer* buf;
/** destination */ /** destination */
struct sockaddr_storage dest; struct sockaddr_storage dest;
@ -306,8 +306,8 @@ static void
perfreply(struct perfinfo* info, size_t n, struct timeval* now) perfreply(struct perfinfo* info, size_t n, struct timeval* now)
{ {
ssize_t r; ssize_t r;
r = recv(info->io[n].fd, (void*)ldns_buffer_begin(info->buf), r = recv(info->io[n].fd, (void*)sldns_buffer_begin(info->buf),
ldns_buffer_capacity(info->buf), 0); sldns_buffer_capacity(info->buf), 0);
if(r == -1) { if(r == -1) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
log_err("recv: %s", strerror(errno)); 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())); log_err("recv: %s", wsa_strerror(WSAGetLastError()));
#endif #endif
} else { } else {
info->by_rcode[LDNS_RCODE_WIRE(ldns_buffer_begin( info->by_rcode[LDNS_RCODE_WIRE(sldns_buffer_begin(
info->buf))]++; info->buf))]++;
info->numrecv++; info->numrecv++;
} }
/*ldns_buffer_set_limit(info->buf, r); /*sldns_buffer_set_limit(info->buf, r);
log_buf(0, "reply", info->buf);*/ log_buf(0, "reply", info->buf);*/
perfsend(info, n, now); perfsend(info, n, now);
} }
@ -438,7 +438,7 @@ perfendstats(struct perfinfo* info)
{ {
if(info->by_rcode[i] > 0) { if(info->by_rcode[i] > 0) {
char rc[16]; 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", printf("%d(%5s): %u replies\n",
i, rc, (unsigned)info->by_rcode[i]); i, rc, (unsigned)info->by_rcode[i]);
} }
@ -461,7 +461,7 @@ perfmain(struct perfinfo* info)
/** parse a query line to a packet into buffer */ /** parse a query line to a packet into buffer */
static int 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]; char nm[1024], cl[1024], tp[1024], fl[1024];
int r; int r;
@ -473,23 +473,23 @@ qlist_parse_line(ldns_buffer* buf, char* p)
return 0; return 0;
/*printf("nm='%s', cl='%s', tp='%s', fl='%s'\n", nm, cl, tp, fl);*/ /*printf("nm='%s', cl='%s', tp='%s', fl='%s'\n", nm, cl, tp, fl);*/
if(strcmp(tp, "IN") == 0 || strcmp(tp, "CH") == 0) { if(strcmp(tp, "IN") == 0 || strcmp(tp, "CH") == 0) {
qinfo.qtype = ldns_get_rr_type_by_name(cl); qinfo.qtype = sldns_get_rr_type_by_name(cl);
qinfo.qclass = ldns_get_rr_class_by_name(tp); qinfo.qclass = sldns_get_rr_class_by_name(tp);
} else { } else {
qinfo.qtype = ldns_get_rr_type_by_name(tp); qinfo.qtype = sldns_get_rr_type_by_name(tp);
qinfo.qclass = ldns_get_rr_class_by_name(cl); qinfo.qclass = sldns_get_rr_class_by_name(cl);
} }
if(fl[0] == '+') rec = 1; if(fl[0] == '+') rec = 1;
else if(fl[0] == '-') rec = 0; else if(fl[0] == '-') rec = 0;
else if(fl[0] == 'E') edns = 1; else if(fl[0] == 'E') edns = 1;
if((fl[0] == '+' || fl[0] == '-') && fl[1] == 'E') if((fl[0] == '+' || fl[0] == '-') && fl[1] == 'E')
edns = 1; edns = 1;
qinfo.qname = ldns_str2wire_dname(nm, &qinfo.qname_len); qinfo.qname = sldns_str2wire_dname(nm, &qinfo.qname_len);
if(!qinfo.qname) if(!qinfo.qname)
return 0; return 0;
qinfo_query_encode(buf, &qinfo); qinfo_query_encode(buf, &qinfo);
ldns_buffer_write_u16_at(buf, 0, 0); /* zero ID */ sldns_buffer_write_u16_at(buf, 0, 0); /* zero ID */
if(rec) LDNS_RD_SET(ldns_buffer_begin(buf)); if(rec) LDNS_RD_SET(sldns_buffer_begin(buf));
if(edns) { if(edns) {
struct edns_data ed; struct edns_data ed;
memset(&ed, 0, sizeof(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); printf("error parsing query %d: %s\n", no, line);
exit(1); 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) { if(info->qlist_size + 1 > info->qlist_capacity) {
qlist_grow_capacity(info); 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( 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]) if(!info->qlist_data[info->qlist_size])
fatal_exit("out of memory"); fatal_exit("out of memory");
info->qlist_size ++; info->qlist_size ++;
@ -597,7 +597,7 @@ int main(int argc, char* argv[])
fatal_exit("WSAStartup failed: %s", wsa_strerror(r)); fatal_exit("WSAStartup failed: %s", wsa_strerror(r));
#endif #endif
info.buf = ldns_buffer_new(65553); info.buf = sldns_buffer_new(65553);
if(!info.buf) fatal_exit("out of memory"); if(!info.buf) fatal_exit("out of memory");
/* parse the options */ /* parse the options */
@ -644,7 +644,7 @@ int main(int argc, char* argv[])
/* do the performance test */ /* do the performance test */
perfmain(&info); perfmain(&info);
ldns_buffer_free(info.buf); sldns_buffer_free(info.buf);
#ifdef USE_WINSOCK #ifdef USE_WINSOCK
WSACleanup(); WSACleanup();
#endif #endif

74
testcode/pktview.c
View file

@ -57,7 +57,7 @@ static void usage(char* argv[])
} }
/** read hex input */ /** 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 buf[102400];
char* np = buf; char* np = buf;
@ -70,22 +70,22 @@ static void read_input(ldns_buffer* pkt, FILE* in)
} }
/** analyze domain name in packet, possibly compressed */ /** 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; size_t len;
printf("[pos %d] dname: ", (int)oldpos); 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); len = pkt_dname_len(pkt);
printf(" len=%d", (int)len); printf(" len=%d", (int)len);
if(ldns_buffer_position(pkt)-oldpos != len) if(sldns_buffer_position(pkt)-oldpos != len)
printf(" comprlen=%d\n", printf(" comprlen=%d\n",
(int)(ldns_buffer_position(pkt)-oldpos)); (int)(sldns_buffer_position(pkt)-oldpos));
else printf("\n"); else printf("\n");
} }
/** analyze rdata in packet */ /** 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) uint16_t rdlen)
{ {
int rdf = 0; int rdf = 0;
@ -94,21 +94,21 @@ static void analyze_rdata(ldns_buffer*pkt, const ldns_rr_descriptor* desc,
while(rdlen > 0 && count) { while(rdlen > 0 && count) {
switch(desc->_wireformat[rdf]) { switch(desc->_wireformat[rdf]) {
case LDNS_RDF_TYPE_DNAME: case LDNS_RDF_TYPE_DNAME:
oldpos = ldns_buffer_position(pkt); oldpos = sldns_buffer_position(pkt);
analyze_dname(pkt); analyze_dname(pkt);
rdlen -= ldns_buffer_position(pkt)-oldpos; rdlen -= sldns_buffer_position(pkt)-oldpos;
count --; count --;
len = 0; len = 0;
break; break;
case LDNS_RDF_TYPE_STR: case LDNS_RDF_TYPE_STR:
len = ldns_buffer_current(pkt)[0] + 1; len = sldns_buffer_current(pkt)[0] + 1;
break; break;
default: default:
len = get_rdf_size(desc->_wireformat[rdf]); len = get_rdf_size(desc->_wireformat[rdf]);
} }
if(len) { if(len) {
printf(" wf[%d]", (int)len); printf(" wf[%d]", (int)len);
ldns_buffer_skip(pkt, (ssize_t)len); sldns_buffer_skip(pkt, (ssize_t)len);
rdlen -= len; rdlen -= len;
} }
rdf++; rdf++;
@ -117,62 +117,62 @@ static void analyze_rdata(ldns_buffer*pkt, const ldns_rr_descriptor* desc,
size_t i; size_t i;
printf(" remain[%d]\n", (int)rdlen); printf(" remain[%d]\n", (int)rdlen);
for(i=0; i<rdlen; i++) 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"); printf("\n");
} }
else printf("\n"); else printf("\n");
ldns_buffer_skip(pkt, (ssize_t)rdlen); sldns_buffer_skip(pkt, (ssize_t)rdlen);
} }
/** analyze rr in packet */ /** 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; uint16_t type, dclass, len;
uint32_t ttl; uint32_t ttl;
analyze_dname(pkt); analyze_dname(pkt);
type = ldns_buffer_read_u16(pkt); type = sldns_buffer_read_u16(pkt);
dclass = ldns_buffer_read_u16(pkt); dclass = sldns_buffer_read_u16(pkt);
printf("type %s(%d)", ldns_rr_descript(type)? printf("type %s(%d)", sldns_rr_descript(type)?
ldns_rr_descript(type)->_name: "??" , (int)type); sldns_rr_descript(type)->_name: "??" , (int)type);
printf(" class %s(%d) ", ldns_lookup_by_id(sldns_rr_classes, printf(" class %s(%d) ", sldns_lookup_by_id(sldns_rr_classes,
(int)dclass)?ldns_lookup_by_id(sldns_rr_classes, (int)dclass)?sldns_lookup_by_id(sldns_rr_classes,
(int)dclass)->name:"??", (int)dclass); (int)dclass)->name:"??", (int)dclass);
if(q) { if(q) {
printf("\n"); printf("\n");
} else { } else {
ttl = ldns_buffer_read_u32(pkt); ttl = sldns_buffer_read_u32(pkt);
printf(" ttl %d (0x%x)", (int)ttl, (unsigned)ttl); 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); printf(" rdata len %d:\n", (int)len);
if(ldns_rr_descript(type)) if(sldns_rr_descript(type))
analyze_rdata(pkt, ldns_rr_descript(type), len); analyze_rdata(pkt, sldns_rr_descript(type), len);
else ldns_buffer_skip(pkt, (ssize_t)len); else sldns_buffer_skip(pkt, (ssize_t)len);
} }
} }
/** analyse pkt */ /** analyse pkt */
static void analyze(ldns_buffer* pkt) static void analyze(sldns_buffer* pkt)
{ {
uint16_t i, f, qd, an, ns, ar; uint16_t i, f, qd, an, ns, ar;
int rrnum = 0; int rrnum = 0;
printf("packet length %d\n", (int)ldns_buffer_limit(pkt)); printf("packet length %d\n", (int)sldns_buffer_limit(pkt));
if(ldns_buffer_limit(pkt) < 12) return; 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); 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); 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); printf("qdcount: %d\n", (int)qd);
an = ldns_buffer_read_u16(pkt); an = sldns_buffer_read_u16(pkt);
printf("ancount: %d\n", (int)an); printf("ancount: %d\n", (int)an);
ns = ldns_buffer_read_u16(pkt); ns = sldns_buffer_read_u16(pkt);
printf("nscount: %d\n", (int)ns); 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("arcount: %d\n", (int)ar);
printf(";-- query section\n"); printf(";-- query section\n");
while(ldns_buffer_remaining(pkt) > 0) { while(sldns_buffer_remaining(pkt) > 0) {
if(rrnum == (int)qd) if(rrnum == (int)qd)
printf(";-- answer section\n"); printf(";-- answer section\n");
if(rrnum == (int)qd+(int)an) if(rrnum == (int)qd+(int)an)
@ -188,7 +188,7 @@ static void analyze(ldns_buffer* pkt)
/** main program for pktview */ /** main program for pktview */
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
ldns_buffer* pkt = ldns_buffer_new(65553); sldns_buffer* pkt = sldns_buffer_new(65553);
if(argc != 1) { if(argc != 1) {
usage(argv); usage(argv);
} }
@ -197,6 +197,6 @@ int main(int argc, char* argv[])
read_input(pkt, stdin); read_input(pkt, stdin);
analyze(pkt); analyze(pkt);
ldns_buffer_free(pkt); sldns_buffer_free(pkt);
return 0; return 0;
} }

14
testcode/readhex.c
View file

@ -62,24 +62,24 @@ skip_whites(const char** p)
} }
/* takes a hex string and puts into buffer */ /* 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; const char* p = hex;
int val; int val;
ldns_buffer_clear(pkt); sldns_buffer_clear(pkt);
while(*p) { while(*p) {
skip_whites(&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"); fatal_exit("hex_to_buf: buffer too small");
if(!isalnum((int)*p)) if(!isalnum((int)*p))
break; break;
val = ldns_hexdigit_to_int(*p++) << 4; val = sldns_hexdigit_to_int(*p++) << 4;
skip_whites(&p); skip_whites(&p);
log_assert(*p && isalnum((int)*p)); log_assert(*p && isalnum((int)*p));
val |= ldns_hexdigit_to_int(*p++); val |= sldns_hexdigit_to_int(*p++);
ldns_buffer_write_u8(pkt, (uint8_t)val); sldns_buffer_write_u8(pkt, (uint8_t)val);
skip_whites(&p); skip_whites(&p);
} }
ldns_buffer_flip(pkt); sldns_buffer_flip(pkt);
} }

4
testcode/readhex.h
View file

@ -40,13 +40,13 @@
#ifndef TESTCODE_READHEX_H #ifndef TESTCODE_READHEX_H
#define TESTCODE_READHEX_H #define TESTCODE_READHEX_H
struct ldns_buffer; struct sldns_buffer;
/** /**
* Helper to convert hex string to packet buffer. * Helper to convert hex string to packet buffer.
* @param pkt: buffer to put result in. * @param pkt: buffer to put result in.
* @param hex: string of hex data. Spaces and ';...' comments are skipped. * @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 */ #endif /* TESTCODE_READHEX_H */

6
testcode/replay.c
View file

@ -149,7 +149,7 @@ strip_end_white(char* p)
*/ */
static struct replay_range* static struct replay_range*
replay_range_read(char* remain, FILE* in, const char* name, 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( struct replay_range* rng = (struct replay_range*)malloc(
sizeof(struct replay_range)); sizeof(struct replay_range));
@ -266,7 +266,7 @@ read_assign_step(char* remain, struct replay_moment* mom)
*/ */
static struct replay_moment* static struct replay_moment*
replay_moment_read(char* remain, FILE* in, const char* name, 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( struct replay_moment* mom = (struct replay_moment*)malloc(
sizeof(struct replay_moment)); sizeof(struct replay_moment));
@ -432,7 +432,7 @@ replay_scenario_read(FILE* in, const char* name, int* lineno)
char line[MAX_LINE_LEN]; char line[MAX_LINE_LEN];
char *parse; char *parse;
struct replay_scenario* scen = NULL; struct replay_scenario* scen = NULL;
struct ldns_file_parse_state pstate; struct sldns_file_parse_state pstate;
line[MAX_LINE_LEN-1]=0; line[MAX_LINE_LEN-1]=0;
memset(&pstate, 0, sizeof(pstate)); memset(&pstate, 0, sizeof(pstate));
pstate.default_ttl = 3600; pstate.default_ttl = 3600;

6
testcode/replay.h
View file

@ -138,7 +138,7 @@ struct fake_pending;
struct fake_timer; struct fake_timer;
struct replay_var; struct replay_var;
struct infra_cache; struct infra_cache;
struct ldns_buffer; struct sldns_buffer;
/** /**
* A replay scenario. * A replay scenario.
@ -313,7 +313,7 @@ struct replay_runtime {
*/ */
struct fake_pending { struct fake_pending {
/** what is important only that we remember the query, copied here. */ /** 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. */ /** and to what address this is sent to. */
struct sockaddr_storage addr; struct sockaddr_storage addr;
/** len of addr */ /** len of addr */
@ -333,7 +333,7 @@ struct fake_pending {
/** next in pending list */ /** next in pending list */
struct fake_pending* next; struct fake_pending* next;
/** the buffer parsed into a ldns_pkt */ /** the buffer parsed into a sldns_pkt */
uint8_t* pkt; uint8_t* pkt;
size_t pkt_len; size_t pkt_len;
/** by what transport was the query sent out */ /** by what transport was the query sent out */

108
testcode/signit.c
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_min < 0 || tm.tm_min > 59) return 0;
if (tm.tm_sec < 0 || tm.tm_sec > 59) return 0; if (tm.tm_sec < 0 || tm.tm_sec > 59) return 0;
/* call ldns conversion function */ /* call ldns conversion function */
t = ldns_mktime_from_utc(&tm); t = sldns_mktime_from_utc(&tm);
return t; return t;
} }
@ -121,14 +121,14 @@ parse_cmdline(char *argv[], struct keysets* s)
} }
/** read all key files, exit on error */ /** read all key files, exit on error */
static ldns_key_list* static sldns_key_list*
read_keys(int num, char* names[], struct keysets* set) read_keys(int num, char* names[], struct keysets* set)
{ {
int i; int i;
ldns_key_list* keys = ldns_key_list_new(); sldns_key_list* keys = sldns_key_list_new();
ldns_key* k; sldns_key* k;
ldns_rdf* rdf; sldns_rdf* rdf;
ldns_status s; sldns_status s;
int b; int b;
FILE* in; FILE* in;
@ -138,45 +138,45 @@ read_keys(int num, char* names[], struct keysets* set)
in = fopen(names[i], "r"); in = fopen(names[i], "r");
if(!in) fatal_exit("could not open %s: %s", names[i], if(!in) fatal_exit("could not open %s: %s", names[i],
strerror(errno)); strerror(errno));
s = ldns_key_new_frm_fp(&k, in); s = sldns_key_new_frm_fp(&k, in);
fclose(in); fclose(in);
if(s != LDNS_STATUS_OK) if(s != LDNS_STATUS_OK)
fatal_exit("bad keyfile %s: %s", names[i], fatal_exit("bad keyfile %s: %s", names[i],
ldns_get_errorstr_by_id(s)); sldns_get_errorstr_by_id(s));
ldns_key_set_expiration(k, set->expi); sldns_key_set_expiration(k, set->expi);
ldns_key_set_inception(k, set->incep); sldns_key_set_inception(k, set->incep);
s = ldns_str2rdf_dname(&rdf, set->owner); s = sldns_str2rdf_dname(&rdf, set->owner);
if(s != LDNS_STATUS_OK) if(s != LDNS_STATUS_OK)
fatal_exit("bad owner name %s: %s", set->owner, fatal_exit("bad owner name %s: %s", set->owner,
ldns_get_errorstr_by_id(s)); sldns_get_errorstr_by_id(s));
ldns_key_set_pubkey_owner(k, rdf); sldns_key_set_pubkey_owner(k, rdf);
ldns_key_set_flags(k, set->flags); sldns_key_set_flags(k, set->flags);
ldns_key_set_keytag(k, set->keytag); sldns_key_set_keytag(k, set->keytag);
b = ldns_key_list_push_key(keys, k); b = sldns_key_list_push_key(keys, k);
assert(b); assert(b);
} }
return keys; return keys;
} }
/** read list of rrs from the file */ /** read list of rrs from the file */
static ldns_rr_list* static sldns_rr_list*
read_rrs(FILE* in) read_rrs(FILE* in)
{ {
uint32_t my_ttl = 3600; uint32_t my_ttl = 3600;
ldns_rdf *my_origin = NULL; sldns_rdf *my_origin = NULL;
ldns_rdf *my_prev = NULL; sldns_rdf *my_prev = NULL;
ldns_status s; sldns_status s;
int line_nr = 1; int line_nr = 1;
int b; int b;
ldns_rr_list* list; sldns_rr_list* list;
ldns_rr *rr; sldns_rr *rr;
list = ldns_rr_list_new(); list = sldns_rr_list_new();
if(!list) fatal_exit("alloc error"); if(!list) fatal_exit("alloc error");
while(!feof(in)) { 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); &my_prev, &line_nr);
if(s == LDNS_STATUS_SYNTAX_TTL || if(s == LDNS_STATUS_SYNTAX_TTL ||
s == LDNS_STATUS_SYNTAX_ORIGIN || s == LDNS_STATUS_SYNTAX_ORIGIN ||
@ -184,8 +184,8 @@ read_rrs(FILE* in)
continue; continue;
else if(s != LDNS_STATUS_OK) else if(s != LDNS_STATUS_OK)
fatal_exit("parse error in line %d: %s", line_nr, fatal_exit("parse error in line %d: %s", line_nr,
ldns_get_errorstr_by_id(s)); sldns_get_errorstr_by_id(s));
b = ldns_rr_list_push_rr(list, rr); b = sldns_rr_list_push_rr(list, rr);
assert(b); assert(b);
} }
printf("read %d lines\n", line_nr); printf("read %d lines\n", line_nr);
@ -195,21 +195,21 @@ read_rrs(FILE* in)
/** sign the rrs with the keys */ /** sign the rrs with the keys */
static void static void
signit(ldns_rr_list* rrs, ldns_key_list* keys) signit(sldns_rr_list* rrs, sldns_key_list* keys)
{ {
ldns_rr_list* rrset; sldns_rr_list* rrset;
ldns_rr_list* sigs; sldns_rr_list* sigs;
while(ldns_rr_list_rr_count(rrs) > 0) { while(sldns_rr_list_rr_count(rrs) > 0) {
rrset = ldns_rr_list_pop_rrset(rrs); rrset = sldns_rr_list_pop_rrset(rrs);
if(!rrset) fatal_exit("copy alloc failure"); 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"); if(!sigs) fatal_exit("failed to sign");
ldns_rr_list_print(stdout, rrset); sldns_rr_list_print(stdout, rrset);
ldns_rr_list_print(stdout, sigs); sldns_rr_list_print(stdout, sigs);
printf("\n"); printf("\n");
ldns_rr_list_free(rrset); sldns_rr_list_free(rrset);
ldns_rr_list_free(sigs); sldns_rr_list_free(sigs);
} }
} }
@ -217,8 +217,8 @@ signit(ldns_rr_list* rrs, ldns_key_list* keys)
static void static void
process_keys(int argc, char* argv[]) process_keys(int argc, char* argv[])
{ {
ldns_rr_list* rrs; sldns_rr_list* rrs;
ldns_key_list* keys; sldns_key_list* keys;
struct keysets settings; struct keysets settings;
assert(argc == 6); assert(argc == 6);
@ -227,8 +227,8 @@ process_keys(int argc, char* argv[])
rrs = read_rrs(stdin); rrs = read_rrs(stdin);
signit(rrs, keys); signit(rrs, keys);
ldns_rr_list_deep_free(rrs); sldns_rr_list_deep_free(rrs);
ldns_key_list_free(keys); sldns_key_list_free(keys);
} }
/** process nsec3 params and perform hashing */ /** process nsec3 params and perform hashing */
@ -236,37 +236,37 @@ static void
process_nsec3(int argc, char* argv[]) process_nsec3(int argc, char* argv[])
{ {
char line[10240]; char line[10240];
ldns_rdf* salt; sldns_rdf* salt;
ldns_rdf* in, *out; sldns_rdf* in, *out;
ldns_status status; sldns_status status;
status = ldns_str2rdf_nsec3_salt(&salt, argv[5]); status = sldns_str2rdf_nsec3_salt(&salt, argv[5]);
if(status != LDNS_STATUS_OK) if(status != LDNS_STATUS_OK)
fatal_exit("Could not parse salt %s: %s", argv[5], 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); assert(argc == 6);
while(fgets(line, (int)sizeof(line), stdin)) { while(fgets(line, (int)sizeof(line), stdin)) {
if(strlen(line) > 0) if(strlen(line) > 0)
line[strlen(line)-1] = 0; /* remove trailing newline */ line[strlen(line)-1] = 0; /* remove trailing newline */
if(line[0]==0) if(line[0]==0)
continue; continue;
status = ldns_str2rdf_dname(&in, line); status = sldns_str2rdf_dname(&in, line);
if(status != LDNS_STATUS_OK) if(status != LDNS_STATUS_OK)
fatal_exit("Could not parse name %s: %s", line, fatal_exit("Could not parse name %s: %s", line,
ldns_get_errorstr_by_id(status)); sldns_get_errorstr_by_id(status));
ldns_rdf_print(stdout, in); sldns_rdf_print(stdout, in);
printf(" -> "); printf(" -> ");
/* arg 3 is flags, unused */ /* 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]), (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) if(!out)
fatal_exit("Could not hash %s", line); fatal_exit("Could not hash %s", line);
ldns_rdf_print(stdout, out); sldns_rdf_print(stdout, out);
printf("\n"); printf("\n");
ldns_rdf_deep_free(in); sldns_rdf_deep_free(in);
ldns_rdf_deep_free(out); sldns_rdf_deep_free(out);
} }
ldns_rdf_deep_free(salt); sldns_rdf_deep_free(salt);
} }
/** main program */ /** main program */

48
testcode/streamtcp.c
View file

@ -112,26 +112,26 @@ open_svr(const char* svr, int udp)
/** write a query over the TCP fd */ /** write a query over the TCP fd */
static void 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) const char* strname, const char* strtype, const char* strclass)
{ {
struct query_info qinfo; struct query_info qinfo;
uint16_t len; uint16_t len;
/* qname */ /* qname */
qinfo.qname = ldns_str2wire_dname(strname, &qinfo.qname_len); qinfo.qname = sldns_str2wire_dname(strname, &qinfo.qname_len);
if(!qinfo.qname) { if(!qinfo.qname) {
printf("cannot parse query name: '%s'\n", strname); printf("cannot parse query name: '%s'\n", strname);
exit(1); exit(1);
} }
/* qtype and qclass */ /* qtype and qclass */
qinfo.qtype = ldns_get_rr_type_by_name(strtype); qinfo.qtype = sldns_get_rr_type_by_name(strtype);
qinfo.qclass = ldns_get_rr_class_by_name(strclass); qinfo.qclass = sldns_get_rr_class_by_name(strclass);
/* make query */ /* make query */
qinfo_query_encode(buf, &qinfo); qinfo_query_encode(buf, &qinfo);
ldns_buffer_write_u16_at(buf, 0, id); sldns_buffer_write_u16_at(buf, 0, id);
ldns_buffer_write_u16_at(buf, 2, BIT_RD); sldns_buffer_write_u16_at(buf, 2, BIT_RD);
if(1) { if(1) {
/* add EDNS DO */ /* add EDNS DO */
@ -145,7 +145,7 @@ write_q(int fd, int udp, SSL* ssl, ldns_buffer* buf, uint16_t id,
/* send it */ /* send it */
if(!udp) { if(!udp) {
len = (uint16_t)ldns_buffer_limit(buf); len = (uint16_t)sldns_buffer_limit(buf);
len = htons(len); len = htons(len);
if(ssl) { if(ssl) {
if(SSL_write(ssl, (void*)&len, (int)sizeof(len)) <= 0) { 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) {
if(SSL_write(ssl, (void*)ldns_buffer_begin(buf), if(SSL_write(ssl, (void*)sldns_buffer_begin(buf),
(int)ldns_buffer_limit(buf)) <= 0) { (int)sldns_buffer_limit(buf)) <= 0) {
log_crypto_err("cannot SSL_write"); log_crypto_err("cannot SSL_write");
exit(1); exit(1);
} }
} else { } else {
if(send(fd, (void*)ldns_buffer_begin(buf), if(send(fd, (void*)sldns_buffer_begin(buf),
ldns_buffer_limit(buf), 0) < sldns_buffer_limit(buf), 0) <
(ssize_t)ldns_buffer_limit(buf)) { (ssize_t)sldns_buffer_limit(buf)) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
perror("send() data failed"); perror("send() data failed");
#else #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 */ /** receive DNS datagram over TCP and print it */
static void 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; char* pktstr;
uint16_t len; uint16_t len;
@ -212,10 +212,10 @@ recv_one(int fd, int udp, SSL* ssl, ldns_buffer* buf)
} }
} }
len = ntohs(len); len = ntohs(len);
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
ldns_buffer_set_limit(buf, len); sldns_buffer_set_limit(buf, len);
if(ssl) { if(ssl) {
int r = SSL_read(ssl, (void*)ldns_buffer_begin(buf), int r = SSL_read(ssl, (void*)sldns_buffer_begin(buf),
(int)len); (int)len);
if(r <= 0) { if(r <= 0) {
log_crypto_err("could not SSL_read"); 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) if(r != (int)len)
fatal_exit("ssl_read %d of %d", r, len); fatal_exit("ssl_read %d of %d", r, len);
} else { } else {
if(recv(fd, (void*)ldns_buffer_begin(buf), len, 0) < if(recv(fd, (void*)sldns_buffer_begin(buf), len, 0) <
(ssize_t)len) { (ssize_t)len) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
perror("read() data failed"); perror("read() data failed");
@ -237,9 +237,9 @@ recv_one(int fd, int udp, SSL* ssl, ldns_buffer* buf)
} }
} else { } else {
ssize_t l; ssize_t l;
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
if((l=recv(fd, (void*)ldns_buffer_begin(buf), if((l=recv(fd, (void*)sldns_buffer_begin(buf),
ldns_buffer_capacity(buf), 0)) < 0) { sldns_buffer_capacity(buf), 0)) < 0) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
perror("read() data failed"); perror("read() data failed");
#else #else
@ -248,13 +248,13 @@ recv_one(int fd, int udp, SSL* ssl, ldns_buffer* buf)
#endif #endif
exit(1); exit(1);
} }
ldns_buffer_set_limit(buf, (size_t)l); sldns_buffer_set_limit(buf, (size_t)l);
len = (size_t)l; len = (size_t)l;
} }
printf("\nnext received packet\n"); printf("\nnext received packet\n");
log_buf(0, "data", buf); 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); printf("%s", pktstr);
free(pktstr); free(pktstr);
} }
@ -272,7 +272,7 @@ static int get_random(void)
static void static void
send_em(const char* svr, int udp, int usessl, int noanswer, int num, char** qs) 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 fd = open_svr(svr, udp);
int i; int i;
SSL_CTX* ctx = NULL; SSL_CTX* ctx = NULL;
@ -323,7 +323,7 @@ send_em(const char* svr, int udp, int usessl, int noanswer, int num, char** qs)
#else #else
closesocket(fd); closesocket(fd);
#endif #endif
ldns_buffer_free(buf); sldns_buffer_free(buf);
printf("orderly exit\n"); printf("orderly exit\n");
} }

2
testcode/testbound.c
View file

@ -302,7 +302,7 @@ main(int argc, char* argv[])
break; break;
case 'g': case 'g':
#ifdef USE_GOST #ifdef USE_GOST
if(ldns_key_EVP_load_gost_id()) { if(sldns_key_EVP_load_gost_id()) {
printf("GOST supported\n"); printf("GOST supported\n");
exit(0); exit(0);
} else { } else {

138
testcode/testpkts.c
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 */ /** convert hex buffer to binary buffer */
static ldns_buffer * static sldns_buffer *
hex_buffer2wire(ldns_buffer *data_buffer) hex_buffer2wire(sldns_buffer *data_buffer)
{ {
ldns_buffer *wire_buffer = NULL; sldns_buffer *wire_buffer = NULL;
int c; int c;
/* stat hack /* stat hack
@ -335,13 +335,13 @@ hex_buffer2wire(ldns_buffer *data_buffer)
uint8_t *hexbuf; uint8_t *hexbuf;
int hexbufpos = 0; int hexbufpos = 0;
size_t wirelen; 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); uint8_t *wire = (uint8_t*)malloc(MAX_PACKETLEN);
if(!wire) error("out of memory"); if(!wire) error("out of memory");
hexbuf = (uint8_t*)malloc(MAX_PACKETLEN); hexbuf = (uint8_t*)malloc(MAX_PACKETLEN);
if(!hexbuf) error("out of memory"); 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]; c = (int) data_wire[data_buf_pos];
if (state < 2 && !isascii(c)) { if (state < 2 && !isascii(c)) {
@ -402,8 +402,8 @@ hex_buffer2wire(ldns_buffer *data_buffer)
if (state < 2) { if (state < 2) {
wirelen = hexstr2bin((char *) hexbuf, hexbufpos, wire, 0, MAX_PACKETLEN); wirelen = hexstr2bin((char *) hexbuf, hexbufpos, wire, 0, MAX_PACKETLEN);
wire_buffer = ldns_buffer_new(wirelen); wire_buffer = sldns_buffer_new(wirelen);
ldns_buffer_new_frm_data(wire_buffer, wire, wirelen); sldns_buffer_new_frm_data(wire_buffer, wire, wirelen);
} else { } else {
error("Incomplete hex data, not at byte boundary\n"); error("Incomplete hex data, not at byte boundary\n");
} }
@ -414,7 +414,7 @@ hex_buffer2wire(ldns_buffer *data_buffer)
/** parse ORIGIN */ /** parse ORIGIN */
static void 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 */ /* snip off rest of the text so as to make the parse work in ldns */
char* end; char* end;
@ -427,18 +427,18 @@ get_origin(const char* name, struct ldns_file_parse_state* pstate, char* parse)
store = *end; store = *end;
*end = 0; *end = 0;
verbose(3, "parsing '%s'\n", parse); 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); &pstate->origin_len);
*end = store; *end = store;
if(status != 0) if(status != 0)
error("%s line %d:\n\t%s: %s", name, pstate->lineno, 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 */ /** add RR to packet */
static void add_rr(char* rrstr, uint8_t* pktbuf, size_t pktsize, static void add_rr(char* rrstr, uint8_t* pktbuf, size_t pktsize,
size_t* pktlen, struct ldns_file_parse_state* pstate, size_t* pktlen, struct sldns_file_parse_state* pstate,
ldns_pkt_section add_section, const char* fname) sldns_pkt_section add_section, const char* fname)
{ {
/* it must be a RR, parse and add to packet. */ /* it must be a RR, parse and add to packet. */
size_t rr_len = pktsize - *pktlen; size_t rr_len = pktsize - *pktlen;
@ -451,27 +451,27 @@ static void add_rr(char* rrstr, uint8_t* pktbuf, size_t pktsize,
/* parse RR */ /* parse RR */
if(add_section == LDNS_SECTION_QUESTION) 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, &rr_len, &dname_len, origin, pstate->origin_len,
prev, pstate->prev_rr_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, &dname_len, pstate->default_ttl, origin,
pstate->origin_len, prev, pstate->prev_rr_len); pstate->origin_len, prev, pstate->prev_rr_len);
if(status != 0) if(status != 0)
error("%s line %d:%d %s\n\t%s", fname, pstate->lineno, error("%s line %d:%d %s\n\t%s", fname, pstate->lineno,
LDNS_WIREPARSE_OFFSET(status), LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status), rrstr); sldns_get_errorstr_parse(status), rrstr);
*pktlen += rr_len; *pktlen += rr_len;
/* increase RR count */ /* increase RR count */
if(add_section == LDNS_SECTION_QUESTION) 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) 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) 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) 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); 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) if(*pktlen + sizeof(edns) > pktsize)
error("not enough space for EDNS OPT record"); error("not enough space for EDNS OPT record");
memmove(pktbuf+*pktlen, edns, sizeof(edns)); 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); *pktlen += sizeof(edns);
} }
/* Reads one entry from file. Returns entry or NULL on error. */ /* Reads one entry from file. Returns entry or NULL on error. */
struct entry* 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) int skip_whitespace)
{ {
struct entry* current = NULL; struct entry* current = NULL;
char line[MAX_LINE]; char line[MAX_LINE];
char* parse; char* parse;
ldns_pkt_section add_section = LDNS_SECTION_QUESTION; sldns_pkt_section add_section = LDNS_SECTION_QUESTION;
struct reply_packet *cur_reply = NULL; struct reply_packet *cur_reply = NULL;
int reading_hex = 0; int reading_hex = 0;
ldns_buffer* hex_data_buffer = NULL; sldns_buffer* hex_data_buffer = NULL;
uint8_t pktbuf[MAX_PACKETLEN]; uint8_t pktbuf[MAX_PACKETLEN];
size_t pktlen = LDNS_HEADER_SIZE; size_t pktlen = LDNS_HEADER_SIZE;
int do_flag = 0; /* DO flag in EDNS */ 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; add_section = LDNS_SECTION_ADDITIONAL;
else error("%s line %d: bad section %s", name, pstate->lineno, parse); else error("%s line %d: bad section %s", name, pstate->lineno, parse);
} else if(str_keyword(&parse, "HEX_ANSWER_BEGIN")) { } 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; reading_hex = 1;
} else if(str_keyword(&parse, "HEX_ANSWER_END")) { } else if(str_keyword(&parse, "HEX_ANSWER_END")) {
if(!reading_hex) { if(!reading_hex) {
@ -572,11 +572,11 @@ read_entry(FILE* in, const char* name, struct ldns_file_parse_state* pstate,
} }
reading_hex = 0; reading_hex = 0;
cur_reply->reply_from_hex = hex_buffer2wire(hex_data_buffer); 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; hex_data_buffer = NULL;
} else if(str_keyword(&parse, "ENTRY_END")) { } else if(str_keyword(&parse, "ENTRY_END")) {
if(hex_data_buffer) if(hex_data_buffer)
ldns_buffer_free(hex_data_buffer); sldns_buffer_free(hex_data_buffer);
if(pktlen != 0) { if(pktlen != 0) {
if(do_flag) if(do_flag)
add_do_flag(pktbuf, sizeof(pktbuf), 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; return current;
} else if(reading_hex) { } else if(reading_hex) {
ldns_buffer_printf(hex_data_buffer, "%s", line); sldns_buffer_printf(hex_data_buffer, "%s", line);
} else { } else {
add_rr(skip_whitespace?parse:line, pktbuf, add_rr(skip_whitespace?parse:line, pktbuf,
sizeof(pktbuf), &pktlen, pstate, add_section, sizeof(pktbuf), &pktlen, pstate, add_section,
@ -615,7 +615,7 @@ read_datafile(const char* name, int skip_whitespace)
struct entry* last = NULL; struct entry* last = NULL;
struct entry* current = NULL; struct entry* current = NULL;
FILE *in; FILE *in;
struct ldns_file_parse_state pstate; struct sldns_file_parse_state pstate;
int entry_num = 0; int entry_num = 0;
memset(&pstate, 0, sizeof(pstate)); memset(&pstate, 0, sizeof(pstate));
@ -638,7 +638,7 @@ read_datafile(const char* name, int skip_whitespace)
} }
/** get qtype from packet */ /** 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; uint8_t* d;
size_t dl, sl=0; 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 */ /* skip over dname with dname-scan routine */
d = pkt+LDNS_HEADER_SIZE; d = pkt+LDNS_HEADER_SIZE;
dl = pktlen-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) if(dl < 2)
return 0; return 0;
return ldns_read_uint16(d); return sldns_read_uint16(d);
} }
/** get qtype from packet */ /** 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 */ /* skip over dname with dname-scan routine */
d = pkt+LDNS_HEADER_SIZE; d = pkt+LDNS_HEADER_SIZE;
dl = pktlen-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; 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 */ /* skip other records with wire2str_scan */
for(i=0; i < LDNS_QDCOUNT(p); i++) 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); &snull, &sl, p, plen);
for(i=0; i < LDNS_ANCOUNT(p); i++) 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); p, plen);
/* walk through authority section */ /* 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 */ /* if this is SOA then get serial, skip compressed dname */
uint8_t* dstart = walk; uint8_t* dstart = walk;
size_t dlen = walk_len; 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); 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 */ /* skip type, class, TTL, rdatalen */
if(dlen < 10) if(dlen < 10)
return 0; return 0;
if(dlen < 10 + (size_t)ldns_read_uint16(dstart+8)) if(dlen < 10 + (size_t)sldns_read_uint16(dstart+8))
return 0; return 0;
dstart += 10; dstart += 10;
dlen -= 10; dlen -= 10;
/* check third rdf */ /* check third rdf */
(void)ldns_wire2str_dname_scan(&dstart, &dlen, &snull, (void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull,
&sl, p, plen); &sl, p, plen);
(void)ldns_wire2str_dname_scan(&dstart, &dlen, &snull, (void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull,
&sl, p, plen); &sl, p, plen);
if(dlen < 4) if(dlen < 4)
return 0; return 0;
verbose(3, "found serial %u in msg. ", verbose(3, "found serial %u in msg. ",
(int)ldns_read_uint32(dstart)); (int)sldns_read_uint32(dstart));
return ldns_read_uint32(dstart); return sldns_read_uint32(dstart);
} }
/* move to next RR */ /* 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); p, plen);
} }
return 0; return 0;
@ -762,27 +762,27 @@ pkt_find_edns_opt(uint8_t** p, size_t* plen)
/* skip other records with wire2str_scan */ /* skip other records with wire2str_scan */
for(i=0; i < LDNS_QDCOUNT(p); i++) 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); *p, *plen);
for(i=0; i < LDNS_ANCOUNT(p); i++) 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++) 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 */ /* walk through additional section */
for(i=0; i < LDNS_ARCOUNT(p); i++) { for(i=0; i < LDNS_ARCOUNT(p); i++) {
/* if this is OPT then done */ /* if this is OPT then done */
uint8_t* dstart = w; uint8_t* dstart = w;
size_t dlen = wlen; size_t dlen = wlen;
(void)ldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl, (void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl,
*p, *plen); *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; *p = dstart+2;
*plen = dlen-2; *plen = dlen-2;
return 1; return 1;
} }
/* move to next RR */ /* 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; return 0;
} }
@ -807,7 +807,7 @@ get_do_flag(uint8_t* pkt, size_t len)
} }
if(walk_len < 6) if(walk_len < 6)
return 0; /* malformed */ 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); 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 += LDNS_HEADER_SIZE;
walk_len -= LDNS_HEADER_SIZE; walk_len -= LDNS_HEADER_SIZE;
for(i=0; i < LDNS_QDCOUNT(pkt); i++) 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); &snull, &sl, pkt, pktlen);
for(i=0; i < num; i++) { for(i=0; i < num; i++) {
/* wipe TTL */ /* wipe TTL */
uint8_t* dstart = walk; uint8_t* dstart = walk;
size_t dlen = walk_len; 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); pkt, pktlen);
if(dlen < 8) if(dlen < 8)
return; return;
ldns_write_uint32(dstart+4, 0); sldns_write_uint32(dstart+4, 0);
/* go to next RR */ /* 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); 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, static void lowercase_rdata(uint8_t** p, size_t* remain,
uint16_t rdatalen, uint16_t t) 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; uint8_t dname_count = 0;
size_t i = 0; size_t i = 0;
size_t rdataremain = rdatalen; size_t rdataremain = rdatalen;
@ -1011,7 +1011,7 @@ static void lowercase_rdata(uint8_t** p, size_t* remain,
return; return;
} }
while(dname_count < desc->_dname_count) { 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) { if(f == LDNS_RDF_TYPE_DNAME) {
lowercase_dname(p, &rdataremain); lowercase_dname(p, &rdataremain);
dname_count++; 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++) { for(i=0; i<LDNS_ANCOUNT(pkt)+LDNS_NSCOUNT(pkt)+LDNS_ARCOUNT(pkt); i++) {
lowercase_dname(&p, &remain); lowercase_dname(&p, &remain);
if(remain < 10) return; if(remain < 10) return;
t = ldns_read_uint16(p); t = sldns_read_uint16(p);
rdatalen = ldns_read_uint16(p+8); rdatalen = sldns_read_uint16(p+8);
p += 10; p += 10;
remain -= 10; remain -= 10;
if(remain < rdatalen) return; 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(qb, qlen);
lowercase_pkt(pb, plen); lowercase_pkt(pb, plen);
qstr = ldns_wire2str_pkt(qb, qlen); qstr = sldns_wire2str_pkt(qb, qlen);
pstr = ldns_wire2str_pkt(pb, plen); pstr = sldns_wire2str_pkt(pb, plen);
if(!qstr || !pstr) error("cannot pkt2string"); if(!qstr || !pstr) error("cannot pkt2string");
r = (strcmp(qstr, pstr) == 0); r = (strcmp(qstr, pstr) == 0);
if(!r) { 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; char* qss = qs, *pss = ps;
if(!qn || !pn) if(!qn || !pn)
return 0; return 0;
(void)ldns_wire2str_dname_scan(&qn, &qlen, &qss, &qslen, q, qlen); (void)sldns_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(&pn, &plen, &pss, &pslen, p, plen);
return (strcmp(qs, ps) == 0); 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) if(!qn || !pn)
return 0; return 0;
/* decompresses domain names */ /* decompresses domain names */
(void)ldns_wire2str_dname_scan(&qn, &qlen, &qss, &qslen, q, qlen); (void)sldns_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(&pn, &plen, &pss, &pslen, p, plen);
/* same: false, (strict subdomain check)??? */ /* same: false, (strict subdomain check)??? */
if(strcmp(qs, ps) == 0) if(strcmp(qs, ps) == 0)
return 1; 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, memmove(res+LDNS_HEADER_SIZE+dlen+4, orig+LDNS_HEADER_SIZE,
reslen-(LDNS_HEADER_SIZE+dlen+4)); reslen-(LDNS_HEADER_SIZE+dlen+4));
/* set QDCOUNT */ /* set QDCOUNT */
ldns_write_uint16(res+4, 1); sldns_write_uint16(res+4, 1);
} else if(match->copy_query && origlen >= LDNS_HEADER_SIZE && } else if(match->copy_query && origlen >= LDNS_HEADER_SIZE &&
query_len >= LDNS_HEADER_SIZE && LDNS_QDCOUNT(query_pkt)!=0 query_len >= LDNS_HEADER_SIZE && LDNS_QDCOUNT(query_pkt)!=0
&& get_qname_len(orig, origlen) == 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), (int)(inlen>=2?LDNS_ID_WIRE(inbuf):0),
(transport==transport_tcp)?"TCP":"UDP", (int)inlen); (transport==transport_tcp)?"TCP":"UDP", (int)inlen);
if(verbose_out) { 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); printf("%s\n", out);
free(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, * parsed, we can use adjust rules. if not,
* send packet literally */ * send packet literally */
/* still try to adjust ID if others fail */ /* still try to adjust ID if others fail */
outlen = ldns_buffer_limit(p->reply_from_hex); outlen = sldns_buffer_limit(p->reply_from_hex);
outbuf = ldns_buffer_begin(p->reply_from_hex); outbuf = sldns_buffer_begin(p->reply_from_hex);
} else { } else {
outbuf = p->reply_pkt; outbuf = p->reply_pkt;
outlen = p->reply_len; 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); adjust_packet(entry, &outbuf, &outlen, inbuf, (size_t)inlen);
verbose(1, "Answer packet size: %u bytes.\n", (unsigned int)outlen); verbose(1, "Answer packet size: %u bytes.\n", (unsigned int)outlen);
if(verbose_out) { if(verbose_out) {
char* out = ldns_wire2str_pkt(outbuf, outlen); char* out = sldns_wire2str_pkt(outbuf, outlen);
printf("%s\n", out); printf("%s\n", out);
free(out); free(out);
} }
@ -1409,7 +1409,7 @@ void delete_replylist(struct reply_packet* replist)
while(p) { while(p) {
np = p->next; np = p->next;
free(p->reply_pkt); free(p->reply_pkt);
ldns_buffer_free(p->reply_from_hex); sldns_buffer_free(p->reply_from_hex);
free(p); free(p);
p=np; p=np;
} }

8
testcode/testpkts.h
View file

@ -9,8 +9,8 @@
#ifndef TESTPKTS_H #ifndef TESTPKTS_H
#define TESTPKTS_H #define TESTPKTS_H
struct ldns_buffer; struct sldns_buffer;
struct ldns_file_parse_state; struct sldns_file_parse_state;
/** /**
* \file * \file
@ -145,7 +145,7 @@ struct reply_packet {
/** length of reply pkt */ /** length of reply pkt */
size_t reply_len; size_t reply_len;
/** or reply pkt in hex if not parsable */ /** 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 */ /** seconds to sleep before giving packet */
unsigned int packet_sleep; 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. * @return: The entry read (malloced) or NULL if no entry could be read.
*/ */
struct entry* read_entry(FILE* in, const char* name, 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. * finds entry in list, or returns NULL.

10
testcode/unitanchor.c
View file

@ -64,7 +64,7 @@ test_anchor_empty(struct val_anchors* a)
/** test set of one anchor */ /** test set of one anchor */
static void 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; struct trust_anchor* ta;
uint16_t c = LDNS_RR_CLASS_IN; 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 */ /** test with several anchors */
static void static void
test_anchors(ldns_buffer* buff, struct val_anchors* a) test_anchors(sldns_buffer* buff, struct val_anchors* a)
{ {
struct trust_anchor* ta; struct trust_anchor* ta;
uint16_t c = LDNS_RR_CLASS_IN; uint16_t c = LDNS_RR_CLASS_IN;
@ -124,14 +124,14 @@ test_anchors(ldns_buffer* buff, struct val_anchors* a)
void anchors_test(void) void anchors_test(void)
{ {
ldns_buffer* buff = ldns_buffer_new(65800); sldns_buffer* buff = sldns_buffer_new(65800);
struct val_anchors* a; struct val_anchors* a;
unit_show_feature("trust anchor store"); unit_show_feature("trust anchor store");
unit_assert(a = anchors_create()); unit_assert(a = anchors_create());
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
test_anchor_empty(a); test_anchor_empty(a);
test_anchor_one(buff, a); test_anchor_one(buff, a);
test_anchors(buff, a); test_anchors(buff, a);
anchors_delete(a); anchors_delete(a);
ldns_buffer_free(buff); sldns_buffer_free(buff);
} }

180
testcode/unitdname.c
View file

@ -46,24 +46,24 @@
#include "ldns/str2wire.h" #include "ldns/str2wire.h"
/** put dname into buffer */ /** put dname into buffer */
static ldns_buffer* static sldns_buffer*
dname_to_buf(ldns_buffer* b, const char* str) dname_to_buf(sldns_buffer* b, const char* str)
{ {
int e; int e;
size_t len = ldns_buffer_capacity(b); size_t len = sldns_buffer_capacity(b);
ldns_buffer_clear(b); sldns_buffer_clear(b);
e = ldns_str2wire_dname_buf(str, ldns_buffer_begin(b), &len); e = sldns_str2wire_dname_buf(str, sldns_buffer_begin(b), &len);
if(e != 0) if(e != 0)
fatal_exit("%s ldns: %s", __func__, fatal_exit("%s ldns: %s", __func__,
ldns_get_errorstr_parse(e)); sldns_get_errorstr_parse(e));
ldns_buffer_set_position(b, len); sldns_buffer_set_position(b, len);
ldns_buffer_flip(b); sldns_buffer_flip(b);
return b; return b;
} }
/** test query_dname_len function */ /** test query_dname_len function */
static void 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_show_func("util/data/dname.c", "query_dname_len");
unit_assert( query_dname_len(buff) == 0); unit_assert( query_dname_len(buff) == 0);
@ -75,26 +75,26 @@ dname_test_qdl(ldns_buffer* buff)
/** test query_dname_tolower */ /** test query_dname_tolower */
static void static void
dname_test_qdtl(ldns_buffer* buff) dname_test_qdtl(sldns_buffer* buff)
{ {
unit_show_func("util/data/dname.c", "query_dname_tolower"); unit_show_func("util/data/dname.c", "query_dname_tolower");
ldns_buffer_write_at(buff, 0, "\012abCDeaBCde\003cOm\000", 16); sldns_buffer_write_at(buff, 0, "\012abCDeaBCde\003cOm\000", 16);
query_dname_tolower(ldns_buffer_begin(buff)); query_dname_tolower(sldns_buffer_begin(buff));
unit_assert( memcmp(ldns_buffer_begin(buff), unit_assert( memcmp(sldns_buffer_begin(buff),
"\012abcdeabcde\003com\000", 16) == 0); "\012abcdeabcde\003com\000", 16) == 0);
ldns_buffer_write_at(buff, 0, "\001+\012abC{e-ZYXe\003NET\000", 18); sldns_buffer_write_at(buff, 0, "\001+\012abC{e-ZYXe\003NET\000", 18);
query_dname_tolower(ldns_buffer_begin(buff)); query_dname_tolower(sldns_buffer_begin(buff));
unit_assert( memcmp(ldns_buffer_begin(buff), unit_assert( memcmp(sldns_buffer_begin(buff),
"\001+\012abc{e-zyxe\003net\000", 18) == 0); "\001+\012abc{e-zyxe\003net\000", 18) == 0);
ldns_buffer_write_at(buff, 0, "\000", 1); sldns_buffer_write_at(buff, 0, "\000", 1);
query_dname_tolower(ldns_buffer_begin(buff)); query_dname_tolower(sldns_buffer_begin(buff));
unit_assert( memcmp(ldns_buffer_begin(buff), "\000", 1) == 0); unit_assert( memcmp(sldns_buffer_begin(buff), "\000", 1) == 0);
ldns_buffer_write_at(buff, 0, "\002NL\000", 4); sldns_buffer_write_at(buff, 0, "\002NL\000", 4);
query_dname_tolower(ldns_buffer_begin(buff)); query_dname_tolower(sldns_buffer_begin(buff));
unit_assert( memcmp(ldns_buffer_begin(buff), "\002nl\000", 4) == 0); unit_assert( memcmp(sldns_buffer_begin(buff), "\002nl\000", 4) == 0);
} }
/** test query_dname_compare */ /** test query_dname_compare */
@ -163,62 +163,62 @@ dname_test_count_size_labels(void)
/** test pkt_dname_len */ /** test pkt_dname_len */
static void 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"); unit_show_func("util/data/dname.c", "pkt_dname_len");
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write(buff, "\000", 1); sldns_buffer_write(buff, "\000", 1);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 1 ); 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); sldns_buffer_clear(buff);
ldns_buffer_write(buff, "\003org\000", 5); sldns_buffer_write(buff, "\003org\000", 5);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 5 ); 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); sldns_buffer_clear(buff);
ldns_buffer_write(buff, "\002os\007example\003org\000", 16); sldns_buffer_write(buff, "\002os\007example\003org\000", 16);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 16 ); 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 */ /* invalid compression pointer: to self */
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write(buff, "\300\000os\007example\003org\000", 17); sldns_buffer_write(buff, "\300\000os\007example\003org\000", 17);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 ); unit_assert( pkt_dname_len(buff) == 0 );
/* valid compression pointer */ /* valid compression pointer */
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write(buff, "\003com\000\040\300\000", 8); sldns_buffer_write(buff, "\003com\000\040\300\000", 8);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
ldns_buffer_set_position(buff, 6); sldns_buffer_set_position(buff, 6);
unit_assert( pkt_dname_len(buff) == 5 ); unit_assert( pkt_dname_len(buff) == 5 );
unit_assert( ldns_buffer_position(buff) == 8); unit_assert( sldns_buffer_position(buff) == 8);
/* unknown label type */ /* unknown label type */
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write(buff, "\002os\107example\003org\000", 16); sldns_buffer_write(buff, "\002os\107example\003org\000", 16);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 ); unit_assert( pkt_dname_len(buff) == 0 );
/* label too long */ /* label too long */
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write(buff, "\002os\047example\003org\000", 16); sldns_buffer_write(buff, "\002os\047example\003org\000", 16);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 ); unit_assert( pkt_dname_len(buff) == 0 );
/* label exceeds packet */ /* label exceeds packet */
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write(buff, "\002os\007example\007org\004", 16); sldns_buffer_write(buff, "\002os\007example\007org\004", 16);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 ); unit_assert( pkt_dname_len(buff) == 0 );
/* name very long */ /* name very long */
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write(buff, sldns_buffer_write(buff,
"\020a1cdef5555544444" "\020a1cdef5555544444"
"\020a2cdef5555544444" "\020a2cdef5555544444"
"\020a3cdef5555544444" "\020a3cdef5555544444"
@ -236,13 +236,13 @@ dname_test_pkt_dname_len(ldns_buffer* buff)
"\007aabbccd" /* 246 up to here */ "\007aabbccd" /* 246 up to here */
"\007example\000" /* 255 to here */ "\007example\000" /* 255 to here */
, 255); , 255);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 255 ); unit_assert( pkt_dname_len(buff) == 255 );
unit_assert( ldns_buffer_position(buff) == 255); unit_assert( sldns_buffer_position(buff) == 255);
/* name too long */ /* name too long */
ldns_buffer_clear(buff); sldns_buffer_clear(buff);
ldns_buffer_write(buff, sldns_buffer_write(buff,
"\020a1cdef5555544444" "\020a1cdef5555544444"
"\020a2cdef5555544444" "\020a2cdef5555544444"
"\020a3cdef5555544444" "\020a3cdef5555544444"
@ -263,7 +263,7 @@ dname_test_pkt_dname_len(ldns_buffer* buff)
"\007aabbccd" /* 246 up to here */ "\007aabbccd" /* 246 up to here */
"\007example\000" /* 255 to here */ "\007example\000" /* 255 to here */
, 255); , 255);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
unit_assert( pkt_dname_len(buff) == 0 ); unit_assert( pkt_dname_len(buff) == 0 );
} }
@ -796,47 +796,47 @@ dname_test_valid(void)
/** test pkt_dname_tolower */ /** test pkt_dname_tolower */
static void 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"); unit_show_func("util/data/dname.c", "pkt_dname_tolower");
pkt_dname_tolower(loopbuf, ldns_buffer_at(loopbuf, 12)); pkt_dname_tolower(loopbuf, sldns_buffer_at(loopbuf, 12));
pkt_dname_tolower(boundbuf, ldns_buffer_at(boundbuf, 12)); pkt_dname_tolower(boundbuf, sldns_buffer_at(boundbuf, 12));
} }
/** setup looped dname and out-of-bounds dname ptr */ /** setup looped dname and out-of-bounds dname ptr */
static void 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 */ sldns_buffer_write_u16(loopbuf, 0xd54d); /* id */
ldns_buffer_write_u16(loopbuf, 0x12); /* flags */ sldns_buffer_write_u16(loopbuf, 0x12); /* flags */
ldns_buffer_write_u16(loopbuf, 1); /* qdcount */ sldns_buffer_write_u16(loopbuf, 1); /* qdcount */
ldns_buffer_write_u16(loopbuf, 0); /* ancount */ sldns_buffer_write_u16(loopbuf, 0); /* ancount */
ldns_buffer_write_u16(loopbuf, 0); /* nscount */ sldns_buffer_write_u16(loopbuf, 0); /* nscount */
ldns_buffer_write_u16(loopbuf, 0); /* arcount */ sldns_buffer_write_u16(loopbuf, 0); /* arcount */
ldns_buffer_write_u8(loopbuf, 0xc0); /* PTR back at itself */ sldns_buffer_write_u8(loopbuf, 0xc0); /* PTR back at itself */
ldns_buffer_write_u8(loopbuf, 0x0c); sldns_buffer_write_u8(loopbuf, 0x0c);
ldns_buffer_flip(loopbuf); sldns_buffer_flip(loopbuf);
ldns_buffer_write_u16(boundbuf, 0xd54d); /* id */ sldns_buffer_write_u16(boundbuf, 0xd54d); /* id */
ldns_buffer_write_u16(boundbuf, 0x12); /* flags */ sldns_buffer_write_u16(boundbuf, 0x12); /* flags */
ldns_buffer_write_u16(boundbuf, 1); /* qdcount */ sldns_buffer_write_u16(boundbuf, 1); /* qdcount */
ldns_buffer_write_u16(boundbuf, 0); /* ancount */ sldns_buffer_write_u16(boundbuf, 0); /* ancount */
ldns_buffer_write_u16(boundbuf, 0); /* nscount */ sldns_buffer_write_u16(boundbuf, 0); /* nscount */
ldns_buffer_write_u16(boundbuf, 0); /* arcount */ sldns_buffer_write_u16(boundbuf, 0); /* arcount */
ldns_buffer_write_u8(boundbuf, 0x01); /* len=1 */ sldns_buffer_write_u8(boundbuf, 0x01); /* len=1 */
ldns_buffer_write_u8(boundbuf, (uint8_t)'A'); /* A. label */ sldns_buffer_write_u8(boundbuf, (uint8_t)'A'); /* A. label */
ldns_buffer_write_u8(boundbuf, 0xc0); /* PTR out of bounds */ sldns_buffer_write_u8(boundbuf, 0xc0); /* PTR out of bounds */
ldns_buffer_write_u8(boundbuf, 0xcc); sldns_buffer_write_u8(boundbuf, 0xcc);
ldns_buffer_flip(boundbuf); sldns_buffer_flip(boundbuf);
} }
void dname_test(void) void dname_test(void)
{ {
ldns_buffer* loopbuf = ldns_buffer_new(14); sldns_buffer* loopbuf = sldns_buffer_new(14);
ldns_buffer* boundbuf = ldns_buffer_new(16); sldns_buffer* boundbuf = sldns_buffer_new(16);
ldns_buffer* buff = ldns_buffer_new(65800); sldns_buffer* buff = sldns_buffer_new(65800);
unit_assert(loopbuf && boundbuf && buff); unit_assert(loopbuf && boundbuf && buff);
ldns_buffer_flip(buff); sldns_buffer_flip(buff);
dname_setup_bufs(loopbuf, boundbuf); dname_setup_bufs(loopbuf, boundbuf);
dname_test_qdl(buff); dname_test_qdl(buff);
dname_test_qdtl(buff); dname_test_qdtl(buff);
@ -855,7 +855,7 @@ void dname_test(void)
dname_test_canoncmp(); dname_test_canoncmp();
dname_test_topdomain(); dname_test_topdomain();
dname_test_valid(); dname_test_valid();
ldns_buffer_free(buff); sldns_buffer_free(buff);
ldns_buffer_free(loopbuf); sldns_buffer_free(loopbuf);
ldns_buffer_free(boundbuf); sldns_buffer_free(boundbuf);
} }

4
testcode/unitmain.c
View file

@ -568,7 +568,7 @@ main(int argc, char* argv[])
OPENSSL_config("unbound"); OPENSSL_config("unbound");
# endif # endif
# ifdef USE_GOST # ifdef USE_GOST
(void)ldns_key_EVP_load_gost_id(); (void)sldns_key_EVP_load_gost_id();
# endif # endif
#elif defined(HAVE_NSS) #elif defined(HAVE_NSS)
if(NSS_NoDB_Init(".") != SECSuccess) if(NSS_NoDB_Init(".") != SECSuccess)
@ -593,7 +593,7 @@ main(int argc, char* argv[])
printf("%d checks ok.\n", testcount); printf("%d checks ok.\n", testcount);
#ifdef HAVE_SSL #ifdef HAVE_SSL
# if defined(USE_GOST) && defined(HAVE_LDNS_KEY_EVP_UNLOAD_GOST) # if defined(USE_GOST) && defined(HAVE_LDNS_KEY_EVP_UNLOAD_GOST)
ldns_key_EVP_unload_gost(); sldns_key_EVP_unload_gost();
# endif # endif
# ifdef HAVE_OPENSSL_CONFIG # ifdef HAVE_OPENSSL_CONFIG
EVP_cleanup(); EVP_cleanup();

114
testcode/unitmsgparse.c
View file

@ -68,36 +68,36 @@ static int check_nosameness = 0;
/** see if buffers contain the same packet */ /** see if buffers contain the same packet */
static int static int
test_buffers(ldns_buffer* pkt, ldns_buffer* out) test_buffers(sldns_buffer* pkt, sldns_buffer* out)
{ {
/* check binary same */ /* check binary same */
if(ldns_buffer_limit(pkt) == ldns_buffer_limit(out) && if(sldns_buffer_limit(pkt) == sldns_buffer_limit(out) &&
memcmp(ldns_buffer_begin(pkt), ldns_buffer_begin(out), memcmp(sldns_buffer_begin(pkt), sldns_buffer_begin(out),
ldns_buffer_limit(pkt)) == 0) { sldns_buffer_limit(pkt)) == 0) {
if(vbmp) printf("binary the same (length=%u)\n", if(vbmp) printf("binary the same (length=%u)\n",
(unsigned)ldns_buffer_limit(pkt)); (unsigned)sldns_buffer_limit(pkt));
return 1; return 1;
} }
if(vbmp) { if(vbmp) {
size_t sz = 16; size_t sz = 16;
size_t count; size_t count;
size_t lim = ldns_buffer_limit(out); size_t lim = sldns_buffer_limit(out);
if(ldns_buffer_limit(pkt) < lim) if(sldns_buffer_limit(pkt) < lim)
lim = ldns_buffer_limit(pkt); lim = sldns_buffer_limit(pkt);
for(count=0; count<lim; count+=sz) { for(count=0; count<lim; count+=sz) {
size_t rem = sz; size_t rem = sz;
if(lim-count < sz) rem = lim-count; if(lim-count < sz) rem = lim-count;
if(memcmp(ldns_buffer_at(pkt, count), if(memcmp(sldns_buffer_at(pkt, count),
ldns_buffer_at(out, count), rem) == 0) { sldns_buffer_at(out, count), rem) == 0) {
log_info("same %d %d", (int)count, (int)rem); 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); rem);
} else { } else {
log_info("diff %d %d", (int)count, (int)rem); 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); rem);
log_hex("difo: ", ldns_buffer_at(out, count), log_hex("difo: ", sldns_buffer_at(out, count),
rem); rem);
} }
} }
@ -109,24 +109,24 @@ test_buffers(ldns_buffer* pkt, ldns_buffer* out)
log_buf(0, "orig in hex", pkt); log_buf(0, "orig in hex", pkt);
log_buf(0, "unbound out in hex", out); log_buf(0, "unbound out in hex", out);
printf("\npacket from unbound (%d):\n", printf("\npacket from unbound (%d):\n",
(int)ldns_buffer_limit(out)); (int)sldns_buffer_limit(out));
s1 = ldns_wire2str_pkt(ldns_buffer_begin(out), s1 = sldns_wire2str_pkt(sldns_buffer_begin(out),
ldns_buffer_limit(out)); sldns_buffer_limit(out));
printf("%s\n", s1?s1:"null"); printf("%s\n", s1?s1:"null");
free(s1); free(s1);
printf("\npacket original (%d):\n", printf("\npacket original (%d):\n",
(int)ldns_buffer_limit(pkt)); (int)sldns_buffer_limit(pkt));
s2 = ldns_wire2str_pkt(ldns_buffer_begin(pkt), s2 = sldns_wire2str_pkt(sldns_buffer_begin(pkt),
ldns_buffer_limit(pkt)); sldns_buffer_limit(pkt));
printf("%s\n", s2?s2:"null"); printf("%s\n", s2?s2:"null");
free(s2); free(s2);
printf("\n"); printf("\n");
} }
/* if it had two EDNS sections, skip comparison */ /* if it had two EDNS sections, skip comparison */
if(1) { if(1) {
char* s = ldns_wire2str_pkt(ldns_buffer_begin(pkt), char* s = sldns_wire2str_pkt(sldns_buffer_begin(pkt),
ldns_buffer_limit(pkt)); sldns_buffer_limit(pkt));
char* e1 = strstr(s, "; EDNS:"); char* e1 = strstr(s, "; EDNS:");
if(e1 && strstr(e1+4, "; EDNS:")) { if(e1 && strstr(e1+4, "; EDNS:")) {
free(s); free(s);
@ -135,19 +135,19 @@ test_buffers(ldns_buffer* pkt, ldns_buffer* out)
free(s); free(s);
} }
/* compare packets */ /* compare packets */
unit_assert(match_all(ldns_buffer_begin(pkt), ldns_buffer_limit(pkt), unit_assert(match_all(sldns_buffer_begin(pkt), sldns_buffer_limit(pkt),
ldns_buffer_begin(out), ldns_buffer_limit(out), 1, sldns_buffer_begin(out), sldns_buffer_limit(out), 1,
matches_nolocation)); matches_nolocation));
return 0; return 0;
} }
/** check if unbound formerr equals ldns formerr */ /** check if unbound formerr equals ldns formerr */
static void static void
checkformerr(ldns_buffer* pkt) checkformerr(sldns_buffer* pkt)
{ {
int status = 0; int status = 0;
char* s = ldns_wire2str_pkt(ldns_buffer_begin(pkt), char* s = sldns_wire2str_pkt(sldns_buffer_begin(pkt),
ldns_buffer_limit(pkt)); sldns_buffer_limit(pkt));
if(!s) fatal_exit("out of memory"); if(!s) fatal_exit("out of memory");
if(strstr(s, "Error")) status = 1; if(strstr(s, "Error")) status = 1;
if(strstr(s, "error")) status = 1; if(strstr(s, "error")) status = 1;
@ -164,7 +164,7 @@ checkformerr(ldns_buffer* pkt)
/** performance test message encoding */ /** performance test message encoding */
static void static void
perf_encode(struct query_info* qi, struct reply_info* rep, uint16_t id, 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) struct edns_data* edns)
{ {
static int num = 0; 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.; ((double)end.tv_usec - (double)start.tv_usec)/1000.;
printf("[%d] did %u in %g msec for %f encode/sec size %d\n", num++, printf("[%d] did %u in %g msec for %f encode/sec size %d\n", num++,
(unsigned)max, dt, (double)max / (dt/1000.), (unsigned)max, dt, (double)max / (dt/1000.),
(int)ldns_buffer_limit(out)); (int)sldns_buffer_limit(out));
regional_destroy(r2); regional_destroy(r2);
} }
/** perf test a packet */ /** perf test a packet */
static void 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) const char* hex)
{ {
struct query_info qi; struct query_info qi;
@ -210,15 +210,15 @@ perftestpkt(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
struct edns_data edns; struct edns_data edns;
hex_to_buf(pkt, hex); hex_to_buf(pkt, hex);
memmove(&id, ldns_buffer_begin(pkt), sizeof(id)); memmove(&id, sldns_buffer_begin(pkt), sizeof(id));
if(ldns_buffer_limit(pkt) < 2) if(sldns_buffer_limit(pkt) < 2)
flags = 0; 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); flags = ntohs(flags);
ret = reply_info_parse(pkt, alloc, &qi, &rep, region, &edns); ret = reply_info_parse(pkt, alloc, &qi, &rep, region, &edns);
if(ret != 0) { if(ret != 0) {
char rbuf[16]; 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(vbmp) printf("parse code %d: %s\n", ret, rbuf);
if(ret == LDNS_RCODE_FORMERR) if(ret == LDNS_RCODE_FORMERR)
checkformerr(pkt); checkformerr(pkt);
@ -311,7 +311,7 @@ check_the_rrsigs(struct query_info* qinfo, struct reply_info* rep)
/** test a packet */ /** test a packet */
static void 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) const char* hex)
{ {
struct query_info qi; struct query_info qi;
@ -324,15 +324,15 @@ testpkt(ldns_buffer* pkt, struct alloc_cache* alloc, ldns_buffer* out,
struct edns_data edns; struct edns_data edns;
hex_to_buf(pkt, hex); hex_to_buf(pkt, hex);
memmove(&id, ldns_buffer_begin(pkt), sizeof(id)); memmove(&id, sldns_buffer_begin(pkt), sizeof(id));
if(ldns_buffer_limit(pkt) < 2) if(sldns_buffer_limit(pkt) < 2)
flags = 0; 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); flags = ntohs(flags);
ret = reply_info_parse(pkt, alloc, &qi, &rep, region, &edns); ret = reply_info_parse(pkt, alloc, &qi, &rep, region, &edns);
if(ret != 0) { if(ret != 0) {
char rbuf[16]; 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(vbmp) printf("parse code %d: %s\n", ret, rbuf);
if(ret == LDNS_RCODE_FORMERR) { if(ret == LDNS_RCODE_FORMERR) {
unit_assert(!check_formerr_gone); 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 */ unit_assert(ret != 0); /* udp packets should fit */
attach_edns_record(out, &edns); attach_edns_record(out, &edns);
if(vbmp) printf("inlen %u outlen %u\n", if(vbmp) printf("inlen %u outlen %u\n",
(unsigned)ldns_buffer_limit(pkt), (unsigned)sldns_buffer_limit(pkt),
(unsigned)ldns_buffer_limit(out)); (unsigned)sldns_buffer_limit(out));
if(!check_nosameness) if(!check_nosameness)
test_buffers(pkt, out); test_buffers(pkt, out);
if(check_rrsigs) if(check_rrsigs)
check_the_rrsigs(&qi, rep); 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, ret = reply_info_encode(&qi, rep, id, flags, out,
timenow, region, timenow, region,
lim - calc_edns_field_size(&edns), lim - calc_edns_field_size(&edns),
(int)(edns.bits & EDNS_DO)); (int)(edns.bits & EDNS_DO));
unit_assert(ret != 0); /* should fit, but with TC */ unit_assert(ret != 0); /* should fit, but with TC */
attach_edns_record(out, &edns); attach_edns_record(out, &edns);
if( LDNS_QDCOUNT(ldns_buffer_begin(out)) != if( LDNS_QDCOUNT(sldns_buffer_begin(out)) !=
LDNS_QDCOUNT(ldns_buffer_begin(pkt)) || LDNS_QDCOUNT(sldns_buffer_begin(pkt)) ||
LDNS_ANCOUNT(ldns_buffer_begin(out)) != LDNS_ANCOUNT(sldns_buffer_begin(out)) !=
LDNS_ANCOUNT(ldns_buffer_begin(pkt)) || LDNS_ANCOUNT(sldns_buffer_begin(pkt)) ||
LDNS_NSCOUNT(ldns_buffer_begin(out)) != LDNS_NSCOUNT(sldns_buffer_begin(out)) !=
LDNS_NSCOUNT(ldns_buffer_begin(pkt))) LDNS_NSCOUNT(sldns_buffer_begin(pkt)))
unit_assert( unit_assert(
LDNS_TC_WIRE(ldns_buffer_begin(out))); LDNS_TC_WIRE(sldns_buffer_begin(out)));
/* must set TC bit if shortened */ /* 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 */ /** simple test of parsing */
static void 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 - */ /* a root query drill -q - */
testpkt(pkt, alloc, out, 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 */ /** simple test of parsing, pcat file */
static void 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) const char* fname)
{ {
FILE* in = fopen(fname, "r"); 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 */ /** simple test of parsing, drill file */
static void static void
testfromdrillfile(ldns_buffer* pkt, struct alloc_cache* alloc, testfromdrillfile(sldns_buffer* pkt, struct alloc_cache* alloc,
ldns_buffer* out, const char* fname) sldns_buffer* out, const char* fname)
{ {
/* ;-- is used to indicate a new message */ /* ;-- is used to indicate a new message */
FILE* in = fopen(fname, "r"); FILE* in = fopen(fname, "r");
@ -497,8 +497,8 @@ testfromdrillfile(ldns_buffer* pkt, struct alloc_cache* alloc,
void msgparse_test(void) void msgparse_test(void)
{ {
ldns_buffer* pkt = ldns_buffer_new(65553); sldns_buffer* pkt = sldns_buffer_new(65553);
ldns_buffer* out = ldns_buffer_new(65553); sldns_buffer* out = sldns_buffer_new(65553);
struct alloc_cache super_a, alloc; struct alloc_cache super_a, alloc;
/* init */ /* init */
alloc_init(&super_a, NULL, 0); alloc_init(&super_a, NULL, 0);
@ -534,6 +534,6 @@ void msgparse_test(void)
/* cleanup */ /* cleanup */
alloc_clear(&alloc); alloc_clear(&alloc);
alloc_clear(&super_a); alloc_clear(&super_a);
ldns_buffer_free(pkt); sldns_buffer_free(pkt);
ldns_buffer_free(out); sldns_buffer_free(out);
} }

42
testcode/unitverify.c
View file

@ -66,23 +66,23 @@ static int vsig = 0;
/** entry to packet buffer with wireformat */ /** entry to packet buffer with wireformat */
static void 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); unit_assert(e->reply_list);
if(e->reply_list->reply_from_hex) { 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 { } else {
ldns_buffer_clear(pkt); sldns_buffer_clear(pkt);
ldns_buffer_write(pkt, e->reply_list->reply_pkt, sldns_buffer_write(pkt, e->reply_list->reply_pkt,
e->reply_list->reply_len); e->reply_list->reply_len);
ldns_buffer_flip(pkt); sldns_buffer_flip(pkt);
} }
} }
/** entry to reply info conversion */ /** entry to reply info conversion */
static void static void
entry_to_repinfo(struct entry* e, struct alloc_cache* alloc, 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) struct reply_info** rep)
{ {
int ret; int ret;
@ -97,7 +97,7 @@ entry_to_repinfo(struct entry* e, struct alloc_cache* alloc,
lock_quick_unlock(&alloc->lock); lock_quick_unlock(&alloc->lock);
if(ret != 0) { if(ret != 0) {
char rcode[16]; 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); printf("parse code %d: %s\n", ret, rcode);
unit_assert(ret != 0); 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 */ /** extract DNSKEY rrset from answer and convert it */
static struct ub_packed_rrset_key* static struct ub_packed_rrset_key*
extract_keys(struct entry* e, struct alloc_cache* alloc, 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 ub_packed_rrset_key* dnskey = NULL;
struct query_info qinfo; 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 */ /** verify and test an entry - every rr in the message */
static void static void
verifytest_entry(struct entry* e, struct alloc_cache* alloc, 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 ub_packed_rrset_key* dnskey, struct module_env* env,
struct val_env* ve) struct val_env* ve)
{ {
@ -211,7 +211,7 @@ verifytest_entry(struct entry* e, struct alloc_cache* alloc,
regional_free_all(region); regional_free_all(region);
if(vsig) { 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); e->reply_list->reply_len);
printf("verifying pkt:\n%s\n", s?s:"outofmemory"); printf("verifying pkt:\n%s\n", s?s:"outofmemory");
free(s); 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 */ /** DS sig test an entry - get DNSKEY and DS in entry and verify */
static void static void
dstest_entry(struct entry* e, struct alloc_cache* alloc, 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 query_info qinfo;
struct reply_info* rep = NULL; struct reply_info* rep = NULL;
@ -250,7 +250,7 @@ dstest_entry(struct entry* e, struct alloc_cache* alloc,
regional_free_all(region); regional_free_all(region);
if(vsig) { 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); e->reply_list->reply_len);
printf("verifying DS-DNSKEY match:\n%s\n", s?s:"outofmemory"); printf("verifying DS-DNSKEY match:\n%s\n", s?s:"outofmemory");
free(s); free(s);
@ -293,7 +293,7 @@ verifytest_file(const char* fname, const char* at_date)
struct ub_packed_rrset_key* dnskey; struct ub_packed_rrset_key* dnskey;
struct regional* region = regional_create(); struct regional* region = regional_create();
struct alloc_cache alloc; struct alloc_cache alloc;
ldns_buffer* buf = ldns_buffer_new(65535); sldns_buffer* buf = sldns_buffer_new(65535);
struct entry* e; struct entry* e;
struct entry* list = read_datafile(fname, 1); struct entry* list = read_datafile(fname, 1);
struct module_env env; struct module_env env;
@ -323,7 +323,7 @@ verifytest_file(const char* fname, const char* at_date)
delete_entry(list); delete_entry(list);
regional_destroy(region); regional_destroy(region);
alloc_clear(&alloc); alloc_clear(&alloc);
ldns_buffer_free(buf); sldns_buffer_free(buf);
} }
/** verify DS matches DNSKEY from a file */ /** verify DS matches DNSKEY from a file */
@ -337,7 +337,7 @@ dstest_file(const char* fname)
*/ */
struct regional* region = regional_create(); struct regional* region = regional_create();
struct alloc_cache alloc; struct alloc_cache alloc;
ldns_buffer* buf = ldns_buffer_new(65535); sldns_buffer* buf = sldns_buffer_new(65535);
struct entry* e; struct entry* e;
struct entry* list = read_datafile(fname, 1); struct entry* list = read_datafile(fname, 1);
struct module_env env; struct module_env env;
@ -358,7 +358,7 @@ dstest_file(const char* fname)
delete_entry(list); delete_entry(list);
regional_destroy(region); regional_destroy(region);
alloc_clear(&alloc); alloc_clear(&alloc);
ldns_buffer_free(buf); sldns_buffer_free(buf);
} }
/** helper for unittest of NSEC routines */ /** helper for unittest of NSEC routines */
@ -414,7 +414,7 @@ nsectest(void)
static void static void
nsec3_hash_test_entry(struct entry* e, rbtree_t* ct, nsec3_hash_test_entry(struct entry* e, rbtree_t* ct,
struct alloc_cache* alloc, struct regional* region, struct alloc_cache* alloc, struct regional* region,
ldns_buffer* buf) sldns_buffer* buf)
{ {
struct query_info qinfo; struct query_info qinfo;
struct reply_info* rep = NULL; struct reply_info* rep = NULL;
@ -424,7 +424,7 @@ nsec3_hash_test_entry(struct entry* e, rbtree_t* ct,
uint8_t* qname; uint8_t* qname;
if(vsig) { 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); e->reply_list->reply_len);
printf("verifying NSEC3 hash:\n%s\n", s?s:"outofmemory"); printf("verifying NSEC3 hash:\n%s\n", s?s:"outofmemory");
free(s); free(s);
@ -471,7 +471,7 @@ nsec3_hash_test(const char* fname)
rbtree_t ct; rbtree_t ct;
struct regional* region = regional_create(); struct regional* region = regional_create();
struct alloc_cache alloc; struct alloc_cache alloc;
ldns_buffer* buf = ldns_buffer_new(65535); sldns_buffer* buf = sldns_buffer_new(65535);
struct entry* e; struct entry* e;
struct entry* list = read_datafile(fname, 1); struct entry* list = read_datafile(fname, 1);
@ -489,7 +489,7 @@ nsec3_hash_test(const char* fname)
delete_entry(list); delete_entry(list);
regional_destroy(region); regional_destroy(region);
alloc_clear(&alloc); alloc_clear(&alloc);
ldns_buffer_free(buf); sldns_buffer_free(buf);
} }
void void
@ -515,7 +515,7 @@ verify_test(void)
verifytest_file("testdata/test_sigs.hinfo", "20090107100022"); verifytest_file("testdata/test_sigs.hinfo", "20090107100022");
verifytest_file("testdata/test_sigs.revoked", "20080414005004"); verifytest_file("testdata/test_sigs.revoked", "20080414005004");
#ifdef USE_GOST #ifdef USE_GOST
if(ldns_key_EVP_load_gost_id()) if(sldns_key_EVP_load_gost_id())
verifytest_file("testdata/test_sigs.gost", "20090807060504"); verifytest_file("testdata/test_sigs.gost", "20090807060504");
else printf("Warning: skipped GOST, openssl does not provide gost.\n"); else printf("Warning: skipped GOST, openssl does not provide gost.\n");
#endif #endif

6
util/alloc.c
View file

@ -601,13 +601,13 @@ char* unbound_lite_wrapstr(char* s)
return n; return n;
} }
#undef ldns_pkt2wire #undef sldns_pkt2wire
ldns_status unbound_lite_pkt2wire(uint8_t **dest, const ldns_pkt *p, sldns_status unbound_lite_pkt2wire(uint8_t **dest, const sldns_pkt *p,
size_t *size) size_t *size)
{ {
uint8_t* md = NULL; uint8_t* md = NULL;
size_t ms = 0; size_t ms = 0;
ldns_status s = ldns_pkt2wire(&md, p, &ms); sldns_status s = sldns_pkt2wire(&md, p, &ms);
if(md) { if(md) {
*dest = unbound_stat_malloc_lite(ms, __FILE__, __LINE__, *dest = unbound_stat_malloc_lite(ms, __FILE__, __LINE__,
__func__); __func__);

18
util/alloc.h
View file

@ -201,15 +201,15 @@ void *unbound_stat_realloc_lite(void *ptr, size_t size, const char* file,
char* unbound_strdup_lite(const char* s, const char* file, int line, char* unbound_strdup_lite(const char* s, const char* file, int line,
const char* func); const char* func);
char* unbound_lite_wrapstr(char* s); char* unbound_lite_wrapstr(char* s);
# define ldns_rr2str(rr) unbound_lite_wrapstr(ldns_rr2str(rr)) # define sldns_rr2str(rr) unbound_lite_wrapstr(sldns_rr2str(rr))
# define ldns_rdf2str(rdf) unbound_lite_wrapstr(ldns_rdf2str(rdf)) # define sldns_rdf2str(rdf) unbound_lite_wrapstr(sldns_rdf2str(rdf))
# define ldns_rr_type2str(t) unbound_lite_wrapstr(ldns_rr_type2str(t)) # define sldns_rr_type2str(t) unbound_lite_wrapstr(sldns_rr_type2str(t))
# define ldns_rr_class2str(c) unbound_lite_wrapstr(ldns_rr_class2str(c)) # define sldns_rr_class2str(c) unbound_lite_wrapstr(sldns_rr_class2str(c))
# define ldns_rr_list2str(r) unbound_lite_wrapstr(ldns_rr_list2str(r)) # define sldns_rr_list2str(r) unbound_lite_wrapstr(sldns_rr_list2str(r))
# define ldns_pkt2str(p) unbound_lite_wrapstr(ldns_pkt2str(p)) # define sldns_pkt2str(p) unbound_lite_wrapstr(sldns_pkt2str(p))
# define ldns_pkt_rcode2str(r) unbound_lite_wrapstr(ldns_pkt_rcode2str(r)) # define sldns_pkt_rcode2str(r) unbound_lite_wrapstr(sldns_pkt_rcode2str(r))
# define ldns_pkt2wire(a, r, s) unbound_lite_pkt2wire(a, r, s) # define sldns_pkt2wire(a, r, s) unbound_lite_pkt2wire(a, r, s)
ldns_status unbound_lite_pkt2wire(uint8_t **dest, const ldns_pkt *p, size_t *size); sldns_status unbound_lite_pkt2wire(uint8_t **dest, const sldns_pkt *p, size_t *size);
# define i2d_DSA_SIG(d, s) unbound_lite_i2d_DSA_SIG(d, s) # define i2d_DSA_SIG(d, s) unbound_lite_i2d_DSA_SIG(d, s)
int unbound_lite_i2d_DSA_SIG(DSA_SIG* dsasig, unsigned char** sig); int unbound_lite_i2d_DSA_SIG(DSA_SIG* dsasig, unsigned char** sig);
#endif /* UNBOUND_ALLOC_LITE */ #endif /* UNBOUND_ALLOC_LITE */

10
util/config_file.c
View file

@ -1086,7 +1086,7 @@ cfg_convert_timeval(const char* str)
if (tm.tm_min < 0 || tm.tm_min > 59) return 0; if (tm.tm_min < 0 || tm.tm_min > 59) return 0;
if (tm.tm_sec < 0 || tm.tm_sec > 59) return 0; if (tm.tm_sec < 0 || tm.tm_sec > 59) return 0;
/* call ldns conversion function */ /* call ldns conversion function */
t = ldns_mktime_from_utc(&tm); t = sldns_mktime_from_utc(&tm);
return t; return t;
} }
@ -1521,8 +1521,8 @@ char* errinf_to_str(struct module_qstate* qstate)
struct config_strlist* s; struct config_strlist* s;
char dname[LDNS_MAX_DOMAINLEN+1]; char dname[LDNS_MAX_DOMAINLEN+1];
char t[16], c[16]; char t[16], c[16];
ldns_wire2str_type_buf(qstate->qinfo.qtype, t, sizeof(t)); sldns_wire2str_type_buf(qstate->qinfo.qtype, t, sizeof(t));
ldns_wire2str_class_buf(qstate->qinfo.qclass, c, sizeof(c)); sldns_wire2str_class_buf(qstate->qinfo.qclass, c, sizeof(c));
dname_str(qstate->qinfo.qname, dname); dname_str(qstate->qinfo.qname, dname);
snprintf(p, left, "validation failure <%s %s %s>:", dname, t, c); snprintf(p, left, "validation failure <%s %s %s>:", dname, t, c);
left -= strlen(p); p += strlen(p); left -= strlen(p); p += strlen(p);
@ -1545,8 +1545,8 @@ void errinf_rrset(struct module_qstate* qstate, struct ub_packed_rrset_key *rr)
char t[16], c[16]; char t[16], c[16];
if(qstate->env->cfg->val_log_level < 2 || !rr) if(qstate->env->cfg->val_log_level < 2 || !rr)
return; return;
ldns_wire2str_type_buf(ntohs(rr->rk.type), t, sizeof(t)); sldns_wire2str_type_buf(ntohs(rr->rk.type), t, sizeof(t));
ldns_wire2str_class_buf(ntohs(rr->rk.rrset_class), c, sizeof(c)); sldns_wire2str_class_buf(ntohs(rr->rk.rrset_class), c, sizeof(c));
dname_str(rr->rk.dname, dname); dname_str(rr->rk.dname, dname);
snprintf(buf, sizeof(buf), "for <%s %s %s>", dname, t, c); snprintf(buf, sizeof(buf), "for <%s %s %s>", dname, t, c);
errinf(qstate, buf); errinf(qstate, buf);

74
util/data/dname.c
View file

@ -49,14 +49,14 @@
/* determine length of a dname in buffer, no compression pointers allowed */ /* determine length of a dname in buffer, no compression pointers allowed */
size_t size_t
query_dname_len(ldns_buffer* query) query_dname_len(sldns_buffer* query)
{ {
size_t len = 0; size_t len = 0;
size_t labellen; size_t labellen;
while(1) { while(1) {
if(ldns_buffer_remaining(query) < 1) if(sldns_buffer_remaining(query) < 1)
return 0; /* parse error, need label len */ return 0; /* parse error, need label len */
labellen = ldns_buffer_read_u8(query); labellen = sldns_buffer_read_u8(query);
if(labellen&0xc0) if(labellen&0xc0)
return 0; /* no compression allowed in queries */ return 0; /* no compression allowed in queries */
len += labellen + 1; len += labellen + 1;
@ -64,9 +64,9 @@ query_dname_len(ldns_buffer* query)
return 0; /* too long */ return 0; /* too long */
if(labellen == 0) if(labellen == 0)
return len; return len;
if(ldns_buffer_remaining(query) < labellen) if(sldns_buffer_remaining(query) < labellen)
return 0; /* parse error, need content */ return 0; /* parse error, need content */
ldns_buffer_skip(query, (ssize_t)labellen); sldns_buffer_skip(query, (ssize_t)labellen);
} }
} }
@ -146,31 +146,31 @@ query_dname_tolower(uint8_t* dname)
} }
void void
pkt_dname_tolower(ldns_buffer* pkt, uint8_t* dname) pkt_dname_tolower(sldns_buffer* pkt, uint8_t* dname)
{ {
uint8_t lablen; uint8_t lablen;
int count = 0; int count = 0;
if(dname >= ldns_buffer_end(pkt)) if(dname >= sldns_buffer_end(pkt))
return; return;
lablen = *dname++; lablen = *dname++;
while(lablen) { while(lablen) {
if(LABEL_IS_PTR(lablen)) { if(LABEL_IS_PTR(lablen)) {
if((size_t)PTR_OFFSET(lablen, *dname) if((size_t)PTR_OFFSET(lablen, *dname)
>= ldns_buffer_limit(pkt)) >= sldns_buffer_limit(pkt))
return; return;
dname = ldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname)); dname = sldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
lablen = *dname++; lablen = *dname++;
if(count++ > MAX_COMPRESS_PTRS) if(count++ > MAX_COMPRESS_PTRS)
return; return;
continue; continue;
} }
if(dname+lablen >= ldns_buffer_end(pkt)) if(dname+lablen >= sldns_buffer_end(pkt))
return; return;
while(lablen--) { while(lablen--) {
*dname = (uint8_t)tolower((int)*dname); *dname = (uint8_t)tolower((int)*dname);
dname++; dname++;
} }
if(dname >= ldns_buffer_end(pkt)) if(dname >= sldns_buffer_end(pkt))
return; return;
lablen = *dname++; lablen = *dname++;
} }
@ -178,7 +178,7 @@ pkt_dname_tolower(ldns_buffer* pkt, uint8_t* dname)
size_t size_t
pkt_dname_len(ldns_buffer* pkt) pkt_dname_len(sldns_buffer* pkt)
{ {
size_t len = 0; size_t len = 0;
int ptrcount = 0; int ptrcount = 0;
@ -189,22 +189,22 @@ pkt_dname_len(ldns_buffer* pkt)
/* check compression pointers, loops, out of bounds */ /* check compression pointers, loops, out of bounds */
while(1) { while(1) {
/* read next label */ /* read next label */
if(ldns_buffer_remaining(pkt) < 1) if(sldns_buffer_remaining(pkt) < 1)
return 0; return 0;
labellen = ldns_buffer_read_u8(pkt); labellen = sldns_buffer_read_u8(pkt);
if(LABEL_IS_PTR(labellen)) { if(LABEL_IS_PTR(labellen)) {
/* compression ptr */ /* compression ptr */
uint16_t ptr; uint16_t ptr;
if(ldns_buffer_remaining(pkt) < 1) if(sldns_buffer_remaining(pkt) < 1)
return 0; return 0;
ptr = PTR_OFFSET(labellen, ldns_buffer_read_u8(pkt)); ptr = PTR_OFFSET(labellen, sldns_buffer_read_u8(pkt));
if(ptrcount++ > MAX_COMPRESS_PTRS) if(ptrcount++ > MAX_COMPRESS_PTRS)
return 0; /* loop! */ return 0; /* loop! */
if(ldns_buffer_limit(pkt) <= ptr) if(sldns_buffer_limit(pkt) <= ptr)
return 0; /* out of bounds! */ return 0; /* out of bounds! */
if(!endpos) if(!endpos)
endpos = ldns_buffer_position(pkt); endpos = sldns_buffer_position(pkt);
ldns_buffer_set_position(pkt, ptr); sldns_buffer_set_position(pkt, ptr);
} else { } else {
/* label contents */ /* label contents */
if(labellen > 0x3f) if(labellen > 0x3f)
@ -216,19 +216,19 @@ pkt_dname_len(ldns_buffer* pkt)
/* end of dname */ /* end of dname */
break; break;
} }
if(ldns_buffer_remaining(pkt) < labellen) if(sldns_buffer_remaining(pkt) < labellen)
return 0; return 0;
ldns_buffer_skip(pkt, (ssize_t)labellen); sldns_buffer_skip(pkt, (ssize_t)labellen);
} }
} }
if(endpos) if(endpos)
ldns_buffer_set_position(pkt, endpos); sldns_buffer_set_position(pkt, endpos);
return len; return len;
} }
int int
dname_pkt_compare(ldns_buffer* pkt, uint8_t* d1, uint8_t* d2) dname_pkt_compare(sldns_buffer* pkt, uint8_t* d1, uint8_t* d2)
{ {
uint8_t len1, len2; uint8_t len1, len2;
log_assert(pkt && d1 && d2); log_assert(pkt && d1 && d2);
@ -237,12 +237,12 @@ dname_pkt_compare(ldns_buffer* pkt, uint8_t* d1, uint8_t* d2)
while( len1 != 0 || len2 != 0 ) { while( len1 != 0 || len2 != 0 ) {
/* resolve ptrs */ /* resolve ptrs */
if(LABEL_IS_PTR(len1)) { if(LABEL_IS_PTR(len1)) {
d1 = ldns_buffer_at(pkt, PTR_OFFSET(len1, *d1)); d1 = sldns_buffer_at(pkt, PTR_OFFSET(len1, *d1));
len1 = *d1++; len1 = *d1++;
continue; continue;
} }
if(LABEL_IS_PTR(len2)) { if(LABEL_IS_PTR(len2)) {
d2 = ldns_buffer_at(pkt, PTR_OFFSET(len2, *d2)); d2 = sldns_buffer_at(pkt, PTR_OFFSET(len2, *d2));
len2 = *d2++; len2 = *d2++;
continue; continue;
} }
@ -291,7 +291,7 @@ dname_query_hash(uint8_t* dname, hashvalue_t h)
} }
hashvalue_t hashvalue_t
dname_pkt_hash(ldns_buffer* pkt, uint8_t* dname, hashvalue_t h) dname_pkt_hash(sldns_buffer* pkt, uint8_t* dname, hashvalue_t h)
{ {
uint8_t labuf[LDNS_MAX_LABELLEN+1]; uint8_t labuf[LDNS_MAX_LABELLEN+1];
uint8_t lablen; uint8_t lablen;
@ -302,7 +302,7 @@ dname_pkt_hash(ldns_buffer* pkt, uint8_t* dname, hashvalue_t h)
while(lablen) { while(lablen) {
if(LABEL_IS_PTR(lablen)) { if(LABEL_IS_PTR(lablen)) {
/* follow pointer */ /* follow pointer */
dname = ldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname)); dname = sldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
lablen = *dname++; lablen = *dname++;
continue; continue;
} }
@ -318,7 +318,7 @@ dname_pkt_hash(ldns_buffer* pkt, uint8_t* dname, hashvalue_t h)
return h; return h;
} }
void dname_pkt_copy(ldns_buffer* pkt, uint8_t* to, uint8_t* dname) void dname_pkt_copy(sldns_buffer* pkt, uint8_t* to, uint8_t* dname)
{ {
/* copy over the dname and decompress it at the same time */ /* copy over the dname and decompress it at the same time */
size_t len = 0; size_t len = 0;
@ -327,7 +327,7 @@ void dname_pkt_copy(ldns_buffer* pkt, uint8_t* to, uint8_t* dname)
while(lablen) { while(lablen) {
if(LABEL_IS_PTR(lablen)) { if(LABEL_IS_PTR(lablen)) {
/* follow pointer */ /* follow pointer */
dname = ldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname)); dname = sldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
lablen = *dname++; lablen = *dname++;
continue; continue;
} }
@ -348,7 +348,7 @@ void dname_pkt_copy(ldns_buffer* pkt, uint8_t* to, uint8_t* dname)
*to = 0; *to = 0;
} }
void dname_print(FILE* out, struct ldns_buffer* pkt, uint8_t* dname) void dname_print(FILE* out, struct sldns_buffer* pkt, uint8_t* dname)
{ {
uint8_t lablen; uint8_t lablen;
if(!out) out = stdout; if(!out) out = stdout;
@ -364,7 +364,7 @@ void dname_print(FILE* out, struct ldns_buffer* pkt, uint8_t* dname)
fputs("??compressionptr??", out); fputs("??compressionptr??", out);
return; return;
} }
dname = ldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname)); dname = sldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
lablen = *dname++; lablen = *dname++;
continue; continue;
} }
@ -518,21 +518,21 @@ dname_lab_cmp(uint8_t* d1, int labs1, uint8_t* d2, int labs2, int* mlabs)
} }
int int
dname_buffer_write(ldns_buffer* pkt, uint8_t* dname) dname_buffer_write(sldns_buffer* pkt, uint8_t* dname)
{ {
uint8_t lablen; uint8_t lablen;
if(ldns_buffer_remaining(pkt) < 1) if(sldns_buffer_remaining(pkt) < 1)
return 0; return 0;
lablen = *dname++; lablen = *dname++;
ldns_buffer_write_u8(pkt, lablen); sldns_buffer_write_u8(pkt, lablen);
while(lablen) { while(lablen) {
if(ldns_buffer_remaining(pkt) < (size_t)lablen+1) if(sldns_buffer_remaining(pkt) < (size_t)lablen+1)
return 0; return 0;
ldns_buffer_write(pkt, dname, lablen); sldns_buffer_write(pkt, dname, lablen);
dname += lablen; dname += lablen;
lablen = *dname++; lablen = *dname++;
ldns_buffer_write_u8(pkt, lablen); sldns_buffer_write_u8(pkt, lablen);
} }
return 1; return 1;
} }

18
util/data/dname.h
View file

@ -45,7 +45,7 @@
#ifndef UTIL_DATA_DNAME_H #ifndef UTIL_DATA_DNAME_H
#define UTIL_DATA_DNAME_H #define UTIL_DATA_DNAME_H
#include "util/storage/lruhash.h" #include "util/storage/lruhash.h"
struct ldns_buffer; struct sldns_buffer;
/** max number of compression ptrs to follow */ /** max number of compression ptrs to follow */
#define MAX_COMPRESS_PTRS 256 #define MAX_COMPRESS_PTRS 256
@ -56,7 +56,7 @@ struct ldns_buffer;
* at end, position is at end of the dname. * at end, position is at end of the dname.
* @return: 0 on parse failure, or length including ending 0 of dname. * @return: 0 on parse failure, or length including ending 0 of dname.
*/ */
size_t query_dname_len(struct ldns_buffer* query); size_t query_dname_len(struct sldns_buffer* query);
/** /**
* Determine if dname in memory is correct. no compression ptrs allowed. * Determine if dname in memory is correct. no compression ptrs allowed.
@ -75,7 +75,7 @@ void query_dname_tolower(uint8_t* dname);
* is unchanged. * is unchanged.
* @param dname: start of dname in packet. * @param dname: start of dname in packet.
*/ */
void pkt_dname_tolower(struct ldns_buffer* pkt, uint8_t* dname); void pkt_dname_tolower(struct sldns_buffer* pkt, uint8_t* dname);
/** /**
* Compare query dnames (uncompressed storage). The Dnames passed do not * Compare query dnames (uncompressed storage). The Dnames passed do not
@ -107,7 +107,7 @@ int query_dname_compare(uint8_t* d1, uint8_t* d2);
* Compression pointers are followed and checked for loops. * Compression pointers are followed and checked for loops.
* The uncompressed wireformat length is returned. * The uncompressed wireformat length is returned.
*/ */
size_t pkt_dname_len(struct ldns_buffer* pkt); size_t pkt_dname_len(struct sldns_buffer* pkt);
/** /**
* Compare dnames in packet (compressed). Dnames must be valid. * Compare dnames in packet (compressed). Dnames must be valid.
@ -118,7 +118,7 @@ size_t pkt_dname_len(struct ldns_buffer* pkt);
* @return: -1, 0, or +1 depending on comparison results. * @return: -1, 0, or +1 depending on comparison results.
* Sort order is first difference found. not the canonical ordering. * Sort order is first difference found. not the canonical ordering.
*/ */
int dname_pkt_compare(struct ldns_buffer* pkt, uint8_t* d1, uint8_t* d2); int dname_pkt_compare(struct sldns_buffer* pkt, uint8_t* d1, uint8_t* d2);
/** /**
* Hash dname, label by label, lowercasing, into hashvalue. * Hash dname, label by label, lowercasing, into hashvalue.
@ -139,7 +139,7 @@ hashvalue_t dname_query_hash(uint8_t* dname, hashvalue_t h);
* @return: result hash value. * @return: result hash value.
* Result is the same as dname_query_hash, even if compression is used. * Result is the same as dname_query_hash, even if compression is used.
*/ */
hashvalue_t dname_pkt_hash(struct ldns_buffer* pkt, uint8_t* dname, hashvalue_t h); hashvalue_t dname_pkt_hash(struct sldns_buffer* pkt, uint8_t* dname, hashvalue_t h);
/** /**
* Copy over a valid dname and decompress it. * Copy over a valid dname and decompress it.
@ -147,7 +147,7 @@ hashvalue_t dname_pkt_hash(struct ldns_buffer* pkt, uint8_t* dname, hashvalue_t
* @param to: buffer of size from pkt_len function to hold result. * @param to: buffer of size from pkt_len function to hold result.
* @param dname: pointer into packet where dname starts. * @param dname: pointer into packet where dname starts.
*/ */
void dname_pkt_copy(struct ldns_buffer* pkt, uint8_t* to, uint8_t* dname); void dname_pkt_copy(struct sldns_buffer* pkt, uint8_t* to, uint8_t* dname);
/** /**
* Copy over a valid dname to a packet. * Copy over a valid dname to a packet.
@ -155,7 +155,7 @@ void dname_pkt_copy(struct ldns_buffer* pkt, uint8_t* to, uint8_t* dname);
* @param dname: dname to copy. * @param dname: dname to copy.
* @return: 0 if not enough space in buffer. * @return: 0 if not enough space in buffer.
*/ */
int dname_buffer_write(struct ldns_buffer* pkt, uint8_t* dname); int dname_buffer_write(struct sldns_buffer* pkt, uint8_t* dname);
/** /**
* Count the number of labels in an uncompressed dname in memory. * Count the number of labels in an uncompressed dname in memory.
@ -217,7 +217,7 @@ int dname_subdomain_c(uint8_t* d1, uint8_t* d2);
* @param pkt: if not NULL, the packet for resolving compression ptrs. * @param pkt: if not NULL, the packet for resolving compression ptrs.
* @param dname: pointer to (start of) dname. * @param dname: pointer to (start of) dname.
*/ */
void dname_print(FILE* out, struct ldns_buffer* pkt, uint8_t* dname); void dname_print(FILE* out, struct sldns_buffer* pkt, uint8_t* dname);
/** /**
* Debug helper. Print dname to given string buffer (string buffer must * Debug helper. Print dname to given string buffer (string buffer must

262
util/data/msgencode.c
View file

@ -243,7 +243,7 @@ compress_tree_store(uint8_t* dname, int labs, size_t offset,
/** compress a domain name */ /** compress a domain name */
static int static int
write_compressed_dname(ldns_buffer* pkt, uint8_t* dname, int labs, write_compressed_dname(sldns_buffer* pkt, uint8_t* dname, int labs,
struct compress_tree_node* p) struct compress_tree_node* p)
{ {
/* compress it */ /* compress it */
@ -253,32 +253,32 @@ write_compressed_dname(ldns_buffer* pkt, uint8_t* dname, int labs,
if(labs == 1) { if(labs == 1) {
/* write root label */ /* write root label */
if(ldns_buffer_remaining(pkt) < 1) if(sldns_buffer_remaining(pkt) < 1)
return 0; return 0;
ldns_buffer_write_u8(pkt, 0); sldns_buffer_write_u8(pkt, 0);
return 1; return 1;
} }
/* copy the first couple of labels */ /* copy the first couple of labels */
while(labcopy--) { while(labcopy--) {
lablen = *dname++; lablen = *dname++;
if(ldns_buffer_remaining(pkt) < (size_t)lablen+1) if(sldns_buffer_remaining(pkt) < (size_t)lablen+1)
return 0; return 0;
ldns_buffer_write_u8(pkt, lablen); sldns_buffer_write_u8(pkt, lablen);
ldns_buffer_write(pkt, dname, lablen); sldns_buffer_write(pkt, dname, lablen);
dname += lablen; dname += lablen;
} }
/* insert compression ptr */ /* insert compression ptr */
if(ldns_buffer_remaining(pkt) < 2) if(sldns_buffer_remaining(pkt) < 2)
return 0; return 0;
ptr = PTR_CREATE(p->offset); ptr = PTR_CREATE(p->offset);
ldns_buffer_write_u16(pkt, ptr); sldns_buffer_write_u16(pkt, ptr);
return 1; return 1;
} }
/** compress owner name of RR, return RETVAL_OUTMEM RETVAL_TRUNC */ /** compress owner name of RR, return RETVAL_OUTMEM RETVAL_TRUNC */
static int static int
compress_owner(struct ub_packed_rrset_key* key, ldns_buffer* pkt, compress_owner(struct ub_packed_rrset_key* key, sldns_buffer* pkt,
struct regional* region, struct compress_tree_node** tree, struct regional* region, struct compress_tree_node** tree,
size_t owner_pos, uint16_t* owner_ptr, int owner_labs) size_t owner_pos, uint16_t* owner_ptr, int owner_labs)
{ {
@ -296,13 +296,13 @@ compress_owner(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
owner_labs, p)) owner_labs, p))
return RETVAL_TRUNC; return RETVAL_TRUNC;
/* check if typeclass+4 ttl + rdatalen is available */ /* check if typeclass+4 ttl + rdatalen is available */
if(ldns_buffer_remaining(pkt) < 4+4+2) if(sldns_buffer_remaining(pkt) < 4+4+2)
return RETVAL_TRUNC; return RETVAL_TRUNC;
} else { } else {
/* no compress */ /* no compress */
if(ldns_buffer_remaining(pkt) < key->rk.dname_len+4+4+2) if(sldns_buffer_remaining(pkt) < key->rk.dname_len+4+4+2)
return RETVAL_TRUNC; return RETVAL_TRUNC;
ldns_buffer_write(pkt, key->rk.dname, sldns_buffer_write(pkt, key->rk.dname,
key->rk.dname_len); key->rk.dname_len);
if(owner_pos <= PTR_MAX_OFFSET) if(owner_pos <= PTR_MAX_OFFSET)
*owner_ptr = htons(PTR_CREATE(owner_pos)); *owner_ptr = htons(PTR_CREATE(owner_pos));
@ -313,13 +313,13 @@ compress_owner(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
} else { } else {
/* always compress 2nd-further RRs in RRset */ /* always compress 2nd-further RRs in RRset */
if(owner_labs == 1) { if(owner_labs == 1) {
if(ldns_buffer_remaining(pkt) < 1+4+4+2) if(sldns_buffer_remaining(pkt) < 1+4+4+2)
return RETVAL_TRUNC; return RETVAL_TRUNC;
ldns_buffer_write_u8(pkt, 0); sldns_buffer_write_u8(pkt, 0);
} else { } else {
if(ldns_buffer_remaining(pkt) < 2+4+4+2) if(sldns_buffer_remaining(pkt) < 2+4+4+2)
return RETVAL_TRUNC; return RETVAL_TRUNC;
ldns_buffer_write(pkt, owner_ptr, 2); sldns_buffer_write(pkt, owner_ptr, 2);
} }
} }
return RETVAL_OK; return RETVAL_OK;
@ -327,12 +327,12 @@ compress_owner(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
/** compress any domain name to the packet, return RETVAL_* */ /** compress any domain name to the packet, return RETVAL_* */
static int static int
compress_any_dname(uint8_t* dname, ldns_buffer* pkt, int labs, compress_any_dname(uint8_t* dname, sldns_buffer* pkt, int labs,
struct regional* region, struct compress_tree_node** tree) struct regional* region, struct compress_tree_node** tree)
{ {
struct compress_tree_node* p; struct compress_tree_node* p;
struct compress_tree_node** insertpt = NULL; struct compress_tree_node** insertpt = NULL;
size_t pos = ldns_buffer_position(pkt); size_t pos = sldns_buffer_position(pkt);
if((p = compress_tree_lookup(tree, dname, labs, &insertpt))) { if((p = compress_tree_lookup(tree, dname, labs, &insertpt))) {
if(!write_compressed_dname(pkt, dname, labs, p)) if(!write_compressed_dname(pkt, dname, labs, p))
return RETVAL_TRUNC; return RETVAL_TRUNC;
@ -346,27 +346,27 @@ compress_any_dname(uint8_t* dname, ldns_buffer* pkt, int labs,
} }
/** return true if type needs domain name compression in rdata */ /** return true if type needs domain name compression in rdata */
static const ldns_rr_descriptor* static const sldns_rr_descriptor*
type_rdata_compressable(struct ub_packed_rrset_key* key) type_rdata_compressable(struct ub_packed_rrset_key* key)
{ {
uint16_t t = ntohs(key->rk.type); uint16_t t = ntohs(key->rk.type);
if(ldns_rr_descript(t) && if(sldns_rr_descript(t) &&
ldns_rr_descript(t)->_compress == LDNS_RR_COMPRESS) sldns_rr_descript(t)->_compress == LDNS_RR_COMPRESS)
return ldns_rr_descript(t); return sldns_rr_descript(t);
return 0; return 0;
} }
/** compress domain names in rdata, return RETVAL_* */ /** compress domain names in rdata, return RETVAL_* */
static int static int
compress_rdata(ldns_buffer* pkt, uint8_t* rdata, size_t todolen, compress_rdata(sldns_buffer* pkt, uint8_t* rdata, size_t todolen,
struct regional* region, struct compress_tree_node** tree, struct regional* region, struct compress_tree_node** tree,
const ldns_rr_descriptor* desc) const sldns_rr_descriptor* desc)
{ {
int labs, r, rdf = 0; int labs, r, rdf = 0;
size_t dname_len, len, pos = ldns_buffer_position(pkt); size_t dname_len, len, pos = sldns_buffer_position(pkt);
uint8_t count = desc->_dname_count; uint8_t count = desc->_dname_count;
ldns_buffer_skip(pkt, 2); /* rdata len fill in later */ sldns_buffer_skip(pkt, 2); /* rdata len fill in later */
/* space for rdatalen checked for already */ /* space for rdatalen checked for already */
rdata += 2; rdata += 2;
todolen -= 2; todolen -= 2;
@ -390,9 +390,9 @@ compress_rdata(ldns_buffer* pkt, uint8_t* rdata, size_t todolen,
} }
if(len) { if(len) {
/* copy over */ /* copy over */
if(ldns_buffer_remaining(pkt) < len) if(sldns_buffer_remaining(pkt) < len)
return RETVAL_TRUNC; return RETVAL_TRUNC;
ldns_buffer_write(pkt, rdata, len); sldns_buffer_write(pkt, rdata, len);
todolen -= len; todolen -= len;
rdata += len; rdata += len;
} }
@ -400,19 +400,19 @@ compress_rdata(ldns_buffer* pkt, uint8_t* rdata, size_t todolen,
} }
/* copy remainder */ /* copy remainder */
if(todolen > 0) { if(todolen > 0) {
if(ldns_buffer_remaining(pkt) < todolen) if(sldns_buffer_remaining(pkt) < todolen)
return RETVAL_TRUNC; return RETVAL_TRUNC;
ldns_buffer_write(pkt, rdata, todolen); sldns_buffer_write(pkt, rdata, todolen);
} }
/* set rdata len */ /* set rdata len */
ldns_buffer_write_u16_at(pkt, pos, ldns_buffer_position(pkt)-pos-2); sldns_buffer_write_u16_at(pkt, pos, sldns_buffer_position(pkt)-pos-2);
return RETVAL_OK; return RETVAL_OK;
} }
/** Returns true if RR type should be included */ /** Returns true if RR type should be included */
static int static int
rrset_belongs_in_reply(ldns_pkt_section s, uint16_t rrtype, uint16_t qtype, rrset_belongs_in_reply(sldns_pkt_section s, uint16_t rrtype, uint16_t qtype,
int dnssec) int dnssec)
{ {
if(dnssec) if(dnssec)
@ -440,10 +440,10 @@ rrset_belongs_in_reply(ldns_pkt_section s, uint16_t rrtype, uint16_t qtype,
/** store rrset in buffer in wireformat, return RETVAL_* */ /** store rrset in buffer in wireformat, return RETVAL_* */
static int static int
packed_rrset_encode(struct ub_packed_rrset_key* key, ldns_buffer* pkt, packed_rrset_encode(struct ub_packed_rrset_key* key, sldns_buffer* pkt,
uint16_t* num_rrs, time_t timenow, struct regional* region, uint16_t* num_rrs, time_t timenow, struct regional* region,
int do_data, int do_sig, struct compress_tree_node** tree, int do_data, int do_sig, struct compress_tree_node** tree,
ldns_pkt_section s, uint16_t qtype, int dnssec, size_t rr_offset) sldns_pkt_section s, uint16_t qtype, int dnssec, size_t rr_offset)
{ {
size_t i, j, owner_pos; size_t i, j, owner_pos;
int r, owner_labs; int r, owner_labs;
@ -456,10 +456,10 @@ packed_rrset_encode(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
return RETVAL_OK; return RETVAL_OK;
owner_labs = dname_count_labels(key->rk.dname); owner_labs = dname_count_labels(key->rk.dname);
owner_pos = ldns_buffer_position(pkt); owner_pos = sldns_buffer_position(pkt);
if(do_data) { if(do_data) {
const ldns_rr_descriptor* c = type_rdata_compressable(key); const sldns_rr_descriptor* c = type_rdata_compressable(key);
for(i=0; i<data->count; i++) { for(i=0; i<data->count; i++) {
/* rrset roundrobin */ /* rrset roundrobin */
j = (i + rr_offset) % data->count; j = (i + rr_offset) % data->count;
@ -467,11 +467,11 @@ packed_rrset_encode(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
owner_pos, &owner_ptr, owner_labs)) owner_pos, &owner_ptr, owner_labs))
!= RETVAL_OK) != RETVAL_OK)
return r; return r;
ldns_buffer_write(pkt, &key->rk.type, 2); sldns_buffer_write(pkt, &key->rk.type, 2);
ldns_buffer_write(pkt, &key->rk.rrset_class, 2); sldns_buffer_write(pkt, &key->rk.rrset_class, 2);
if(data->rr_ttl[j] < timenow) if(data->rr_ttl[j] < timenow)
ldns_buffer_write_u32(pkt, 0); sldns_buffer_write_u32(pkt, 0);
else ldns_buffer_write_u32(pkt, else sldns_buffer_write_u32(pkt,
data->rr_ttl[j]-timenow); data->rr_ttl[j]-timenow);
if(c) { if(c) {
if((r=compress_rdata(pkt, data->rr_data[j], if((r=compress_rdata(pkt, data->rr_data[j],
@ -479,9 +479,9 @@ packed_rrset_encode(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
!= RETVAL_OK) != RETVAL_OK)
return r; return r;
} else { } else {
if(ldns_buffer_remaining(pkt) < data->rr_len[j]) if(sldns_buffer_remaining(pkt) < data->rr_len[j])
return RETVAL_TRUNC; return RETVAL_TRUNC;
ldns_buffer_write(pkt, data->rr_data[j], sldns_buffer_write(pkt, data->rr_data[j],
data->rr_len[j]); data->rr_len[j]);
} }
} }
@ -491,28 +491,28 @@ packed_rrset_encode(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
size_t total = data->count+data->rrsig_count; size_t total = data->count+data->rrsig_count;
for(i=data->count; i<total; i++) { for(i=data->count; i<total; i++) {
if(owner_ptr && owner_labs != 1) { if(owner_ptr && owner_labs != 1) {
if(ldns_buffer_remaining(pkt) < if(sldns_buffer_remaining(pkt) <
2+4+4+data->rr_len[i]) 2+4+4+data->rr_len[i])
return RETVAL_TRUNC; return RETVAL_TRUNC;
ldns_buffer_write(pkt, &owner_ptr, 2); sldns_buffer_write(pkt, &owner_ptr, 2);
} else { } else {
if((r=compress_any_dname(key->rk.dname, if((r=compress_any_dname(key->rk.dname,
pkt, owner_labs, region, tree)) pkt, owner_labs, region, tree))
!= RETVAL_OK) != RETVAL_OK)
return r; return r;
if(ldns_buffer_remaining(pkt) < if(sldns_buffer_remaining(pkt) <
4+4+data->rr_len[i]) 4+4+data->rr_len[i])
return RETVAL_TRUNC; return RETVAL_TRUNC;
} }
ldns_buffer_write_u16(pkt, LDNS_RR_TYPE_RRSIG); sldns_buffer_write_u16(pkt, LDNS_RR_TYPE_RRSIG);
ldns_buffer_write(pkt, &key->rk.rrset_class, 2); sldns_buffer_write(pkt, &key->rk.rrset_class, 2);
if(data->rr_ttl[i] < timenow) if(data->rr_ttl[i] < timenow)
ldns_buffer_write_u32(pkt, 0); sldns_buffer_write_u32(pkt, 0);
else ldns_buffer_write_u32(pkt, else sldns_buffer_write_u32(pkt,
data->rr_ttl[i]-timenow); data->rr_ttl[i]-timenow);
/* rrsig rdata cannot be compressed, perform 100+ byte /* rrsig rdata cannot be compressed, perform 100+ byte
* memcopy. */ * memcopy. */
ldns_buffer_write(pkt, data->rr_data[i], sldns_buffer_write(pkt, data->rr_data[i],
data->rr_len[i]); data->rr_len[i]);
} }
} }
@ -528,9 +528,9 @@ packed_rrset_encode(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
/** store msg section in wireformat buffer, return RETVAL_* */ /** store msg section in wireformat buffer, return RETVAL_* */
static int static int
insert_section(struct reply_info* rep, size_t num_rrsets, uint16_t* num_rrs, insert_section(struct reply_info* rep, size_t num_rrsets, uint16_t* num_rrs,
ldns_buffer* pkt, size_t rrsets_before, time_t timenow, sldns_buffer* pkt, size_t rrsets_before, time_t timenow,
struct regional* region, struct compress_tree_node** tree, struct regional* region, struct compress_tree_node** tree,
ldns_pkt_section s, uint16_t qtype, int dnssec, size_t rr_offset) sldns_pkt_section s, uint16_t qtype, int dnssec, size_t rr_offset)
{ {
int r; int r;
size_t i, setstart; size_t i, setstart;
@ -539,36 +539,36 @@ insert_section(struct reply_info* rep, size_t num_rrsets, uint16_t* num_rrs,
if(s == LDNS_SECTION_ANSWER && qtype == LDNS_RR_TYPE_ANY) if(s == LDNS_SECTION_ANSWER && qtype == LDNS_RR_TYPE_ANY)
dnssec = 1; /* include all types in ANY answer */ dnssec = 1; /* include all types in ANY answer */
for(i=0; i<num_rrsets; i++) { for(i=0; i<num_rrsets; i++) {
setstart = ldns_buffer_position(pkt); setstart = sldns_buffer_position(pkt);
if((r=packed_rrset_encode(rep->rrsets[rrsets_before+i], if((r=packed_rrset_encode(rep->rrsets[rrsets_before+i],
pkt, num_rrs, timenow, region, 1, 1, tree, pkt, num_rrs, timenow, region, 1, 1, tree,
s, qtype, dnssec, rr_offset)) s, qtype, dnssec, rr_offset))
!= RETVAL_OK) { != RETVAL_OK) {
/* Bad, but if due to size must set TC bit */ /* Bad, but if due to size must set TC bit */
/* trim off the rrset neatly. */ /* trim off the rrset neatly. */
ldns_buffer_set_position(pkt, setstart); sldns_buffer_set_position(pkt, setstart);
return r; return r;
} }
} }
} else { } else {
for(i=0; i<num_rrsets; i++) { for(i=0; i<num_rrsets; i++) {
setstart = ldns_buffer_position(pkt); setstart = sldns_buffer_position(pkt);
if((r=packed_rrset_encode(rep->rrsets[rrsets_before+i], if((r=packed_rrset_encode(rep->rrsets[rrsets_before+i],
pkt, num_rrs, timenow, region, 1, 0, tree, pkt, num_rrs, timenow, region, 1, 0, tree,
s, qtype, dnssec, rr_offset)) s, qtype, dnssec, rr_offset))
!= RETVAL_OK) { != RETVAL_OK) {
ldns_buffer_set_position(pkt, setstart); sldns_buffer_set_position(pkt, setstart);
return r; return r;
} }
} }
if(dnssec) if(dnssec)
for(i=0; i<num_rrsets; i++) { for(i=0; i<num_rrsets; i++) {
setstart = ldns_buffer_position(pkt); setstart = sldns_buffer_position(pkt);
if((r=packed_rrset_encode(rep->rrsets[rrsets_before+i], if((r=packed_rrset_encode(rep->rrsets[rrsets_before+i],
pkt, num_rrs, timenow, region, 0, 1, tree, pkt, num_rrs, timenow, region, 0, 1, tree,
s, qtype, dnssec, rr_offset)) s, qtype, dnssec, rr_offset))
!= RETVAL_OK) { != RETVAL_OK) {
ldns_buffer_set_position(pkt, setstart); sldns_buffer_set_position(pkt, setstart);
return r; return r;
} }
} }
@ -579,21 +579,21 @@ insert_section(struct reply_info* rep, size_t num_rrsets, uint16_t* num_rrs,
/** store query section in wireformat buffer, return RETVAL */ /** store query section in wireformat buffer, return RETVAL */
static int static int
insert_query(struct query_info* qinfo, struct compress_tree_node** tree, insert_query(struct query_info* qinfo, struct compress_tree_node** tree,
ldns_buffer* buffer, struct regional* region) sldns_buffer* buffer, struct regional* region)
{ {
if(ldns_buffer_remaining(buffer) < if(sldns_buffer_remaining(buffer) <
qinfo->qname_len+sizeof(uint16_t)*2) qinfo->qname_len+sizeof(uint16_t)*2)
return RETVAL_TRUNC; /* buffer too small */ return RETVAL_TRUNC; /* buffer too small */
/* the query is the first name inserted into the tree */ /* the query is the first name inserted into the tree */
if(!compress_tree_store(qinfo->qname, if(!compress_tree_store(qinfo->qname,
dname_count_labels(qinfo->qname), dname_count_labels(qinfo->qname),
ldns_buffer_position(buffer), region, NULL, tree)) sldns_buffer_position(buffer), region, NULL, tree))
return RETVAL_OUTMEM; return RETVAL_OUTMEM;
if(ldns_buffer_current(buffer) == qinfo->qname) if(sldns_buffer_current(buffer) == qinfo->qname)
ldns_buffer_skip(buffer, (ssize_t)qinfo->qname_len); sldns_buffer_skip(buffer, (ssize_t)qinfo->qname_len);
else ldns_buffer_write(buffer, qinfo->qname, qinfo->qname_len); else sldns_buffer_write(buffer, qinfo->qname, qinfo->qname_len);
ldns_buffer_write_u16(buffer, qinfo->qtype); sldns_buffer_write_u16(buffer, qinfo->qtype);
ldns_buffer_write_u16(buffer, qinfo->qclass); sldns_buffer_write_u16(buffer, qinfo->qclass);
return RETVAL_OK; return RETVAL_OK;
} }
@ -624,7 +624,7 @@ positive_answer(struct reply_info* rep, uint16_t qtype) {
int int
reply_info_encode(struct query_info* qinfo, struct reply_info* rep, reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
uint16_t id, uint16_t flags, ldns_buffer* buffer, time_t timenow, uint16_t id, uint16_t flags, sldns_buffer* buffer, time_t timenow,
struct regional* region, uint16_t udpsize, int dnssec) struct regional* region, uint16_t udpsize, int dnssec)
{ {
uint16_t ancount=0, nscount=0, arcount=0; uint16_t ancount=0, nscount=0, arcount=0;
@ -632,17 +632,17 @@ reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
int r; int r;
size_t rr_offset; size_t rr_offset;
ldns_buffer_clear(buffer); sldns_buffer_clear(buffer);
if(udpsize < ldns_buffer_limit(buffer)) if(udpsize < sldns_buffer_limit(buffer))
ldns_buffer_set_limit(buffer, udpsize); sldns_buffer_set_limit(buffer, udpsize);
if(ldns_buffer_remaining(buffer) < LDNS_HEADER_SIZE) if(sldns_buffer_remaining(buffer) < LDNS_HEADER_SIZE)
return 0; return 0;
ldns_buffer_write(buffer, &id, sizeof(uint16_t)); sldns_buffer_write(buffer, &id, sizeof(uint16_t));
ldns_buffer_write_u16(buffer, flags); sldns_buffer_write_u16(buffer, flags);
ldns_buffer_write_u16(buffer, rep->qdcount); sldns_buffer_write_u16(buffer, rep->qdcount);
/* set an, ns, ar counts to zero in case of small packets */ /* set an, ns, ar counts to zero in case of small packets */
ldns_buffer_write(buffer, "\000\000\000\000\000\000", 6); sldns_buffer_write(buffer, "\000\000\000\000\000\000", 6);
/* insert query section */ /* insert query section */
if(rep->qdcount) { if(rep->qdcount) {
@ -650,9 +650,9 @@ reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
RETVAL_OK) { RETVAL_OK) {
if(r == RETVAL_TRUNC) { if(r == RETVAL_TRUNC) {
/* create truncated message */ /* create truncated message */
ldns_buffer_write_u16_at(buffer, 4, 0); sldns_buffer_write_u16_at(buffer, 4, 0);
LDNS_TC_SET(ldns_buffer_begin(buffer)); LDNS_TC_SET(sldns_buffer_begin(buffer));
ldns_buffer_flip(buffer); sldns_buffer_flip(buffer);
return 1; return 1;
} }
return 0; return 0;
@ -668,14 +668,14 @@ reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
dnssec, rr_offset)) != RETVAL_OK) { dnssec, rr_offset)) != RETVAL_OK) {
if(r == RETVAL_TRUNC) { if(r == RETVAL_TRUNC) {
/* create truncated message */ /* create truncated message */
ldns_buffer_write_u16_at(buffer, 6, ancount); sldns_buffer_write_u16_at(buffer, 6, ancount);
LDNS_TC_SET(ldns_buffer_begin(buffer)); LDNS_TC_SET(sldns_buffer_begin(buffer));
ldns_buffer_flip(buffer); sldns_buffer_flip(buffer);
return 1; return 1;
} }
return 0; return 0;
} }
ldns_buffer_write_u16_at(buffer, 6, ancount); sldns_buffer_write_u16_at(buffer, 6, ancount);
/* if response is positive answer, auth/add sections are not required */ /* if response is positive answer, auth/add sections are not required */
if( ! (MINIMAL_RESPONSES && positive_answer(rep, qinfo->qtype)) ) { if( ! (MINIMAL_RESPONSES && positive_answer(rep, qinfo->qtype)) ) {
@ -686,14 +686,14 @@ reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
dnssec, rr_offset)) != RETVAL_OK) { dnssec, rr_offset)) != RETVAL_OK) {
if(r == RETVAL_TRUNC) { if(r == RETVAL_TRUNC) {
/* create truncated message */ /* create truncated message */
ldns_buffer_write_u16_at(buffer, 8, nscount); sldns_buffer_write_u16_at(buffer, 8, nscount);
LDNS_TC_SET(ldns_buffer_begin(buffer)); LDNS_TC_SET(sldns_buffer_begin(buffer));
ldns_buffer_flip(buffer); sldns_buffer_flip(buffer);
return 1; return 1;
} }
return 0; return 0;
} }
ldns_buffer_write_u16_at(buffer, 8, nscount); sldns_buffer_write_u16_at(buffer, 8, nscount);
/* insert add section */ /* insert add section */
if((r=insert_section(rep, rep->ar_numrrsets, &arcount, buffer, if((r=insert_section(rep, rep->ar_numrrsets, &arcount, buffer,
@ -702,15 +702,15 @@ reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
dnssec, rr_offset)) != RETVAL_OK) { dnssec, rr_offset)) != RETVAL_OK) {
if(r == RETVAL_TRUNC) { if(r == RETVAL_TRUNC) {
/* no need to set TC bit, this is the additional */ /* no need to set TC bit, this is the additional */
ldns_buffer_write_u16_at(buffer, 10, arcount); sldns_buffer_write_u16_at(buffer, 10, arcount);
ldns_buffer_flip(buffer); sldns_buffer_flip(buffer);
return 1; return 1;
} }
return 0; return 0;
} }
ldns_buffer_write_u16_at(buffer, 10, arcount); sldns_buffer_write_u16_at(buffer, 10, arcount);
} }
ldns_buffer_flip(buffer); sldns_buffer_flip(buffer);
return 1; return 1;
} }
@ -724,31 +724,31 @@ calc_edns_field_size(struct edns_data* edns)
} }
void void
attach_edns_record(ldns_buffer* pkt, struct edns_data* edns) attach_edns_record(sldns_buffer* pkt, struct edns_data* edns)
{ {
size_t len; size_t len;
if(!edns || !edns->edns_present) if(!edns || !edns->edns_present)
return; return;
/* inc additional count */ /* inc additional count */
ldns_buffer_write_u16_at(pkt, 10, sldns_buffer_write_u16_at(pkt, 10,
ldns_buffer_read_u16_at(pkt, 10) + 1); sldns_buffer_read_u16_at(pkt, 10) + 1);
len = ldns_buffer_limit(pkt); len = sldns_buffer_limit(pkt);
ldns_buffer_clear(pkt); sldns_buffer_clear(pkt);
ldns_buffer_set_position(pkt, len); sldns_buffer_set_position(pkt, len);
/* write EDNS record */ /* write EDNS record */
ldns_buffer_write_u8(pkt, 0); /* '.' label */ sldns_buffer_write_u8(pkt, 0); /* '.' label */
ldns_buffer_write_u16(pkt, LDNS_RR_TYPE_OPT); /* type */ sldns_buffer_write_u16(pkt, LDNS_RR_TYPE_OPT); /* type */
ldns_buffer_write_u16(pkt, edns->udp_size); /* class */ sldns_buffer_write_u16(pkt, edns->udp_size); /* class */
ldns_buffer_write_u8(pkt, edns->ext_rcode); /* ttl */ sldns_buffer_write_u8(pkt, edns->ext_rcode); /* ttl */
ldns_buffer_write_u8(pkt, edns->edns_version); sldns_buffer_write_u8(pkt, edns->edns_version);
ldns_buffer_write_u16(pkt, edns->bits); sldns_buffer_write_u16(pkt, edns->bits);
ldns_buffer_write_u16(pkt, 0); /* rdatalen */ sldns_buffer_write_u16(pkt, 0); /* rdatalen */
ldns_buffer_flip(pkt); sldns_buffer_flip(pkt);
} }
int int
reply_info_answer_encode(struct query_info* qinf, struct reply_info* rep, reply_info_answer_encode(struct query_info* qinf, struct reply_info* rep,
uint16_t id, uint16_t qflags, ldns_buffer* pkt, time_t timenow, uint16_t id, uint16_t qflags, sldns_buffer* pkt, time_t timenow,
int cached, struct regional* region, uint16_t udpsize, int cached, struct regional* region, uint16_t udpsize,
struct edns_data* edns, int dnssec, int secure) struct edns_data* edns, int dnssec, int secure)
{ {
@ -786,54 +786,54 @@ reply_info_answer_encode(struct query_info* qinf, struct reply_info* rep,
} }
void void
qinfo_query_encode(ldns_buffer* pkt, struct query_info* qinfo) qinfo_query_encode(sldns_buffer* pkt, struct query_info* qinfo)
{ {
uint16_t flags = 0; /* QUERY, NOERROR */ uint16_t flags = 0; /* QUERY, NOERROR */
ldns_buffer_clear(pkt); sldns_buffer_clear(pkt);
log_assert(ldns_buffer_remaining(pkt) >= 12+255+4/*max query*/); log_assert(sldns_buffer_remaining(pkt) >= 12+255+4/*max query*/);
ldns_buffer_skip(pkt, 2); /* id done later */ sldns_buffer_skip(pkt, 2); /* id done later */
ldns_buffer_write_u16(pkt, flags); sldns_buffer_write_u16(pkt, flags);
ldns_buffer_write_u16(pkt, 1); /* query count */ sldns_buffer_write_u16(pkt, 1); /* query count */
ldns_buffer_write(pkt, "\000\000\000\000\000\000", 6); /* counts */ sldns_buffer_write(pkt, "\000\000\000\000\000\000", 6); /* counts */
ldns_buffer_write(pkt, qinfo->qname, qinfo->qname_len); sldns_buffer_write(pkt, qinfo->qname, qinfo->qname_len);
ldns_buffer_write_u16(pkt, qinfo->qtype); sldns_buffer_write_u16(pkt, qinfo->qtype);
ldns_buffer_write_u16(pkt, qinfo->qclass); sldns_buffer_write_u16(pkt, qinfo->qclass);
ldns_buffer_flip(pkt); sldns_buffer_flip(pkt);
} }
void void
error_encode(ldns_buffer* buf, int r, struct query_info* qinfo, error_encode(sldns_buffer* buf, int r, struct query_info* qinfo,
uint16_t qid, uint16_t qflags, struct edns_data* edns) uint16_t qid, uint16_t qflags, struct edns_data* edns)
{ {
uint16_t flags; uint16_t flags;
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
ldns_buffer_write(buf, &qid, sizeof(uint16_t)); sldns_buffer_write(buf, &qid, sizeof(uint16_t));
flags = (uint16_t)(BIT_QR | BIT_RA | r); /* QR and retcode*/ flags = (uint16_t)(BIT_QR | BIT_RA | r); /* QR and retcode*/
flags |= (qflags & (BIT_RD|BIT_CD)); /* copy RD and CD bit */ flags |= (qflags & (BIT_RD|BIT_CD)); /* copy RD and CD bit */
ldns_buffer_write_u16(buf, flags); sldns_buffer_write_u16(buf, flags);
if(qinfo) flags = 1; if(qinfo) flags = 1;
else flags = 0; else flags = 0;
ldns_buffer_write_u16(buf, flags); sldns_buffer_write_u16(buf, flags);
flags = 0; flags = 0;
ldns_buffer_write(buf, &flags, sizeof(uint16_t)); sldns_buffer_write(buf, &flags, sizeof(uint16_t));
ldns_buffer_write(buf, &flags, sizeof(uint16_t)); sldns_buffer_write(buf, &flags, sizeof(uint16_t));
ldns_buffer_write(buf, &flags, sizeof(uint16_t)); sldns_buffer_write(buf, &flags, sizeof(uint16_t));
if(qinfo) { if(qinfo) {
if(ldns_buffer_current(buf) == qinfo->qname) if(sldns_buffer_current(buf) == qinfo->qname)
ldns_buffer_skip(buf, (ssize_t)qinfo->qname_len); sldns_buffer_skip(buf, (ssize_t)qinfo->qname_len);
else ldns_buffer_write(buf, qinfo->qname, qinfo->qname_len); else sldns_buffer_write(buf, qinfo->qname, qinfo->qname_len);
ldns_buffer_write_u16(buf, qinfo->qtype); sldns_buffer_write_u16(buf, qinfo->qtype);
ldns_buffer_write_u16(buf, qinfo->qclass); sldns_buffer_write_u16(buf, qinfo->qclass);
} }
ldns_buffer_flip(buf); sldns_buffer_flip(buf);
if(edns) { if(edns) {
struct edns_data es = *edns; struct edns_data es = *edns;
es.edns_version = EDNS_ADVERTISED_VERSION; es.edns_version = EDNS_ADVERTISED_VERSION;
es.udp_size = EDNS_ADVERTISED_SIZE; es.udp_size = EDNS_ADVERTISED_SIZE;
es.ext_rcode = 0; es.ext_rcode = 0;
es.bits &= EDNS_DO; es.bits &= EDNS_DO;
if(ldns_buffer_limit(buf) + calc_edns_field_size(&es) > if(sldns_buffer_limit(buf) + calc_edns_field_size(&es) >
edns->udp_size) edns->udp_size)
return; return;
attach_edns_record(buf, &es); attach_edns_record(buf, &es);

12
util/data/msgencode.h
View file

@ -42,7 +42,7 @@
#ifndef UTIL_DATA_MSGENCODE_H #ifndef UTIL_DATA_MSGENCODE_H
#define UTIL_DATA_MSGENCODE_H #define UTIL_DATA_MSGENCODE_H
struct ldns_buffer; struct sldns_buffer;
struct query_info; struct query_info;
struct reply_info; struct reply_info;
struct regional; struct regional;
@ -67,7 +67,7 @@ struct edns_data;
* @return: 0 on error (server failure). * @return: 0 on error (server failure).
*/ */
int reply_info_answer_encode(struct query_info* qinf, struct reply_info* rep, int reply_info_answer_encode(struct query_info* qinf, struct reply_info* rep,
uint16_t id, uint16_t qflags, struct ldns_buffer* dest, time_t timenow, uint16_t id, uint16_t qflags, struct sldns_buffer* dest, time_t timenow,
int cached, struct regional* region, uint16_t udpsize, int cached, struct regional* region, uint16_t udpsize,
struct edns_data* edns, int dnssec, int secure); struct edns_data* edns, int dnssec, int secure);
@ -89,7 +89,7 @@ int reply_info_answer_encode(struct query_info* qinf, struct reply_info* rep,
* 0 on error: malloc failure (no log_err has been done). * 0 on error: malloc failure (no log_err has been done).
*/ */
int reply_info_encode(struct query_info* qinfo, struct reply_info* rep, int reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
uint16_t id, uint16_t flags, struct ldns_buffer* buffer, time_t timenow, uint16_t id, uint16_t flags, struct sldns_buffer* buffer, time_t timenow,
struct regional* region, uint16_t udpsize, int dnssec); struct regional* region, uint16_t udpsize, int dnssec);
/** /**
@ -97,7 +97,7 @@ int reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
* @param pkt: where to store the packet. * @param pkt: where to store the packet.
* @param qinfo: query info. * @param qinfo: query info.
*/ */
void qinfo_query_encode(struct ldns_buffer* pkt, struct query_info* qinfo); void qinfo_query_encode(struct sldns_buffer* pkt, struct query_info* qinfo);
/** /**
* Estimate size of EDNS record in packet. EDNS record will be no larger. * Estimate size of EDNS record in packet. EDNS record will be no larger.
@ -112,7 +112,7 @@ uint16_t calc_edns_field_size(struct edns_data* edns);
* @param pkt: packet added to. * @param pkt: packet added to.
* @param edns: if NULL or present=0, nothing is added to the packet. * @param edns: if NULL or present=0, nothing is added to the packet.
*/ */
void attach_edns_record(struct ldns_buffer* pkt, struct edns_data* edns); void attach_edns_record(struct sldns_buffer* pkt, struct edns_data* edns);
/** /**
* Encode an error. With QR and RA set. * Encode an error. With QR and RA set.
@ -125,7 +125,7 @@ void attach_edns_record(struct ldns_buffer* pkt, struct edns_data* edns);
* @param edns: if not NULL, this is the query edns info, * @param edns: if not NULL, this is the query edns info,
* and an edns reply is attached. Only attached if EDNS record fits reply. * and an edns reply is attached. Only attached if EDNS record fits reply.
*/ */
void error_encode(struct ldns_buffer* pkt, int r, struct query_info* qinfo, void error_encode(struct sldns_buffer* pkt, int r, struct query_info* qinfo,
uint16_t qid, uint16_t qflags, struct edns_data* edns); uint16_t qid, uint16_t qflags, struct edns_data* edns);
#endif /* UTIL_DATA_MSGENCODE_H */ #endif /* UTIL_DATA_MSGENCODE_H */

242
util/data/msgparse.c
View file

@ -49,12 +49,12 @@
/** smart comparison of (compressed, valid) dnames from packet */ /** smart comparison of (compressed, valid) dnames from packet */
static int static int
smart_compare(ldns_buffer* pkt, uint8_t* dnow, smart_compare(sldns_buffer* pkt, uint8_t* dnow,
uint8_t* dprfirst, uint8_t* dprlast) uint8_t* dprfirst, uint8_t* dprlast)
{ {
if(LABEL_IS_PTR(*dnow)) { if(LABEL_IS_PTR(*dnow)) {
/* ptr points to a previous dname */ /* ptr points to a previous dname */
uint8_t* p = ldns_buffer_at(pkt, PTR_OFFSET(dnow[0], dnow[1])); uint8_t* p = sldns_buffer_at(pkt, PTR_OFFSET(dnow[0], dnow[1]));
if( p == dprfirst || p == dprlast ) if( p == dprfirst || p == dprlast )
return 0; return 0;
/* prev dname is also a ptr, both ptrs are the same. */ /* prev dname is also a ptr, both ptrs are the same. */
@ -71,7 +71,7 @@ smart_compare(ldns_buffer* pkt, uint8_t* dnow,
static struct rrset_parse* static struct rrset_parse*
new_rrset(struct msg_parse* msg, uint8_t* dname, size_t dnamelen, new_rrset(struct msg_parse* msg, uint8_t* dname, size_t dnamelen,
uint16_t type, uint16_t dclass, hashvalue_t hash, uint16_t type, uint16_t dclass, hashvalue_t hash,
uint32_t rrset_flags, ldns_pkt_section section, uint32_t rrset_flags, sldns_pkt_section section,
struct regional* region) struct regional* region)
{ {
struct rrset_parse* p = regional_alloc(region, sizeof(*p)); struct rrset_parse* p = regional_alloc(region, sizeof(*p));
@ -102,52 +102,52 @@ new_rrset(struct msg_parse* msg, uint8_t* dname, size_t dnamelen,
/** See if next rrset is nsec at zone apex */ /** See if next rrset is nsec at zone apex */
static int static int
nsec_at_apex(ldns_buffer* pkt) nsec_at_apex(sldns_buffer* pkt)
{ {
/* we are at ttl position in packet. */ /* we are at ttl position in packet. */
size_t pos = ldns_buffer_position(pkt); size_t pos = sldns_buffer_position(pkt);
uint16_t rdatalen; uint16_t rdatalen;
if(ldns_buffer_remaining(pkt) < 7) /* ttl+len+root */ if(sldns_buffer_remaining(pkt) < 7) /* ttl+len+root */
return 0; /* eek! */ return 0; /* eek! */
ldns_buffer_skip(pkt, 4); /* ttl */; sldns_buffer_skip(pkt, 4); /* ttl */;
rdatalen = ldns_buffer_read_u16(pkt); rdatalen = sldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < rdatalen) { if(sldns_buffer_remaining(pkt) < rdatalen) {
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
return 0; /* parse error happens later */ return 0; /* parse error happens later */
} }
/* must validate the nsec next domain name format */ /* must validate the nsec next domain name format */
if(pkt_dname_len(pkt) == 0) { if(pkt_dname_len(pkt) == 0) {
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
return 0; /* parse error */ return 0; /* parse error */
} }
/* see if SOA bit is set. */ /* see if SOA bit is set. */
if(ldns_buffer_position(pkt) < pos+4+rdatalen) { if(sldns_buffer_position(pkt) < pos+4+rdatalen) {
/* nsec type bitmap contains items */ /* nsec type bitmap contains items */
uint8_t win, blen, bits; uint8_t win, blen, bits;
/* need: windownum, bitmap len, firstbyte */ /* need: windownum, bitmap len, firstbyte */
if(ldns_buffer_position(pkt)+3 > pos+4+rdatalen) { if(sldns_buffer_position(pkt)+3 > pos+4+rdatalen) {
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
return 0; /* malformed nsec */ return 0; /* malformed nsec */
} }
win = ldns_buffer_read_u8(pkt); win = sldns_buffer_read_u8(pkt);
blen = ldns_buffer_read_u8(pkt); blen = sldns_buffer_read_u8(pkt);
bits = ldns_buffer_read_u8(pkt); bits = sldns_buffer_read_u8(pkt);
/* 0window always first window. bitlen >=1 or parse /* 0window always first window. bitlen >=1 or parse
error really. bit 0x2 is SOA. */ error really. bit 0x2 is SOA. */
if(win == 0 && blen >= 1 && (bits & 0x02)) { if(win == 0 && blen >= 1 && (bits & 0x02)) {
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
return 1; return 1;
} }
} }
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
return 0; return 0;
} }
/** Calculate rrset flags */ /** Calculate rrset flags */
static uint32_t static uint32_t
pkt_rrset_flags(ldns_buffer* pkt, uint16_t type, ldns_pkt_section sec) pkt_rrset_flags(sldns_buffer* pkt, uint16_t type, sldns_pkt_section sec)
{ {
uint32_t f = 0; uint32_t f = 0;
if(type == LDNS_RR_TYPE_NSEC && nsec_at_apex(pkt)) { if(type == LDNS_RR_TYPE_NSEC && nsec_at_apex(pkt)) {
@ -159,7 +159,7 @@ pkt_rrset_flags(ldns_buffer* pkt, uint16_t type, ldns_pkt_section sec)
} }
hashvalue_t hashvalue_t
pkt_hash_rrset(ldns_buffer* pkt, uint8_t* dname, uint16_t type, pkt_hash_rrset(sldns_buffer* pkt, uint8_t* dname, uint16_t type,
uint16_t dclass, uint32_t rrset_flags) uint16_t dclass, uint32_t rrset_flags)
{ {
/* note this MUST be identical to rrset_key_hash in packed_rrset.c */ /* note this MUST be identical to rrset_key_hash in packed_rrset.c */
@ -174,7 +174,7 @@ pkt_hash_rrset(ldns_buffer* pkt, uint8_t* dname, uint16_t type,
/** create partial dname hash for rrset hash */ /** create partial dname hash for rrset hash */
static hashvalue_t static hashvalue_t
pkt_hash_rrset_first(ldns_buffer* pkt, uint8_t* dname) pkt_hash_rrset_first(sldns_buffer* pkt, uint8_t* dname)
{ {
/* works together with pkt_hash_rrset_rest */ /* works together with pkt_hash_rrset_rest */
/* note this MUST be identical to rrset_key_hash in packed_rrset.c */ /* note this MUST be identical to rrset_key_hash in packed_rrset.c */
@ -200,7 +200,7 @@ pkt_hash_rrset_rest(hashvalue_t dname_h, uint16_t type, uint16_t dclass,
/** compare rrset_parse with data */ /** compare rrset_parse with data */
static int static int
rrset_parse_equals(struct rrset_parse* p, ldns_buffer* pkt, hashvalue_t h, rrset_parse_equals(struct rrset_parse* p, sldns_buffer* pkt, hashvalue_t h,
uint32_t rrset_flags, uint8_t* dname, size_t dnamelen, uint32_t rrset_flags, uint8_t* dname, size_t dnamelen,
uint16_t type, uint16_t dclass) uint16_t type, uint16_t dclass)
{ {
@ -213,7 +213,7 @@ rrset_parse_equals(struct rrset_parse* p, ldns_buffer* pkt, hashvalue_t h,
struct rrset_parse* struct rrset_parse*
msgparse_hashtable_lookup(struct msg_parse* msg, ldns_buffer* pkt, msgparse_hashtable_lookup(struct msg_parse* msg, sldns_buffer* pkt,
hashvalue_t h, uint32_t rrset_flags, uint8_t* dname, size_t dnamelen, hashvalue_t h, uint32_t rrset_flags, uint8_t* dname, size_t dnamelen,
uint16_t type, uint16_t dclass) uint16_t type, uint16_t dclass)
{ {
@ -229,26 +229,26 @@ msgparse_hashtable_lookup(struct msg_parse* msg, ldns_buffer* pkt,
/** return type networkformat that rrsig in packet covers */ /** return type networkformat that rrsig in packet covers */
static int static int
pkt_rrsig_covered(ldns_buffer* pkt, uint8_t* here, uint16_t* type) pkt_rrsig_covered(sldns_buffer* pkt, uint8_t* here, uint16_t* type)
{ {
size_t pos = ldns_buffer_position(pkt); size_t pos = sldns_buffer_position(pkt);
ldns_buffer_set_position(pkt, (size_t)(here-ldns_buffer_begin(pkt))); sldns_buffer_set_position(pkt, (size_t)(here-sldns_buffer_begin(pkt)));
/* ttl + len + size of small rrsig(rootlabel, no signature) */ /* ttl + len + size of small rrsig(rootlabel, no signature) */
if(ldns_buffer_remaining(pkt) < 4+2+19) if(sldns_buffer_remaining(pkt) < 4+2+19)
return 0; return 0;
ldns_buffer_skip(pkt, 4); /* ttl */ sldns_buffer_skip(pkt, 4); /* ttl */
if(ldns_buffer_read_u16(pkt) < 19) /* too short */ { if(sldns_buffer_read_u16(pkt) < 19) /* too short */ {
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
return 0; return 0;
} }
*type = ldns_buffer_read_u16(pkt); *type = sldns_buffer_read_u16(pkt);
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
return 1; return 1;
} }
/** true if covered type equals prevtype */ /** true if covered type equals prevtype */
static int static int
pkt_rrsig_covered_equals(ldns_buffer* pkt, uint8_t* here, uint16_t type) pkt_rrsig_covered_equals(sldns_buffer* pkt, uint8_t* here, uint16_t type)
{ {
uint16_t t; uint16_t t;
if(pkt_rrsig_covered(pkt, here, &t) && t == type) if(pkt_rrsig_covered(pkt, here, &t) && t == type)
@ -273,7 +273,7 @@ msgparse_bucket_remove(struct msg_parse* msg, struct rrset_parse* rrset)
/** change section of rrset from previous to current section */ /** change section of rrset from previous to current section */
static void static void
change_section(struct msg_parse* msg, struct rrset_parse* rrset, change_section(struct msg_parse* msg, struct rrset_parse* rrset,
ldns_pkt_section section) sldns_pkt_section section)
{ {
struct rrset_parse *p, *prev; struct rrset_parse *p, *prev;
/* remove from list */ /* remove from list */
@ -316,7 +316,7 @@ change_section(struct msg_parse* msg, struct rrset_parse* rrset,
/** see if rrset of type RRSIG contains sig over given type */ /** see if rrset of type RRSIG contains sig over given type */
static int static int
rrset_has_sigover(ldns_buffer* pkt, struct rrset_parse* rrset, uint16_t type, rrset_has_sigover(sldns_buffer* pkt, struct rrset_parse* rrset, uint16_t type,
int* hasother) int* hasother)
{ {
int res = 0; int res = 0;
@ -333,7 +333,7 @@ rrset_has_sigover(ldns_buffer* pkt, struct rrset_parse* rrset, uint16_t type,
/** move rrsigs from sigset to dataset */ /** move rrsigs from sigset to dataset */
static int static int
moveover_rrsigs(ldns_buffer* pkt, struct regional* region, moveover_rrsigs(sldns_buffer* pkt, struct regional* region,
struct rrset_parse* sigset, struct rrset_parse* dataset, int duplicate) struct rrset_parse* sigset, struct rrset_parse* dataset, int duplicate)
{ {
struct rr_parse* sig = sigset->rr_first; struct rr_parse* sig = sigset->rr_first;
@ -383,8 +383,8 @@ moveover_rrsigs(ldns_buffer* pkt, struct regional* region,
/** change an rrsig rrset for use as data rrset */ /** change an rrsig rrset for use as data rrset */
static struct rrset_parse* static struct rrset_parse*
change_rrsig_rrset(struct rrset_parse* sigset, struct msg_parse* msg, change_rrsig_rrset(struct rrset_parse* sigset, struct msg_parse* msg,
ldns_buffer* pkt, uint16_t datatype, uint32_t rrset_flags, sldns_buffer* pkt, uint16_t datatype, uint32_t rrset_flags,
int hasother, ldns_pkt_section section, struct regional* region) int hasother, sldns_pkt_section section, struct regional* region)
{ {
struct rrset_parse* dataset = sigset; struct rrset_parse* dataset = sigset;
hashvalue_t hash = pkt_hash_rrset(pkt, sigset->dname, datatype, hashvalue_t hash = pkt_hash_rrset(pkt, sigset->dname, datatype,
@ -453,13 +453,13 @@ change_rrsig_rrset(struct rrset_parse* sigset, struct msg_parse* msg,
* @return 0 on out of memory. * @return 0 on out of memory.
*/ */
static int static int
find_rrset(struct msg_parse* msg, ldns_buffer* pkt, uint8_t* dname, find_rrset(struct msg_parse* msg, sldns_buffer* pkt, uint8_t* dname,
size_t dnamelen, uint16_t type, uint16_t dclass, hashvalue_t* hash, size_t dnamelen, uint16_t type, uint16_t dclass, hashvalue_t* hash,
uint32_t* rrset_flags, uint32_t* rrset_flags,
uint8_t** prev_dname_first, uint8_t** prev_dname_last, uint8_t** prev_dname_first, uint8_t** prev_dname_last,
size_t* prev_dnamelen, uint16_t* prev_type, size_t* prev_dnamelen, uint16_t* prev_type,
uint16_t* prev_dclass, struct rrset_parse** rrset_prev, uint16_t* prev_dclass, struct rrset_parse** rrset_prev,
ldns_pkt_section section, struct regional* region) sldns_pkt_section section, struct regional* region)
{ {
hashvalue_t dname_h = pkt_hash_rrset_first(pkt, dname); hashvalue_t dname_h = pkt_hash_rrset_first(pkt, dname);
uint16_t covtype; uint16_t covtype;
@ -476,7 +476,7 @@ find_rrset(struct msg_parse* msg, ldns_buffer* pkt, uint8_t* dname,
} }
/* check if rrsig over previous item */ /* check if rrsig over previous item */
if(type == LDNS_RR_TYPE_RRSIG && dclass == *prev_dclass && if(type == LDNS_RR_TYPE_RRSIG && dclass == *prev_dclass &&
pkt_rrsig_covered_equals(pkt, ldns_buffer_current(pkt), pkt_rrsig_covered_equals(pkt, sldns_buffer_current(pkt),
*prev_type) && *prev_type) &&
smart_compare(pkt, dname, *prev_dname_first, smart_compare(pkt, dname, *prev_dname_first,
*prev_dname_last) == 0) { *prev_dname_last) == 0) {
@ -490,7 +490,7 @@ find_rrset(struct msg_parse* msg, ldns_buffer* pkt, uint8_t* dname,
/* if rrsig - try to lookup matching data set first */ /* if rrsig - try to lookup matching data set first */
if(type == LDNS_RR_TYPE_RRSIG && pkt_rrsig_covered(pkt, if(type == LDNS_RR_TYPE_RRSIG && pkt_rrsig_covered(pkt,
ldns_buffer_current(pkt), &covtype)) { sldns_buffer_current(pkt), &covtype)) {
*hash = pkt_hash_rrset_rest(dname_h, covtype, dclass, *hash = pkt_hash_rrset_rest(dname_h, covtype, dclass,
*rrset_flags); *rrset_flags);
*rrset_prev = msgparse_hashtable_lookup(msg, pkt, *hash, *rrset_prev = msgparse_hashtable_lookup(msg, pkt, *hash,
@ -571,27 +571,27 @@ find_rrset(struct msg_parse* msg, ldns_buffer* pkt, uint8_t* dname,
* @return: 0 if OK, or rcode on error. * @return: 0 if OK, or rcode on error.
*/ */
static int static int
parse_query_section(ldns_buffer* pkt, struct msg_parse* msg) parse_query_section(sldns_buffer* pkt, struct msg_parse* msg)
{ {
if(msg->qdcount == 0) if(msg->qdcount == 0)
return 0; return 0;
if(msg->qdcount > 1) if(msg->qdcount > 1)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
log_assert(msg->qdcount == 1); log_assert(msg->qdcount == 1);
if(ldns_buffer_remaining(pkt) <= 0) if(sldns_buffer_remaining(pkt) <= 0)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
msg->qname = ldns_buffer_current(pkt); msg->qname = sldns_buffer_current(pkt);
if((msg->qname_len = pkt_dname_len(pkt)) == 0) if((msg->qname_len = pkt_dname_len(pkt)) == 0)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
if(ldns_buffer_remaining(pkt) < sizeof(uint16_t)*2) if(sldns_buffer_remaining(pkt) < sizeof(uint16_t)*2)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
msg->qtype = ldns_buffer_read_u16(pkt); msg->qtype = sldns_buffer_read_u16(pkt);
msg->qclass = ldns_buffer_read_u16(pkt); msg->qclass = sldns_buffer_read_u16(pkt);
return 0; return 0;
} }
size_t size_t
get_rdf_size(ldns_rdf_type rdf) get_rdf_size(sldns_rdf_type rdf)
{ {
switch(rdf) { switch(rdf) {
case LDNS_RDF_TYPE_CLASS: case LDNS_RDF_TYPE_CLASS:
@ -626,16 +626,16 @@ get_rdf_size(ldns_rdf_type rdf)
/** calculate the size of one rr */ /** calculate the size of one rr */
static int static int
calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr) calc_size(sldns_buffer* pkt, uint16_t type, struct rr_parse* rr)
{ {
const ldns_rr_descriptor* desc; const sldns_rr_descriptor* desc;
uint16_t pkt_len; /* length of rr inside the packet */ uint16_t pkt_len; /* length of rr inside the packet */
rr->size = sizeof(uint16_t); /* the rdatalen */ rr->size = sizeof(uint16_t); /* the rdatalen */
ldns_buffer_skip(pkt, 4); /* skip ttl */ sldns_buffer_skip(pkt, 4); /* skip ttl */
pkt_len = ldns_buffer_read_u16(pkt); pkt_len = sldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < pkt_len) if(sldns_buffer_remaining(pkt) < pkt_len)
return 0; return 0;
desc = ldns_rr_descript(type); desc = sldns_rr_descript(type);
if(pkt_len > 0 && desc && desc->_dname_count > 0) { if(pkt_len > 0 && desc && desc->_dname_count > 0) {
int count = (int)desc->_dname_count; int count = (int)desc->_dname_count;
int rdf = 0; int rdf = 0;
@ -646,12 +646,12 @@ calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr)
switch(desc->_wireformat[rdf]) { switch(desc->_wireformat[rdf]) {
case LDNS_RDF_TYPE_DNAME: case LDNS_RDF_TYPE_DNAME:
/* decompress every domain name */ /* decompress every domain name */
oldpos = ldns_buffer_position(pkt); oldpos = sldns_buffer_position(pkt);
if((len = pkt_dname_len(pkt)) == 0) if((len = pkt_dname_len(pkt)) == 0)
return 0; /* malformed dname */ return 0; /* malformed dname */
if(ldns_buffer_position(pkt)-oldpos > pkt_len) if(sldns_buffer_position(pkt)-oldpos > pkt_len)
return 0; /* dname exceeds rdata */ return 0; /* dname exceeds rdata */
pkt_len -= ldns_buffer_position(pkt)-oldpos; pkt_len -= sldns_buffer_position(pkt)-oldpos;
rr->size += len; rr->size += len;
count--; count--;
len = 0; len = 0;
@ -661,7 +661,7 @@ calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr)
/* NOTREACHED, due to 'while(>0)' */ /* NOTREACHED, due to 'while(>0)' */
return 0; /* len byte exceeds rdata */ return 0; /* len byte exceeds rdata */
} }
len = ldns_buffer_current(pkt)[0] + 1; len = sldns_buffer_current(pkt)[0] + 1;
break; break;
default: default:
len = get_rdf_size(desc->_wireformat[rdf]); len = get_rdf_size(desc->_wireformat[rdf]);
@ -670,7 +670,7 @@ calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr)
if(pkt_len < len) if(pkt_len < len)
return 0; /* exceeds rdata */ return 0; /* exceeds rdata */
pkt_len -= len; pkt_len -= len;
ldns_buffer_skip(pkt, (ssize_t)len); sldns_buffer_skip(pkt, (ssize_t)len);
rr->size += len; rr->size += len;
} }
rdf++; rdf++;
@ -678,41 +678,41 @@ calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr)
} }
/* remaining rdata */ /* remaining rdata */
rr->size += pkt_len; rr->size += pkt_len;
ldns_buffer_skip(pkt, (ssize_t)pkt_len); sldns_buffer_skip(pkt, (ssize_t)pkt_len);
return 1; return 1;
} }
/** skip rr ttl and rdata */ /** skip rr ttl and rdata */
static int static int
skip_ttl_rdata(ldns_buffer* pkt) skip_ttl_rdata(sldns_buffer* pkt)
{ {
uint16_t rdatalen; uint16_t rdatalen;
if(ldns_buffer_remaining(pkt) < 6) /* ttl + rdatalen */ if(sldns_buffer_remaining(pkt) < 6) /* ttl + rdatalen */
return 0; return 0;
ldns_buffer_skip(pkt, 4); /* ttl */ sldns_buffer_skip(pkt, 4); /* ttl */
rdatalen = ldns_buffer_read_u16(pkt); rdatalen = sldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < rdatalen) if(sldns_buffer_remaining(pkt) < rdatalen)
return 0; return 0;
ldns_buffer_skip(pkt, (ssize_t)rdatalen); sldns_buffer_skip(pkt, (ssize_t)rdatalen);
return 1; return 1;
} }
/** see if RRSIG is a duplicate of another */ /** see if RRSIG is a duplicate of another */
static int static int
sig_is_double(ldns_buffer* pkt, struct rrset_parse* rrset, uint8_t* ttldata) sig_is_double(sldns_buffer* pkt, struct rrset_parse* rrset, uint8_t* ttldata)
{ {
uint16_t rlen, siglen; uint16_t rlen, siglen;
size_t pos = ldns_buffer_position(pkt); size_t pos = sldns_buffer_position(pkt);
struct rr_parse* sig; struct rr_parse* sig;
if(ldns_buffer_remaining(pkt) < 6) if(sldns_buffer_remaining(pkt) < 6)
return 0; return 0;
ldns_buffer_skip(pkt, 4); /* ttl */ sldns_buffer_skip(pkt, 4); /* ttl */
rlen = ldns_buffer_read_u16(pkt); rlen = sldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < rlen) { if(sldns_buffer_remaining(pkt) < rlen) {
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
return 0; return 0;
} }
ldns_buffer_set_position(pkt, pos); sldns_buffer_set_position(pkt, pos);
sig = rrset->rrsig_first; sig = rrset->rrsig_first;
while(sig) { while(sig) {
@ -741,9 +741,9 @@ sig_is_double(ldns_buffer* pkt, struct rrset_parse* rrset, uint8_t* ttldata)
/** Add rr (from packet here) to rrset, skips rr */ /** Add rr (from packet here) to rrset, skips rr */
static int static int
add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt, add_rr_to_rrset(struct rrset_parse* rrset, sldns_buffer* pkt,
struct msg_parse* msg, struct regional* region, struct msg_parse* msg, struct regional* region,
ldns_pkt_section section, uint16_t type) sldns_pkt_section section, uint16_t type)
{ {
struct rr_parse* rr; struct rr_parse* rr;
/* check section of rrset. */ /* check section of rrset. */
@ -767,7 +767,7 @@ add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt,
if( (msg->qtype == LDNS_RR_TYPE_RRSIG || if( (msg->qtype == LDNS_RR_TYPE_RRSIG ||
msg->qtype == LDNS_RR_TYPE_ANY) msg->qtype == LDNS_RR_TYPE_ANY)
&& sig_is_double(pkt, rrset, ldns_buffer_current(pkt))) { && sig_is_double(pkt, rrset, sldns_buffer_current(pkt))) {
if(!skip_ttl_rdata(pkt)) if(!skip_ttl_rdata(pkt))
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
return 0; return 0;
@ -777,7 +777,7 @@ add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt,
if(!(rr = (struct rr_parse*)regional_alloc(region, sizeof(*rr)))) if(!(rr = (struct rr_parse*)regional_alloc(region, sizeof(*rr))))
return LDNS_RCODE_SERVFAIL; return LDNS_RCODE_SERVFAIL;
rr->outside_packet = 0; rr->outside_packet = 0;
rr->ttl_data = ldns_buffer_current(pkt); rr->ttl_data = sldns_buffer_current(pkt);
rr->next = 0; rr->next = 0;
if(type == LDNS_RR_TYPE_RRSIG && rrset->type != LDNS_RR_TYPE_RRSIG) { if(type == LDNS_RR_TYPE_RRSIG && rrset->type != LDNS_RR_TYPE_RRSIG) {
if(rrset->rrsig_last) if(rrset->rrsig_last)
@ -813,8 +813,8 @@ add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt,
* @return: 0 if OK, or rcode on error. * @return: 0 if OK, or rcode on error.
*/ */
static int static int
parse_section(ldns_buffer* pkt, struct msg_parse* msg, parse_section(sldns_buffer* pkt, struct msg_parse* msg,
struct regional* region, ldns_pkt_section section, struct regional* region, sldns_pkt_section section,
uint16_t num_rrs, size_t* num_rrsets) uint16_t num_rrs, size_t* num_rrsets)
{ {
uint16_t i; uint16_t i;
@ -829,38 +829,38 @@ parse_section(ldns_buffer* pkt, struct msg_parse* msg,
if(num_rrs == 0) if(num_rrs == 0)
return 0; return 0;
if(ldns_buffer_remaining(pkt) <= 0) if(sldns_buffer_remaining(pkt) <= 0)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
for(i=0; i<num_rrs; i++) { for(i=0; i<num_rrs; i++) {
/* parse this RR. */ /* parse this RR. */
dname = ldns_buffer_current(pkt); dname = sldns_buffer_current(pkt);
if((dnamelen = pkt_dname_len(pkt)) == 0) if((dnamelen = pkt_dname_len(pkt)) == 0)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
if(ldns_buffer_remaining(pkt) < 10) /* type, class, ttl, len */ if(sldns_buffer_remaining(pkt) < 10) /* type, class, ttl, len */
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
type = ldns_buffer_read_u16(pkt); type = sldns_buffer_read_u16(pkt);
ldns_buffer_read(pkt, &dclass, sizeof(dclass)); sldns_buffer_read(pkt, &dclass, sizeof(dclass));
if(0) { /* debug show what is being parsed. */ if(0) { /* debug show what is being parsed. */
if(type == LDNS_RR_TYPE_RRSIG) { if(type == LDNS_RR_TYPE_RRSIG) {
uint16_t t; uint16_t t;
if(pkt_rrsig_covered(pkt, if(pkt_rrsig_covered(pkt,
ldns_buffer_current(pkt), &t)) sldns_buffer_current(pkt), &t))
fprintf(stderr, "parse of %s(%d) [%s(%d)]", fprintf(stderr, "parse of %s(%d) [%s(%d)]",
ldns_rr_descript(type)? sldns_rr_descript(type)?
ldns_rr_descript(type)->_name: "??", sldns_rr_descript(type)->_name: "??",
(int)type, (int)type,
ldns_rr_descript(t)? sldns_rr_descript(t)?
ldns_rr_descript(t)->_name: "??", sldns_rr_descript(t)->_name: "??",
(int)t); (int)t);
} else } else
fprintf(stderr, "parse of %s(%d)", fprintf(stderr, "parse of %s(%d)",
ldns_rr_descript(type)? sldns_rr_descript(type)?
ldns_rr_descript(type)->_name: "??", sldns_rr_descript(type)->_name: "??",
(int)type); (int)type);
fprintf(stderr, " %s(%d) ", fprintf(stderr, " %s(%d) ",
ldns_lookup_by_id(sldns_rr_classes, sldns_lookup_by_id(sldns_rr_classes,
(int)ntohs(dclass))?ldns_lookup_by_id( (int)ntohs(dclass))?sldns_lookup_by_id(
sldns_rr_classes, (int)ntohs(dclass))->name: sldns_rr_classes, (int)ntohs(dclass))->name:
"??", (int)ntohs(dclass)); "??", (int)ntohs(dclass));
dname_print(stderr, pkt, dname); dname_print(stderr, pkt, dname);
@ -885,8 +885,8 @@ parse_section(ldns_buffer* pkt, struct msg_parse* msg,
fprintf(stderr, "is part of existing: "); fprintf(stderr, "is part of existing: ");
dname_print(stderr, pkt, rrset->dname); dname_print(stderr, pkt, rrset->dname);
fprintf(stderr, " type %s(%d)\n", fprintf(stderr, " type %s(%d)\n",
ldns_rr_descript(rrset->type)? sldns_rr_descript(rrset->type)?
ldns_rr_descript(rrset->type)->_name: "??", sldns_rr_descript(rrset->type)->_name: "??",
(int)rrset->type); (int)rrset->type);
} }
/* add to rrset. */ /* add to rrset. */
@ -898,18 +898,18 @@ parse_section(ldns_buffer* pkt, struct msg_parse* msg,
} }
int int
parse_packet(ldns_buffer* pkt, struct msg_parse* msg, struct regional* region) parse_packet(sldns_buffer* pkt, struct msg_parse* msg, struct regional* region)
{ {
int ret; int ret;
if(ldns_buffer_remaining(pkt) < LDNS_HEADER_SIZE) if(sldns_buffer_remaining(pkt) < LDNS_HEADER_SIZE)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
/* read the header */ /* read the header */
ldns_buffer_read(pkt, &msg->id, sizeof(uint16_t)); sldns_buffer_read(pkt, &msg->id, sizeof(uint16_t));
msg->flags = ldns_buffer_read_u16(pkt); msg->flags = sldns_buffer_read_u16(pkt);
msg->qdcount = ldns_buffer_read_u16(pkt); msg->qdcount = sldns_buffer_read_u16(pkt);
msg->ancount = ldns_buffer_read_u16(pkt); msg->ancount = sldns_buffer_read_u16(pkt);
msg->nscount = ldns_buffer_read_u16(pkt); msg->nscount = sldns_buffer_read_u16(pkt);
msg->arcount = ldns_buffer_read_u16(pkt); msg->arcount = sldns_buffer_read_u16(pkt);
if(msg->qdcount > 1) if(msg->qdcount > 1)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
if((ret = parse_query_section(pkt, msg)) != 0) if((ret = parse_query_section(pkt, msg)) != 0)
@ -920,13 +920,13 @@ parse_packet(ldns_buffer* pkt, struct msg_parse* msg, struct regional* region)
if((ret = parse_section(pkt, msg, region, LDNS_SECTION_AUTHORITY, if((ret = parse_section(pkt, msg, region, LDNS_SECTION_AUTHORITY,
msg->nscount, &msg->ns_rrsets)) != 0) msg->nscount, &msg->ns_rrsets)) != 0)
return ret; return ret;
if(ldns_buffer_remaining(pkt) == 0 && msg->arcount == 1) { if(sldns_buffer_remaining(pkt) == 0 && msg->arcount == 1) {
/* BIND accepts leniently that an EDNS record is missing. /* BIND accepts leniently that an EDNS record is missing.
* so, we do too. */ * so, we do too. */
} else if((ret = parse_section(pkt, msg, region, } else if((ret = parse_section(pkt, msg, region,
LDNS_SECTION_ADDITIONAL, msg->arcount, &msg->ar_rrsets)) != 0) LDNS_SECTION_ADDITIONAL, msg->arcount, &msg->ar_rrsets)) != 0)
return ret; return ret;
/* if(ldns_buffer_remaining(pkt) > 0) { */ /* if(sldns_buffer_remaining(pkt) > 0) { */
/* there is spurious data at end of packet. ignore */ /* there is spurious data at end of packet. ignore */
/* } */ /* } */
msg->rrset_count = msg->an_rrsets + msg->ns_rrsets + msg->ar_rrsets; msg->rrset_count = msg->an_rrsets + msg->ns_rrsets + msg->ar_rrsets;
@ -984,23 +984,23 @@ parse_extract_edns(struct msg_parse* msg, struct edns_data* edns)
edns->edns_present = 1; edns->edns_present = 1;
edns->ext_rcode = found->rr_last->ttl_data[0]; edns->ext_rcode = found->rr_last->ttl_data[0];
edns->edns_version = found->rr_last->ttl_data[1]; edns->edns_version = found->rr_last->ttl_data[1];
edns->bits = ldns_read_uint16(&found->rr_last->ttl_data[2]); edns->bits = sldns_read_uint16(&found->rr_last->ttl_data[2]);
edns->udp_size = ntohs(found->rrset_class); edns->udp_size = ntohs(found->rrset_class);
/* ignore rdata and rrsigs */ /* ignore rdata and rrsigs */
return 0; return 0;
} }
int int
parse_edns_from_pkt(ldns_buffer* pkt, struct edns_data* edns) parse_edns_from_pkt(sldns_buffer* pkt, struct edns_data* edns)
{ {
log_assert(LDNS_QDCOUNT(ldns_buffer_begin(pkt)) == 1); log_assert(LDNS_QDCOUNT(sldns_buffer_begin(pkt)) == 1);
log_assert(LDNS_ANCOUNT(ldns_buffer_begin(pkt)) == 0); log_assert(LDNS_ANCOUNT(sldns_buffer_begin(pkt)) == 0);
log_assert(LDNS_NSCOUNT(ldns_buffer_begin(pkt)) == 0); log_assert(LDNS_NSCOUNT(sldns_buffer_begin(pkt)) == 0);
/* check edns section is present */ /* check edns section is present */
if(LDNS_ARCOUNT(ldns_buffer_begin(pkt)) > 1) { if(LDNS_ARCOUNT(sldns_buffer_begin(pkt)) > 1) {
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
} }
if(LDNS_ARCOUNT(ldns_buffer_begin(pkt)) == 0) { if(LDNS_ARCOUNT(sldns_buffer_begin(pkt)) == 0) {
memset(edns, 0, sizeof(*edns)); memset(edns, 0, sizeof(*edns));
edns->udp_size = 512; edns->udp_size = 512;
return 0; return 0;
@ -1008,15 +1008,15 @@ parse_edns_from_pkt(ldns_buffer* pkt, struct edns_data* edns)
/* domain name must be the root of length 1. */ /* domain name must be the root of length 1. */
if(pkt_dname_len(pkt) != 1) if(pkt_dname_len(pkt) != 1)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
if(ldns_buffer_remaining(pkt) < 10) /* type, class, ttl, rdatalen */ if(sldns_buffer_remaining(pkt) < 10) /* type, class, ttl, rdatalen */
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
if(ldns_buffer_read_u16(pkt) != LDNS_RR_TYPE_OPT) if(sldns_buffer_read_u16(pkt) != LDNS_RR_TYPE_OPT)
return LDNS_RCODE_FORMERR; return LDNS_RCODE_FORMERR;
edns->edns_present = 1; edns->edns_present = 1;
edns->udp_size = ldns_buffer_read_u16(pkt); /* class is udp size */ edns->udp_size = sldns_buffer_read_u16(pkt); /* class is udp size */
edns->ext_rcode = ldns_buffer_read_u8(pkt); /* ttl used for bits */ edns->ext_rcode = sldns_buffer_read_u8(pkt); /* ttl used for bits */
edns->edns_version = ldns_buffer_read_u8(pkt); edns->edns_version = sldns_buffer_read_u8(pkt);
edns->bits = ldns_buffer_read_u16(pkt); edns->bits = sldns_buffer_read_u16(pkt);
/* ignore rdata and rrsigs */ /* ignore rdata and rrsigs */
return 0; return 0;
} }

14
util/data/msgparse.h
View file

@ -65,7 +65,7 @@
#include "util/storage/lruhash.h" #include "util/storage/lruhash.h"
#include "ldns/pkthdr.h" #include "ldns/pkthdr.h"
#include "ldns/rrdef.h" #include "ldns/rrdef.h"
struct ldns_buffer; struct sldns_buffer;
struct rrset_parse; struct rrset_parse;
struct rr_parse; struct rr_parse;
struct regional; struct regional;
@ -139,7 +139,7 @@ struct rrset_parse {
/** which section was it found in: one of /** which section was it found in: one of
* LDNS_SECTION_ANSWER, LDNS_SECTION_AUTHORITY, LDNS_SECTION_ADDITIONAL * LDNS_SECTION_ANSWER, LDNS_SECTION_AUTHORITY, LDNS_SECTION_ADDITIONAL
*/ */
ldns_pkt_section section; sldns_pkt_section section;
/** start of (possibly compressed) dname in packet */ /** start of (possibly compressed) dname in packet */
uint8_t* dname; uint8_t* dname;
/** length of the dname uncompressed wireformat */ /** length of the dname uncompressed wireformat */
@ -221,7 +221,7 @@ struct edns_data {
* @param rdf: the rdf type from the descriptor. * @param rdf: the rdf type from the descriptor.
* @return: size in octets. 0 on failure. * @return: size in octets. 0 on failure.
*/ */
size_t get_rdf_size(ldns_rdf_type rdf); size_t get_rdf_size(sldns_rdf_type rdf);
/** /**
* Parse the packet. * Parse the packet.
@ -231,7 +231,7 @@ size_t get_rdf_size(ldns_rdf_type rdf);
* @param region: how to alloc results. * @param region: how to alloc results.
* @return: 0 if OK, or rcode on error. * @return: 0 if OK, or rcode on error.
*/ */
int parse_packet(struct ldns_buffer* pkt, struct msg_parse* msg, int parse_packet(struct sldns_buffer* pkt, struct msg_parse* msg,
struct regional* region); struct regional* region);
/** /**
@ -261,7 +261,7 @@ int parse_extract_edns(struct msg_parse* msg, struct edns_data* edns);
* @return: 0 on success, or an RCODE on error. * @return: 0 on success, or an RCODE on error.
* RCODE formerr if OPT is badly formatted and so on. * RCODE formerr if OPT is badly formatted and so on.
*/ */
int parse_edns_from_pkt(struct ldns_buffer* pkt, struct edns_data* edns); int parse_edns_from_pkt(struct sldns_buffer* pkt, struct edns_data* edns);
/** /**
* Calculate hash value for rrset in packet. * Calculate hash value for rrset in packet.
@ -272,7 +272,7 @@ int parse_edns_from_pkt(struct ldns_buffer* pkt, struct edns_data* edns);
* @param rrset_flags: rrset flags (same as packed_rrset flags). * @param rrset_flags: rrset flags (same as packed_rrset flags).
* @return hash value * @return hash value
*/ */
hashvalue_t pkt_hash_rrset(struct ldns_buffer* pkt, uint8_t* dname, uint16_t type, hashvalue_t pkt_hash_rrset(struct sldns_buffer* pkt, uint8_t* dname, uint16_t type,
uint16_t dclass, uint32_t rrset_flags); uint16_t dclass, uint32_t rrset_flags);
/** /**
@ -288,7 +288,7 @@ hashvalue_t pkt_hash_rrset(struct ldns_buffer* pkt, uint8_t* dname, uint16_t typ
* @return NULL or the rrset_parse if found. * @return NULL or the rrset_parse if found.
*/ */
struct rrset_parse* msgparse_hashtable_lookup(struct msg_parse* msg, struct rrset_parse* msgparse_hashtable_lookup(struct msg_parse* msg,
struct ldns_buffer* pkt, hashvalue_t h, uint32_t rrset_flags, struct sldns_buffer* pkt, hashvalue_t h, uint32_t rrset_flags,
uint8_t* dname, size_t dnamelen, uint16_t type, uint16_t dclass); uint8_t* dname, size_t dnamelen, uint16_t type, uint16_t dclass);
/** /**

74
util/data/msgreply.c
View file

@ -60,7 +60,7 @@ time_t MIN_TTL = 0;
/** allocate qinfo, return 0 on error */ /** allocate qinfo, return 0 on error */
static int static int
parse_create_qinfo(ldns_buffer* pkt, struct msg_parse* msg, parse_create_qinfo(sldns_buffer* pkt, struct msg_parse* msg,
struct query_info* qinf, struct regional* region) struct query_info* qinf, struct regional* region)
{ {
if(msg->qname) { if(msg->qname) {
@ -154,13 +154,13 @@ repinfo_alloc_rrset_keys(struct reply_info* rep, struct alloc_cache* alloc,
/** do the rdata copy */ /** do the rdata copy */
static int static int
rdata_copy(ldns_buffer* pkt, struct packed_rrset_data* data, uint8_t* to, rdata_copy(sldns_buffer* pkt, struct packed_rrset_data* data, uint8_t* to,
struct rr_parse* rr, time_t* rr_ttl, uint16_t type) struct rr_parse* rr, time_t* rr_ttl, uint16_t type)
{ {
uint16_t pkt_len; uint16_t pkt_len;
const ldns_rr_descriptor* desc; const sldns_rr_descriptor* desc;
*rr_ttl = ldns_read_uint32(rr->ttl_data); *rr_ttl = sldns_read_uint32(rr->ttl_data);
/* RFC 2181 Section 8. if msb of ttl is set treat as if zero. */ /* RFC 2181 Section 8. if msb of ttl is set treat as if zero. */
if(*rr_ttl & 0x80000000U) if(*rr_ttl & 0x80000000U)
*rr_ttl = 0; *rr_ttl = 0;
@ -175,18 +175,18 @@ rdata_copy(ldns_buffer* pkt, struct packed_rrset_data* data, uint8_t* to,
return 1; return 1;
} }
ldns_buffer_set_position(pkt, (size_t) sldns_buffer_set_position(pkt, (size_t)
(rr->ttl_data - ldns_buffer_begin(pkt) + sizeof(uint32_t))); (rr->ttl_data - sldns_buffer_begin(pkt) + sizeof(uint32_t)));
/* insert decompressed size into rdata len stored in memory */ /* insert decompressed size into rdata len stored in memory */
/* -2 because rdatalen bytes are not included. */ /* -2 because rdatalen bytes are not included. */
pkt_len = htons(rr->size - 2); pkt_len = htons(rr->size - 2);
memmove(to, &pkt_len, sizeof(uint16_t)); memmove(to, &pkt_len, sizeof(uint16_t));
to += 2; to += 2;
/* read packet rdata len */ /* read packet rdata len */
pkt_len = ldns_buffer_read_u16(pkt); pkt_len = sldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < pkt_len) if(sldns_buffer_remaining(pkt) < pkt_len)
return 0; return 0;
desc = ldns_rr_descript(type); desc = sldns_rr_descript(type);
if(pkt_len > 0 && desc && desc->_dname_count > 0) { if(pkt_len > 0 && desc && desc->_dname_count > 0) {
int count = (int)desc->_dname_count; int count = (int)desc->_dname_count;
int rdf = 0; int rdf = 0;
@ -196,25 +196,25 @@ rdata_copy(ldns_buffer* pkt, struct packed_rrset_data* data, uint8_t* to,
while(pkt_len > 0 && count) { while(pkt_len > 0 && count) {
switch(desc->_wireformat[rdf]) { switch(desc->_wireformat[rdf]) {
case LDNS_RDF_TYPE_DNAME: case LDNS_RDF_TYPE_DNAME:
oldpos = ldns_buffer_position(pkt); oldpos = sldns_buffer_position(pkt);
dname_pkt_copy(pkt, to, dname_pkt_copy(pkt, to,
ldns_buffer_current(pkt)); sldns_buffer_current(pkt));
to += pkt_dname_len(pkt); to += pkt_dname_len(pkt);
pkt_len -= ldns_buffer_position(pkt)-oldpos; pkt_len -= sldns_buffer_position(pkt)-oldpos;
count--; count--;
len = 0; len = 0;
break; break;
case LDNS_RDF_TYPE_STR: case LDNS_RDF_TYPE_STR:
len = ldns_buffer_current(pkt)[0] + 1; len = sldns_buffer_current(pkt)[0] + 1;
break; break;
default: default:
len = get_rdf_size(desc->_wireformat[rdf]); len = get_rdf_size(desc->_wireformat[rdf]);
break; break;
} }
if(len) { if(len) {
memmove(to, ldns_buffer_current(pkt), len); memmove(to, sldns_buffer_current(pkt), len);
to += len; to += len;
ldns_buffer_skip(pkt, (ssize_t)len); sldns_buffer_skip(pkt, (ssize_t)len);
log_assert(len <= pkt_len); log_assert(len <= pkt_len);
pkt_len -= len; pkt_len -= len;
} }
@ -223,14 +223,14 @@ rdata_copy(ldns_buffer* pkt, struct packed_rrset_data* data, uint8_t* to,
} }
/* copy remaining rdata */ /* copy remaining rdata */
if(pkt_len > 0) if(pkt_len > 0)
memmove(to, ldns_buffer_current(pkt), pkt_len); memmove(to, sldns_buffer_current(pkt), pkt_len);
return 1; return 1;
} }
/** copy over the data into packed rrset */ /** copy over the data into packed rrset */
static int static int
parse_rr_copy(ldns_buffer* pkt, struct rrset_parse* pset, parse_rr_copy(sldns_buffer* pkt, struct rrset_parse* pset,
struct packed_rrset_data* data) struct packed_rrset_data* data)
{ {
size_t i; size_t i;
@ -273,7 +273,7 @@ parse_rr_copy(ldns_buffer* pkt, struct rrset_parse* pset,
/** create rrset return 0 on failure */ /** create rrset return 0 on failure */
static int static int
parse_create_rrset(ldns_buffer* pkt, struct rrset_parse* pset, parse_create_rrset(sldns_buffer* pkt, struct rrset_parse* pset,
struct packed_rrset_data** data, struct regional* region) struct packed_rrset_data** data, struct regional* region)
{ {
/* allocate */ /* allocate */
@ -333,7 +333,7 @@ get_rrset_trust(struct msg_parse* msg, struct rrset_parse* rrset)
} }
int int
parse_copy_decompress_rrset(ldns_buffer* pkt, struct msg_parse* msg, parse_copy_decompress_rrset(sldns_buffer* pkt, struct msg_parse* msg,
struct rrset_parse *pset, struct regional* region, struct rrset_parse *pset, struct regional* region,
struct ub_packed_rrset_key* pk) struct ub_packed_rrset_key* pk)
{ {
@ -371,7 +371,7 @@ parse_copy_decompress_rrset(ldns_buffer* pkt, struct msg_parse* msg,
* @return 0 on failure. * @return 0 on failure.
*/ */
static int static int
parse_copy_decompress(ldns_buffer* pkt, struct msg_parse* msg, parse_copy_decompress(sldns_buffer* pkt, struct msg_parse* msg,
struct reply_info* rep, struct regional* region) struct reply_info* rep, struct regional* region)
{ {
size_t i; size_t i;
@ -398,7 +398,7 @@ parse_copy_decompress(ldns_buffer* pkt, struct msg_parse* msg,
} }
int int
parse_create_msg(ldns_buffer* pkt, struct msg_parse* msg, parse_create_msg(sldns_buffer* pkt, struct msg_parse* msg,
struct alloc_cache* alloc, struct query_info* qinf, struct alloc_cache* alloc, struct query_info* qinf,
struct reply_info** rep, struct regional* region) struct reply_info** rep, struct regional* region)
{ {
@ -414,7 +414,7 @@ parse_create_msg(ldns_buffer* pkt, struct msg_parse* msg,
return 1; return 1;
} }
int reply_info_parse(ldns_buffer* pkt, struct alloc_cache* alloc, int reply_info_parse(sldns_buffer* pkt, struct alloc_cache* alloc,
struct query_info* qinf, struct reply_info** rep, struct query_info* qinf, struct reply_info** rep,
struct regional* region, struct edns_data* edns) struct regional* region, struct edns_data* edns)
{ {
@ -429,7 +429,7 @@ int reply_info_parse(ldns_buffer* pkt, struct alloc_cache* alloc,
} }
memset(msg, 0, sizeof(*msg)); memset(msg, 0, sizeof(*msg));
ldns_buffer_set_position(pkt, 0); sldns_buffer_set_position(pkt, 0);
if((ret = parse_packet(pkt, msg, region)) != 0) { if((ret = parse_packet(pkt, msg, region)) != 0) {
return ret; return ret;
} }
@ -497,23 +497,23 @@ reply_info_parsedelete(struct reply_info* rep, struct alloc_cache* alloc)
} }
int int
query_info_parse(struct query_info* m, ldns_buffer* query) query_info_parse(struct query_info* m, sldns_buffer* query)
{ {
uint8_t* q = ldns_buffer_begin(query); uint8_t* q = sldns_buffer_begin(query);
/* minimum size: header + \0 + qtype + qclass */ /* minimum size: header + \0 + qtype + qclass */
if(ldns_buffer_limit(query) < LDNS_HEADER_SIZE + 5) if(sldns_buffer_limit(query) < LDNS_HEADER_SIZE + 5)
return 0; return 0;
if(LDNS_OPCODE_WIRE(q) != LDNS_PACKET_QUERY || if(LDNS_OPCODE_WIRE(q) != LDNS_PACKET_QUERY ||
LDNS_QDCOUNT(q) != 1 || ldns_buffer_position(query) != 0) LDNS_QDCOUNT(q) != 1 || sldns_buffer_position(query) != 0)
return 0; return 0;
ldns_buffer_skip(query, LDNS_HEADER_SIZE); sldns_buffer_skip(query, LDNS_HEADER_SIZE);
m->qname = ldns_buffer_current(query); m->qname = sldns_buffer_current(query);
if((m->qname_len = query_dname_len(query)) == 0) if((m->qname_len = query_dname_len(query)) == 0)
return 0; /* parse error */ return 0; /* parse error */
if(ldns_buffer_remaining(query) < 4) if(sldns_buffer_remaining(query) < 4)
return 0; /* need qtype, qclass */ return 0; /* need qtype, qclass */
m->qtype = ldns_buffer_read_u16(query); m->qtype = sldns_buffer_read_u16(query);
m->qclass = ldns_buffer_read_u16(query); m->qclass = sldns_buffer_read_u16(query);
return 1; return 1;
} }
@ -765,23 +765,23 @@ void
log_dns_msg(const char* str, struct query_info* qinfo, struct reply_info* rep) log_dns_msg(const char* str, struct query_info* qinfo, struct reply_info* rep)
{ {
/* not particularly fast but flexible, make wireformat and print */ /* not particularly fast but flexible, make wireformat and print */
ldns_buffer* buf = ldns_buffer_new(65535); sldns_buffer* buf = sldns_buffer_new(65535);
struct regional* region = regional_create(); struct regional* region = regional_create();
if(!reply_info_encode(qinfo, rep, 0, rep->flags, buf, 0, if(!reply_info_encode(qinfo, rep, 0, rep->flags, buf, 0,
region, 65535, 1)) { region, 65535, 1)) {
log_info("%s: log_dns_msg: out of memory", str); log_info("%s: log_dns_msg: out of memory", str);
} else { } else {
char* str = ldns_wire2str_pkt(ldns_buffer_begin(buf), char* str = sldns_wire2str_pkt(sldns_buffer_begin(buf),
ldns_buffer_limit(buf)); sldns_buffer_limit(buf));
if(!str) { if(!str) {
log_info("%s: log_dns_msg: ldns tostr failed", str); log_info("%s: log_dns_msg: ldns tostr failed", str);
} else { } else {
log_info("%s %s", log_info("%s %s",
str, (char*)ldns_buffer_begin(buf)); str, (char*)sldns_buffer_begin(buf));
} }
free(str); free(str);
} }
ldns_buffer_free(buf); sldns_buffer_free(buf);
regional_destroy(region); regional_destroy(region);
} }

10
util/data/msgreply.h
View file

@ -43,7 +43,7 @@
#define UTIL_DATA_MSGREPLY_H #define UTIL_DATA_MSGREPLY_H
#include "util/storage/lruhash.h" #include "util/storage/lruhash.h"
#include "util/data/packed_rrset.h" #include "util/data/packed_rrset.h"
struct ldns_buffer; struct sldns_buffer;
struct comm_reply; struct comm_reply;
struct alloc_cache; struct alloc_cache;
struct iovec; struct iovec;
@ -202,7 +202,7 @@ struct msgreply_entry {
* @param query: the wireformat packet query. starts with ID. * @param query: the wireformat packet query. starts with ID.
* @return: 0 on format error. * @return: 0 on format error.
*/ */
int query_info_parse(struct query_info* m, struct ldns_buffer* query); int query_info_parse(struct query_info* m, struct sldns_buffer* query);
/** /**
* Parse query reply. * Parse query reply.
@ -219,7 +219,7 @@ int query_info_parse(struct query_info* m, struct ldns_buffer* query);
* o FORMERR for parse errors. * o FORMERR for parse errors.
* o SERVFAIL for memory allocation errors. * o SERVFAIL for memory allocation errors.
*/ */
int reply_info_parse(struct ldns_buffer* pkt, struct alloc_cache* alloc, int reply_info_parse(struct sldns_buffer* pkt, struct alloc_cache* alloc,
struct query_info* qinf, struct reply_info** rep, struct query_info* qinf, struct reply_info** rep,
struct regional* region, struct edns_data* edns); struct regional* region, struct edns_data* edns);
@ -238,7 +238,7 @@ int reply_info_parse(struct ldns_buffer* pkt, struct alloc_cache* alloc,
* and no rrset_ref array in the reply is built up. * and no rrset_ref array in the reply is built up.
* @return 0 if allocation failed. * @return 0 if allocation failed.
*/ */
int parse_create_msg(struct ldns_buffer* pkt, struct msg_parse* msg, int parse_create_msg(struct sldns_buffer* pkt, struct msg_parse* msg,
struct alloc_cache* alloc, struct query_info* qinf, struct alloc_cache* alloc, struct query_info* qinf,
struct reply_info** rep, struct regional* region); struct reply_info** rep, struct regional* region);
@ -323,7 +323,7 @@ struct reply_info* reply_info_copy(struct reply_info* rep,
* Note that TTL will still be relative on return. * Note that TTL will still be relative on return.
* @return false on alloc failure. * @return false on alloc failure.
*/ */
int parse_copy_decompress_rrset(struct ldns_buffer* pkt, struct msg_parse* msg, int parse_copy_decompress_rrset(struct sldns_buffer* pkt, struct msg_parse* msg,
struct rrset_parse *pset, struct regional* region, struct rrset_parse *pset, struct regional* region,
struct ub_packed_rrset_key* pk); struct ub_packed_rrset_key* pk);

8
util/data/packed_rrset.c
View file

@ -207,7 +207,7 @@ get_cname_target(struct ub_packed_rrset_key* rrset, uint8_t** dname,
return; return;
if(d->rr_len[0] < 3) /* at least rdatalen + 0byte root label */ if(d->rr_len[0] < 3) /* at least rdatalen + 0byte root label */
return; return;
len = ldns_read_uint16(d->rr_data[0]); len = sldns_read_uint16(d->rr_data[0]);
if(len != d->rr_len[0] - sizeof(uint16_t)) if(len != d->rr_len[0] - sizeof(uint16_t))
return; return;
if(dname_valid(d->rr_data[0]+sizeof(uint16_t), len) != len) if(dname_valid(d->rr_data[0]+sizeof(uint16_t), len) != len)
@ -283,12 +283,12 @@ int packed_rr_to_string(struct ub_packed_rrset_key* rrset, size_t i,
memmove(rr, rrset->rk.dname, rrset->rk.dname_len); memmove(rr, rrset->rk.dname, rrset->rk.dname_len);
if(i < d->count) if(i < d->count)
memmove(rr+rrset->rk.dname_len, &rrset->rk.type, 2); memmove(rr+rrset->rk.dname_len, &rrset->rk.type, 2);
else ldns_write_uint16(rr+rrset->rk.dname_len, LDNS_RR_TYPE_RRSIG); else sldns_write_uint16(rr+rrset->rk.dname_len, LDNS_RR_TYPE_RRSIG);
memmove(rr+rrset->rk.dname_len+2, &rrset->rk.rrset_class, 2); memmove(rr+rrset->rk.dname_len+2, &rrset->rk.rrset_class, 2);
ldns_write_uint32(rr+rrset->rk.dname_len+4, sldns_write_uint32(rr+rrset->rk.dname_len+4,
(uint32_t)(d->rr_ttl[i]-now)); (uint32_t)(d->rr_ttl[i]-now));
memmove(rr+rrset->rk.dname_len+8, d->rr_data[i], d->rr_len[i]); memmove(rr+rrset->rk.dname_len+8, d->rr_data[i], d->rr_len[i]);
if(ldns_wire2str_rr_buf(rr, rlen, dest, dest_len) == -1) { if(sldns_wire2str_rr_buf(rr, rlen, dest, dest_len) == -1) {
log_info("rrbuf failure %d %s", (int)d->rr_len[i], dest); log_info("rrbuf failure %d %s", (int)d->rr_len[i], dest);
dest[0] = 0; dest[0] = 0;
return 0; return 0;

4
util/log.c
View file

@ -347,11 +347,11 @@ log_hex(const char* msg, void* data, size_t length)
log_hex_f(verbosity, msg, data, length); log_hex_f(verbosity, msg, data, length);
} }
void log_buf(enum verbosity_value level, const char* msg, ldns_buffer* buf) void log_buf(enum verbosity_value level, const char* msg, sldns_buffer* buf)
{ {
if(verbosity < level) if(verbosity < level)
return; return;
log_hex_f(level, msg, ldns_buffer_begin(buf), ldns_buffer_limit(buf)); log_hex_f(level, msg, sldns_buffer_begin(buf), sldns_buffer_limit(buf));
} }
#ifdef USE_WINSOCK #ifdef USE_WINSOCK

6
util/log.h
View file

@ -41,7 +41,7 @@
#ifndef UTIL_LOG_H #ifndef UTIL_LOG_H
#define UTIL_LOG_H #define UTIL_LOG_H
struct ldns_buffer; struct sldns_buffer;
/** /**
* verbosity value: * verbosity value:
@ -149,13 +149,13 @@ void log_warn(const char* format, ...) ATTR_FORMAT(printf, 1, 2);
void log_hex(const char* msg, void* data, size_t length); void log_hex(const char* msg, void* data, size_t length);
/** /**
* Easy alternative for log_hex, takes a ldns_buffer. * Easy alternative for log_hex, takes a sldns_buffer.
* @param level: verbosity level for this message, compared to global * @param level: verbosity level for this message, compared to global
* verbosity setting. * verbosity setting.
* @param msg: string desc to print * @param msg: string desc to print
* @param buf: the buffer. * @param buf: the buffer.
*/ */
void log_buf(enum verbosity_value level, const char* msg, struct ldns_buffer* buf); void log_buf(enum verbosity_value level, const char* msg, struct sldns_buffer* buf);
/** /**
* Log fatal error message, and exit the current process. * Log fatal error message, and exit the current process.

4
util/module.h
View file

@ -44,7 +44,7 @@
#include "util/storage/lruhash.h" #include "util/storage/lruhash.h"
#include "util/data/msgreply.h" #include "util/data/msgreply.h"
#include "util/data/msgparse.h" #include "util/data/msgparse.h"
struct ldns_buffer; struct sldns_buffer;
struct alloc_cache; struct alloc_cache;
struct rrset_cache; struct rrset_cache;
struct key_cache; struct key_cache;
@ -177,7 +177,7 @@ struct module_env {
/** region for temporary usage. May be cleared after operate() call. */ /** region for temporary usage. May be cleared after operate() call. */
struct regional* scratch; struct regional* scratch;
/** buffer for temporary usage. May be cleared after operate() call. */ /** buffer for temporary usage. May be cleared after operate() call. */
struct ldns_buffer* scratch_buffer; struct sldns_buffer* scratch_buffer;
/** internal data for daemon - worker thread. */ /** internal data for daemon - worker thread. */
struct worker* worker; struct worker* worker;
/** mesh area with query state dependencies */ /** mesh area with query state dependencies */

10
util/net_help.c
View file

@ -281,15 +281,15 @@ log_nametypeclass(enum verbosity_value v, const char* str, uint8_t* name,
else if(type == LDNS_RR_TYPE_MAILB) ts = "MAILB"; else if(type == LDNS_RR_TYPE_MAILB) ts = "MAILB";
else if(type == LDNS_RR_TYPE_MAILA) ts = "MAILA"; else if(type == LDNS_RR_TYPE_MAILA) ts = "MAILA";
else if(type == LDNS_RR_TYPE_ANY) ts = "ANY"; else if(type == LDNS_RR_TYPE_ANY) ts = "ANY";
else if(ldns_rr_descript(type) && ldns_rr_descript(type)->_name) else if(sldns_rr_descript(type) && sldns_rr_descript(type)->_name)
ts = ldns_rr_descript(type)->_name; ts = sldns_rr_descript(type)->_name;
else { else {
snprintf(t, sizeof(t), "TYPE%d", (int)type); snprintf(t, sizeof(t), "TYPE%d", (int)type);
ts = t; ts = t;
} }
if(ldns_lookup_by_id(SLDNS(_rr_classes), (int)dclass) && if(sldns_lookup_by_id(sldns_rr_classes, (int)dclass) &&
ldns_lookup_by_id(SLDNS(_rr_classes), (int)dclass)->name) sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name)
cs = ldns_lookup_by_id(SLDNS(_rr_classes), (int)dclass)->name; cs = sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name;
else { else {
snprintf(c, sizeof(c), "CLASS%d", (int)dclass); snprintf(c, sizeof(c), "CLASS%d", (int)dclass);
cs = c; cs = c;

156
util/netevent.c
View file

@ -378,18 +378,18 @@ int tcp_connect_errno_needs_log(struct sockaddr* addr, socklen_t addrlen)
/* send a UDP reply */ /* send a UDP reply */
int int
comm_point_send_udp_msg(struct comm_point *c, ldns_buffer* packet, comm_point_send_udp_msg(struct comm_point *c, sldns_buffer* packet,
struct sockaddr* addr, socklen_t addrlen) struct sockaddr* addr, socklen_t addrlen)
{ {
ssize_t sent; ssize_t sent;
log_assert(c->fd != -1); log_assert(c->fd != -1);
#ifdef UNBOUND_DEBUG #ifdef UNBOUND_DEBUG
if(ldns_buffer_remaining(packet) == 0) if(sldns_buffer_remaining(packet) == 0)
log_err("error: send empty UDP packet"); log_err("error: send empty UDP packet");
#endif #endif
log_assert(addr && addrlen > 0); log_assert(addr && addrlen > 0);
sent = sendto(c->fd, (void*)ldns_buffer_begin(packet), sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
ldns_buffer_remaining(packet), 0, sldns_buffer_remaining(packet), 0,
addr, addrlen); addr, addrlen);
if(sent == -1) { if(sent == -1) {
if(!udp_send_errno_needs_log(addr, addrlen)) if(!udp_send_errno_needs_log(addr, addrlen))
@ -403,9 +403,9 @@ comm_point_send_udp_msg(struct comm_point *c, ldns_buffer* packet,
log_addr(VERB_OPS, "remote address is", log_addr(VERB_OPS, "remote address is",
(struct sockaddr_storage*)addr, addrlen); (struct sockaddr_storage*)addr, addrlen);
return 0; return 0;
} else if((size_t)sent != ldns_buffer_remaining(packet)) { } else if((size_t)sent != sldns_buffer_remaining(packet)) {
log_err("sent %d in place of %d bytes", log_err("sent %d in place of %d bytes",
(int)sent, (int)ldns_buffer_remaining(packet)); (int)sent, (int)sldns_buffer_remaining(packet));
return 0; return 0;
} }
return 1; return 1;
@ -461,7 +461,7 @@ static void p_ancil(const char* str, struct comm_reply* r)
/** send a UDP reply over specified interface*/ /** send a UDP reply over specified interface*/
static int static int
comm_point_send_udp_msg_if(struct comm_point *c, ldns_buffer* packet, comm_point_send_udp_msg_if(struct comm_point *c, sldns_buffer* packet,
struct sockaddr* addr, socklen_t addrlen, struct comm_reply* r) struct sockaddr* addr, socklen_t addrlen, struct comm_reply* r)
{ {
#if defined(AF_INET6) && defined(IPV6_PKTINFO) && defined(HAVE_SENDMSG) #if defined(AF_INET6) && defined(IPV6_PKTINFO) && defined(HAVE_SENDMSG)
@ -475,15 +475,15 @@ comm_point_send_udp_msg_if(struct comm_point *c, ldns_buffer* packet,
log_assert(c->fd != -1); log_assert(c->fd != -1);
#ifdef UNBOUND_DEBUG #ifdef UNBOUND_DEBUG
if(ldns_buffer_remaining(packet) == 0) if(sldns_buffer_remaining(packet) == 0)
log_err("error: send empty UDP packet"); log_err("error: send empty UDP packet");
#endif #endif
log_assert(addr && addrlen > 0); log_assert(addr && addrlen > 0);
msg.msg_name = addr; msg.msg_name = addr;
msg.msg_namelen = addrlen; msg.msg_namelen = addrlen;
iov[0].iov_base = ldns_buffer_begin(packet); iov[0].iov_base = sldns_buffer_begin(packet);
iov[0].iov_len = ldns_buffer_remaining(packet); iov[0].iov_len = sldns_buffer_remaining(packet);
msg.msg_iov = iov; msg.msg_iov = iov;
msg.msg_iovlen = 1; msg.msg_iovlen = 1;
msg.msg_control = control; msg.msg_control = control;
@ -543,9 +543,9 @@ comm_point_send_udp_msg_if(struct comm_point *c, ldns_buffer* packet,
log_addr(VERB_OPS, "remote address is", log_addr(VERB_OPS, "remote address is",
(struct sockaddr_storage*)addr, addrlen); (struct sockaddr_storage*)addr, addrlen);
return 0; return 0;
} else if((size_t)sent != ldns_buffer_remaining(packet)) { } else if((size_t)sent != sldns_buffer_remaining(packet)) {
log_err("sent %d in place of %d bytes", log_err("sent %d in place of %d bytes",
(int)sent, (int)ldns_buffer_remaining(packet)); (int)sent, (int)sldns_buffer_remaining(packet));
return 0; return 0;
} }
return 1; return 1;
@ -582,14 +582,14 @@ comm_point_udp_ancil_callback(int fd, short event, void* arg)
log_assert(rep.c && rep.c->buffer && rep.c->fd == fd); log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
comm_base_now(rep.c->ev->base); comm_base_now(rep.c->ev->base);
for(i=0; i<NUM_UDP_PER_SELECT; i++) { for(i=0; i<NUM_UDP_PER_SELECT; i++) {
ldns_buffer_clear(rep.c->buffer); sldns_buffer_clear(rep.c->buffer);
rep.addrlen = (socklen_t)sizeof(rep.addr); rep.addrlen = (socklen_t)sizeof(rep.addr);
log_assert(fd != -1); log_assert(fd != -1);
log_assert(ldns_buffer_remaining(rep.c->buffer) > 0); log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
msg.msg_name = &rep.addr; msg.msg_name = &rep.addr;
msg.msg_namelen = (socklen_t)sizeof(rep.addr); msg.msg_namelen = (socklen_t)sizeof(rep.addr);
iov[0].iov_base = ldns_buffer_begin(rep.c->buffer); iov[0].iov_base = sldns_buffer_begin(rep.c->buffer);
iov[0].iov_len = ldns_buffer_remaining(rep.c->buffer); iov[0].iov_len = sldns_buffer_remaining(rep.c->buffer);
msg.msg_iov = iov; msg.msg_iov = iov;
msg.msg_iovlen = 1; msg.msg_iovlen = 1;
msg.msg_control = ancil; msg.msg_control = ancil;
@ -605,8 +605,8 @@ comm_point_udp_ancil_callback(int fd, short event, void* arg)
return; return;
} }
rep.addrlen = msg.msg_namelen; rep.addrlen = msg.msg_namelen;
ldns_buffer_skip(rep.c->buffer, rcv); sldns_buffer_skip(rep.c->buffer, rcv);
ldns_buffer_flip(rep.c->buffer); sldns_buffer_flip(rep.c->buffer);
rep.srctype = 0; rep.srctype = 0;
#ifndef S_SPLINT_S #ifndef S_SPLINT_S
for(cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; for(cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
@ -670,12 +670,12 @@ comm_point_udp_callback(int fd, short event, void* arg)
log_assert(rep.c && rep.c->buffer && rep.c->fd == fd); log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
comm_base_now(rep.c->ev->base); comm_base_now(rep.c->ev->base);
for(i=0; i<NUM_UDP_PER_SELECT; i++) { for(i=0; i<NUM_UDP_PER_SELECT; i++) {
ldns_buffer_clear(rep.c->buffer); sldns_buffer_clear(rep.c->buffer);
rep.addrlen = (socklen_t)sizeof(rep.addr); rep.addrlen = (socklen_t)sizeof(rep.addr);
log_assert(fd != -1); log_assert(fd != -1);
log_assert(ldns_buffer_remaining(rep.c->buffer) > 0); log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
rcv = recvfrom(fd, (void*)ldns_buffer_begin(rep.c->buffer), rcv = recvfrom(fd, (void*)sldns_buffer_begin(rep.c->buffer),
ldns_buffer_remaining(rep.c->buffer), 0, sldns_buffer_remaining(rep.c->buffer), 0,
(struct sockaddr*)&rep.addr, &rep.addrlen); (struct sockaddr*)&rep.addr, &rep.addrlen);
if(rcv == -1) { if(rcv == -1) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
@ -691,8 +691,8 @@ comm_point_udp_callback(int fd, short event, void* arg)
#endif #endif
return; return;
} }
ldns_buffer_skip(rep.c->buffer, rcv); sldns_buffer_skip(rep.c->buffer, rcv);
ldns_buffer_flip(rep.c->buffer); sldns_buffer_flip(rep.c->buffer);
rep.srctype = 0; rep.srctype = 0;
fptr_ok(fptr_whitelist_comm_point(rep.c->callback)); fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) { if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
@ -712,7 +712,7 @@ setup_tcp_handler(struct comm_point* c, int fd)
{ {
log_assert(c->type == comm_tcp); log_assert(c->type == comm_tcp);
log_assert(c->fd == -1); log_assert(c->fd == -1);
ldns_buffer_clear(c->buffer); sldns_buffer_clear(c->buffer);
c->tcp_is_reading = 1; c->tcp_is_reading = 1;
c->tcp_byte_count = 0; c->tcp_byte_count = 0;
comm_point_start_listening(c, fd, TCP_QUERY_TIMEOUT); comm_point_start_listening(c, fd, TCP_QUERY_TIMEOUT);
@ -914,7 +914,7 @@ static void
tcp_callback_writer(struct comm_point* c) tcp_callback_writer(struct comm_point* c)
{ {
log_assert(c->type == comm_tcp); log_assert(c->type == comm_tcp);
ldns_buffer_clear(c->buffer); sldns_buffer_clear(c->buffer);
if(c->tcp_do_toggle_rw) if(c->tcp_do_toggle_rw)
c->tcp_is_reading = 1; c->tcp_is_reading = 1;
c->tcp_byte_count = 0; c->tcp_byte_count = 0;
@ -928,7 +928,7 @@ static void
tcp_callback_reader(struct comm_point* c) tcp_callback_reader(struct comm_point* c)
{ {
log_assert(c->type == comm_tcp || c->type == comm_local); log_assert(c->type == comm_tcp || c->type == comm_local);
ldns_buffer_flip(c->buffer); sldns_buffer_flip(c->buffer);
if(c->tcp_do_toggle_rw) if(c->tcp_do_toggle_rw)
c->tcp_is_reading = 0; c->tcp_is_reading = 0;
c->tcp_byte_count = 0; c->tcp_byte_count = 0;
@ -1021,7 +1021,7 @@ ssl_handle_read(struct comm_point* c)
if(c->tcp_byte_count < sizeof(uint16_t)) { if(c->tcp_byte_count < sizeof(uint16_t)) {
/* read length bytes */ /* read length bytes */
ERR_clear_error(); ERR_clear_error();
if((r=SSL_read(c->ssl, (void*)ldns_buffer_at(c->buffer, if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(c->buffer,
c->tcp_byte_count), (int)(sizeof(uint16_t) - c->tcp_byte_count), (int)(sizeof(uint16_t) -
c->tcp_byte_count))) <= 0) { c->tcp_byte_count))) <= 0) {
int want = SSL_get_error(c->ssl, r); int want = SSL_get_error(c->ssl, r);
@ -1045,24 +1045,24 @@ ssl_handle_read(struct comm_point* c)
c->tcp_byte_count += r; c->tcp_byte_count += r;
if(c->tcp_byte_count != sizeof(uint16_t)) if(c->tcp_byte_count != sizeof(uint16_t))
return 1; return 1;
if(ldns_buffer_read_u16_at(c->buffer, 0) > if(sldns_buffer_read_u16_at(c->buffer, 0) >
ldns_buffer_capacity(c->buffer)) { sldns_buffer_capacity(c->buffer)) {
verbose(VERB_QUERY, "ssl: dropped larger than buffer"); verbose(VERB_QUERY, "ssl: dropped larger than buffer");
return 0; return 0;
} }
ldns_buffer_set_limit(c->buffer, sldns_buffer_set_limit(c->buffer,
ldns_buffer_read_u16_at(c->buffer, 0)); sldns_buffer_read_u16_at(c->buffer, 0));
if(ldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) { if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
verbose(VERB_QUERY, "ssl: dropped bogus too short."); verbose(VERB_QUERY, "ssl: dropped bogus too short.");
return 0; return 0;
} }
verbose(VERB_ALGO, "Reading ssl tcp query of length %d", verbose(VERB_ALGO, "Reading ssl tcp query of length %d",
(int)ldns_buffer_limit(c->buffer)); (int)sldns_buffer_limit(c->buffer));
} }
log_assert(ldns_buffer_remaining(c->buffer) > 0); log_assert(sldns_buffer_remaining(c->buffer) > 0);
ERR_clear_error(); ERR_clear_error();
r = SSL_read(c->ssl, (void*)ldns_buffer_current(c->buffer), r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
(int)ldns_buffer_remaining(c->buffer)); (int)sldns_buffer_remaining(c->buffer));
if(r <= 0) { if(r <= 0) {
int want = SSL_get_error(c->ssl, r); int want = SSL_get_error(c->ssl, r);
if(want == SSL_ERROR_ZERO_RETURN) { if(want == SSL_ERROR_ZERO_RETURN) {
@ -1082,8 +1082,8 @@ ssl_handle_read(struct comm_point* c)
log_crypto_err("could not SSL_read"); log_crypto_err("could not SSL_read");
return 0; return 0;
} }
ldns_buffer_skip(c->buffer, (ssize_t)r); sldns_buffer_skip(c->buffer, (ssize_t)r);
if(ldns_buffer_remaining(c->buffer) <= 0) { if(sldns_buffer_remaining(c->buffer) <= 0) {
tcp_callback_reader(c); tcp_callback_reader(c);
} }
return 1; return 1;
@ -1108,7 +1108,7 @@ ssl_handle_write(struct comm_point* c)
/* ignore return, if fails we may simply block */ /* ignore return, if fails we may simply block */
(void)SSL_set_mode(c->ssl, SSL_MODE_ENABLE_PARTIAL_WRITE); (void)SSL_set_mode(c->ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
if(c->tcp_byte_count < sizeof(uint16_t)) { if(c->tcp_byte_count < sizeof(uint16_t)) {
uint16_t len = htons(ldns_buffer_limit(c->buffer)); uint16_t len = htons(sldns_buffer_limit(c->buffer));
ERR_clear_error(); ERR_clear_error();
r = SSL_write(c->ssl, r = SSL_write(c->ssl,
(void*)(((uint8_t*)&len)+c->tcp_byte_count), (void*)(((uint8_t*)&len)+c->tcp_byte_count),
@ -1135,17 +1135,17 @@ ssl_handle_write(struct comm_point* c)
c->tcp_byte_count += r; c->tcp_byte_count += r;
if(c->tcp_byte_count < sizeof(uint16_t)) if(c->tcp_byte_count < sizeof(uint16_t))
return 1; return 1;
ldns_buffer_set_position(c->buffer, c->tcp_byte_count - sldns_buffer_set_position(c->buffer, c->tcp_byte_count -
sizeof(uint16_t)); sizeof(uint16_t));
if(ldns_buffer_remaining(c->buffer) == 0) { if(sldns_buffer_remaining(c->buffer) == 0) {
tcp_callback_writer(c); tcp_callback_writer(c);
return 1; return 1;
} }
} }
log_assert(ldns_buffer_remaining(c->buffer) > 0); log_assert(sldns_buffer_remaining(c->buffer) > 0);
ERR_clear_error(); ERR_clear_error();
r = SSL_write(c->ssl, (void*)ldns_buffer_current(c->buffer), r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
(int)ldns_buffer_remaining(c->buffer)); (int)sldns_buffer_remaining(c->buffer));
if(r <= 0) { if(r <= 0) {
int want = SSL_get_error(c->ssl, r); int want = SSL_get_error(c->ssl, r);
if(want == SSL_ERROR_ZERO_RETURN) { if(want == SSL_ERROR_ZERO_RETURN) {
@ -1165,9 +1165,9 @@ ssl_handle_write(struct comm_point* c)
log_crypto_err("could not SSL_write"); log_crypto_err("could not SSL_write");
return 0; return 0;
} }
ldns_buffer_skip(c->buffer, (ssize_t)r); sldns_buffer_skip(c->buffer, (ssize_t)r);
if(ldns_buffer_remaining(c->buffer) == 0) { if(sldns_buffer_remaining(c->buffer) == 0) {
tcp_callback_writer(c); tcp_callback_writer(c);
} }
return 1; return 1;
@ -1205,7 +1205,7 @@ comm_point_tcp_handle_read(int fd, struct comm_point* c, int short_ok)
log_assert(fd != -1); log_assert(fd != -1);
if(c->tcp_byte_count < sizeof(uint16_t)) { if(c->tcp_byte_count < sizeof(uint16_t)) {
/* read length bytes */ /* read length bytes */
r = recv(fd,(void*)ldns_buffer_at(c->buffer,c->tcp_byte_count), r = recv(fd,(void*)sldns_buffer_at(c->buffer,c->tcp_byte_count),
sizeof(uint16_t)-c->tcp_byte_count, 0); sizeof(uint16_t)-c->tcp_byte_count, 0);
if(r == 0) if(r == 0)
return 0; return 0;
@ -1237,25 +1237,25 @@ comm_point_tcp_handle_read(int fd, struct comm_point* c, int short_ok)
c->tcp_byte_count += r; c->tcp_byte_count += r;
if(c->tcp_byte_count != sizeof(uint16_t)) if(c->tcp_byte_count != sizeof(uint16_t))
return 1; return 1;
if(ldns_buffer_read_u16_at(c->buffer, 0) > if(sldns_buffer_read_u16_at(c->buffer, 0) >
ldns_buffer_capacity(c->buffer)) { sldns_buffer_capacity(c->buffer)) {
verbose(VERB_QUERY, "tcp: dropped larger than buffer"); verbose(VERB_QUERY, "tcp: dropped larger than buffer");
return 0; return 0;
} }
ldns_buffer_set_limit(c->buffer, sldns_buffer_set_limit(c->buffer,
ldns_buffer_read_u16_at(c->buffer, 0)); sldns_buffer_read_u16_at(c->buffer, 0));
if(!short_ok && if(!short_ok &&
ldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) { sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
verbose(VERB_QUERY, "tcp: dropped bogus too short."); verbose(VERB_QUERY, "tcp: dropped bogus too short.");
return 0; return 0;
} }
verbose(VERB_ALGO, "Reading tcp query of length %d", verbose(VERB_ALGO, "Reading tcp query of length %d",
(int)ldns_buffer_limit(c->buffer)); (int)sldns_buffer_limit(c->buffer));
} }
log_assert(ldns_buffer_remaining(c->buffer) > 0); log_assert(sldns_buffer_remaining(c->buffer) > 0);
r = recv(fd, (void*)ldns_buffer_current(c->buffer), r = recv(fd, (void*)sldns_buffer_current(c->buffer),
ldns_buffer_remaining(c->buffer), 0); sldns_buffer_remaining(c->buffer), 0);
if(r == 0) { if(r == 0) {
return 0; return 0;
} else if(r == -1) { } else if(r == -1) {
@ -1279,8 +1279,8 @@ comm_point_tcp_handle_read(int fd, struct comm_point* c, int short_ok)
c->repinfo.addrlen); c->repinfo.addrlen);
return 0; return 0;
} }
ldns_buffer_skip(c->buffer, r); sldns_buffer_skip(c->buffer, r);
if(ldns_buffer_remaining(c->buffer) <= 0) { if(sldns_buffer_remaining(c->buffer) <= 0) {
tcp_callback_reader(c); tcp_callback_reader(c);
} }
return 1; return 1;
@ -1344,13 +1344,13 @@ comm_point_tcp_handle_write(int fd, struct comm_point* c)
return ssl_handle_it(c); return ssl_handle_it(c);
if(c->tcp_byte_count < sizeof(uint16_t)) { if(c->tcp_byte_count < sizeof(uint16_t)) {
uint16_t len = htons(ldns_buffer_limit(c->buffer)); uint16_t len = htons(sldns_buffer_limit(c->buffer));
#ifdef HAVE_WRITEV #ifdef HAVE_WRITEV
struct iovec iov[2]; struct iovec iov[2];
iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count; iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count;
iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count; iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count;
iov[1].iov_base = ldns_buffer_begin(c->buffer); iov[1].iov_base = sldns_buffer_begin(c->buffer);
iov[1].iov_len = ldns_buffer_limit(c->buffer); iov[1].iov_len = sldns_buffer_limit(c->buffer);
log_assert(iov[0].iov_len > 0); log_assert(iov[0].iov_len > 0);
log_assert(iov[1].iov_len > 0); log_assert(iov[1].iov_len > 0);
r = writev(fd, iov, 2); r = writev(fd, iov, 2);
@ -1386,16 +1386,16 @@ comm_point_tcp_handle_write(int fd, struct comm_point* c)
c->tcp_byte_count += r; c->tcp_byte_count += r;
if(c->tcp_byte_count < sizeof(uint16_t)) if(c->tcp_byte_count < sizeof(uint16_t))
return 1; return 1;
ldns_buffer_set_position(c->buffer, c->tcp_byte_count - sldns_buffer_set_position(c->buffer, c->tcp_byte_count -
sizeof(uint16_t)); sizeof(uint16_t));
if(ldns_buffer_remaining(c->buffer) == 0) { if(sldns_buffer_remaining(c->buffer) == 0) {
tcp_callback_writer(c); tcp_callback_writer(c);
return 1; return 1;
} }
} }
log_assert(ldns_buffer_remaining(c->buffer) > 0); log_assert(sldns_buffer_remaining(c->buffer) > 0);
r = send(fd, (void*)ldns_buffer_current(c->buffer), r = send(fd, (void*)sldns_buffer_current(c->buffer),
ldns_buffer_remaining(c->buffer), 0); sldns_buffer_remaining(c->buffer), 0);
if(r == -1) { if(r == -1) {
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
if(errno == EINTR || errno == EAGAIN) if(errno == EINTR || errno == EAGAIN)
@ -1415,9 +1415,9 @@ comm_point_tcp_handle_write(int fd, struct comm_point* c)
c->repinfo.addrlen); c->repinfo.addrlen);
return 0; return 0;
} }
ldns_buffer_skip(c->buffer, r); sldns_buffer_skip(c->buffer, r);
if(ldns_buffer_remaining(c->buffer) == 0) { if(sldns_buffer_remaining(c->buffer) == 0) {
tcp_callback_writer(c); tcp_callback_writer(c);
} }
@ -1500,7 +1500,7 @@ void comm_point_raw_handle_callback(int ATTR_UNUSED(fd),
} }
struct comm_point* struct comm_point*
comm_point_create_udp(struct comm_base *base, int fd, ldns_buffer* buffer, comm_point_create_udp(struct comm_base *base, int fd, sldns_buffer* buffer,
comm_point_callback_t* callback, void* callback_arg) comm_point_callback_t* callback, void* callback_arg)
{ {
struct comm_point* c = (struct comm_point*)calloc(1, struct comm_point* c = (struct comm_point*)calloc(1,
@ -1550,7 +1550,7 @@ comm_point_create_udp(struct comm_base *base, int fd, ldns_buffer* buffer,
struct comm_point* struct comm_point*
comm_point_create_udp_ancil(struct comm_base *base, int fd, comm_point_create_udp_ancil(struct comm_base *base, int fd,
ldns_buffer* buffer, sldns_buffer* buffer,
comm_point_callback_t* callback, void* callback_arg) comm_point_callback_t* callback, void* callback_arg)
{ {
struct comm_point* c = (struct comm_point*)calloc(1, struct comm_point* c = (struct comm_point*)calloc(1,
@ -1616,7 +1616,7 @@ comm_point_create_tcp_handler(struct comm_base *base,
} }
c->ev->base = base; c->ev->base = base;
c->fd = -1; c->fd = -1;
c->buffer = ldns_buffer_new(bufsize); c->buffer = sldns_buffer_new(bufsize);
if(!c->buffer) { if(!c->buffer) {
free(c->ev); free(c->ev);
free(c); free(c);
@ -1624,7 +1624,7 @@ comm_point_create_tcp_handler(struct comm_base *base,
} }
c->timeout = (struct timeval*)malloc(sizeof(struct timeval)); c->timeout = (struct timeval*)malloc(sizeof(struct timeval));
if(!c->timeout) { if(!c->timeout) {
ldns_buffer_free(c->buffer); sldns_buffer_free(c->buffer);
free(c->ev); free(c->ev);
free(c); free(c);
return NULL; return NULL;
@ -1741,7 +1741,7 @@ comm_point_create_tcp_out(struct comm_base *base, size_t bufsize,
} }
c->ev->base = base; c->ev->base = base;
c->fd = -1; c->fd = -1;
c->buffer = ldns_buffer_new(bufsize); c->buffer = sldns_buffer_new(bufsize);
if(!c->buffer) { if(!c->buffer) {
free(c->ev); free(c->ev);
free(c); free(c);
@ -1767,7 +1767,7 @@ comm_point_create_tcp_out(struct comm_base *base, size_t bufsize,
if(event_base_set(base->eb->base, &c->ev->ev) != 0) if(event_base_set(base->eb->base, &c->ev->ev) != 0)
{ {
log_err("could not basetset tcpout event"); log_err("could not basetset tcpout event");
ldns_buffer_free(c->buffer); sldns_buffer_free(c->buffer);
free(c->ev); free(c->ev);
free(c); free(c);
return NULL; return NULL;
@ -1793,7 +1793,7 @@ comm_point_create_local(struct comm_base *base, int fd, size_t bufsize,
} }
c->ev->base = base; c->ev->base = base;
c->fd = fd; c->fd = fd;
c->buffer = ldns_buffer_new(bufsize); c->buffer = sldns_buffer_new(bufsize);
if(!c->buffer) { if(!c->buffer) {
free(c->ev); free(c->ev);
free(c); free(c);
@ -1918,7 +1918,7 @@ comm_point_delete(struct comm_point* c)
} }
free(c->timeout); free(c->timeout);
if(c->type == comm_tcp || c->type == comm_local) if(c->type == comm_tcp || c->type == comm_local)
ldns_buffer_free(c->buffer); sldns_buffer_free(c->buffer);
free(c->ev); free(c->ev);
free(c); free(c);
} }
@ -2030,7 +2030,7 @@ size_t comm_point_get_mem(struct comm_point* c)
if(c->timeout) if(c->timeout)
s += sizeof(*c->timeout); s += sizeof(*c->timeout);
if(c->type == comm_tcp || c->type == comm_local) if(c->type == comm_tcp || c->type == comm_local)
s += sizeof(*c->buffer) + ldns_buffer_capacity(c->buffer); s += sizeof(*c->buffer) + sldns_buffer_capacity(c->buffer);
if(c->type == comm_tcp_accept) { if(c->type == comm_tcp_accept) {
int i; int i;
for(i=0; i<c->max_tcp_count; i++) for(i=0; i<c->max_tcp_count; i++)

10
util/netevent.h
View file

@ -60,7 +60,7 @@
#ifndef NET_EVENT_H #ifndef NET_EVENT_H
#define NET_EVENT_H #define NET_EVENT_H
struct ldns_buffer; struct sldns_buffer;
struct comm_point; struct comm_point;
struct comm_reply; struct comm_reply;
struct event_base; struct event_base;
@ -149,7 +149,7 @@ struct comm_point {
struct timeval* timeout; struct timeval* timeout;
/** buffer pointer. Either to perthread, or own buffer or NULL */ /** buffer pointer. Either to perthread, or own buffer or NULL */
struct ldns_buffer* buffer; struct sldns_buffer* buffer;
/* -------- TCP Handler -------- */ /* -------- TCP Handler -------- */
/** Read/Write state for TCP */ /** Read/Write state for TCP */
@ -367,7 +367,7 @@ struct event_base* comm_base_internal(struct comm_base* b);
* Sets timeout to NULL. Turns off TCP options. * Sets timeout to NULL. Turns off TCP options.
*/ */
struct comm_point* comm_point_create_udp(struct comm_base* base, struct comm_point* comm_point_create_udp(struct comm_base* base,
int fd, struct ldns_buffer* buffer, int fd, struct sldns_buffer* buffer,
comm_point_callback_t* callback, void* callback_arg); comm_point_callback_t* callback, void* callback_arg);
/** /**
@ -383,7 +383,7 @@ struct comm_point* comm_point_create_udp(struct comm_base* base,
* Sets timeout to NULL. Turns off TCP options. * Sets timeout to NULL. Turns off TCP options.
*/ */
struct comm_point* comm_point_create_udp_ancil(struct comm_base* base, struct comm_point* comm_point_create_udp_ancil(struct comm_base* base,
int fd, struct ldns_buffer* buffer, int fd, struct sldns_buffer* buffer,
comm_point_callback_t* callback, void* callback_arg); comm_point_callback_t* callback, void* callback_arg);
/** /**
@ -477,7 +477,7 @@ void comm_point_drop_reply(struct comm_reply* repinfo);
* @param addrlen: length of addr. * @param addrlen: length of addr.
* @return: false on a failure. * @return: false on a failure.
*/ */
int comm_point_send_udp_msg(struct comm_point* c, struct ldns_buffer* packet, int comm_point_send_udp_msg(struct comm_point* c, struct sldns_buffer* packet,
struct sockaddr* addr, socklen_t addrlen); struct sockaddr* addr, socklen_t addrlen);
/** /**

102
validator/autotrust.c
View file

@ -144,10 +144,10 @@ verbose_key(struct autr_ta* ta, enum verbosity_value level,
va_list args; va_list args;
va_start(args, format); va_start(args, format);
if(verbosity >= level) { if(verbosity >= level) {
char* str = ldns_wire2str_dname(ta->rr, ta->dname_len); char* str = sldns_wire2str_dname(ta->rr, ta->dname_len);
int keytag = (int)ldns_calc_keytag_raw(ldns_wirerr_get_rdata( int keytag = (int)sldns_calc_keytag_raw(sldns_wirerr_get_rdata(
ta->rr, ta->rr_len, ta->dname_len), ta->rr, ta->rr_len, ta->dname_len),
ldns_wirerr_get_rdatalen(ta->rr, ta->rr_len, sldns_wirerr_get_rdatalen(ta->rr, ta->rr_len,
ta->dname_len)); ta->dname_len));
char msg[MAXSYSLOGMSGLEN]; char msg[MAXSYSLOGMSGLEN];
vsnprintf(msg, sizeof(msg), format, args); vsnprintf(msg, sizeof(msg), format, args);
@ -299,9 +299,9 @@ static int
ta_is_dnskey_sep(struct autr_ta* ta) ta_is_dnskey_sep(struct autr_ta* ta)
{ {
return (dnskey_flags( return (dnskey_flags(
ldns_wirerr_get_type(ta->rr, ta->rr_len, ta->dname_len), sldns_wirerr_get_type(ta->rr, ta->rr_len, ta->dname_len),
ldns_wirerr_get_rdata(ta->rr, ta->rr_len, ta->dname_len), sldns_wirerr_get_rdata(ta->rr, ta->rr_len, ta->dname_len),
ldns_wirerr_get_rdatalen(ta->rr, ta->rr_len, ta->dname_len) sldns_wirerr_get_rdatalen(ta->rr, ta->rr_len, ta->dname_len)
) & DNSKEY_BIT_SEP); ) & DNSKEY_BIT_SEP);
} }
@ -419,7 +419,7 @@ find_add_tp(struct val_anchors* anchors, uint8_t* rr, size_t rr_len,
{ {
struct trust_anchor* tp; struct trust_anchor* tp;
tp = anchor_find(anchors, rr, dname_count_labels(rr), dname_len, tp = anchor_find(anchors, rr, dname_count_labels(rr), dname_len,
ldns_wirerr_get_class(rr, rr_len, dname_len)); sldns_wirerr_get_class(rr, rr_len, dname_len));
if(tp) { if(tp) {
if(!tp->autr) { if(!tp->autr) {
log_err("anchor cannot be with and without autotrust"); log_err("anchor cannot be with and without autotrust");
@ -428,7 +428,7 @@ find_add_tp(struct val_anchors* anchors, uint8_t* rr, size_t rr_len,
} }
return tp; return tp;
} }
tp = autr_tp_create(anchors, rr, dname_len, ldns_wirerr_get_class(rr, tp = autr_tp_create(anchors, rr, dname_len, sldns_wirerr_get_class(rr,
rr_len, dname_len)); rr_len, dname_len));
lock_basic_lock(&tp->lock); lock_basic_lock(&tp->lock);
return tp; return tp;
@ -480,12 +480,12 @@ add_trustanchor_frm_str(struct val_anchors* anchors, char* str,
*skip = 1; *skip = 1;
return NULL; /* empty line */ return NULL; /* empty line */
} }
if(0 != (lstatus = ldns_str2wire_rr_buf(str, rr, &rr_len, &dname_len, if(0 != (lstatus = sldns_str2wire_rr_buf(str, rr, &rr_len, &dname_len,
0, origin, origin_len, *prev, *prev_len))) 0, origin, origin_len, *prev, *prev_len)))
{ {
log_err("ldns error while converting string to RR at%d: %s: %s", log_err("ldns error while converting string to RR at%d: %s: %s",
LDNS_WIREPARSE_OFFSET(lstatus), LDNS_WIREPARSE_OFFSET(lstatus),
ldns_get_errorstr_parse(lstatus), str); sldns_get_errorstr_parse(lstatus), str);
return NULL; return NULL;
} }
free(*prev); free(*prev);
@ -495,8 +495,8 @@ add_trustanchor_frm_str(struct val_anchors* anchors, char* str,
log_err("malloc failure in add_trustanchor"); log_err("malloc failure in add_trustanchor");
return NULL; return NULL;
} }
if(ldns_wirerr_get_type(rr, rr_len, dname_len)!=LDNS_RR_TYPE_DNSKEY && if(sldns_wirerr_get_type(rr, rr_len, dname_len)!=LDNS_RR_TYPE_DNSKEY &&
ldns_wirerr_get_type(rr, rr_len, dname_len)!=LDNS_RR_TYPE_DS) { sldns_wirerr_get_type(rr, rr_len, dname_len)!=LDNS_RR_TYPE_DS) {
*skip = 1; *skip = 1;
return NULL; /* only DS and DNSKEY allowed */ return NULL; /* only DS and DNSKEY allowed */
} }
@ -555,7 +555,7 @@ assemble_iterate_ds(struct autr_ta** list, uint8_t** rr, size_t* rr_len,
size_t* dname_len) size_t* dname_len)
{ {
while(*list) { while(*list) {
if(ldns_wirerr_get_type((*list)->rr, (*list)->rr_len, if(sldns_wirerr_get_type((*list)->rr, (*list)->rr_len,
(*list)->dname_len) == LDNS_RR_TYPE_DS) { (*list)->dname_len) == LDNS_RR_TYPE_DS) {
*rr = (*list)->rr; *rr = (*list)->rr;
*rr_len = (*list)->rr_len; *rr_len = (*list)->rr_len;
@ -574,7 +574,7 @@ assemble_iterate_dnskey(struct autr_ta** list, uint8_t** rr, size_t* rr_len,
size_t* dname_len) size_t* dname_len)
{ {
while(*list) { while(*list) {
if(ldns_wirerr_get_type((*list)->rr, (*list)->rr_len, if(sldns_wirerr_get_type((*list)->rr, (*list)->rr_len,
(*list)->dname_len) != LDNS_RR_TYPE_DS && (*list)->dname_len) != LDNS_RR_TYPE_DS &&
((*list)->s == AUTR_STATE_VALID || ((*list)->s == AUTR_STATE_VALID ||
(*list)->s == AUTR_STATE_MISSING)) { (*list)->s == AUTR_STATE_MISSING)) {
@ -633,8 +633,8 @@ ub_packed_rrset_heap_key(int iter(struct autr_ta**, uint8_t**, size_t*,
k = (struct ub_packed_rrset_key*)calloc(1, sizeof(*k)); k = (struct ub_packed_rrset_key*)calloc(1, sizeof(*k));
if(!k) if(!k)
return NULL; return NULL;
k->rk.type = htons(ldns_wirerr_get_type(rr, rr_len, dname_len)); k->rk.type = htons(sldns_wirerr_get_type(rr, rr_len, dname_len));
k->rk.rrset_class = htons(ldns_wirerr_get_class(rr, rr_len, dname_len)); k->rk.rrset_class = htons(sldns_wirerr_get_class(rr, rr_len, dname_len));
k->rk.dname_len = dname_len; k->rk.dname_len = dname_len;
k->rk.dname = memdup(rr, dname_len); k->rk.dname = memdup(rr, dname_len);
if(!k->rk.dname) { if(!k->rk.dname) {
@ -664,13 +664,13 @@ packed_rrset_heap_data(int iter(struct autr_ta**, uint8_t**, size_t*,
list_i = list; list_i = list;
while(iter(&list_i, &rr, &rr_len, &dname_len)) { while(iter(&list_i, &rr, &rr_len, &dname_len)) {
if(ldns_wirerr_get_type(rr, rr_len, dname_len) == if(sldns_wirerr_get_type(rr, rr_len, dname_len) ==
LDNS_RR_TYPE_RRSIG) LDNS_RR_TYPE_RRSIG)
rrsig_count++; rrsig_count++;
else count++; else count++;
/* sizeof the rdlength + rdatalen */ /* sizeof the rdlength + rdatalen */
len += 2 + ldns_wirerr_get_rdatalen(rr, rr_len, dname_len); len += 2 + sldns_wirerr_get_rdatalen(rr, rr_len, dname_len);
ttl = (time_t)ldns_wirerr_get_ttl(rr, rr_len, dname_len); ttl = (time_t)sldns_wirerr_get_ttl(rr, rr_len, dname_len);
} }
if(count == 0 && rrsig_count == 0) if(count == 0 && rrsig_count == 0)
return NULL; return NULL;
@ -697,12 +697,12 @@ packed_rrset_heap_data(int iter(struct autr_ta**, uint8_t**, size_t*,
list_i = list; list_i = list;
i = 0; i = 0;
while(iter(&list_i, &rr, &rr_len, &dname_len)) { while(iter(&list_i, &rr, &rr_len, &dname_len)) {
data->rr_ttl[i] = (time_t)ldns_wirerr_get_ttl(rr, rr_len, data->rr_ttl[i] = (time_t)sldns_wirerr_get_ttl(rr, rr_len,
dname_len); dname_len);
if(data->rr_ttl[i] < data->ttl) if(data->rr_ttl[i] < data->ttl)
data->ttl = data->rr_ttl[i]; data->ttl = data->rr_ttl[i];
data->rr_len[i] = 2 /* the rdlength */ + data->rr_len[i] = 2 /* the rdlength */ +
ldns_wirerr_get_rdatalen(rr, rr_len, dname_len); sldns_wirerr_get_rdatalen(rr, rr_len, dname_len);
i++; i++;
} }
@ -717,7 +717,7 @@ packed_rrset_heap_data(int iter(struct autr_ta**, uint8_t**, size_t*,
i = 0; i = 0;
while(iter(&list_i, &rr, &rr_len, &dname_len)) { while(iter(&list_i, &rr, &rr_len, &dname_len)) {
memmove(data->rr_data[i], memmove(data->rr_data[i],
ldns_wirerr_get_rdatawl(rr, rr_len, dname_len), sldns_wirerr_get_rdatawl(rr, rr_len, dname_len),
data->rr_len[i]); data->rr_len[i]);
i++; i++;
} }
@ -732,7 +732,7 @@ packed_rrset_heap_data(int iter(struct autr_ta**, uint8_t**, size_t*,
/** /**
* Assemble the trust anchors into DS and DNSKEY packed rrsets. * Assemble the trust anchors into DS and DNSKEY packed rrsets.
* Uses only VALID and MISSING DNSKEYs. * Uses only VALID and MISSING DNSKEYs.
* Read the ldns_rrs and builds packed rrsets * Read the sldns_rrs and builds packed rrsets
* @param tp: the trust point. Must be locked. * @param tp: the trust point. Must be locked.
* @return false on malloc failure. * @return false on malloc failure.
*/ */
@ -817,7 +817,7 @@ parse_id(struct val_anchors* anchors, char* line)
if(!next) if(!next)
return NULL; return NULL;
next[0] = 0; next[0] = 0;
dname = ldns_str2wire_dname(line, &dname_len); dname = sldns_str2wire_dname(line, &dname_len);
if(!dname) if(!dname)
return NULL; return NULL;
@ -910,7 +910,7 @@ handle_origin(char* line, uint8_t** origin, size_t* origin_len)
line += 7; line += 7;
while(isspace((int)*line)) while(isspace((int)*line))
line++; line++;
*origin = ldns_str2wire_dname(line, &len); *origin = sldns_str2wire_dname(line, &len);
*origin_len = len; *origin_len = len;
if(!*origin) if(!*origin)
log_warn("malloc failure or parse error in $ORIGIN"); log_warn("malloc failure or parse error in $ORIGIN");
@ -1079,7 +1079,7 @@ trustanchor_state2str(autr_state_t s)
static int static int
print_id(FILE* out, char* fname, uint8_t* nm, size_t nmlen, uint16_t dclass) print_id(FILE* out, char* fname, uint8_t* nm, size_t nmlen, uint16_t dclass)
{ {
char* s = ldns_wire2str_dname(nm, nmlen); char* s = sldns_wire2str_dname(nm, nmlen);
if(!s) { if(!s) {
log_err("malloc failure in write to %s", fname); log_err("malloc failure in write to %s", fname);
return 0; return 0;
@ -1144,10 +1144,10 @@ autr_write_contents(FILE* out, char* fn, struct trust_anchor* tp)
if(ta->s == AUTR_STATE_REMOVED) if(ta->s == AUTR_STATE_REMOVED)
continue; continue;
/* only store keys */ /* only store keys */
if(ldns_wirerr_get_type(ta->rr, ta->rr_len, ta->dname_len) if(sldns_wirerr_get_type(ta->rr, ta->rr_len, ta->dname_len)
!= LDNS_RR_TYPE_DNSKEY) != LDNS_RR_TYPE_DNSKEY)
continue; continue;
str = ldns_wire2str_rr(ta->rr, ta->rr_len); str = sldns_wire2str_rr(ta->rr, ta->rr_len);
if(!str || !str[0]) { if(!str || !str[0]) {
free(str); free(str);
log_err("malloc failure writing %s", fn); log_err("malloc failure writing %s", fn);
@ -1238,7 +1238,7 @@ rrsig_get_expiry(uint8_t* d, size_t len)
/* rrsig: 2(rdlen), 2(type) 1(alg) 1(v) 4(origttl), then 4(expi), (4)incep) */ /* rrsig: 2(rdlen), 2(type) 1(alg) 1(v) 4(origttl), then 4(expi), (4)incep) */
if(len < 2+8+4) if(len < 2+8+4)
return 0; return 0;
return ldns_read_uint32(d+2+8); return sldns_read_uint32(d+2+8);
} }
/** Find minimum expiration interval from signatures */ /** Find minimum expiration interval from signatures */
@ -1296,18 +1296,18 @@ revoke_dnskey(struct autr_ta* ta, int off)
{ {
uint16_t flags; uint16_t flags;
uint8_t* data; uint8_t* data;
if(ldns_wirerr_get_type(ta->rr, ta->rr_len, ta->dname_len) != if(sldns_wirerr_get_type(ta->rr, ta->rr_len, ta->dname_len) !=
LDNS_RR_TYPE_DNSKEY) LDNS_RR_TYPE_DNSKEY)
return; return;
if(ldns_wirerr_get_rdatalen(ta->rr, ta->rr_len, ta->dname_len) < 2) if(sldns_wirerr_get_rdatalen(ta->rr, ta->rr_len, ta->dname_len) < 2)
return; return;
data = ldns_wirerr_get_rdata(ta->rr, ta->rr_len, ta->dname_len); data = sldns_wirerr_get_rdata(ta->rr, ta->rr_len, ta->dname_len);
flags = ldns_read_uint16(data); flags = sldns_read_uint16(data);
if (off && (flags&LDNS_KEY_REVOKE_KEY)) if (off && (flags&LDNS_KEY_REVOKE_KEY))
flags ^= LDNS_KEY_REVOKE_KEY; /* flip */ flags ^= LDNS_KEY_REVOKE_KEY; /* flip */
else else
flags |= LDNS_KEY_REVOKE_KEY; flags |= LDNS_KEY_REVOKE_KEY;
ldns_write_uint16(data, flags); sldns_write_uint16(data, flags);
} }
/** Compare two RRs skipping the REVOKED bit. Pass rdata(no len) */ /** Compare two RRs skipping the REVOKED bit. Pass rdata(no len) */
@ -1341,20 +1341,20 @@ ta_compare(struct autr_ta* a, uint16_t t, uint8_t* b, size_t b_len)
{ {
if(!a) return -1; if(!a) return -1;
else if(!b) return -1; else if(!b) return -1;
else if(ldns_wirerr_get_type(a->rr, a->rr_len, a->dname_len) != t) else if(sldns_wirerr_get_type(a->rr, a->rr_len, a->dname_len) != t)
return (int)ldns_wirerr_get_type(a->rr, a->rr_len, return (int)sldns_wirerr_get_type(a->rr, a->rr_len,
a->dname_len) - (int)t; a->dname_len) - (int)t;
else if(t == LDNS_RR_TYPE_DNSKEY) { else if(t == LDNS_RR_TYPE_DNSKEY) {
return dnskey_compare_skip_revbit( return dnskey_compare_skip_revbit(
ldns_wirerr_get_rdata(a->rr, a->rr_len, a->dname_len), sldns_wirerr_get_rdata(a->rr, a->rr_len, a->dname_len),
ldns_wirerr_get_rdatalen(a->rr, a->rr_len, sldns_wirerr_get_rdatalen(a->rr, a->rr_len,
a->dname_len), b, b_len); a->dname_len), b, b_len);
} }
else if(t == LDNS_RR_TYPE_DS) { else if(t == LDNS_RR_TYPE_DS) {
if(ldns_wirerr_get_rdatalen(a->rr, a->rr_len, a->dname_len) != if(sldns_wirerr_get_rdatalen(a->rr, a->rr_len, a->dname_len) !=
b_len) b_len)
return -1; return -1;
return memcmp(ldns_wirerr_get_rdata(a->rr, return memcmp(sldns_wirerr_get_rdata(a->rr,
a->rr_len, a->dname_len), b, b_len); a->rr_len, a->dname_len), b, b_len);
} }
return -1; return -1;
@ -1507,14 +1507,14 @@ check_contains_revoked(struct module_env* env, struct val_env* ve,
/* same keytag, but stored can be revoked already, so /* same keytag, but stored can be revoked already, so
* compare keytags, with +0 or +128(REVOKE flag) */ * compare keytags, with +0 or +128(REVOKE flag) */
log_assert(dnskey_calc_keytag(dnskey_rrset, i)-128 == log_assert(dnskey_calc_keytag(dnskey_rrset, i)-128 ==
ldns_calc_keytag_raw(ldns_wirerr_get_rdata( sldns_calc_keytag_raw(sldns_wirerr_get_rdata(
ta->rr, ta->rr_len, ta->dname_len), ta->rr, ta->rr_len, ta->dname_len),
ldns_wirerr_get_rdatalen(ta->rr, ta->rr_len, sldns_wirerr_get_rdatalen(ta->rr, ta->rr_len,
ta->dname_len)) || ta->dname_len)) ||
dnskey_calc_keytag(dnskey_rrset, i) == dnskey_calc_keytag(dnskey_rrset, i) ==
ldns_calc_keytag_raw(ldns_wirerr_get_rdata( sldns_calc_keytag_raw(sldns_wirerr_get_rdata(
ta->rr, ta->rr_len, ta->dname_len), ta->rr, ta->rr_len, ta->dname_len),
ldns_wirerr_get_rdatalen(ta->rr, ta->rr_len, sldns_wirerr_get_rdatalen(ta->rr, ta->rr_len,
ta->dname_len))); /* checks conversion*/ ta->dname_len))); /* checks conversion*/
verbose_key(ta, VERB_ALGO, "is self-signed revoked"); verbose_key(ta, VERB_ALGO, "is self-signed revoked");
if(!ta->revoked) if(!ta->revoked)
@ -1808,7 +1808,7 @@ init_zsk_to_ksk(struct module_env* env, struct trust_anchor* tp, int* changed)
int validksk = 0; int validksk = 0;
for(anchor = tp->autr->keys; anchor; anchor = anchor->next) { for(anchor = tp->autr->keys; anchor; anchor = anchor->next) {
/* last_change test makes sure it was manually configured */ /* last_change test makes sure it was manually configured */
if(ldns_wirerr_get_type(anchor->rr, anchor->rr_len, if(sldns_wirerr_get_type(anchor->rr, anchor->rr_len,
anchor->dname_len) == LDNS_RR_TYPE_DNSKEY && anchor->dname_len) == LDNS_RR_TYPE_DNSKEY &&
anchor->last_change == 0 && anchor->last_change == 0 &&
!ta_is_dnskey_sep(anchor) && !ta_is_dnskey_sep(anchor) &&
@ -1929,7 +1929,7 @@ autr_cleanup_keys(struct trust_anchor* tp)
while(p) { while(p) {
/* do we want to remove this key? */ /* do we want to remove this key? */
if(p->s == AUTR_STATE_START || p->s == AUTR_STATE_REMOVED || if(p->s == AUTR_STATE_START || p->s == AUTR_STATE_REMOVED ||
ldns_wirerr_get_type(p->rr, p->rr_len, p->dname_len) sldns_wirerr_get_type(p->rr, p->rr_len, p->dname_len)
!= LDNS_RR_TYPE_DNSKEY) { != LDNS_RR_TYPE_DNSKEY) {
struct autr_ta* np = p->next; struct autr_ta* np = p->next;
/* remove */ /* remove */
@ -2205,7 +2205,7 @@ static void
autr_debug_print_ta(struct autr_ta* ta) autr_debug_print_ta(struct autr_ta* ta)
{ {
char buf[32]; char buf[32];
char* str = ldns_wire2str_rr(ta->rr, ta->rr_len); char* str = sldns_wire2str_rr(ta->rr, ta->rr_len);
if(!str) { if(!str) {
log_info("out of memory in debug_print_ta"); log_info("out of memory in debug_print_ta");
return; return;
@ -2271,7 +2271,7 @@ autr_debug_print(struct val_anchors* anchors)
} }
void probe_answer_cb(void* arg, int ATTR_UNUSED(rcode), void probe_answer_cb(void* arg, int ATTR_UNUSED(rcode),
ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(sec), sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(sec),
char* ATTR_UNUSED(why_bogus)) char* ATTR_UNUSED(why_bogus))
{ {
/* retry was set before the query was done, /* retry was set before the query was done,
@ -2296,7 +2296,7 @@ probe_anchor(struct module_env* env, struct trust_anchor* tp)
struct query_info qinfo; struct query_info qinfo;
uint16_t qflags = BIT_RD; uint16_t qflags = BIT_RD;
struct edns_data edns; struct edns_data edns;
ldns_buffer* buf = env->scratch_buffer; sldns_buffer* buf = env->scratch_buffer;
qinfo.qname = regional_alloc_init(env->scratch, tp->name, tp->namelen); qinfo.qname = regional_alloc_init(env->scratch, tp->name, tp->namelen);
if(!qinfo.qname) { if(!qinfo.qname) {
log_err("out of memory making 5011 probe"); log_err("out of memory making 5011 probe");
@ -2312,8 +2312,8 @@ probe_anchor(struct module_env* env, struct trust_anchor* tp)
edns.ext_rcode = 0; edns.ext_rcode = 0;
edns.edns_version = 0; edns.edns_version = 0;
edns.bits = EDNS_DO; edns.bits = EDNS_DO;
if(ldns_buffer_capacity(buf) < 65535) if(sldns_buffer_capacity(buf) < 65535)
edns.udp_size = (uint16_t)ldns_buffer_capacity(buf); edns.udp_size = (uint16_t)sldns_buffer_capacity(buf);
else edns.udp_size = 65535; else edns.udp_size = 65535;
/* can't hold the lock while mesh_run is processing */ /* can't hold the lock while mesh_run is processing */

4
validator/autotrust.h
View file

@ -48,7 +48,7 @@ struct trust_anchor;
struct ub_packed_rrset_key; struct ub_packed_rrset_key;
struct module_env; struct module_env;
struct val_env; struct val_env;
struct ldns_buffer; struct sldns_buffer;
/** Autotrust anchor states */ /** Autotrust anchor states */
typedef enum { typedef enum {
@ -202,7 +202,7 @@ int autr_process_prime(struct module_env* env, struct val_env* ve,
void autr_debug_print(struct val_anchors* anchors); void autr_debug_print(struct val_anchors* anchors);
/** callback for query answer to 5011 probe */ /** callback for query answer to 5011 probe */
void probe_answer_cb(void* arg, int rcode, struct ldns_buffer* buf, void probe_answer_cb(void* arg, int rcode, struct sldns_buffer* buf,
enum sec_status sec, char* errinf); enum sec_status sec, char* errinf);
#endif /* VALIDATOR_AUTOTRUST_H */ #endif /* VALIDATOR_AUTOTRUST_H */

140
validator/val_anchor.c
View file

@ -358,15 +358,15 @@ anchor_store_new_rr(struct val_anchors* anchors, uint8_t* rr, size_t rl,
{ {
struct trust_anchor* ta; struct trust_anchor* ta;
if(!(ta=anchor_store_new_key(anchors, rr, if(!(ta=anchor_store_new_key(anchors, rr,
ldns_wirerr_get_type(rr, rl, dl), sldns_wirerr_get_type(rr, rl, dl),
ldns_wirerr_get_class(rr, rl, dl), sldns_wirerr_get_class(rr, rl, dl),
ldns_wirerr_get_rdatawl(rr, rl, dl), sldns_wirerr_get_rdatawl(rr, rl, dl),
ldns_wirerr_get_rdatalen(rr, rl, dl)+2))) { sldns_wirerr_get_rdatalen(rr, rl, dl)+2))) {
return NULL; return NULL;
} }
log_nametypeclass(VERB_QUERY, "adding trusted key", log_nametypeclass(VERB_QUERY, "adding trusted key",
rr, ldns_wirerr_get_type(rr, rl, dl), rr, sldns_wirerr_get_type(rr, rl, dl),
ldns_wirerr_get_class(rr, rl, dl)); sldns_wirerr_get_class(rr, rl, dl));
return ta; return ta;
} }
@ -381,7 +381,7 @@ anchor_insert_insecure(struct val_anchors* anchors, const char* str)
{ {
struct trust_anchor* ta; struct trust_anchor* ta;
size_t dname_len = 0; size_t dname_len = 0;
uint8_t* nm = ldns_str2wire_dname(str, &dname_len); uint8_t* nm = sldns_str2wire_dname(str, &dname_len);
if(!nm) { if(!nm) {
log_err("parse error in domain name '%s'", str); log_err("parse error in domain name '%s'", str);
return NULL; return NULL;
@ -393,18 +393,18 @@ anchor_insert_insecure(struct val_anchors* anchors, const char* str)
} }
struct trust_anchor* struct trust_anchor*
anchor_store_str(struct val_anchors* anchors, ldns_buffer* buffer, anchor_store_str(struct val_anchors* anchors, sldns_buffer* buffer,
const char* str) const char* str)
{ {
struct trust_anchor* ta; struct trust_anchor* ta;
uint8_t* rr = ldns_buffer_begin(buffer); uint8_t* rr = sldns_buffer_begin(buffer);
size_t len = ldns_buffer_capacity(buffer), dname_len = 0; size_t len = sldns_buffer_capacity(buffer), dname_len = 0;
int status = ldns_str2wire_rr_buf(str, rr, &len, &dname_len, int status = sldns_str2wire_rr_buf(str, rr, &len, &dname_len,
0, NULL, 0, NULL, 0); 0, NULL, 0, NULL, 0);
if(status != 0) { if(status != 0) {
log_err("error parsing trust anchor %s: at %d: %s", log_err("error parsing trust anchor %s: at %d: %s",
str, LDNS_WIREPARSE_OFFSET(status), str, LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status)); sldns_get_errorstr_parse(status));
return NULL; return NULL;
} }
if(!(ta=anchor_store_new_rr(anchors, rr, len, dname_len))) { if(!(ta=anchor_store_new_rr(anchors, rr, len, dname_len))) {
@ -423,14 +423,14 @@ anchor_store_str(struct val_anchors* anchors, ldns_buffer* buffer,
* @return NULL on error. Else last trust-anchor point. * @return NULL on error. Else last trust-anchor point.
*/ */
static struct trust_anchor* static struct trust_anchor*
anchor_read_file(struct val_anchors* anchors, ldns_buffer* buffer, anchor_read_file(struct val_anchors* anchors, sldns_buffer* buffer,
const char* fname, int onlyone) const char* fname, int onlyone)
{ {
struct trust_anchor* ta = NULL, *tanew; struct trust_anchor* ta = NULL, *tanew;
struct ldns_file_parse_state pst; struct sldns_file_parse_state pst;
int status; int status;
size_t len, dname_len; size_t len, dname_len;
uint8_t* rr = ldns_buffer_begin(buffer); uint8_t* rr = sldns_buffer_begin(buffer);
int ok = 1; int ok = 1;
FILE* in = fopen(fname, "r"); FILE* in = fopen(fname, "r");
if(!in) { if(!in) {
@ -441,20 +441,20 @@ anchor_read_file(struct val_anchors* anchors, ldns_buffer* buffer,
pst.default_ttl = 3600; pst.default_ttl = 3600;
pst.lineno = 1; pst.lineno = 1;
while(!feof(in)) { while(!feof(in)) {
len = ldns_buffer_capacity(buffer); len = sldns_buffer_capacity(buffer);
dname_len = 0; dname_len = 0;
status = ldns_fp2wire_rr_buf(in, rr, &len, &dname_len, &pst); status = sldns_fp2wire_rr_buf(in, rr, &len, &dname_len, &pst);
if(len == 0) /* empty, $TTL, $ORIGIN */ if(len == 0) /* empty, $TTL, $ORIGIN */
continue; continue;
if(status != 0) { if(status != 0) {
log_err("parse error in %s:%d:%d : %s", fname, log_err("parse error in %s:%d:%d : %s", fname,
pst.lineno, LDNS_WIREPARSE_OFFSET(status), pst.lineno, LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status)); sldns_get_errorstr_parse(status));
ok = 0; ok = 0;
break; break;
} }
if(ldns_wirerr_get_type(rr, len, dname_len) != if(sldns_wirerr_get_type(rr, len, dname_len) !=
LDNS_RR_TYPE_DS && ldns_wirerr_get_type(rr, len, LDNS_RR_TYPE_DS && sldns_wirerr_get_type(rr, len,
dname_len) != LDNS_RR_TYPE_DNSKEY) { dname_len) != LDNS_RR_TYPE_DNSKEY) {
continue; continue;
} }
@ -527,7 +527,7 @@ is_bind_special(int c)
* 0 on end of file. * 0 on end of file.
*/ */
static int static int
readkeyword_bindfile(FILE* in, ldns_buffer* buf, int* line, int comments) readkeyword_bindfile(FILE* in, sldns_buffer* buf, int* line, int comments)
{ {
int c; int c;
int numdone = 0; int numdone = 0;
@ -537,17 +537,17 @@ readkeyword_bindfile(FILE* in, ldns_buffer* buf, int* line, int comments)
(*line)++; (*line)++;
continue; continue;
} else if(comments && c=='/' && numdone>0 && /* /_/ bla*/ } else if(comments && c=='/' && numdone>0 && /* /_/ bla*/
ldns_buffer_read_u8_at(buf, sldns_buffer_read_u8_at(buf,
ldns_buffer_position(buf)-1) == '/') { sldns_buffer_position(buf)-1) == '/') {
ldns_buffer_skip(buf, -1); sldns_buffer_skip(buf, -1);
numdone--; numdone--;
skip_to_eol(in); skip_to_eol(in);
(*line)++; (*line)++;
continue; continue;
} else if(comments && c=='*' && numdone>0 && /* /_* bla *_/ */ } else if(comments && c=='*' && numdone>0 && /* /_* bla *_/ */
ldns_buffer_read_u8_at(buf, sldns_buffer_read_u8_at(buf,
ldns_buffer_position(buf)-1) == '/') { sldns_buffer_position(buf)-1) == '/') {
ldns_buffer_skip(buf, -1); sldns_buffer_skip(buf, -1);
numdone--; numdone--;
/* skip to end of comment */ /* skip to end of comment */
while(c != EOF && (c=getc(in)) != EOF ) { while(c != EOF && (c=getc(in)) != EOF ) {
@ -577,10 +577,10 @@ readkeyword_bindfile(FILE* in, ldns_buffer* buf, int* line, int comments)
(*line)++; (*line)++;
} }
/* space for 1 char + 0 string terminator */ /* space for 1 char + 0 string terminator */
if(ldns_buffer_remaining(buf) < 2) { if(sldns_buffer_remaining(buf) < 2) {
fatal_exit("trusted-keys, %d, string too long", *line); fatal_exit("trusted-keys, %d, string too long", *line);
} }
ldns_buffer_write_u8(buf, (uint8_t)c); sldns_buffer_write_u8(buf, (uint8_t)c);
numdone++; numdone++;
if(isspace(c)) { if(isspace(c)) {
/* collate whitespace into ' ' */ /* collate whitespace into ' ' */
@ -602,17 +602,17 @@ readkeyword_bindfile(FILE* in, ldns_buffer* buf, int* line, int comments)
/** skip through file to { or ; */ /** skip through file to { or ; */
static int static int
skip_to_special(FILE* in, ldns_buffer* buf, int* line, int spec) skip_to_special(FILE* in, sldns_buffer* buf, int* line, int spec)
{ {
int rdlen; int rdlen;
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
while((rdlen=readkeyword_bindfile(in, buf, line, 1))) { while((rdlen=readkeyword_bindfile(in, buf, line, 1))) {
if(rdlen == 1 && isspace((int)*ldns_buffer_begin(buf))) { if(rdlen == 1 && isspace((int)*sldns_buffer_begin(buf))) {
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
continue; continue;
} }
if(rdlen != 1 || *ldns_buffer_begin(buf) != (uint8_t)spec) { if(rdlen != 1 || *sldns_buffer_begin(buf) != (uint8_t)spec) {
ldns_buffer_write_u8(buf, 0); sldns_buffer_write_u8(buf, 0);
log_err("trusted-keys, line %d, expected %c", log_err("trusted-keys, line %d, expected %c",
*line, spec); *line, spec);
return 0; return 0;
@ -632,7 +632,7 @@ skip_to_special(FILE* in, ldns_buffer* buf, int* line, int spec)
* @return 0 on error. * @return 0 on error.
*/ */
static int static int
process_bind_contents(struct val_anchors* anchors, ldns_buffer* buf, process_bind_contents(struct val_anchors* anchors, sldns_buffer* buf,
int* line, FILE* in) int* line, FILE* in)
{ {
/* loop over contents, collate strings before ; */ /* loop over contents, collate strings before ; */
@ -645,41 +645,41 @@ process_bind_contents(struct val_anchors* anchors, ldns_buffer* buf,
int comments = 1; int comments = 1;
int rdlen; int rdlen;
char* str = 0; char* str = 0;
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
while((rdlen=readkeyword_bindfile(in, buf, line, comments))) { while((rdlen=readkeyword_bindfile(in, buf, line, comments))) {
if(rdlen == 1 && ldns_buffer_position(buf) == 1 if(rdlen == 1 && sldns_buffer_position(buf) == 1
&& isspace((int)*ldns_buffer_begin(buf))) { && isspace((int)*sldns_buffer_begin(buf))) {
/* starting whitespace is removed */ /* starting whitespace is removed */
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
continue; continue;
} else if(rdlen == 1 && ldns_buffer_current(buf)[-1] == '"') { } else if(rdlen == 1 && sldns_buffer_current(buf)[-1] == '"') {
/* remove " from the string */ /* remove " from the string */
if(contnum == 0) { if(contnum == 0) {
quoted = 1; quoted = 1;
comments = 0; comments = 0;
} }
ldns_buffer_skip(buf, -1); sldns_buffer_skip(buf, -1);
if(contnum > 0 && quoted) { if(contnum > 0 && quoted) {
if(ldns_buffer_remaining(buf) < 8+1) { if(sldns_buffer_remaining(buf) < 8+1) {
log_err("line %d, too long", *line); log_err("line %d, too long", *line);
return 0; return 0;
} }
ldns_buffer_write(buf, " DNSKEY ", 8); sldns_buffer_write(buf, " DNSKEY ", 8);
quoted = 0; quoted = 0;
comments = 1; comments = 1;
} else if(contnum > 0) } else if(contnum > 0)
comments = !comments; comments = !comments;
continue; continue;
} else if(rdlen == 1 && ldns_buffer_current(buf)[-1] == ';') { } else if(rdlen == 1 && sldns_buffer_current(buf)[-1] == ';') {
if(contnum < 5) { if(contnum < 5) {
ldns_buffer_write_u8(buf, 0); sldns_buffer_write_u8(buf, 0);
log_err("line %d, bad key", *line); log_err("line %d, bad key", *line);
return 0; return 0;
} }
ldns_buffer_skip(buf, -1); sldns_buffer_skip(buf, -1);
ldns_buffer_write_u8(buf, 0); sldns_buffer_write_u8(buf, 0);
str = strdup((char*)ldns_buffer_begin(buf)); str = strdup((char*)sldns_buffer_begin(buf));
if(!str) { if(!str) {
log_err("line %d, allocation failure", *line); log_err("line %d, allocation failure", *line);
return 0; return 0;
@ -690,30 +690,30 @@ process_bind_contents(struct val_anchors* anchors, ldns_buffer* buf,
return 0; return 0;
} }
free(str); free(str);
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
contnum = 0; contnum = 0;
quoted = 0; quoted = 0;
comments = 1; comments = 1;
continue; continue;
} else if(rdlen == 1 && ldns_buffer_current(buf)[-1] == '}') { } else if(rdlen == 1 && sldns_buffer_current(buf)[-1] == '}') {
if(contnum > 0) { if(contnum > 0) {
ldns_buffer_write_u8(buf, 0); sldns_buffer_write_u8(buf, 0);
log_err("line %d, bad key before }", *line); log_err("line %d, bad key before }", *line);
return 0; return 0;
} }
return 1; return 1;
} else if(rdlen == 1 && } else if(rdlen == 1 &&
isspace((int)ldns_buffer_current(buf)[-1])) { isspace((int)sldns_buffer_current(buf)[-1])) {
/* leave whitespace here */ /* leave whitespace here */
} else { } else {
/* not space or whatnot, so actual content */ /* not space or whatnot, so actual content */
contnum ++; contnum ++;
if(contnum == 1 && !quoted) { if(contnum == 1 && !quoted) {
if(ldns_buffer_remaining(buf) < 8+1) { if(sldns_buffer_remaining(buf) < 8+1) {
log_err("line %d, too long", *line); log_err("line %d, too long", *line);
return 0; return 0;
} }
ldns_buffer_write(buf, " DNSKEY ", 8); sldns_buffer_write(buf, " DNSKEY ", 8);
} }
} }
} }
@ -730,7 +730,7 @@ process_bind_contents(struct val_anchors* anchors, ldns_buffer* buf,
* @return false on error. * @return false on error.
*/ */
static int static int
anchor_read_bind_file(struct val_anchors* anchors, ldns_buffer* buffer, anchor_read_bind_file(struct val_anchors* anchors, sldns_buffer* buffer,
const char* fname) const char* fname)
{ {
int line_nr = 1; int line_nr = 1;
@ -742,11 +742,11 @@ anchor_read_bind_file(struct val_anchors* anchors, ldns_buffer* buffer,
} }
verbose(VERB_QUERY, "reading in bind-compat-mode: '%s'", fname); verbose(VERB_QUERY, "reading in bind-compat-mode: '%s'", fname);
/* scan for trusted-keys keyword, ignore everything else */ /* scan for trusted-keys keyword, ignore everything else */
ldns_buffer_clear(buffer); sldns_buffer_clear(buffer);
while((rdlen=readkeyword_bindfile(in, buffer, &line_nr, 1)) != 0) { while((rdlen=readkeyword_bindfile(in, buffer, &line_nr, 1)) != 0) {
if(rdlen != 12 || strncmp((char*)ldns_buffer_begin(buffer), if(rdlen != 12 || strncmp((char*)sldns_buffer_begin(buffer),
"trusted-keys", 12) != 0) { "trusted-keys", 12) != 0) {
ldns_buffer_clear(buffer); sldns_buffer_clear(buffer);
/* ignore everything but trusted-keys */ /* ignore everything but trusted-keys */
continue; continue;
} }
@ -766,7 +766,7 @@ anchor_read_bind_file(struct val_anchors* anchors, ldns_buffer* buffer,
fclose(in); fclose(in);
return 0; return 0;
} }
ldns_buffer_clear(buffer); sldns_buffer_clear(buffer);
} }
fclose(in); fclose(in);
return 1; return 1;
@ -781,7 +781,7 @@ anchor_read_bind_file(struct val_anchors* anchors, ldns_buffer* buffer,
* @return false on error. * @return false on error.
*/ */
static int static int
anchor_read_bind_file_wild(struct val_anchors* anchors, ldns_buffer* buffer, anchor_read_bind_file_wild(struct val_anchors* anchors, sldns_buffer* buffer,
const char* pat) const char* pat)
{ {
#ifdef HAVE_GLOB #ifdef HAVE_GLOB
@ -1039,13 +1039,13 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
{ {
struct config_strlist* f; struct config_strlist* f;
char* nm; char* nm;
ldns_buffer* parsebuf = ldns_buffer_new(65535); sldns_buffer* parsebuf = sldns_buffer_new(65535);
for(f = cfg->domain_insecure; f; f = f->next) { for(f = cfg->domain_insecure; f; f = f->next) {
if(!f->str || f->str[0] == 0) /* empty "" */ if(!f->str || f->str[0] == 0) /* empty "" */
continue; continue;
if(!anchor_insert_insecure(anchors, f->str)) { if(!anchor_insert_insecure(anchors, f->str)) {
log_err("error in domain-insecure: %s", f->str); log_err("error in domain-insecure: %s", f->str);
ldns_buffer_free(parsebuf); sldns_buffer_free(parsebuf);
return 0; return 0;
} }
} }
@ -1058,7 +1058,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
nm += strlen(cfg->chrootdir); nm += strlen(cfg->chrootdir);
if(!anchor_read_file(anchors, parsebuf, nm, 0)) { if(!anchor_read_file(anchors, parsebuf, nm, 0)) {
log_err("error reading trust-anchor-file: %s", f->str); log_err("error reading trust-anchor-file: %s", f->str);
ldns_buffer_free(parsebuf); sldns_buffer_free(parsebuf);
return 0; return 0;
} }
} }
@ -1071,7 +1071,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
nm += strlen(cfg->chrootdir); nm += strlen(cfg->chrootdir);
if(!anchor_read_bind_file_wild(anchors, parsebuf, nm)) { if(!anchor_read_bind_file_wild(anchors, parsebuf, nm)) {
log_err("error reading trusted-keys-file: %s", f->str); log_err("error reading trusted-keys-file: %s", f->str);
ldns_buffer_free(parsebuf); sldns_buffer_free(parsebuf);
return 0; return 0;
} }
} }
@ -1080,7 +1080,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
continue; continue;
if(!anchor_store_str(anchors, parsebuf, f->str)) { if(!anchor_store_str(anchors, parsebuf, f->str)) {
log_err("error in trust-anchor: \"%s\"", f->str); log_err("error in trust-anchor: \"%s\"", f->str);
ldns_buffer_free(parsebuf); sldns_buffer_free(parsebuf);
return 0; return 0;
} }
} }
@ -1094,7 +1094,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
nm, 1))) { nm, 1))) {
log_err("error reading dlv-anchor-file: %s", log_err("error reading dlv-anchor-file: %s",
cfg->dlv_anchor_file); cfg->dlv_anchor_file);
ldns_buffer_free(parsebuf); sldns_buffer_free(parsebuf);
return 0; return 0;
} }
lock_basic_lock(&anchors->lock); lock_basic_lock(&anchors->lock);
@ -1108,7 +1108,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
if(!(dlva = anchor_store_str( if(!(dlva = anchor_store_str(
anchors, parsebuf, f->str))) { anchors, parsebuf, f->str))) {
log_err("error in dlv-anchor: \"%s\"", f->str); log_err("error in dlv-anchor: \"%s\"", f->str);
ldns_buffer_free(parsebuf); sldns_buffer_free(parsebuf);
return 0; return 0;
} }
lock_basic_lock(&anchors->lock); lock_basic_lock(&anchors->lock);
@ -1127,14 +1127,14 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
if(!autr_read_file(anchors, nm)) { if(!autr_read_file(anchors, nm)) {
log_err("error reading auto-trust-anchor-file: %s", log_err("error reading auto-trust-anchor-file: %s",
f->str); f->str);
ldns_buffer_free(parsebuf); sldns_buffer_free(parsebuf);
return 0; return 0;
} }
} }
/* first assemble, since it may delete useless anchors */ /* first assemble, since it may delete useless anchors */
anchors_assemble_rrsets(anchors); anchors_assemble_rrsets(anchors);
init_parents(anchors); init_parents(anchors);
ldns_buffer_free(parsebuf); sldns_buffer_free(parsebuf);
if(verbosity >= VERB_ALGO) autr_debug_print(anchors); if(verbosity >= VERB_ALGO) autr_debug_print(anchors);
return 1; return 1;
} }

4
validator/val_anchor.h
View file

@ -48,7 +48,7 @@ struct config_file;
struct ub_packed_rrset_key; struct ub_packed_rrset_key;
struct autr_point_data; struct autr_point_data;
struct autr_global_data; struct autr_global_data;
struct ldns_buffer; struct sldns_buffer;
/** /**
* Trust anchor store. * Trust anchor store.
@ -185,7 +185,7 @@ struct trust_anchor* anchor_find(struct val_anchors* anchors,
* @return NULL on error. * @return NULL on error.
*/ */
struct trust_anchor* anchor_store_str(struct val_anchors* anchors, struct trust_anchor* anchor_store_str(struct val_anchors* anchors,
struct ldns_buffer* buffer, const char* str); struct sldns_buffer* buffer, const char* str);
/** /**
* Get memory in use by the trust anchor storage * Get memory in use by the trust anchor storage

2
validator/val_kentry.c
View file

@ -378,7 +378,7 @@ dnskey_get_keysize(struct packed_rrset_data* data, size_t idx)
algo = (int)data->rr_data[idx][2+3]; algo = (int)data->rr_data[idx][2+3];
pk = (unsigned char*)data->rr_data[idx]+2+4; pk = (unsigned char*)data->rr_data[idx]+2+4;
pklen = (unsigned)data->rr_len[idx]-2-4; pklen = (unsigned)data->rr_len[idx]-2-4;
return ldns_rr_dnskey_key_size_raw(pk, pklen, algo); return sldns_rr_dnskey_key_size_raw(pk, pklen, algo);
} }
/** get dnskey flags from data */ /** get dnskey flags from data */

6
validator/val_neg.c
View file

@ -1176,7 +1176,7 @@ grab_nsec(struct rrset_cache* rrset_cache, uint8_t* qname, size_t qname_len,
/** find nsec3 closest encloser in neg cache */ /** find nsec3 closest encloser in neg cache */
static struct val_neg_data* static struct val_neg_data*
neg_find_nsec3_ce(struct val_neg_zone* zone, uint8_t* qname, size_t qname_len, neg_find_nsec3_ce(struct val_neg_zone* zone, uint8_t* qname, size_t qname_len,
int qlabs, ldns_buffer* buf, uint8_t* hashnc, size_t* nclen) int qlabs, sldns_buffer* buf, uint8_t* hashnc, size_t* nclen)
{ {
struct val_neg_data* data; struct val_neg_data* data;
uint8_t hashce[NSEC3_SHA_LEN]; uint8_t hashce[NSEC3_SHA_LEN];
@ -1259,7 +1259,7 @@ neg_nsec3_getnc(struct val_neg_zone* zone, uint8_t* hashnc, size_t nclen,
/** neg cache nsec3 proof procedure*/ /** neg cache nsec3 proof procedure*/
static struct dns_msg* static struct dns_msg*
neg_nsec3_proof_ds(struct val_neg_zone* zone, uint8_t* qname, size_t qname_len, neg_nsec3_proof_ds(struct val_neg_zone* zone, uint8_t* qname, size_t qname_len,
int qlabs, ldns_buffer* buf, struct rrset_cache* rrset_cache, int qlabs, sldns_buffer* buf, struct rrset_cache* rrset_cache,
struct regional* region, time_t now, uint8_t* topname) struct regional* region, time_t now, uint8_t* topname)
{ {
struct dns_msg* msg; struct dns_msg* msg;
@ -1390,7 +1390,7 @@ static int add_soa(struct rrset_cache* rrset_cache, time_t now,
struct dns_msg* struct dns_msg*
val_neg_getmsg(struct val_neg_cache* neg, struct query_info* qinfo, val_neg_getmsg(struct val_neg_cache* neg, struct query_info* qinfo,
struct regional* region, struct rrset_cache* rrset_cache, struct regional* region, struct rrset_cache* rrset_cache,
ldns_buffer* buf, time_t now, int addsoa, uint8_t* topname) sldns_buffer* buf, time_t now, int addsoa, uint8_t* topname)
{ {
struct dns_msg* msg; struct dns_msg* msg;
struct ub_packed_rrset_key* rrset; struct ub_packed_rrset_key* rrset;

4
validator/val_neg.h
View file

@ -46,7 +46,7 @@
#define VALIDATOR_VAL_NEG_H #define VALIDATOR_VAL_NEG_H
#include "util/locks.h" #include "util/locks.h"
#include "util/rbtree.h" #include "util/rbtree.h"
struct ldns_buffer; struct sldns_buffer;
struct val_neg_data; struct val_neg_data;
struct config_file; struct config_file;
struct reply_info; struct reply_info;
@ -256,7 +256,7 @@ int val_neg_dlvlookup(struct val_neg_cache* neg, uint8_t* qname, size_t len,
*/ */
struct dns_msg* val_neg_getmsg(struct val_neg_cache* neg, struct dns_msg* val_neg_getmsg(struct val_neg_cache* neg,
struct query_info* qinfo, struct regional* region, struct query_info* qinfo, struct regional* region,
struct rrset_cache* rrset_cache, struct ldns_buffer* buf, time_t now, struct rrset_cache* rrset_cache, struct sldns_buffer* buf, time_t now,
int addsoa, uint8_t* topname); int addsoa, uint8_t* topname);

100
validator/val_nsec3.c
View file

@ -68,13 +68,13 @@
* This function we get from ldns-compat or from base system * This function we get from ldns-compat or from base system
* it returns the number of data bytes stored at the target, or <0 on error. * it returns the number of data bytes stored at the target, or <0 on error.
*/ */
int ldns_b32_ntop_extended_hex(uint8_t const *src, size_t srclength, int sldns_b32_ntop_extended_hex(uint8_t const *src, size_t srclength,
char *target, size_t targsize); char *target, size_t targsize);
/** /**
* This function we get from ldns-compat or from base system * This function we get from ldns-compat or from base system
* it returns the number of data bytes stored at the target, or <0 on error. * it returns the number of data bytes stored at the target, or <0 on error.
*/ */
int ldns_b32_pton_extended_hex(char const *src, size_t hashed_owner_str_len, int sldns_b32_pton_extended_hex(char const *src, size_t hashed_owner_str_len,
uint8_t *target, size_t targsize); uint8_t *target, size_t targsize);
/** /**
@ -260,7 +260,7 @@ size_t nsec3_hash_to_b32(uint8_t* hash, size_t hashlen, uint8_t* zone,
int ret; int ret;
if(max < hashlen*2+1) /* quick approx of b32, as if hexb16 */ if(max < hashlen*2+1) /* quick approx of b32, as if hexb16 */
return 0; return 0;
ret = ldns_b32_ntop_extended_hex(hash, hashlen, (char*)buf+1, max-1); ret = sldns_b32_ntop_extended_hex(hash, hashlen, (char*)buf+1, max-1);
if(ret < 1) if(ret < 1)
return 0; return 0;
buf[0] = (uint8_t)ret; /* length of b32 label */ buf[0] = (uint8_t)ret; /* length of b32 label */
@ -535,16 +535,16 @@ nsec3_hash_cmp(const void* c1, const void* c2)
} }
size_t size_t
nsec3_get_hashed(ldns_buffer* buf, uint8_t* nm, size_t nmlen, int algo, nsec3_get_hashed(sldns_buffer* buf, uint8_t* nm, size_t nmlen, int algo,
size_t iter, uint8_t* salt, size_t saltlen, uint8_t* res, size_t max) size_t iter, uint8_t* salt, size_t saltlen, uint8_t* res, size_t max)
{ {
size_t i, hash_len; size_t i, hash_len;
/* prepare buffer for first iteration */ /* prepare buffer for first iteration */
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
ldns_buffer_write(buf, nm, nmlen); sldns_buffer_write(buf, nm, nmlen);
query_dname_tolower(ldns_buffer_begin(buf)); query_dname_tolower(sldns_buffer_begin(buf));
ldns_buffer_write(buf, salt, saltlen); sldns_buffer_write(buf, salt, saltlen);
ldns_buffer_flip(buf); sldns_buffer_flip(buf);
switch(algo) { switch(algo) {
#if defined(HAVE_EVP_SHA1) || defined(HAVE_NSS) #if defined(HAVE_EVP_SHA1) || defined(HAVE_NSS)
case NSEC3_HASH_SHA1: case NSEC3_HASH_SHA1:
@ -556,29 +556,29 @@ nsec3_get_hashed(ldns_buffer* buf, uint8_t* nm, size_t nmlen, int algo,
if(hash_len > max) if(hash_len > max)
return 0; return 0;
# ifdef HAVE_SSL # ifdef HAVE_SSL
(void)SHA1((unsigned char*)ldns_buffer_begin(buf), (void)SHA1((unsigned char*)sldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf), (unsigned long)sldns_buffer_limit(buf),
(unsigned char*)res); (unsigned char*)res);
# else # else
(void)HASH_HashBuf(HASH_AlgSHA1, (unsigned char*)res, (void)HASH_HashBuf(HASH_AlgSHA1, (unsigned char*)res,
(unsigned char*)ldns_buffer_begin(buf), (unsigned char*)sldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf)); (unsigned long)sldns_buffer_limit(buf));
# endif # endif
for(i=0; i<iter; i++) { for(i=0; i<iter; i++) {
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
ldns_buffer_write(buf, res, hash_len); sldns_buffer_write(buf, res, hash_len);
ldns_buffer_write(buf, salt, saltlen); sldns_buffer_write(buf, salt, saltlen);
ldns_buffer_flip(buf); sldns_buffer_flip(buf);
# ifdef HAVE_SSL # ifdef HAVE_SSL
(void)SHA1( (void)SHA1(
(unsigned char*)ldns_buffer_begin(buf), (unsigned char*)sldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf), (unsigned long)sldns_buffer_limit(buf),
(unsigned char*)res); (unsigned char*)res);
# else # else
(void)HASH_HashBuf(HASH_AlgSHA1, (void)HASH_HashBuf(HASH_AlgSHA1,
(unsigned char*)res, (unsigned char*)res,
(unsigned char*)ldns_buffer_begin(buf), (unsigned char*)sldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf)); (unsigned long)sldns_buffer_limit(buf));
# endif # endif
} }
break; break;
@ -592,7 +592,7 @@ nsec3_get_hashed(ldns_buffer* buf, uint8_t* nm, size_t nmlen, int algo,
/** perform hash of name */ /** perform hash of name */
static int static int
nsec3_calc_hash(struct regional* region, ldns_buffer* buf, nsec3_calc_hash(struct regional* region, sldns_buffer* buf,
struct nsec3_cached_hash* c) struct nsec3_cached_hash* c)
{ {
int algo = nsec3_get_algo(c->nsec3, c->rr); int algo = nsec3_get_algo(c->nsec3, c->rr);
@ -602,11 +602,11 @@ nsec3_calc_hash(struct regional* region, ldns_buffer* buf,
if(!nsec3_get_salt(c->nsec3, c->rr, &salt, &saltlen)) if(!nsec3_get_salt(c->nsec3, c->rr, &salt, &saltlen))
return -1; return -1;
/* prepare buffer for first iteration */ /* prepare buffer for first iteration */
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
ldns_buffer_write(buf, c->dname, c->dname_len); sldns_buffer_write(buf, c->dname, c->dname_len);
query_dname_tolower(ldns_buffer_begin(buf)); query_dname_tolower(sldns_buffer_begin(buf));
ldns_buffer_write(buf, salt, saltlen); sldns_buffer_write(buf, salt, saltlen);
ldns_buffer_flip(buf); sldns_buffer_flip(buf);
switch(algo) { switch(algo) {
#if defined(HAVE_EVP_SHA1) || defined(HAVE_NSS) #if defined(HAVE_EVP_SHA1) || defined(HAVE_NSS)
case NSEC3_HASH_SHA1: case NSEC3_HASH_SHA1:
@ -620,30 +620,30 @@ nsec3_calc_hash(struct regional* region, ldns_buffer* buf,
if(!c->hash) if(!c->hash)
return 0; return 0;
# ifdef HAVE_SSL # ifdef HAVE_SSL
(void)SHA1((unsigned char*)ldns_buffer_begin(buf), (void)SHA1((unsigned char*)sldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf), (unsigned long)sldns_buffer_limit(buf),
(unsigned char*)c->hash); (unsigned char*)c->hash);
# else # else
(void)HASH_HashBuf(HASH_AlgSHA1, (void)HASH_HashBuf(HASH_AlgSHA1,
(unsigned char*)c->hash, (unsigned char*)c->hash,
(unsigned char*)ldns_buffer_begin(buf), (unsigned char*)sldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf)); (unsigned long)sldns_buffer_limit(buf));
# endif # endif
for(i=0; i<iter; i++) { for(i=0; i<iter; i++) {
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
ldns_buffer_write(buf, c->hash, c->hash_len); sldns_buffer_write(buf, c->hash, c->hash_len);
ldns_buffer_write(buf, salt, saltlen); sldns_buffer_write(buf, salt, saltlen);
ldns_buffer_flip(buf); sldns_buffer_flip(buf);
# ifdef HAVE_SSL # ifdef HAVE_SSL
(void)SHA1( (void)SHA1(
(unsigned char*)ldns_buffer_begin(buf), (unsigned char*)sldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf), (unsigned long)sldns_buffer_limit(buf),
(unsigned char*)c->hash); (unsigned char*)c->hash);
# else # else
(void)HASH_HashBuf(HASH_AlgSHA1, (void)HASH_HashBuf(HASH_AlgSHA1,
(unsigned char*)c->hash, (unsigned char*)c->hash,
(unsigned char*)ldns_buffer_begin(buf), (unsigned char*)sldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf)); (unsigned long)sldns_buffer_limit(buf));
# endif # endif
} }
break; break;
@ -657,19 +657,19 @@ nsec3_calc_hash(struct regional* region, ldns_buffer* buf,
/** perform b32 encoding of hash */ /** perform b32 encoding of hash */
static int static int
nsec3_calc_b32(struct regional* region, ldns_buffer* buf, nsec3_calc_b32(struct regional* region, sldns_buffer* buf,
struct nsec3_cached_hash* c) struct nsec3_cached_hash* c)
{ {
int r; int r;
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
r = ldns_b32_ntop_extended_hex(c->hash, c->hash_len, r = sldns_b32_ntop_extended_hex(c->hash, c->hash_len,
(char*)ldns_buffer_begin(buf), ldns_buffer_limit(buf)); (char*)sldns_buffer_begin(buf), sldns_buffer_limit(buf));
if(r < 1) { if(r < 1) {
log_err("b32_ntop_extended_hex: error in encoding: %d", r); log_err("b32_ntop_extended_hex: error in encoding: %d", r);
return 0; return 0;
} }
c->b32_len = (size_t)r; c->b32_len = (size_t)r;
c->b32 = regional_alloc_init(region, ldns_buffer_begin(buf), c->b32 = regional_alloc_init(region, sldns_buffer_begin(buf),
c->b32_len); c->b32_len);
if(!c->b32) if(!c->b32)
return 0; return 0;
@ -677,7 +677,7 @@ nsec3_calc_b32(struct regional* region, ldns_buffer* buf,
} }
int int
nsec3_hash_name(rbtree_t* table, struct regional* region, ldns_buffer* buf, nsec3_hash_name(rbtree_t* table, struct regional* region, sldns_buffer* buf,
struct ub_packed_rrset_key* nsec3, int rr, uint8_t* dname, struct ub_packed_rrset_key* nsec3, int rr, uint8_t* dname,
size_t dname_len, struct nsec3_cached_hash** hash) size_t dname_len, struct nsec3_cached_hash** hash)
{ {
@ -817,7 +817,7 @@ find_matching_nsec3(struct module_env* env, struct nsec3_filter* flt,
int int
nsec3_covers(uint8_t* zone, struct nsec3_cached_hash* hash, nsec3_covers(uint8_t* zone, struct nsec3_cached_hash* hash,
struct ub_packed_rrset_key* rrset, int rr, ldns_buffer* buf) struct ub_packed_rrset_key* rrset, int rr, sldns_buffer* buf)
{ {
uint8_t* next, *owner; uint8_t* next, *owner;
size_t nextlen; size_t nextlen;
@ -841,10 +841,10 @@ nsec3_covers(uint8_t* zone, struct nsec3_cached_hash* hash,
return 1; return 1;
/* convert owner name from text to binary */ /* convert owner name from text to binary */
ldns_buffer_clear(buf); sldns_buffer_clear(buf);
owner = ldns_buffer_begin(buf); owner = sldns_buffer_begin(buf);
len = ldns_b32_pton_extended_hex((char*)rrset->rk.dname+1, len = sldns_b32_pton_extended_hex((char*)rrset->rk.dname+1,
hash->b32_len, owner, ldns_buffer_limit(buf)); hash->b32_len, owner, sldns_buffer_limit(buf));
if(len<1) if(len<1)
return 0; /* bad owner name in some way */ return 0; /* bad owner name in some way */
if((size_t)len != hash->hash_len || (size_t)len != nextlen) if((size_t)len != hash->hash_len || (size_t)len != nextlen)

8
validator/val_nsec3.h
View file

@ -75,7 +75,7 @@ struct ub_packed_rrset_key;
struct reply_info; struct reply_info;
struct query_info; struct query_info;
struct key_entry_key; struct key_entry_key;
struct ldns_buffer; struct sldns_buffer;
/** /**
* 0 1 2 3 4 5 6 7 * 0 1 2 3 4 5 6 7
@ -272,7 +272,7 @@ int nsec3_hash_cmp(const void* c1, const void* c2);
* -1 if the NSEC3 rr was badly formatted (i.e. formerr). * -1 if the NSEC3 rr was badly formatted (i.e. formerr).
*/ */
int nsec3_hash_name(rbtree_t* table, struct regional* region, int nsec3_hash_name(rbtree_t* table, struct regional* region,
struct ldns_buffer* buf, struct ub_packed_rrset_key* nsec3, int rr, struct sldns_buffer* buf, struct ub_packed_rrset_key* nsec3, int rr,
uint8_t* dname, size_t dname_len, struct nsec3_cached_hash** hash); uint8_t* dname, size_t dname_len, struct nsec3_cached_hash** hash);
/** /**
@ -329,7 +329,7 @@ int nsec3_get_params(struct ub_packed_rrset_key* rrset, int r,
* @param max: maximum space for result. * @param max: maximum space for result.
* @return 0 on failure, otherwise bytelength stored. * @return 0 on failure, otherwise bytelength stored.
*/ */
size_t nsec3_get_hashed(struct ldns_buffer* buf, uint8_t* nm, size_t nmlen, size_t nsec3_get_hashed(struct sldns_buffer* buf, uint8_t* nm, size_t nmlen,
int algo, size_t iter, uint8_t* salt, size_t saltlen, uint8_t* res, int algo, size_t iter, uint8_t* salt, size_t saltlen, uint8_t* res,
size_t max); size_t max);
@ -375,6 +375,6 @@ int nsec3_get_nextowner(struct ub_packed_rrset_key* rrset, int r,
* @return true if covers, false if not. * @return true if covers, false if not.
*/ */
int nsec3_covers(uint8_t* zone, struct nsec3_cached_hash* hash, int nsec3_covers(uint8_t* zone, struct nsec3_cached_hash* hash,
struct ub_packed_rrset_key* rrset, int rr, struct ldns_buffer* buf); struct ub_packed_rrset_key* rrset, int rr, struct sldns_buffer* buf);
#endif /* VALIDATOR_VAL_NSEC3_H */ #endif /* VALIDATOR_VAL_NSEC3_H */

40
validator/val_secalgo.c
View file

@ -110,7 +110,7 @@ do_gost94(unsigned char* data, size_t len, unsigned char* dest)
const EVP_MD* md = EVP_get_digestbyname("md_gost94"); const EVP_MD* md = EVP_get_digestbyname("md_gost94");
if(!md) if(!md)
return 0; return 0;
return ldns_digest_evp(data, (unsigned int)len, dest, md); return sldns_digest_evp(data, (unsigned int)len, dest, md);
} }
#endif #endif
@ -174,7 +174,7 @@ dnskey_algo_id_is_supported(int id)
#ifdef USE_GOST #ifdef USE_GOST
case LDNS_ECC_GOST: case LDNS_ECC_GOST:
/* we support GOST if it can be loaded */ /* we support GOST if it can be loaded */
return ldns_key_EVP_load_gost_id(); return sldns_key_EVP_load_gost_id();
#endif #endif
default: default:
return 0; return 0;
@ -306,10 +306,10 @@ setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type,
log_err("verify: malloc failure in crypto"); log_err("verify: malloc failure in crypto");
return 0; return 0;
} }
dsa = ldns_key_buf2dsa_raw(key, keylen); dsa = sldns_key_buf2dsa_raw(key, keylen);
if(!dsa) { if(!dsa) {
verbose(VERB_QUERY, "verify: " verbose(VERB_QUERY, "verify: "
"ldns_key_buf2dsa_raw failed"); "sldns_key_buf2dsa_raw failed");
return 0; return 0;
} }
if(EVP_PKEY_assign_DSA(*evp_key, dsa) == 0) { if(EVP_PKEY_assign_DSA(*evp_key, dsa) == 0) {
@ -333,10 +333,10 @@ setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type,
log_err("verify: malloc failure in crypto"); log_err("verify: malloc failure in crypto");
return 0; return 0;
} }
rsa = ldns_key_buf2rsa_raw(key, keylen); rsa = sldns_key_buf2rsa_raw(key, keylen);
if(!rsa) { if(!rsa) {
verbose(VERB_QUERY, "verify: " verbose(VERB_QUERY, "verify: "
"ldns_key_buf2rsa_raw SHA failed"); "sldns_key_buf2rsa_raw SHA failed");
return 0; return 0;
} }
if(EVP_PKEY_assign_RSA(*evp_key, rsa) == 0) { if(EVP_PKEY_assign_RSA(*evp_key, rsa) == 0) {
@ -365,10 +365,10 @@ setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type,
log_err("verify: malloc failure in crypto"); log_err("verify: malloc failure in crypto");
return 0; return 0;
} }
rsa = ldns_key_buf2rsa_raw(key, keylen); rsa = sldns_key_buf2rsa_raw(key, keylen);
if(!rsa) { if(!rsa) {
verbose(VERB_QUERY, "verify: " verbose(VERB_QUERY, "verify: "
"ldns_key_buf2rsa_raw MD5 failed"); "sldns_key_buf2rsa_raw MD5 failed");
return 0; return 0;
} }
if(EVP_PKEY_assign_RSA(*evp_key, rsa) == 0) { if(EVP_PKEY_assign_RSA(*evp_key, rsa) == 0) {
@ -381,10 +381,10 @@ setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type,
break; break;
#ifdef USE_GOST #ifdef USE_GOST
case LDNS_ECC_GOST: case LDNS_ECC_GOST:
*evp_key = ldns_gost2pkey_raw(key, keylen); *evp_key = sldns_gost2pkey_raw(key, keylen);
if(!*evp_key) { if(!*evp_key) {
verbose(VERB_QUERY, "verify: " verbose(VERB_QUERY, "verify: "
"ldns_gost2pkey_raw failed"); "sldns_gost2pkey_raw failed");
return 0; return 0;
} }
*digest_type = EVP_get_digestbyname("md_gost94"); *digest_type = EVP_get_digestbyname("md_gost94");
@ -397,11 +397,11 @@ setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type,
#endif #endif
#ifdef USE_ECDSA #ifdef USE_ECDSA
case LDNS_ECDSAP256SHA256: case LDNS_ECDSAP256SHA256:
*evp_key = ldns_ecdsa2pkey_raw(key, keylen, *evp_key = sldns_ecdsa2pkey_raw(key, keylen,
LDNS_ECDSAP256SHA256); LDNS_ECDSAP256SHA256);
if(!*evp_key) { if(!*evp_key) {
verbose(VERB_QUERY, "verify: " verbose(VERB_QUERY, "verify: "
"ldns_ecdsa2pkey_raw failed"); "sldns_ecdsa2pkey_raw failed");
return 0; return 0;
} }
#ifdef USE_ECDSA_EVP_WORKAROUND #ifdef USE_ECDSA_EVP_WORKAROUND
@ -424,11 +424,11 @@ setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type,
#endif #endif
break; break;
case LDNS_ECDSAP384SHA384: case LDNS_ECDSAP384SHA384:
*evp_key = ldns_ecdsa2pkey_raw(key, keylen, *evp_key = sldns_ecdsa2pkey_raw(key, keylen,
LDNS_ECDSAP384SHA384); LDNS_ECDSAP384SHA384);
if(!*evp_key) { if(!*evp_key) {
verbose(VERB_QUERY, "verify: " verbose(VERB_QUERY, "verify: "
"ldns_ecdsa2pkey_raw failed"); "sldns_ecdsa2pkey_raw failed");
return 0; return 0;
} }
#ifdef USE_ECDSA_EVP_WORKAROUND #ifdef USE_ECDSA_EVP_WORKAROUND
@ -473,7 +473,7 @@ setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type,
* unchecked on format errors and alloc failures. * unchecked on format errors and alloc failures.
*/ */
enum sec_status enum sec_status
verify_canonrrset(ldns_buffer* buf, int algo, unsigned char* sigblock, verify_canonrrset(sldns_buffer* buf, int algo, unsigned char* sigblock,
unsigned int sigblock_len, unsigned char* key, unsigned int keylen, unsigned int sigblock_len, unsigned char* key, unsigned int keylen,
char** reason) char** reason)
{ {
@ -520,8 +520,8 @@ verify_canonrrset(ldns_buffer* buf, int algo, unsigned char* sigblock,
if(dofree) free(sigblock); if(dofree) free(sigblock);
return sec_status_unchecked; return sec_status_unchecked;
} }
if(EVP_VerifyUpdate(&ctx, (unsigned char*)ldns_buffer_begin(buf), if(EVP_VerifyUpdate(&ctx, (unsigned char*)sldns_buffer_begin(buf),
(unsigned int)ldns_buffer_limit(buf)) == 0) { (unsigned int)sldns_buffer_limit(buf)) == 0) {
verbose(VERB_QUERY, "verify: EVP_VerifyUpdate failed"); verbose(VERB_QUERY, "verify: EVP_VerifyUpdate failed");
EVP_PKEY_free(evp_key); EVP_PKEY_free(evp_key);
if(dofree) free(sigblock); if(dofree) free(sigblock);
@ -965,7 +965,7 @@ nss_setup_key_digest(int algo, SECKEYPublicKey** pubkey, HASH_HashType* htype,
* unchecked on format errors and alloc failures. * unchecked on format errors and alloc failures.
*/ */
enum sec_status enum sec_status
verify_canonrrset(ldns_buffer* buf, int algo, unsigned char* sigblock, verify_canonrrset(sldns_buffer* buf, int algo, unsigned char* sigblock,
unsigned int sigblock_len, unsigned char* key, unsigned int keylen, unsigned int sigblock_len, unsigned char* key, unsigned int keylen,
char** reason) char** reason)
{ {
@ -1021,8 +1021,8 @@ verify_canonrrset(ldns_buffer* buf, int algo, unsigned char* sigblock,
SECKEY_DestroyPublicKey(pubkey); SECKEY_DestroyPublicKey(pubkey);
return sec_status_unchecked; return sec_status_unchecked;
} }
if(HASH_HashBuf(htype, hash, (unsigned char*)ldns_buffer_begin(buf), if(HASH_HashBuf(htype, hash, (unsigned char*)sldns_buffer_begin(buf),
(unsigned int)ldns_buffer_limit(buf)) != SECSuccess) { (unsigned int)sldns_buffer_limit(buf)) != SECSuccess) {
verbose(VERB_QUERY, "verify: HASH_HashBuf failed"); verbose(VERB_QUERY, "verify: HASH_HashBuf failed");
SECKEY_DestroyPublicKey(pubkey); SECKEY_DestroyPublicKey(pubkey);
return sec_status_unchecked; return sec_status_unchecked;

4
validator/val_secalgo.h
View file

@ -42,7 +42,7 @@
#ifndef VALIDATOR_VAL_SECALGO_H #ifndef VALIDATOR_VAL_SECALGO_H
#define VALIDATOR_VAL_SECALGO_H #define VALIDATOR_VAL_SECALGO_H
struct ldns_buffer; struct sldns_buffer;
/** /**
* Return size of DS digest according to its hash algorithm. * Return size of DS digest according to its hash algorithm.
@ -77,7 +77,7 @@ int dnskey_algo_id_is_supported(int id);
* @return secure if verification succeeded, bogus on crypto failure, * @return secure if verification succeeded, bogus on crypto failure,
* unchecked on format errors and alloc failures. * unchecked on format errors and alloc failures.
*/ */
enum sec_status verify_canonrrset(struct ldns_buffer* buf, int algo, enum sec_status verify_canonrrset(struct sldns_buffer* buf, int algo,
unsigned char* sigblock, unsigned int sigblock_len, unsigned char* sigblock, unsigned int sigblock_len,
unsigned char* key, unsigned int keylen, char** reason); unsigned char* key, unsigned int keylen, char** reason);

Some files were not shown because too many files have changed in this diff Show more