upstream/unbound
1
0
Fork 0
mirror of https://github.com/NLnetLabs/unbound.git synced 2025-12-20 23:00:56 -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 */
#define USE_SLDNS 1
#define SLDNS sldns_
#ifdef HAVE_SSL
# define LDNS_BUILD_CONFIG_HAVE_SSL 1
#endif

1
configure.ac
View file

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

76
daemon/cachedump.c
View file

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

4
daemon/daemon.c
View file

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

32
daemon/remote.c
View file

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

4
daemon/stats.h
View file

@ -48,7 +48,7 @@ struct config_file;
struct comm_point;
struct comm_reply;
struct edns_data;
struct ldns_buffer;
struct sldns_buffer;
/** number of qtype that is stored for in array */
#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 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 */

182
daemon/worker.c
View file

@ -179,7 +179,7 @@ worker_mem_report(struct worker* ATTR_UNUSED(worker),
+ sizeof(worker->rndstate)
+ regional_get_mem(worker->scratchpad)
+ 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)
+ hints_get_mem(worker->env.hints);
if(worker->thread_num == 0)
@ -241,10 +241,10 @@ worker_handle_reply(struct comm_point* c, void* arg, int error,
return 0;
}
/* sanity check. */
if(!LDNS_QR_WIRE(ldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) !=
if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
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
* never arrived. */
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;
}
/* sanity check. */
if(!LDNS_QR_WIRE(ldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) !=
if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
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
* never arrived. */
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.
*/
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");
return -1;
}
if(ldns_buffer_limit(pkt) > NORMAL_UDP_SIZE &&
if(sldns_buffer_limit(pkt) > NORMAL_UDP_SIZE &&
worker->daemon->cfg->harden_large_queries) {
verbose(VERB_QUERY, "request too large, discarded");
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");
return -1;
}
if(LDNS_TC_WIRE(ldns_buffer_begin(pkt))) {
LDNS_TC_CLR(ldns_buffer_begin(pkt));
if(LDNS_TC_WIRE(sldns_buffer_begin(pkt))) {
LDNS_TC_CLR(sldns_buffer_begin(pkt));
verbose(VERB_QUERY, "request bad, has TC bit on");
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",
LDNS_OPCODE_WIRE(ldns_buffer_begin(pkt)));
LDNS_OPCODE_WIRE(sldns_buffer_begin(pkt)));
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",
LDNS_QDCOUNT(ldns_buffer_begin(pkt)));
LDNS_QDCOUNT(sldns_buffer_begin(pkt)));
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",
LDNS_ANCOUNT(ldns_buffer_begin(pkt)));
LDNS_ANCOUNT(sldns_buffer_begin(pkt)));
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",
LDNS_NSCOUNT(ldns_buffer_begin(pkt)));
LDNS_NSCOUNT(sldns_buffer_begin(pkt)));
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",
LDNS_ARCOUNT(ldns_buffer_begin(pkt)));
LDNS_ARCOUNT(sldns_buffer_begin(pkt)));
return LDNS_RCODE_FORMERR;
}
return 0;
@ -359,7 +359,7 @@ worker_handle_control_cmd(struct tube* ATTR_UNUSED(tube), uint8_t* msg,
if(len != sizeof(uint32_t)) {
fatal_exit("bad control msg length %d", (int)len);
}
cmd = ldns_read_uint32(msg);
cmd = sldns_read_uint32(msg);
free(msg);
switch(cmd) {
case worker_cmd_quit:
@ -636,32 +636,32 @@ reply_and_prefetch(struct worker* worker, struct query_info* qinfo,
* @param edns: edns reply information.
*/
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);
unsigned int rd = LDNS_RD_WIRE(ldns_buffer_begin(pkt));
unsigned int cd = LDNS_CD_WIRE(ldns_buffer_begin(pkt));
unsigned int rd = LDNS_RD_WIRE(sldns_buffer_begin(pkt));
unsigned int cd = LDNS_CD_WIRE(sldns_buffer_begin(pkt));
if(len>255) len=255; /* cap size of TXT record */
ldns_buffer_clear(pkt);
ldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip id */
ldns_buffer_write_u16(pkt, (uint16_t)(BIT_QR|BIT_RA));
if(rd) LDNS_RD_SET(ldns_buffer_begin(pkt));
if(cd) LDNS_CD_SET(ldns_buffer_begin(pkt));
ldns_buffer_write_u16(pkt, 1); /* qdcount */
ldns_buffer_write_u16(pkt, 1); /* ancount */
ldns_buffer_write_u16(pkt, 0); /* nscount */
ldns_buffer_write_u16(pkt, 0); /* arcount */
sldns_buffer_clear(pkt);
sldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip id */
sldns_buffer_write_u16(pkt, (uint16_t)(BIT_QR|BIT_RA));
if(rd) LDNS_RD_SET(sldns_buffer_begin(pkt));
if(cd) LDNS_CD_SET(sldns_buffer_begin(pkt));
sldns_buffer_write_u16(pkt, 1); /* qdcount */
sldns_buffer_write_u16(pkt, 1); /* ancount */
sldns_buffer_write_u16(pkt, 0); /* nscount */
sldns_buffer_write_u16(pkt, 0); /* arcount */
(void)query_dname_len(pkt); /* skip qname */
ldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip qtype */
ldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip qclass */
ldns_buffer_write_u16(pkt, 0xc00c); /* compr ptr to query */
ldns_buffer_write_u16(pkt, LDNS_RR_TYPE_TXT);
ldns_buffer_write_u16(pkt, LDNS_RR_CLASS_CH);
ldns_buffer_write_u32(pkt, 0); /* TTL */
ldns_buffer_write_u16(pkt, sizeof(uint8_t) + len);
ldns_buffer_write_u8(pkt, len);
ldns_buffer_write(pkt, str, len);
ldns_buffer_flip(pkt);
sldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip qtype */
sldns_buffer_skip(pkt, (ssize_t)sizeof(uint16_t)); /* skip qclass */
sldns_buffer_write_u16(pkt, 0xc00c); /* compr ptr to query */
sldns_buffer_write_u16(pkt, LDNS_RR_TYPE_TXT);
sldns_buffer_write_u16(pkt, LDNS_RR_CLASS_CH);
sldns_buffer_write_u32(pkt, 0); /* TTL */
sldns_buffer_write_u16(pkt, sizeof(uint8_t) + len);
sldns_buffer_write_u8(pkt, len);
sldns_buffer_write(pkt, str, len);
sldns_buffer_flip(pkt);
edns->edns_version = EDNS_ADVERTISED_VERSION;
edns->udp_size = EDNS_ADVERTISED_SIZE;
edns->bits &= EDNS_DO;
@ -678,7 +678,7 @@ chaos_replystr(ldns_buffer* pkt, const char* str, struct edns_data* edns)
*/
static int
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;
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);
return 0; /* discard this */
}
ldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE);
ldns_buffer_write_at(c->buffer, 4,
sldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE);
sldns_buffer_write_at(c->buffer, 4,
(uint8_t*)"\0\0\0\0\0\0\0\0", 8);
LDNS_QR_SET(ldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer),
LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_REFUSED);
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.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
if(ret != -1) {
LDNS_QR_SET(ldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), ret);
LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret);
return 1;
}
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)) {
verbose(VERB_ALGO, "worker parse request: formerror.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
ldns_buffer_rewind(c->buffer);
LDNS_QR_SET(ldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer),
sldns_buffer_rewind(c->buffer);
LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_FORMERR);
server_stats_insrcode(&worker->stats, c->buffer);
return 1;
@ -819,9 +819,9 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
qinfo.qtype == LDNS_RR_TYPE_IXFR) {
verbose(VERB_ALGO, "worker request: refused zone transfer.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
ldns_buffer_rewind(c->buffer);
LDNS_QR_SET(ldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer),
sldns_buffer_rewind(c->buffer);
LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_REFUSED);
if(worker->stats.extended) {
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) {
verbose(VERB_ALGO, "worker parse edns: formerror.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
ldns_buffer_rewind(c->buffer);
LDNS_QR_SET(ldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer), ret);
sldns_buffer_rewind(c->buffer);
LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(sldns_buffer_begin(c->buffer), ret);
server_stats_insrcode(&worker->stats, c->buffer);
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.");
log_addr(VERB_CLIENT,"from",&repinfo->addr, repinfo->addrlen);
error_encode(c->buffer, EDNS_RCODE_BADVERS&0xf, &qinfo,
*(uint16_t*)ldns_buffer_begin(c->buffer),
ldns_buffer_read_u16_at(c->buffer, 2), NULL);
*(uint16_t*)sldns_buffer_begin(c->buffer),
sldns_buffer_read_u16_at(c->buffer, 2), NULL);
attach_edns_record(c->buffer, &edns);
return 1;
}
@ -869,14 +869,14 @@ worker_handle_request(struct comm_point* c, void* arg, int error,
if(edns.udp_size < LDNS_HEADER_SIZE) {
verbose(VERB_ALGO, "worker request: edns is too small.");
log_addr(VERB_CLIENT, "from", &repinfo->addr, repinfo->addrlen);
LDNS_QR_SET(ldns_buffer_begin(c->buffer));
LDNS_TC_SET(ldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer),
LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_TC_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_SERVFAIL);
ldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
ldns_buffer_write_at(c->buffer, 4,
sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
sldns_buffer_write_at(c->buffer, 4,
(uint8_t*)"\0\0\0\0\0\0\0\0", 8);
ldns_buffer_flip(c->buffer);
sldns_buffer_flip(c->buffer);
return 1;
}
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,
c->buffer, 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);
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
* 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 ) {
ldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE);
ldns_buffer_write_at(c->buffer, 4,
sldns_buffer_set_limit(c->buffer, LDNS_HEADER_SIZE);
sldns_buffer_write_at(c->buffer, 4,
(uint8_t*)"\0\0\0\0\0\0\0\0", 8);
LDNS_QR_SET(ldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(ldns_buffer_begin(c->buffer),
LDNS_QR_SET(sldns_buffer_begin(c->buffer));
LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
LDNS_RCODE_REFUSED);
ldns_buffer_flip(c->buffer);
sldns_buffer_flip(c->buffer);
server_stats_insrcode(&worker->stats, c->buffer);
log_addr(VERB_ALGO, "refused nonrec (cache snoop) query from",
&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 */
if(answer_from_cache(worker, &qinfo,
(struct reply_info*)e->data,
*(uint16_t*)ldns_buffer_begin(c->buffer),
ldns_buffer_read_u16_at(c->buffer, 2), repinfo,
*(uint16_t*)sldns_buffer_begin(c->buffer),
sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
&edns)) {
/* prefetch it if the prefetch TTL expired */
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;
lock_rw_unlock(&e->lock);
reply_and_prefetch(worker, &qinfo,
ldns_buffer_read_u16_at(c->buffer, 2),
sldns_buffer_read_u16_at(c->buffer, 2),
repinfo, leeway);
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");
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,
*(uint16_t*)ldns_buffer_begin(c->buffer),
ldns_buffer_read_u16_at(c->buffer, 2), repinfo,
*(uint16_t*)sldns_buffer_begin(c->buffer),
sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
&edns)) {
return 1;
}
verbose(VERB_ALGO, "answer norec from cache -- "
"need to validate or not primed");
}
ldns_buffer_rewind(c->buffer);
sldns_buffer_rewind(c->buffer);
server_stats_querymiss(&worker->stats, worker);
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 */
mesh_new_client(worker->env.mesh, &qinfo,
ldns_buffer_read_u16_at(c->buffer, 2),
&edns, repinfo, *(uint16_t*)ldns_buffer_begin(c->buffer));
sldns_buffer_read_u16_at(c->buffer, 2),
&edns, repinfo, *(uint16_t*)sldns_buffer_begin(c->buffer));
worker_mem_report(worker, NULL);
return 0;
}
@ -1202,7 +1202,7 @@ worker_init(struct worker* worker, struct config_file *cfg,
worker->env.attach_sub = &mesh_attach_sub;
worker->env.kill_sub = &mesh_state_delete;
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()) ||
!forwards_apply_cfg(worker->env.fwds, cfg)) {
log_err("Could not set forward zones");
@ -1265,7 +1265,7 @@ worker_delete(struct worker* worker)
}
outside_network_quit_prepare(worker->back);
mesh_delete(worker->env.mesh);
ldns_buffer_free(worker->env.scratch_buffer);
sldns_buffer_free(worker->env.scratch_buffer);
forwards_delete(worker->env.fwds);
hints_delete(worker->env.hints);
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),
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))
{
log_assert(0);
}
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))
{
log_assert(0);
}
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))
{
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
- Fix sldns to make globals use sldns_ prefix. This fixes
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++) {
if(nsdata->rr_len[i] < 2+1) continue; /* len + root label */
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 */
/* add rdata of NS (= wirefmt dname), skip rdatalen bytes */
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)");
return NULL;
}
dname = ldns_str2wire_dname(s->name, &dname_len);
dname = sldns_str2wire_dname(s->name, &dname_len);
if(!dname) {
log_err("cannot parse forward zone name %s", s->name);
return NULL;
@ -208,7 +208,7 @@ read_fwds_host(struct config_stub* s, struct delegpt* dp)
size_t dname_len;
for(p = s->hosts; p; p = p->next) {
log_assert(p->str);
dname = ldns_str2wire_dname(p->str, &dname_len);
dname = sldns_str2wire_dname(p->str, &dname_len);
if(!dname) {
log_err("cannot parse forward %s server name: '%s'",
s->name, p->str);
@ -294,7 +294,7 @@ make_stub_holes(struct iter_forwards* fwd, struct config_file* cfg)
uint8_t* dname;
size_t dname_len;
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) {
log_err("cannot parse stub name '%s'", s->name);
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;
socklen_t addrlen;
size_t dname_len;
uint8_t* dname = ldns_str2wire_dname(sv, &dname_len);
uint8_t* dname = sldns_str2wire_dname(sv, &dname_len);
if(!dname) {
log_err("could not parse %s", sv);
return 0;
@ -194,7 +194,7 @@ read_stubs_name(struct config_stub* s)
log_err("stub zone without a name");
return NULL;
}
dname = ldns_str2wire_dname(s->name, &dname_len);
dname = sldns_str2wire_dname(s->name, &dname_len);
if(!dname) {
log_err("cannot parse stub zone name %s", s->name);
return NULL;
@ -217,7 +217,7 @@ read_stubs_host(struct config_stub* s, struct delegpt* dp)
uint8_t* dname;
for(p = s->hosts; p; p = p->next) {
log_assert(p->str);
dname = ldns_str2wire_dname(p->str, &dname_len);
dname = sldns_str2wire_dname(p->str, &dname_len);
if(!dname) {
log_err("cannot parse stub %s nameserver name: '%s'",
s->name, p->str);
@ -283,7 +283,7 @@ read_stubs(struct iter_hints* hints, struct config_file* cfg)
static int
read_root_hints(struct iter_hints* hints, char* fname)
{
struct ldns_file_parse_state pstate;
struct sldns_file_parse_state pstate;
struct delegpt* dp;
uint8_t rr[LDNS_RR_BUF_SIZE];
size_t rr_len, dname_len;
@ -308,32 +308,32 @@ read_root_hints(struct iter_hints* hints, char* fname)
while(!feof(f)) {
rr_len = sizeof(rr);
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);
if(status != 0) {
log_err("reading root hints %s %d:%d: %s", fname,
pstate.lineno, LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status));
sldns_get_errorstr_parse(status));
goto stop_read;
}
if(rr_len == 0)
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) {
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)) {
log_err("out of memory reading root hints");
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(!delegpt_set_name_mlc(dp, rr)) {
log_err("out of memory.");
goto stop_read;
}
}
} else if(ldns_wirerr_get_type(rr, rr_len, dname_len)
== LDNS_RR_TYPE_A && ldns_wirerr_get_rdatalen(rr,
} else if(sldns_wirerr_get_type(rr, rr_len, dname_len)
== LDNS_RR_TYPE_A && sldns_wirerr_get_rdatalen(rr,
rr_len, dname_len) == INET_SIZE) {
struct sockaddr_in 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_port = (in_port_t)htons(UNBOUND_DNS_PORT);
memmove(&sa.sin_addr,
ldns_wirerr_get_rdata(rr, rr_len, dname_len),
sldns_wirerr_get_rdata(rr, rr_len, dname_len),
INET_SIZE);
if(!delegpt_add_target_mlc(dp, rr, dname_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");
goto stop_read;
}
} else if(ldns_wirerr_get_type(rr, rr_len, dname_len)
== LDNS_RR_TYPE_AAAA && ldns_wirerr_get_rdatalen(rr,
} else if(sldns_wirerr_get_type(rr, rr_len, dname_len)
== LDNS_RR_TYPE_AAAA && sldns_wirerr_get_rdatalen(rr,
rr_len, dname_len) == INET6_SIZE) {
struct sockaddr_in6 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_port = (in_port_t)htons(UNBOUND_DNS_PORT);
memmove(&sa.sin6_addr,
ldns_wirerr_get_rdata(rr, rr_len, dname_len),
sldns_wirerr_get_rdata(rr, rr_len, dname_len),
INET6_SIZE);
if(!delegpt_add_target_mlc(dp, rr, dname_len,
(struct sockaddr_storage*)&sa, len,
@ -368,7 +368,7 @@ read_root_hints(struct iter_hints* hints, char* fname)
}
} else {
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));
log_warn("root hints %s:%d skipping type %s",
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) {
log_assert(p->str);
nm = ldns_str2wire_dname(p->str, &nm_len);
nm = sldns_str2wire_dname(p->str, &nm_len);
if(!nm) {
log_err("cannot parse private-domain: %s", p->str);
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.
*/
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)
{
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 */
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)
{
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;
}
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)
{
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_port = (in_port_t)htons(UNBOUND_DNS_PORT);
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) {
prev = rr;
continue;
@ -275,7 +275,7 @@ int priv_rrset_bad(struct iter_priv* priv, ldns_buffer* pkt,
sa.sin6_family = AF_INET6;
sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT);
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) {
prev = rr;
continue;

4
iterator/iter_priv.h
View file

@ -43,7 +43,7 @@
#ifndef ITERATOR_ITER_PRIV_H
#define ITERATOR_ITER_PRIV_H
#include "util/rbtree.h"
struct ldns_buffer;
struct sldns_buffer;
struct iter_env;
struct config_file;
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.
* @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);
/**

38
iterator/iter_scrub.c
View file

@ -60,7 +60,7 @@
/** remove rrset, update loop variables */
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)
{
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 */
static int
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 len, oldpos;
@ -133,14 +133,14 @@ get_additional_name(struct rrset_parse* rrset, struct rr_parse* rr,
default:
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)
return 0; /* rdata field too small */
*nm = rr->ttl_data+sizeof(uint32_t)+sizeof(uint16_t)+offset;
oldpos = ldns_buffer_position(pkt);
ldns_buffer_set_position(pkt, (size_t)(*nm - ldns_buffer_begin(pkt)));
oldpos = sldns_buffer_position(pkt);
sldns_buffer_set_position(pkt, (size_t)(*nm - sldns_buffer_begin(pkt)));
*nmlen = pkt_dname_len(pkt);
ldns_buffer_set_position(pkt, oldpos);
sldns_buffer_set_position(pkt, oldpos);
if(*nmlen == 0)
return 0;
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 */
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)
{
/* 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 */
static int
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 */
uint8_t* dtarg = NULL;
@ -234,7 +234,7 @@ static struct rrset_parse*
synth_cname_rrset(uint8_t** sname, size_t* snamelen, uint8_t* alias,
size_t aliaslen, struct regional* region, struct msg_parse* msg,
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,
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);
if(!cn->rr_first->ttl_data)
return NULL;
ldns_write_uint32(cn->rr_first->ttl_data, 0); /* TTL = 0 */
ldns_write_uint16(cn->rr_first->ttl_data+4, aliaslen);
sldns_write_uint32(cn->rr_first->ttl_data, 0); /* TTL = 0 */
sldns_write_uint16(cn->rr_first->ttl_data+4, aliaslen);
memmove(cn->rr_first->ttl_data+6, alias, 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 */
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 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 */
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];
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 */
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];
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.
*/
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)
{
uint8_t* sname = qinfo->qname;
@ -515,7 +515,7 @@ scrub_normalize(ldns_buffer* pkt, struct msg_parse* msg,
* @param rrset: to store.
*/
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 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);
for(rr = rrset->rr_first; rr; rr = rr->next) {
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)) {
/* malformed domain name in rdata */
return 1;
@ -595,7 +595,7 @@ static int sanitize_nsec_is_overreach(struct rrset_parse* rrset,
* @return 0 on error.
*/
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 iter_env* ie)
{
@ -714,7 +714,7 @@ scrub_sanitize(ldns_buffer* pkt, struct msg_parse* msg,
}
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 module_env* env, struct iter_env* ie)
{

4
iterator/iter_scrub.h
View file

@ -42,7 +42,7 @@
#ifndef ITERATOR_ITER_SCRUB_H
#define ITERATOR_ITER_SCRUB_H
struct ldns_buffer;
struct sldns_buffer;
struct msg_parse;
struct query_info;
struct regional;
@ -62,7 +62,7 @@ struct iter_env;
* @param ie: iterator module environment data.
* @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 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*
dns_alloc_msg(ldns_buffer* pkt, struct msg_parse* msg,
dns_alloc_msg(sldns_buffer* pkt, struct msg_parse* msg,
struct regional* 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);
packed_rrset_ptr_fixup(newd);
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 */
log_rrset_key(VERB_ALGO, "store parent-side negative", neg);
iter_store_parentside_rrset(env, neg);

4
iterator/iter_utils.h
View file

@ -43,7 +43,7 @@
#ifndef ITERATOR_ITER_UTILS_H
#define ITERATOR_ITER_UTILS_H
#include "iterator/iter_resptype.h"
struct ldns_buffer;
struct sldns_buffer;
struct iter_env;
struct iter_hints;
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.
* @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);
/**

12
iterator/iterator.c
View file

@ -231,8 +231,8 @@ static int
error_response(struct module_qstate* qstate, int id, int rcode)
{
verbose(VERB_QUERY, "return error response %s",
ldns_lookup_by_id(SLDNS(_rcodes), rcode)?
ldns_lookup_by_id(SLDNS(_rcodes), rcode)->name:"??");
sldns_lookup_by_id(sldns_rcodes, rcode)?
sldns_lookup_by_id(sldns_rcodes, rcode)->name:"??");
qstate->return_rcode = rcode;
qstate->return_msg = NULL;
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 module_qstate* subq;
verbose(VERB_DETAIL, "priming . %s NS",
ldns_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)?
sldns_lookup_by_id(sldns_rr_classes, (int)qclass)->name:"??");
dp = hints_lookup_root(qstate->env->hints, qclass);
if(!dp) {
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 edns_data edns;
ldns_buffer* pkt;
sldns_buffer* pkt;
verbose(VERB_ALGO, "process_response: new external response event");
iq->response = NULL;
@ -2778,7 +2778,7 @@ process_response(struct module_qstate* qstate, struct iter_qstate* iq,
memset(prs, 0, sizeof(*prs));
memset(&edns, 0, sizeof(edns));
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) {
verbose(VERB_ALGO, "parse error on reply packet");
goto handle_it;

32
ldns/keyraw.c
View file

@ -26,7 +26,7 @@
#endif /* HAVE_SSL */
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)
{
/* for DSA keys */
@ -36,7 +36,7 @@ ldns_rr_dnskey_key_size_raw(const unsigned char* keydata,
uint16_t exp;
uint16_t int16;
switch ((ldns_algorithm)alg) {
switch ((sldns_algorithm)alg) {
case LDNS_DSA:
case LDNS_DSA_NSEC3:
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) {
return 0;
@ -113,10 +113,10 @@ uint16_t ldns_calc_keytag_raw(uint8_t* key, size_t keysize)
#ifdef HAVE_SSL
#ifdef USE_GOST
/** store GOST engine reference loaded into OpenSSL library */
ENGINE* ldns_gost_engine = NULL;
ENGINE* sldns_gost_engine = NULL;
int
ldns_key_EVP_load_gost_id(void)
sldns_key_EVP_load_gost_id(void)
{
static int gost_id = 0;
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
* 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);
return gost_id;
}
void ldns_key_EVP_unload_gost(void)
void sldns_key_EVP_unload_gost(void)
{
if(ldns_gost_engine) {
ENGINE_finish(ldns_gost_engine);
ENGINE_free(ldns_gost_engine);
ldns_gost_engine = NULL;
if(sldns_gost_engine) {
ENGINE_finish(sldns_gost_engine);
ENGINE_free(sldns_gost_engine);
sldns_gost_engine = NULL;
}
}
#endif /* USE_GOST */
DSA *
ldns_key_buf2dsa_raw(unsigned char* key, size_t len)
sldns_key_buf2dsa_raw(unsigned char* key, size_t len)
{
uint8_t T;
uint16_t length;
@ -227,7 +227,7 @@ ldns_key_buf2dsa_raw(unsigned char* key, size_t len)
}
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 exp;
@ -284,7 +284,7 @@ ldns_key_buf2rsa_raw(unsigned char* key, size_t len)
#ifdef USE_GOST
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 */
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
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 */
const unsigned char* pp = buf;
@ -349,7 +349,7 @@ ldns_ecdsa2pkey_raw(unsigned char* key, size_t keylen, uint8_t algo)
#endif /* USE_ECDSA */
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)
{
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
* \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);
/**
@ -44,7 +44,7 @@ size_t ldns_rr_dnskey_key_size_raw(const unsigned char *keydata,
* \param[in] keysize length of key data.
* \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
/**
@ -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.
* \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. */
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] len length of key data
* \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.
@ -72,7 +72,7 @@ DSA *ldns_key_buf2dsa_raw(unsigned char* key, size_t len);
* \param[in] keylen length of the key data
* \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.
@ -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.
* \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] len length of key data
* \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.
@ -100,7 +100,7 @@ RSA *ldns_key_buf2rsa_raw(unsigned char* key, size_t len);
* \param[in] md the message digest to use.
* \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);
#endif /* LDNS_BUILD_CONFIG_HAVE_SSL */

48
ldns/parse.c
View file

@ -15,7 +15,7 @@
#include <limits.h>
#include <strings.h>
ldns_lookup_table ldns_directive_types[] = {
sldns_lookup_table sldns_directive_types[] = {
{ LDNS_DIR_TTL, "$TTL" },
{ LDNS_DIR_ORIGIN, "$ORIGIN" },
{ LDNS_DIR_INCLUDE, "$INCLUDE" },
@ -24,13 +24,13 @@ ldns_lookup_table ldns_directive_types[] = {
/* add max_limit here? */
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
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 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;
tokenread:
ldns_fskipcs_l(f, del, line_nr);
sldns_fskipcs_l(f, del, line_nr);
*t = '\0';
if (p != 0) {
return -1;
@ -173,15 +173,15 @@ tokenread:
}
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)
{
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);
}
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)
{
/* 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)
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) {
free(fkeyword);
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) {
/* whee! */
/* 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);
return i;
} else {
@ -215,13 +215,13 @@ ldns_fget_keyword_data_l(FILE *f, const char *keyword, const char *k_del, char *
}
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
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)
{
int c, lc;
@ -250,7 +250,7 @@ ldns_bget_token_par(ldns_buffer *b, char *token, const char *delim,
quoted = 1;
}
while ((c = ldns_bgetc(b)) != EOF) {
while ((c = sldns_bgetc(b)) != EOF) {
if (c == '\r') /* carriage return */
c = ' ';
if (c == '(' && lc != '\\' && !quoted) {
@ -352,7 +352,7 @@ ldns_bget_token_par(ldns_buffer *b, char *token, const char *delim,
return (ssize_t)i;
tokenread:
ldns_bskipcs(b, del);
sldns_bskipcs(b, del);
*t = '\0';
if (!par && p != 0) {
@ -363,14 +363,14 @@ tokenread:
void
ldns_bskipcs(ldns_buffer *buffer, const char *s)
sldns_bskipcs(sldns_buffer *buffer, const char *s)
{
int found;
char c;
const char *d;
while(ldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) {
c = (char) ldns_buffer_read_u8_at(buffer, buffer->_position);
while(sldns_buffer_available_at(buffer, buffer->_position, sizeof(char))) {
c = (char) sldns_buffer_read_u8_at(buffer, buffer->_position);
found = 0;
for (d = s; *d; d++) {
if (*d == c) {
@ -386,13 +386,13 @@ ldns_bskipcs(ldns_buffer *buffer, const char *s)
}
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
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 c;
@ -417,7 +417,7 @@ ldns_fskipcs_l(FILE *fp, const char *s, int *line_nr)
}
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)
{
/* 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)
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) {
free(fkeyword);
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);
/* whee, the match! */
/* retrieve it's data */
i = ldns_bget_token(b, data, d_del, 0);
i = sldns_bget_token(b, data, d_del, 0);
return i;
} else {
free(fkeyword);

28
ldns/parse.h
View file

@ -10,7 +10,7 @@
#ifndef LDNS_PARSE_H
#define LDNS_PARSE_H
struct ldns_buffer;
struct sldns_buffer;
#ifdef __cplusplus
extern "C" {
@ -35,13 +35,13 @@ extern "C" {
* We now deal with $TTL, $ORIGIN and $INCLUDE.
* The latter is not implemented in ldns (yet)
*/
enum ldns_enum_directive
enum sldns_enum_directive
{
LDNS_DIR_TTL,
LDNS_DIR_ORIGIN,
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.
@ -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
* \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.
@ -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)
* \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.
@ -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.
* \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.
@ -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
* \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
@ -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
* \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
@ -124,7 +124,7 @@ ssize_t ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del,
debugging purposes)
* \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
@ -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
* \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.
@ -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
* \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
@ -155,7 +155,7 @@ int ldns_bgetc(struct ldns_buffer *buffer);
* \param[in] *s characters to skip
* \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
@ -164,7 +164,7 @@ void ldns_bskipcs(struct ldns_buffer *buffer, const char *s);
* \param[in] *s characters to skip
* \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)
* \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
}

84
ldns/parseutil.c
View file

@ -18,8 +18,8 @@
#include <time.h>
#include <ctype.h>
ldns_lookup_table *
ldns_lookup_by_name(ldns_lookup_table *table, const char *name)
sldns_lookup_table *
sldns_lookup_by_name(sldns_lookup_table *table, const char *name)
{
while (table->name != NULL) {
if (strcasecmp(name, table->name) == 0)
@ -29,8 +29,8 @@ ldns_lookup_by_name(ldns_lookup_table *table, const char *name)
return NULL;
}
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)
{
while (table->name != NULL) {
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).
*/
time_t
ldns_mktime_from_utc(const struct tm *tm)
sldns_mktime_from_utc(const struct tm *tm)
{
int year = 1900 + tm->tm_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
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 new_year;
@ -117,7 +117,7 @@ static const int leap_year_mdays[] = {
};
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;
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
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 */
+ 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 *
ldns_gmtime64_r(int64_t clock, struct tm *result)
sldns_gmtime64_r(int64_t clock, struct tm *result)
{
result->tm_isdst = 0;
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);
clock = LDNS_DIV(clock, 24);
ldns_year_and_yday_from_days_since_epoch(clock, result);
ldns_mon_and_mday_from_year_and_yday(result);
ldns_wday_from_year_and_yday(result);
sldns_year_and_yday_from_days_since_epoch(clock, result);
sldns_mon_and_mday_from_year_and_yday(result);
sldns_wday_from_year_and_yday(result);
result->tm_year -= 1900;
return result;
@ -165,26 +165,26 @@ ldns_gmtime64_r(int64_t clock, struct tm *result)
#endif /* SIZEOF_TIME_T <= 4 */
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;
return (int64_t) now + offset;
}
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
int64_t secs_since_epoch = ldns_serial_arithmitics_time(time, now);
return ldns_gmtime64_r(secs_since_epoch, result);
int64_t secs_since_epoch = sldns_serial_arithmitics_time(time, now);
return sldns_gmtime64_r(secs_since_epoch, result);
#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);
#endif
}
int
ldns_hexdigit_to_int(char ch)
sldns_hexdigit_to_int(char ch)
{
switch (ch) {
case '0': return 0;
@ -209,7 +209,7 @@ ldns_hexdigit_to_int(char ch)
}
uint32_t
ldns_str2period(const char *nptr, const char **endptr)
sldns_str2period(const char *nptr, const char **endptr)
{
int sign = 0;
uint32_t i = 0;
@ -284,7 +284,7 @@ ldns_str2period(const char *nptr, const char **endptr)
}
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;
@ -315,32 +315,32 @@ error:
/** parse one character, with escape codes */
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) {
case '\0': return 0;
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)++;
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;
}
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;
}
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)
{
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)
*/
ret_sz = add_padding ? ldns_b32_ntop_calculate_size(src_sz)
: ldns_b32_ntop_calculate_size_no_padding(src_sz);
ret_sz = add_padding ? sldns_b32_ntop_calculate_size(src_sz)
: sldns_b32_ntop_calculate_size_no_padding(src_sz);
/* Do we have enough space? */
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
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
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)
{
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;
}
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)
{
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
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
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)
{
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);
}
@ -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.
*/
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)
{
const char* b64 =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const char pad64 = '=';
size_t i = 0, o = 0;
if(targsize < ldns_b64_ntop_calculate_size(srclength))
if(targsize < sldns_b64_ntop_calculate_size(srclength))
return -1;
/* whole chunks: xxxxxxyy yyyyzzzz zzwwwwww */
while(i+3 <= srclength) {
@ -660,12 +660,12 @@ int ldns_b64_ntop(uint8_t const *src, size_t srclength,
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);
}
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 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,
* for instance in host2str.c
*/
struct ldns_struct_lookup_table {
struct sldns_struct_lookup_table {
int id;
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.
@ -36,7 +36,7 @@ typedef struct ldns_struct_lookup_table ldns_lookup_table;
* \param[in] name what to search for
* \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);
/**
* 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
* \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).
@ -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
* \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
@ -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
* \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.
@ -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
* \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
* \param[in] ch the hex char to convert
* \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
*/
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);
/**
* 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
*/
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);
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);
/**
* 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);
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);
/*
@ -135,7 +135,7 @@ int ldns_b32_pton_extended_hex(const char* src_text, size_t src_text_length,
*
* @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,
@ -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.
* @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 */

24
ldns/pkthdr.h
View file

@ -88,32 +88,32 @@ extern "C" {
#define LDNS_RA_CLR(wirebuf) (*(wirebuf+3) &= ~LDNS_RA_MASK)
/* Query ID */
#define LDNS_ID_WIRE(wirebuf) (ldns_read_uint16(wirebuf))
#define LDNS_ID_SET(wirebuf, id) (ldns_write_uint16(wirebuf, id))
#define LDNS_ID_WIRE(wirebuf) (sldns_read_uint16(wirebuf))
#define LDNS_ID_SET(wirebuf, id) (sldns_write_uint16(wirebuf, id))
/* Counter of the question section */
#define LDNS_QDCOUNT_OFF 4
/*
#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 */
#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 */
#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 */
#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
*/
enum ldns_enum_pkt_section {
enum sldns_enum_pkt_section {
LDNS_SECTION_QUESTION = 0,
LDNS_SECTION_ANSWER = 1,
LDNS_SECTION_AUTHORITY = 2,
@ -123,20 +123,20 @@ enum ldns_enum_pkt_section {
/** used to get all non-question rrs from a packet */
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 */
enum ldns_enum_pkt_opcode {
enum sldns_enum_pkt_opcode {
LDNS_PACKET_QUERY = 0,
LDNS_PACKET_IQUERY = 1,
LDNS_PACKET_STATUS = 2, /* there is no 3?? DNS is weird */
LDNS_PACKET_NOTIFY = 4,
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 */
enum ldns_enum_pkt_rcode {
enum sldns_enum_pkt_rcode {
LDNS_RCODE_NOERROR = 0,
LDNS_RCODE_FORMERR = 1,
LDNS_RCODE_SERVFAIL = 2,
@ -149,7 +149,7 @@ enum ldns_enum_pkt_rcode {
LDNS_RCODE_NOTAUTH = 9,
LDNS_RCODE_NOTZONE = 10
};
typedef enum ldns_enum_pkt_rcode ldns_pkt_rcode;
typedef enum sldns_enum_pkt_rcode sldns_pkt_rcode;
#ifdef __cplusplus
}

169
ldns/rrdef.c
View file

@ -17,11 +17,7 @@
#include "ldns/parseutil.h"
/* classes */
#ifdef USE_SLDNS
static ldns_lookup_table sldns_rr_classes_data[] = {
#else
static ldns_lookup_table ldns_rr_classes_data[] = {
#endif
static sldns_lookup_table sldns_rr_classes_data[] = {
{ LDNS_RR_CLASS_IN, "IN" },
{ LDNS_RR_CLASS_CH, "CH" },
{ LDNS_RR_CLASS_HS, "HS" },
@ -29,136 +25,132 @@ static ldns_lookup_table ldns_rr_classes_data[] = {
{ LDNS_RR_CLASS_ANY, "ANY" },
{ 0, NULL }
};
#ifdef USE_SLDNS
ldns_lookup_table* sldns_rr_classes = sldns_rr_classes_data;
#else
ldns_lookup_table* ldns_rr_classes = ldns_rr_classes_data;
#endif
sldns_lookup_table* sldns_rr_classes = sldns_rr_classes_data;
/* types */
static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };
static const ldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_soa_wireformat[] = {
static const sldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
static const sldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };
static const sldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_soa_wireformat[] = {
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
};
static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_wks_wireformat[] = {
static const sldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_wks_wireformat[] = {
LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_WKS
};
static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const ldns_rdf_type type_hinfo_wireformat[] = {
static const sldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_hinfo_wireformat[] = {
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
};
static const ldns_rdf_type type_mx_wireformat[] = {
static const sldns_rdf_type type_mx_wireformat[] = {
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
};
static const ldns_rdf_type type_afsdb_wireformat[] = {
static const sldns_rdf_type type_afsdb_wireformat[] = {
LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
};
static const ldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR };
static const ldns_rdf_type type_isdn_wireformat[] = {
static const sldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR };
static const sldns_rdf_type type_isdn_wireformat[] = {
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
};
static const ldns_rdf_type type_nsap_wireformat[] = {
static const sldns_rdf_type type_nsap_wireformat[] = {
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
};
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_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16,
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
};
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
};
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
};
static const ldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA };
static const ldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC };
static const ldns_rdf_type type_nxt_wireformat[] = {
static const sldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA };
static const sldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC };
static const sldns_rdf_type type_nxt_wireformat[] = {
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
};
static const ldns_rdf_type type_nimloc_wireformat[] = {
static const sldns_rdf_type type_nimloc_wireformat[] = {
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
};
static const ldns_rdf_type type_atma_wireformat[] = {
static const sldns_rdf_type type_atma_wireformat[] = {
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
};
static const ldns_rdf_type type_kx_wireformat[] = {
static const sldns_rdf_type type_kx_wireformat[] = {
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
};
static const ldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
static const ldns_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_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
static const sldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
static const sldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8,
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
};
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
};
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
};
static const ldns_rdf_type type_ipseckey_wireformat[] = {
static const sldns_rdf_type type_ipseckey_wireformat[] = {
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_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
};
static const ldns_rdf_type type_dhcid_wireformat[] = {
static const sldns_rdf_type type_dhcid_wireformat[] = {
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
};
/* 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_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_INT8,
LDNS_RDF_TYPE_INT8,
@ -166,13 +158,13 @@ static const ldns_rdf_type type_nsec3param_wireformat[] = {
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_INT8,
LDNS_RDF_TYPE_ALG,
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_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,
};
static const ldns_rdf_type type_tsig_wireformat[] = {
static const sldns_rdf_type type_tsig_wireformat[] = {
LDNS_RDF_TYPE_DNAME,
LDNS_RDF_TYPE_TSIGTIME,
LDNS_RDF_TYPE_INT16,
@ -190,7 +182,7 @@ static const ldns_rdf_type type_tsig_wireformat[] = {
LDNS_RDF_TYPE_INT16,
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,
@ -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
* 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_HEX,
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_ILNP64
};
static const ldns_rdf_type type_l32_wireformat[] = {
static const sldns_rdf_type type_l32_wireformat[] = {
LDNS_RDF_TYPE_INT16,
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_ILNP64
};
static const ldns_rdf_type type_lp_wireformat[] = {
static const sldns_rdf_type type_lp_wireformat[] = {
LDNS_RDF_TYPE_INT16,
LDNS_RDF_TYPE_DNAME
};
#ifdef DRAFT_RRTYPES
static const ldns_rdf_type type_eui48_wireformat[] = {
static const sldns_rdf_type type_eui48_wireformat[] = {
LDNS_RDF_TYPE_EUI48
};
static const ldns_rdf_type type_eui64_wireformat[] = {
static const sldns_rdf_type type_eui64_wireformat[] = {
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_LONG_STR
};
#endif
static const ldns_rdf_type type_caa_wireformat[] = {
static const sldns_rdf_type type_caa_wireformat[] = {
LDNS_RDF_TYPE_INT8,
LDNS_RDF_TYPE_TAG,
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:
* 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, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
/* 1 */
@ -668,8 +660,8 @@ static ldns_rr_descriptor rdata_field_descriptors[] = {
#define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \
(sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0]))
const ldns_rr_descriptor *
ldns_rr_descript(uint16_t type)
const sldns_rr_descriptor *
sldns_rr_descript(uint16_t type)
{
size_t i;
if (type < LDNS_RDATA_FIELD_DESCRIPTORS_COMMON) {
@ -688,7 +680,7 @@ ldns_rr_descript(uint16_t type)
}
size_t
ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor)
sldns_rr_descriptor_minimum(const sldns_rr_descriptor *descriptor)
{
if (descriptor) {
return descriptor->_minimum;
@ -698,7 +690,7 @@ ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor)
}
size_t
ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor)
sldns_rr_descriptor_maximum(const sldns_rr_descriptor *descriptor)
{
if (descriptor) {
if (descriptor->_variable != LDNS_RDF_TYPE_NONE) {
@ -711,8 +703,8 @@ ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor)
}
}
ldns_rdf_type
ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor,
sldns_rdf_type
sldns_rr_descriptor_field_type(const sldns_rr_descriptor *descriptor,
size_t index)
{
assert(descriptor != NULL);
@ -725,12 +717,12 @@ ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor,
}
}
ldns_rr_type
ldns_get_rr_type_by_name(const char *name)
sldns_rr_type
sldns_get_rr_type_by_name(const char *name)
{
unsigned int i;
const char *desc_name;
const ldns_rr_descriptor *desc;
const sldns_rr_descriptor *desc;
/* TYPEXX representation */
if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) {
@ -765,10 +757,10 @@ ldns_get_rr_type_by_name(const char *name)
return 0;
}
ldns_rr_class
ldns_get_rr_class_by_name(const char *name)
sldns_rr_class
sldns_get_rr_class_by_name(const char *name)
{
ldns_lookup_table *lt;
sldns_lookup_table *lt;
/* CLASSXX representation */
if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) {
@ -776,12 +768,7 @@ ldns_get_rr_class_by_name(const char *name)
}
/* Normal types */
#ifdef USE_SLDNS
lt = ldns_lookup_by_name(sldns_rr_classes, name);
#else
lt = ldns_lookup_by_name(ldns_rr_classes, name);
#endif
lt = sldns_lookup_by_name(sldns_rr_classes, name);
if (lt) {
return lt->id;
}

64
ldns/rrdef.h
View file

@ -41,16 +41,12 @@ extern "C" {
#define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON 258
/** lookuptable for rr classes */
#ifdef USE_SLDNS
extern struct ldns_struct_lookup_table* sldns_rr_classes;
#else
extern struct ldns_struct_lookup_table* ldns_rr_classes;
#endif
extern struct sldns_struct_lookup_table* sldns_rr_classes;
/**
* The different RR classes.
*/
enum ldns_enum_rr_class
enum sldns_enum_rr_class
{
/** the Internet */
LDNS_RR_CLASS_IN = 1,
@ -67,23 +63,23 @@ enum ldns_enum_rr_class
LDNS_RR_CLASS_LAST = 65535,
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.
*/
enum ldns_enum_rr_compress
enum sldns_enum_rr_compress
{
/** compression is allowed */
LDNS_RR_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.
*/
enum ldns_enum_rr_type
enum sldns_enum_rr_type
{
/** a host address */
LDNS_RR_TYPE_A = 1,
@ -240,7 +236,7 @@ enum ldns_enum_rr_type
LDNS_RR_TYPE_LAST = 65535,
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 */
#define LDNS_MAX_RDFLEN 65535
@ -262,7 +258,7 @@ typedef enum ldns_enum_rr_type ldns_rr_type;
/**
* The different types of RDATA fields.
*/
enum ldns_enum_rdf_type
enum sldns_enum_rdf_type
{
/** none */
LDNS_RDF_TYPE_NONE,
@ -351,12 +347,12 @@ enum ldns_enum_rdf_type
/* Aliases */
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
*/
enum ldns_enum_algorithm
enum sldns_enum_algorithm
{
LDNS_RSAMD5 = 1, /* RFC 4034,4035 */
LDNS_DH = 2,
@ -374,24 +370,24 @@ enum ldns_enum_algorithm
LDNS_PRIVATEDNS = 253,
LDNS_PRIVATEOID = 254
};
typedef enum ldns_enum_algorithm ldns_algorithm;
typedef enum sldns_enum_algorithm sldns_algorithm;
/**
* Hashing algorithms used in the DS record
*/
enum ldns_enum_hash
enum sldns_enum_hash
{
LDNS_SHA1 = 1, /* RFC 4034 */
LDNS_SHA256 = 2, /* RFC 4509 */
LDNS_HASH_GOST = 3, /* RFC 5933 */
LDNS_SHA384 = 4 /* RFC 6605 */
};
typedef enum ldns_enum_hash ldns_hash;
typedef enum sldns_enum_hash sldns_hash;
/**
* algorithms used in CERT rrs
*/
enum ldns_enum_cert_algorithm
enum sldns_enum_cert_algorithm
{
LDNS_CERT_PKIX = 1,
LDNS_CERT_SPKI = 2,
@ -404,12 +400,12 @@ enum ldns_enum_cert_algorithm
LDNS_CERT_URI = 253,
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
*/
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_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_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
@ -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.
*/
struct ldns_struct_rr_descriptor
struct sldns_struct_rr_descriptor
{
/** Type of the RR that is described here */
ldns_rr_type _type;
sldns_rr_type _type;
/** Textual name of the RR type. */
const char *_name;
/** 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. */
uint8_t _maximum;
/** 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 */
ldns_rdf_type _variable;
sldns_rdf_type _variable;
/** 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. */
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.
*
* \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.
@ -464,7 +460,7 @@ const ldns_rr_descriptor *ldns_rr_descript(uint16_t type);
* \param[in] descriptor for an rr type
* \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.
@ -472,7 +468,7 @@ size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor);
* \param[in] descriptor for an rr type
* \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.
@ -481,21 +477,21 @@ size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor);
* \param[in] field the field number
* \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.
* \param[in] name a string 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.
* \param[in] name string 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
}

70
ldns/sbuffer.c
View file

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

178
ldns/sbuffer.h
View file

@ -32,7 +32,7 @@ extern "C" {
* (big endian).
*/
INLINE uint16_t
ldns_read_uint16(const void *src)
sldns_read_uint16(const void *src)
{
#ifdef ALLOW_UNALIGNED_ACCESSES
return ntohs(*(uint16_t *) src);
@ -43,7 +43,7 @@ ldns_read_uint16(const void *src)
}
INLINE uint32_t
ldns_read_uint32(const void *src)
sldns_read_uint32(const void *src)
{
#ifdef ALLOW_UNALIGNED_ACCESSES
return ntohl(*(uint32_t *) src);
@ -61,7 +61,7 @@ ldns_read_uint32(const void *src)
* (big endian).
*/
INLINE void
ldns_write_uint16(void *dst, uint16_t data)
sldns_write_uint16(void *dst, uint16_t data)
{
#ifdef ALLOW_UNALIGNED_ACCESSES
* (uint16_t *) dst = htons(data);
@ -73,7 +73,7 @@ ldns_write_uint16(void *dst, uint16_t data)
}
INLINE void
ldns_write_uint32(void *dst, uint32_t data)
sldns_write_uint32(void *dst, uint32_t data)
{
#ifdef ALLOW_UNALIGNED_ACCESSES
* (uint32_t *) dst = htonl(data);
@ -90,17 +90,17 @@ ldns_write_uint32(void *dst, uint32_t data)
/**
* \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
*
* 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
* access any data within it.
*/
struct ldns_buffer
struct sldns_buffer
{
/** The current position used for reading/writing */
size_t _position;
@ -122,16 +122,16 @@ struct ldns_buffer
* multiple writes in sequence and check for success afterwards. */
unsigned _status_err : 1;
};
typedef struct ldns_buffer ldns_buffer;
typedef struct sldns_buffer sldns_buffer;
#ifdef NDEBUG
INLINE void
ldns_buffer_invariant(ldns_buffer *ATTR_UNUSED(buffer))
sldns_buffer_invariant(sldns_buffer *ATTR_UNUSED(buffer))
{
}
#else
INLINE void
ldns_buffer_invariant(ldns_buffer *buffer)
sldns_buffer_invariant(sldns_buffer *buffer)
{
assert(buffer != NULL);
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
* \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
@ -157,7 +157,7 @@ ldns_buffer *ldns_buffer_new(size_t capacity);
* \param[in] data the data to encapsulate in the buffer
* \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.
@ -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] 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
* is set to the capacity and the position is set to 0.
* \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? */
@ -191,9 +191,9 @@ INLINE void ldns_buffer_clear(ldns_buffer *buffer)
* \param[in] buffer the buffer to flip
* \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->_position = 0;
@ -204,9 +204,9 @@ INLINE void ldns_buffer_flip(ldns_buffer *buffer)
* position is reset to 0.
* \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;
}
@ -217,7 +217,7 @@ INLINE void ldns_buffer_rewind(ldns_buffer *buffer)
* \return the current position
*/
INLINE size_t
ldns_buffer_position(ldns_buffer *buffer)
sldns_buffer_position(sldns_buffer *buffer)
{
return buffer->_position;
}
@ -229,7 +229,7 @@ ldns_buffer_position(ldns_buffer *buffer)
* \param[in] mark the mark to use
*/
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);
buffer->_position = mark;
@ -243,7 +243,7 @@ ldns_buffer_set_position(ldns_buffer *buffer, size_t mark)
* \param[in] count the count to use
*/
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);
buffer->_position += count;
@ -255,7 +255,7 @@ ldns_buffer_skip(ldns_buffer *buffer, ssize_t count)
* \return the size
*/
INLINE size_t
ldns_buffer_limit(ldns_buffer *buffer)
sldns_buffer_limit(sldns_buffer *buffer)
{
return buffer->_limit;
}
@ -267,7 +267,7 @@ ldns_buffer_limit(ldns_buffer *buffer)
* \param[in] limit the new limit
*/
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);
buffer->_limit = limit;
@ -281,7 +281,7 @@ ldns_buffer_set_limit(ldns_buffer *buffer, size_t limit)
* \return the number of bytes
*/
INLINE size_t
ldns_buffer_capacity(ldns_buffer *buffer)
sldns_buffer_capacity(sldns_buffer *buffer)
{
return buffer->_capacity;
}
@ -294,7 +294,7 @@ ldns_buffer_capacity(ldns_buffer *buffer)
* \param[in] capacity the capacity to use
* \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
@ -306,7 +306,7 @@ int ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity);
* \param[in] amount amount to use
* \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.
@ -315,7 +315,7 @@ int ldns_buffer_reserve(ldns_buffer *buffer, size_t amount);
* \return the pointer to the data
*/
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);
return buffer->_data + at;
@ -328,9 +328,9 @@ ldns_buffer_at(const ldns_buffer *buffer, size_t at)
* \return the pointer
*/
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
*/
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
*/
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
*/
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);
return buffer->_limit - at;
}
@ -378,9 +378,9 @@ ldns_buffer_remaining_at(ldns_buffer *buffer, size_t at)
* \return the number of bytes
*/
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?)
*/
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?)
*/
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
*/
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);
}
@ -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
*/
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;
}
@ -444,9 +444,9 @@ ldns_buffer_write(ldns_buffer *buffer, const void *data, size_t count)
* \param[in] str the string to write
*/
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
*/
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
*/
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;
}
@ -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
*/
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);
}
@ -492,10 +492,10 @@ ldns_buffer_write_u8(ldns_buffer *buffer, uint8_t data)
* \param[in] data the 16 bits to write
*/
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)));
ldns_write_uint16(buffer->_data + at, data);
assert(sldns_buffer_available_at(buffer, at, sizeof(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
*/
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);
}
@ -517,10 +517,10 @@ ldns_buffer_write_u16(ldns_buffer *buffer, uint16_t data)
* \param[in] data the 32 bits to write
*/
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)));
ldns_write_uint32(buffer->_data + at, data);
assert(sldns_buffer_available_at(buffer, at, sizeof(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
*/
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);
}
@ -543,9 +543,9 @@ ldns_buffer_write_u32(ldns_buffer *buffer, uint32_t data)
* \param[in] count the length of the data to copy
*/
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);
}
@ -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
*/
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;
}
@ -569,9 +569,9 @@ ldns_buffer_read(ldns_buffer *buffer, void *data, size_t count)
* \return 1 byte integer
*/
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];
}
@ -581,9 +581,9 @@ ldns_buffer_read_u8_at(ldns_buffer *buffer, size_t at)
* \return 1 byte integer
*/
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);
return result;
}
@ -595,10 +595,10 @@ ldns_buffer_read_u8(ldns_buffer *buffer)
* \return 2 byte integer
*/
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)));
return ldns_read_uint16(buffer->_data + at);
assert(sldns_buffer_available_at(buffer, at, sizeof(uint16_t)));
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
*/
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);
return result;
}
@ -621,10 +621,10 @@ ldns_buffer_read_u16(ldns_buffer *buffer)
* \return 4 byte integer
*/
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)));
return ldns_read_uint32(buffer->_data + at);
assert(sldns_buffer_available_at(buffer, at, sizeof(uint32_t)));
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
*/
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);
return result;
}
@ -646,7 +646,7 @@ ldns_buffer_read_u32(ldns_buffer *buffer)
* \return the status
*/
INLINE int
ldns_buffer_status(ldns_buffer *buffer)
sldns_buffer_status(sldns_buffer *buffer)
{
return (int)buffer->_status_err;
}
@ -657,10 +657,10 @@ ldns_buffer_status(ldns_buffer *buffer)
* \return true or false
*/
INLINE int
ldns_buffer_status_ok(ldns_buffer *buffer)
sldns_buffer_status_ok(sldns_buffer *buffer)
{
if (buffer) {
return ldns_buffer_status(buffer) == 0;
return sldns_buffer_status(buffer) == 0;
} else {
return 0;
}
@ -672,7 +672,7 @@ ldns_buffer_status_ok(ldns_buffer *buffer)
* Returns the number of characters written (not including the
* 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);
/**
@ -680,7 +680,7 @@ int ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...)
* \param[in] *buffer the buffer to be freed
* \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
@ -688,7 +688,7 @@ void ldns_buffer_free(ldns_buffer *buffer);
* \param[in] *buffer the buffer to be exported
* \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
@ -697,7 +697,7 @@ void *ldns_buffer_export(ldns_buffer *buffer);
* \param[out] *result resulting buffer which is copied to.
* \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
}

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
extern "C" {
#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 */
#define LDNS_RR_BUF_SIZE 65535 /* bytes */
@ -29,8 +29,8 @@ struct ldns_struct_lookup_table;
/*
* To convert class and type to string see
* ldns_get_rr_class_by_name(str)
* ldns_get_rr_type_by_name(str)
* sldns_get_rr_class_by_name(str)
* sldns_get_rr_type_by_name(str)
* 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.
* @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 '.').
* @param str: the text string with the domain name.
* @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.
* @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);
/**
@ -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.
* @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.
@ -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
* the wire-dname(uncompressed), type, class, ttl, rdatalen, rdata.
* 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.
* @param len: on input the length of the buffer, on output the amount of
* 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.
* @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 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.
* 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 rr: the buffer where the result is stored into.
* @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.
* @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 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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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
* 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
* 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.
@ -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.
* @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.
@ -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.
* @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
@ -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_ERROR(e) ((e)&LDNS_WIREPARSE_MASK)
#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_GENERAL 342
#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
* @return string.
*/
const char* ldns_get_errorstr_parse(int e);
const char* sldns_get_errorstr_parse(int e);
/**
* 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 */
uint8_t origin[LDNS_MAX_DOMAINLEN+1];
/** 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.
* @return 0 on success, error on failure.
*/
int ldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len,
struct ldns_file_parse_state* parse_state);
int sldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len,
struct sldns_file_parse_state* parse_state);
/**
* 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.
* @return 0 on success, error on failure.
*/
int ldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len,
ldns_rdf_type rdftype);
int sldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len,
sldns_rdf_type rdftype);
/**
* 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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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.
@ -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.
* @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
}

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
extern "C" {
#endif
struct ldns_struct_lookup_table;
#ifndef SLDNS
# ifdef USE_SLDNS
# define SLDNS(x) sldns##x
# else
# define SLDNS(x) ldns##x
# endif
#endif
struct sldns_struct_lookup_table;
/* lookup tables for standard DNS stuff */
/** 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 */
extern struct ldns_struct_lookup_table* SLDNS(_hashes);
extern struct sldns_struct_lookup_table* sldns_hashes;
/** 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 */
extern struct ldns_struct_lookup_table* SLDNS(_rcodes);
extern struct sldns_struct_lookup_table* sldns_rcodes;
/** Operation codes */
extern struct ldns_struct_lookup_table* SLDNS(_opcodes);
extern struct sldns_struct_lookup_table* sldns_opcodes;
/** EDNS flags */
extern struct ldns_struct_lookup_table* SLDNS(_edns_flags);
extern struct sldns_struct_lookup_table* sldns_edns_flags;
/** 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 */
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
@ -53,7 +45,7 @@ extern struct ldns_struct_lookup_table* SLDNS(_wireparse_errors);
* @param len: length of packet.
* @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.
@ -62,7 +54,7 @@ char* ldns_wire2str_pkt(uint8_t* data, size_t len);
* @param len: length of the rr wireformat.
* @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.
@ -70,28 +62,28 @@ char* ldns_wire2str_rr(uint8_t* rr, size_t len);
* @param dname_len: length of the dname.
* @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'...
* @param rrtype: the RR type in host order.
* @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'.
* @param rrclass: the RR class in host order.
* @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'...
* @param rcode: as integer, host order
* @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.
@ -101,7 +93,7 @@ char* ldns_wire2str_rcode(int rcode);
* @param args: arguments for printf.
* @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.
@ -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.
* @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);
/**
@ -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.
* 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);
/**
@ -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
* 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);
/**
* 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_len: length of data 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.
* @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);
/**
* 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_len: length of data 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.
* @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);
/**
* 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_len: length of data 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.
* @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);
/**
@ -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.
* @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);
/**
* 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_len: length of data buffer.
* @param str: string buffer.
* @param str_len: length of string buffer.
* @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);
/**
* 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_len: length of data buffer. The length of the rdata in the
* 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.
* @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);
/**
* 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_len: length of data buffer, the length of the rdata in buffer.
* @param str: string buffer.
* @param str_len: length of string buffer.
* @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);
/**
* 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_len: length of data 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.
* @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);
/**
* 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_len: length of data buffer.
* @param str: string buffer.
* @param str_len: length of string buffer.
* @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);
/**
* 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_len: length of data buffer.
* @param str: string buffer.
* @param str_len: length of string buffer.
* @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);
/**
* 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_len: length of data buffer.
* @param str: string buffer.
* @param str_len: length of string buffer.
* @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);
@ -309,7 +301,7 @@ int ldns_wire2str_ttl_scan(uint8_t** data, size_t* data_len, char** str,
* @param rrtype: host format rr type.
* @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.
@ -318,7 +310,7 @@ int ldns_wire2str_type_print(char** str, size_t* str_len, uint16_t rrtype);
* @param rrclass: host format rr class.
* @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.
@ -327,7 +319,7 @@ int ldns_wire2str_class_print(char** str, size_t* str_len, uint16_t rrclass);
* @param rcode: host format rcode number.
* @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.
@ -336,7 +328,7 @@ int ldns_wire2str_rcode_print(char** str, size_t* str_len, int rcode);
* @param opcode: host format opcode number.
* @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.
@ -345,7 +337,7 @@ int ldns_wire2str_opcode_print(char** str, size_t* str_len, int opcode);
* @param opcode: host format option number.
* @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);
/**
@ -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.
* 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);
/**
@ -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.
* 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);
/**
@ -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.
* 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);
/**
@ -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.
* 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);
/**
@ -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.
* 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.
@ -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.
* 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.
@ -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.
* 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.
@ -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.
* 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);
/**
* 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_len: length of data buffer.
* @param str: 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 pktlen: length of packet buffer.
* @return number of characters (except null) needed to print.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
* 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_len: length of data 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.
* 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);
/**
@ -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.
* @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);
/**
@ -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.
* @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);
/**
@ -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.
* @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);
/**
@ -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.
* @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);
/**
@ -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.
* @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);
/**
@ -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.
* @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);
/**
@ -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.
* @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);
/**
@ -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.
* @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);
/**
* 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_len: length of data 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.
* @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);
#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;
p = (uint8_t*)malloc(*len);
if(!p) return NULL;
ldns_write_uint32(p, UB_LIBCMD_NEWQUERY);
ldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
ldns_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, UB_LIBCMD_NEWQUERY);
sldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
sldns_write_uint32(p+2*sizeof(uint32_t), (uint32_t)q->res->qtype);
sldns_write_uint32(p+3*sizeof(uint32_t), (uint32_t)q->res->qclass);
memmove(p+4*sizeof(uint32_t), q->res->qname, slen);
return p;
}
@ -238,8 +238,8 @@ context_deserialize_new_query(struct ub_ctx* ctx, uint8_t* p, uint32_t len)
free(q);
return NULL;
}
log_assert( ldns_read_uint32(p) == UB_LIBCMD_NEWQUERY);
q->querynum = (int)ldns_read_uint32(p+sizeof(uint32_t));
log_assert( sldns_read_uint32(p) == UB_LIBCMD_NEWQUERY);
q->querynum = (int)sldns_read_uint32(p+sizeof(uint32_t));
q->node.key = &q->querynum;
q->async = 1;
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);
return NULL;
}
q->res->qtype = (int)ldns_read_uint32(p+2*sizeof(uint32_t));
q->res->qclass = (int)ldns_read_uint32(p+3*sizeof(uint32_t));
q->res->qtype = (int)sldns_read_uint32(p+2*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)));
if(!q->res->qname) {
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) {
return NULL;
}
log_assert( ldns_read_uint32(p) == UB_LIBCMD_NEWQUERY);
querynum = (int)ldns_read_uint32(p+sizeof(uint32_t));
log_assert( sldns_read_uint32(p) == UB_LIBCMD_NEWQUERY);
querynum = (int)sldns_read_uint32(p+sizeof(uint32_t));
q = (struct ctx_query*)rbtree_search(&ctx->queries, &querynum);
if(!q) {
return NULL;
@ -281,7 +281,7 @@ context_lookup_new_query(struct ub_ctx* ctx, uint8_t* p, uint32_t len)
}
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)
{
/* 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.
* 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;
uint8_t* p;
*len = sizeof(uint32_t)*5 + pkt_len + wlen;
p = (uint8_t*)malloc(*len);
if(!p) return NULL;
ldns_write_uint32(p, UB_LIBCMD_ANSWER);
ldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
ldns_write_uint32(p+2*sizeof(uint32_t), (uint32_t)err);
ldns_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, UB_LIBCMD_ANSWER);
sldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
sldns_write_uint32(p+2*sizeof(uint32_t), (uint32_t)err);
sldns_write_uint32(p+3*sizeof(uint32_t), (uint32_t)q->msg_security);
sldns_write_uint32(p+4*sizeof(uint32_t), (uint32_t)wlen);
if(wlen > 0)
memmove(p+5*sizeof(uint32_t), q->res->why_bogus, wlen);
if(pkt_len > 0)
memmove(p+5*sizeof(uint32_t)+wlen,
ldns_buffer_begin(pkt), pkt_len);
sldns_buffer_begin(pkt), pkt_len);
return p;
}
@ -321,13 +321,13 @@ context_deserialize_answer(struct ub_ctx* ctx,
int id;
size_t wlen;
if(len < 5*sizeof(uint32_t)) return NULL;
log_assert( ldns_read_uint32(p) == UB_LIBCMD_ANSWER);
id = (int)ldns_read_uint32(p+sizeof(uint32_t));
log_assert( sldns_read_uint32(p) == UB_LIBCMD_ANSWER);
id = (int)sldns_read_uint32(p+sizeof(uint32_t));
q = (struct ctx_query*)rbtree_search(&ctx->queries, &id);
if(!q) return NULL;
*err = (int)ldns_read_uint32(p+2*sizeof(uint32_t));
q->msg_security = ldns_read_uint32(p+3*sizeof(uint32_t));
wlen = (size_t)ldns_read_uint32(p+4*sizeof(uint32_t));
*err = (int)sldns_read_uint32(p+2*sizeof(uint32_t));
q->msg_security = sldns_read_uint32(p+3*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)
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));
if(!p) return NULL;
*len = 2*sizeof(uint32_t);
ldns_write_uint32(p, UB_LIBCMD_CANCEL);
ldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
sldns_write_uint32(p, UB_LIBCMD_CANCEL);
sldns_write_uint32(p+sizeof(uint32_t), (uint32_t)q->querynum);
return p;
}
@ -374,8 +374,8 @@ struct ctx_query* context_deserialize_cancel(struct ub_ctx* ctx,
struct ctx_query* q;
int id;
if(len != 2*sizeof(uint32_t)) return NULL;
log_assert( ldns_read_uint32(p) == UB_LIBCMD_CANCEL);
id = (int)ldns_read_uint32(p+sizeof(uint32_t));
log_assert( sldns_read_uint32(p) == UB_LIBCMD_CANCEL);
id = (int)sldns_read_uint32(p+sizeof(uint32_t));
q = (struct ctx_query*)rbtree_search(&ctx->queries, &id);
return q;
}
@ -387,7 +387,7 @@ context_serialize_quit(uint32_t* len)
if(!p)
return NULL;
*len = sizeof(uint32_t);
ldns_write_uint32(p, UB_LIBCMD_QUIT);
sldns_write_uint32(p, UB_LIBCMD_QUIT);
return p;
}
@ -396,6 +396,6 @@ enum ub_ctx_cmd context_serial_getcmd(uint8_t* p, uint32_t len)
uint32_t v;
if((size_t)len < sizeof(v))
return UB_LIBCMD_QUIT;
v = ldns_read_uint32(p);
v = sldns_read_uint32(p);
return v;
}

4
libunbound/context.h
View file

@ -48,7 +48,7 @@
#include "util/data/packed_rrset.h"
struct libworker;
struct tube;
struct ldns_buffer;
struct sldns_buffer;
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.
*/
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

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);
} else {
/* 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();
*res = q->res;
(*res)->rcode = LDNS_RCODE_SERVFAIL;
if(region && buf) {
ldns_buffer_clear(buf);
ldns_buffer_write(buf, q->msg, q->msg_len);
ldns_buffer_flip(buf);
sldns_buffer_clear(buf);
sldns_buffer_write(buf, q->msg, q->msg_len);
sldns_buffer_flip(buf);
libworker_enter_result(*res, buf, region,
q->msg_security);
}
(*res)->answer_packet = q->msg;
(*res)->answer_len = (int)q->msg_len;
q->msg = NULL;
ldns_buffer_free(buf);
sldns_buffer_free(buf);
regional_destroy(region);
}
q->res = NULL;

58
libunbound/libworker.c
View file

@ -83,7 +83,7 @@ libworker_delete_env(struct libworker* w)
mesh_delete(w->env->mesh);
context_release_alloc(w->ctx, w->env->alloc,
!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);
forwards_delete(w->env->fwds);
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);
}
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();
if(w->env->fwds && !forwards_apply_cfg(w->env->fwds, cfg)) {
forwards_delete(w->env->fwds);
@ -414,7 +414,7 @@ int libworker_bg(struct ub_ctx* ctx)
/** get msg reply struct (in temp region) */
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 msg_parse* msg;
@ -422,7 +422,7 @@ parse_reply(ldns_buffer* pkt, struct regional* region, struct query_info* qi)
return NULL;
}
memset(msg, 0, sizeof(*msg));
ldns_buffer_set_position(pkt, 0);
sldns_buffer_set_position(pkt, 0);
if(parse_packet(pkt, msg, region) != 0)
return 0;
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 */
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 query_info rq;
@ -526,7 +526,7 @@ libworker_enter_result(struct ub_result* res, ldns_buffer* buf,
/** fillup fg results */
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)
{
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->msg_security = 0;
q->msg = memdup(ldns_buffer_begin(buf), ldns_buffer_limit(buf));
q->msg_len = ldns_buffer_limit(buf);
q->msg = memdup(sldns_buffer_begin(buf), sldns_buffer_limit(buf));
q->msg_len = sldns_buffer_limit(buf);
if(!q->msg) {
return; /* the error is in the rcode */
}
@ -551,7 +551,7 @@ libworker_fillup_fg(struct ctx_query* q, int rcode, ldns_buffer* buf,
}
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)
{
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->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) {
return 0;
}
@ -576,8 +576,8 @@ setup_qinfo_edns(struct libworker* w, struct ctx_query* q,
edns->ext_rcode = 0;
edns->edns_version = 0;
edns->bits = EDNS_DO;
if(ldns_buffer_capacity(w->back->udp_buff) < 65535)
edns->udp_size = (uint16_t)ldns_buffer_capacity(
if(sldns_buffer_capacity(w->back->udp_buff) < 65535)
edns->udp_size = (uint16_t)sldns_buffer_capacity(
w->back->udp_buff);
else edns->udp_size = 65535;
return 1;
@ -599,8 +599,8 @@ int libworker_fg(struct ub_ctx* ctx, struct ctx_query* q)
qflags = BIT_RD;
q->w = w;
/* see if there is a fixed answer */
ldns_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, 0, qid);
sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
if(local_zones_answer(ctx->local_zones, &qinfo, &edns,
w->back->udp_buff, 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
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)
{
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;
q->w = w;
/* see if there is a fixed answer */
ldns_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, 0, qid);
sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
if(local_zones_answer(ctx->local_zones, &qinfo, &edns,
w->back->udp_buff, 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 */
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)
{
uint8_t* msg = NULL;
@ -704,8 +704,8 @@ add_bg_result(struct libworker* w, struct ctx_query* q, ldns_buffer* pkt,
if(reason)
q->res->why_bogus = strdup(reason);
if(pkt) {
q->msg_len = ldns_buffer_remaining(pkt);
q->msg = memdup(ldns_buffer_begin(pkt), q->msg_len);
q->msg_len = sldns_buffer_remaining(pkt);
q->msg = memdup(sldns_buffer_begin(pkt), q->msg_len);
if(!q->msg)
msg = context_serialize_answer(q, UB_NOMEM,
NULL, &len);
@ -733,7 +733,7 @@ add_bg_result(struct libworker* w, struct ctx_query* q, ldns_buffer* pkt,
}
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)
{
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;
qflags = BIT_RD;
/* see if there is a fixed answer */
ldns_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, 0, qid);
sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
if(local_zones_answer(w->ctx->local_zones, &qinfo, &edns,
w->back->udp_buff, 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;
}
/* sanity check. */
if(!LDNS_QR_WIRE(ldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) !=
if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
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
* never arrived. */
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;
}
/* sanity check. */
if(!LDNS_QR_WIRE(ldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(ldns_buffer_begin(c->buffer)) !=
if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
|| LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
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
* never arrived. */
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 regional;
struct tube;
struct ldns_buffer;
struct sldns_buffer;
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);
/** 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);
/** 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);
/** 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);
/**
@ -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
* (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);
#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 */
int createResponse(struct module_qstate* qstate, ldns_buffer* pkt)
int createResponse(struct module_qstate* qstate, sldns_buffer* pkt)
{
struct msg_parse* prs;
struct edns_data edns;
@ -122,7 +122,7 @@ int createResponse(struct module_qstate* qstate, ldns_buffer* pkt)
memset(prs, 0, sizeof(*prs));
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) {
verbose(VERB_ALGO, "storeResponse: parse error on reply packet");
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
*
* @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.
*/
int createResponse(struct module_qstate* qstate, ldns_buffer* pkt);
int createResponse(struct module_qstate* qstate, sldns_buffer* pkt);
/**
* 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;
msg->rep->ttl = 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);
msg->rep->an_numrrsets ++;
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)
return NULL;
front->cps = NULL;
front->udp_buff = ldns_buffer_new(bufsize);
front->udp_buff = sldns_buffer_new(bufsize);
if(!front->udp_buff) {
free(front);
return NULL;
@ -855,7 +855,7 @@ listen_delete(struct listen_dnsport* front)
if(!front)
return;
listen_list_delete(front->cps);
ldns_buffer_free(front->udp_buff);
sldns_buffer_free(front->udp_buff);
free(front);
}
@ -961,7 +961,7 @@ size_t listen_get_mem(struct listen_dnsport* listen)
{
size_t s = sizeof(*listen) + sizeof(*listen->base) +
sizeof(*listen->udp_buff) +
ldns_buffer_capacity(listen->udp_buff);
sldns_buffer_capacity(listen->udp_buff);
struct listen_list* p;
for(p = listen->cps; p; p = p->next) {
s += sizeof(*p);

4
services/listen_dnsport.h
View file

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

54
services/localzone.c
View file

@ -125,7 +125,7 @@ local_data_cmp(const void* d1, const void* d2)
int
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;
if(!*res) {
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)
{
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);
if(e) {
log_err("error parsing local-data at %d: '%s': %s",
LDNS_WIREPARSE_OFFSET(e), str,
ldns_get_errorstr_parse(e));
sldns_get_errorstr_parse(e));
return 0;
}
*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");
return 0;
}
*dclass = ldns_wirerr_get_class(rr, len, dname_len);
*type = ldns_wirerr_get_type(rr, len, dname_len);
*ttl = (time_t)ldns_wirerr_get_ttl(rr, len, dname_len);
*rdata = ldns_wirerr_get_rdatawl(rr, len, dname_len);
*rdata_len = ldns_wirerr_get_rdatalen(rr, len, dname_len)+2;
*dclass = sldns_wirerr_get_class(rr, len, dname_len);
*type = sldns_wirerr_get_type(rr, len, dname_len);
*ttl = (time_t)sldns_wirerr_get_ttl(rr, len, dname_len);
*rdata = sldns_wirerr_get_rdatawl(rr, len, dname_len);
*rdata_len = sldns_wirerr_get_rdatalen(rr, len, dname_len)+2;
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];
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);
if(s != 0) {
log_err("error parsing local-data at %d '%s': %s",
LDNS_WIREPARSE_OFFSET(s), str,
ldns_get_errorstr_parse(s));
sldns_get_errorstr_parse(s));
return 0;
}
*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) {
log_err("out of memory");
return 0;
@ -962,7 +962,7 @@ void local_zones_print(struct local_zones* zones)
/** encode answer consisting of 1 rrset */
static int
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 reply_info rep;
@ -982,20 +982,20 @@ local_encode(struct query_info* qinfo, struct edns_data* edns,
edns->ext_rcode = 0;
edns->bits &= EDNS_DO;
if(!reply_info_answer_encode(qinfo, &rep,
*(uint16_t*)ldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2),
*(uint16_t*)sldns_buffer_begin(buf),
sldns_buffer_read_u16_at(buf, 2),
buf, 0, 0, temp, udpsize, edns,
(int)(edns->bits&EDNS_DO), 0))
error_encode(buf, (LDNS_RCODE_SERVFAIL|BIT_AA), qinfo,
*(uint16_t*)ldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), edns);
*(uint16_t*)sldns_buffer_begin(buf),
sldns_buffer_read_u16_at(buf, 2), edns);
return 1;
}
/** answer local data match */
static int
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)
{
struct local_data key;
@ -1042,18 +1042,18 @@ local_data_answer(struct local_zone* z, struct query_info* qinfo,
*/
static int
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)
{
if(z->type == local_zone_deny) {
/** no reply at all, signal caller by clearing buffer. */
ldns_buffer_clear(buf);
ldns_buffer_flip(buf);
sldns_buffer_clear(buf);
sldns_buffer_flip(buf);
return 1;
} else if(z->type == local_zone_refuse) {
error_encode(buf, (LDNS_RCODE_REFUSED|BIT_AA), qinfo,
*(uint16_t*)ldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), edns);
*(uint16_t*)sldns_buffer_begin(buf),
sldns_buffer_read_u16_at(buf, 2), edns);
return 1;
} else if(z->type == local_zone_static ||
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,
z->soa, 0, rcode);
error_encode(buf, (rcode|BIT_AA), qinfo,
*(uint16_t*)ldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), edns);
*(uint16_t*)sldns_buffer_begin(buf),
sldns_buffer_read_u16_at(buf, 2), edns);
return 1;
} else if(z->type == local_zone_typetransparent) {
/* 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,
z->soa, 0, rcode);
error_encode(buf, (rcode|BIT_AA), qinfo,
*(uint16_t*)ldns_buffer_begin(buf),
ldns_buffer_read_u16_at(buf, 2), edns);
*(uint16_t*)sldns_buffer_begin(buf),
sldns_buffer_read_u16_at(buf, 2), edns);
return 1;
}
@ -1097,7 +1097,7 @@ lz_zone_answer(struct local_zone* z, struct query_info* qinfo,
int
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,
* if so: - try to match (exact) local data

4
services/localzone.h
View file

@ -48,7 +48,7 @@ struct regional;
struct config_file;
struct edns_data;
struct query_info;
struct ldns_buffer;
struct sldns_buffer;
/**
* Local zone type
@ -225,7 +225,7 @@ void local_zones_print(struct local_zones* zones);
* value is true, but the buffer is cleared (empty).
*/
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.

28
services/mesh.c
View file

@ -162,7 +162,7 @@ mesh_create(struct module_stack* stack, struct module_env* env)
return NULL;
}
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) {
free(mesh);
log_err("mesh area alloc: out of memory");
@ -210,7 +210,7 @@ mesh_delete(struct mesh_area* mesh)
while(mesh->all.count)
mesh_delete_helper(mesh->all.root);
timehist_delete(mesh->histogram);
ldns_buffer_free(mesh->qbuf_bak);
sldns_buffer_free(mesh->qbuf_bak);
free(mesh);
}
@ -234,7 +234,7 @@ mesh_delete_all(struct mesh_area* mesh)
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;
/* 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.qclass);
/* backup the query */
if(qbuf) ldns_buffer_copy(mesh->qbuf_bak, qbuf);
if(qbuf) sldns_buffer_copy(mesh->qbuf_bak, qbuf);
/* notify supers */
if(m->super_set.count > 0) {
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);
/* restore the query - note that the qinfo ptr to
* 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;
}
}
@ -372,7 +372,7 @@ void mesh_new_client(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, ldns_buffer* buf,
uint16_t qflags, struct edns_data* edns, sldns_buffer* buf,
uint16_t qid, mesh_cb_func_t cb, void* cb_arg)
{
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);
} else {
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.udp_size = EDNS_ADVERTISED_SIZE;
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) {
/* if the previous reply is identical to this one, fix ID */
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);
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));
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);
comm_point_send_reply(&r->query_reply);
} 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);
timehist_insert(m->s.env->mesh->histogram, &duration);
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));
if(secure) m->s.env->mesh->ans_secure++;
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)
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,
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)
{
struct mesh_cb* r = regional_alloc(s->s.region,
@ -1167,7 +1167,7 @@ mesh_get_mem(struct mesh_area* mesh)
struct mesh_state* m;
size_t s = sizeof(*mesh) + sizeof(struct timehist) +
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) {
/* all, including m itself allocated in qstate 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/module.h"
#include "services/modstack.h"
struct ldns_buffer;
struct sldns_buffer;
struct mesh_state;
struct mesh_reply;
struct mesh_cb;
@ -126,7 +126,7 @@ struct mesh_area {
/** backup of query if other operations recurse and need the
* network buffers */
struct ldns_buffer* qbuf_bak;
struct sldns_buffer* qbuf_bak;
/** double linked list of the run-to-completion query states.
* These are query states with a reply */
@ -220,7 +220,7 @@ struct mesh_reply {
* Mesh result callback func.
* 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*);
/**
@ -236,7 +236,7 @@ struct mesh_cb {
/** flags of query, for reply flags */
uint16_t qflags;
/** buffer for reply */
struct ldns_buffer* buf;
struct sldns_buffer* buf;
/** callback routine for results. if rcode != 0 buf has message.
* 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.
*/
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);
/**
@ -474,7 +474,7 @@ int mesh_state_add_reply(struct mesh_state* s, struct edns_data* edns,
* @return: 0 on alloc error.
*/
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);
/**
@ -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.
* @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.

166
services/outside_network.c
View file

@ -76,10 +76,10 @@
/** initiate TCP transaction for serviced query */
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 */
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
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->c->repinfo.addrlen = w->addrlen;
memcpy(&pend->c->repinfo.addr, &w->addr, w->addrlen);
ldns_buffer_clear(pend->c->buffer);
ldns_buffer_write(pend->c->buffer, pkt, pkt_len);
ldns_buffer_flip(pend->c->buffer);
sldns_buffer_clear(pend->c->buffer);
sldns_buffer_write(pend->c->buffer, pkt, pkt_len);
sldns_buffer_flip(pend->c->buffer);
pend->c->tcp_is_reading = 0;
pend->c->tcp_byte_count = 0;
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 */
} else {
/* check ID */
if(ldns_buffer_limit(c->buffer) < sizeof(uint16_t) ||
LDNS_ID_WIRE(ldns_buffer_begin(c->buffer))!=pend->id) {
if(sldns_buffer_limit(c->buffer) < sizeof(uint16_t) ||
LDNS_ID_WIRE(sldns_buffer_begin(c->buffer))!=pend->id) {
log_addr(VERB_QUERY,
"outnettcp: bad ID in reply, from:",
&pend->query->addr, pend->query->addrlen);
@ -372,9 +372,9 @@ outnet_send_wait_udp(struct outside_network* outnet)
pend = outnet->udp_wait_first;
outnet->udp_wait_first = pend->next_waiting;
if(!pend->next_waiting) outnet->udp_wait_last = NULL;
ldns_buffer_clear(outnet->udp_buff);
ldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
ldns_buffer_flip(outnet->udp_buff);
sldns_buffer_clear(outnet->udp_buff);
sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
sldns_buffer_flip(outnet->udp_buff);
free(pend->pkt); /* freeing now makes get_mem correct */
pend->pkt = NULL;
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);
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");
return 0;
}
log_assert(reply_info);
/* 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);
key.addrlen = reply_info->addrlen;
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;
}
}
if( !(outnet->udp_buff = ldns_buffer_new(bufsize)) ||
if( !(outnet->udp_buff = sldns_buffer_new(bufsize)) ||
!(outnet->pending = rbtree_create(pending_cmp)) ||
!(outnet->serviced = rbtree_create(serviced_cmp)) ||
!create_pending_tcp(outnet, bufsize)) {
@ -731,7 +731,7 @@ outside_network_delete(struct outside_network* outnet)
free(outnet->serviced);
}
if(outnet->udp_buff)
ldns_buffer_free(outnet->udp_buff);
sldns_buffer_free(outnet->udp_buff);
if(outnet->unused_fds) {
struct port_comm* p = outnet->unused_fds, *np;
while(p) {
@ -863,18 +863,18 @@ udp_sockport(struct sockaddr_storage* addr, socklen_t addrlen, int port,
/** Select random ID */
static int
select_id(struct outside_network* outnet, struct pending* pend,
ldns_buffer* packet)
sldns_buffer* packet)
{
int id_tries = 0;
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 */
pend->node.key = pend;
while(!rbtree_insert(outnet->pending, &pend->node)) {
/* change ID to avoid collision */
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++;
if(id_tries == MAX_ID_RETRY) {
pend->id=99999; /* non existant ID */
@ -958,7 +958,7 @@ select_ifport(struct outside_network* outnet, struct pending* pend,
static int
randomize_and_send_udp(struct outside_network* outnet, struct pending* pend,
ldns_buffer* packet, int timeout)
sldns_buffer* packet, int timeout)
{
struct timeval tv;
@ -997,7 +997,7 @@ randomize_and_send_udp(struct outside_network* outnet, struct pending* pend,
}
struct pending*
pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
pending_udp_query(struct outside_network* outnet, sldns_buffer* packet,
struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* 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) */
verbose(VERB_ALGO, "no fds available, udp query waiting");
pend->timeout = timeout;
pend->pkt_len = ldns_buffer_limit(packet);
pend->pkt = (uint8_t*)memdup(ldns_buffer_begin(packet),
pend->pkt_len = sldns_buffer_limit(packet);
pend->pkt = (uint8_t*)memdup(sldns_buffer_begin(packet),
pend->pkt_len);
if(!pend->pkt) {
comm_timer_delete(pend->timer);
@ -1080,7 +1080,7 @@ outnet_tcptimer(void* arg)
}
struct waiting_tcp*
pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
pending_tcp_query(struct outside_network* outnet, sldns_buffer* packet,
struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
comm_point_callback_t* callback, void* callback_arg, int ssl_upstream)
{
@ -1090,7 +1090,7 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
uint16_t id;
/* if no buffer is free allocate space to store query */
w = (struct waiting_tcp*)malloc(sizeof(struct waiting_tcp)
+ (pend?0:ldns_buffer_limit(packet)));
+ (pend?0:sldns_buffer_limit(packet)));
if(!w) {
return NULL;
}
@ -1101,7 +1101,7 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
w->pkt = NULL;
w->pkt_len = 0;
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);
w->addrlen = addrlen;
w->outnet = outnet;
@ -1115,16 +1115,16 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
comm_timer_set(w->timer, &tv);
if(pend) {
/* we have a buffer available right now */
if(!outnet_tcp_take_into_use(w, ldns_buffer_begin(packet),
ldns_buffer_limit(packet))) {
if(!outnet_tcp_take_into_use(w, sldns_buffer_begin(packet),
sldns_buffer_limit(packet))) {
waiting_tcp_delete(w);
return NULL;
}
} else {
/* queue up */
w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp);
w->pkt_len = ldns_buffer_limit(packet);
memmove(w->pkt, ldns_buffer_begin(packet), w->pkt_len);
w->pkt_len = sldns_buffer_limit(packet);
memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len);
w->next_waiting = NULL;
if(outnet->tcp_wait_last)
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 */
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)
{
ldns_buffer_clear(buff);
sldns_buffer_clear(buff);
/* skip id */
ldns_buffer_write_u16(buff, flags);
ldns_buffer_write_u16(buff, 1); /* qdcount */
ldns_buffer_write_u16(buff, 0); /* ancount */
ldns_buffer_write_u16(buff, 0); /* nscount */
ldns_buffer_write_u16(buff, 0); /* arcount */
ldns_buffer_write(buff, qname, qnamelen);
ldns_buffer_write_u16(buff, qtype);
ldns_buffer_write_u16(buff, qclass);
ldns_buffer_flip(buff);
sldns_buffer_write_u16(buff, flags);
sldns_buffer_write_u16(buff, 1); /* qdcount */
sldns_buffer_write_u16(buff, 0); /* ancount */
sldns_buffer_write_u16(buff, 0); /* nscount */
sldns_buffer_write_u16(buff, 0); /* arcount */
sldns_buffer_write(buff, qname, qnamelen);
sldns_buffer_write_u16(buff, qtype);
sldns_buffer_write_u16(buff, qclass);
sldns_buffer_flip(buff);
}
/** lookup serviced query in serviced query rbtree */
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 serviced_query key;
key.node.key = &key;
key.qbuf = ldns_buffer_begin(buff);
key.qbuflen = ldns_buffer_limit(buff);
key.qbuf = sldns_buffer_begin(buff);
key.qbuflen = sldns_buffer_limit(buff);
key.dnssec = dnssec;
memcpy(&key.addr, addr, addrlen);
key.addrlen = addrlen;
@ -1170,7 +1170,7 @@ lookup_serviced(struct outside_network* outnet, ldns_buffer* buff, int dnssec,
/** Create new serviced entry */
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,
struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
size_t zonelen, int qtype)
@ -1182,12 +1182,12 @@ serviced_create(struct outside_network* outnet, ldns_buffer* buff, int dnssec,
if(!sq)
return NULL;
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) {
free(sq);
return NULL;
}
sq->qbuflen = ldns_buffer_limit(buff);
sq->qbuflen = sldns_buffer_limit(buff);
sq->zone = memdup(zone, zonelen);
if(!sq->zone) {
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 */
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(sq->outnet->use_caps_for_id) {
serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
}
/* generate query */
ldns_buffer_clear(buff);
ldns_buffer_write_u16(buff, 0); /* id placeholder */
ldns_buffer_write(buff, sq->qbuf, sq->qbuflen);
ldns_buffer_flip(buff);
sldns_buffer_clear(buff);
sldns_buffer_write_u16(buff, 0); /* id placeholder */
sldns_buffer_write(buff, sq->qbuf, sq->qbuflen);
sldns_buffer_flip(buff);
if(with_edns) {
/* add edns section */
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)
edns.bits = EDNS_DO;
if(sq->dnssec & BIT_CD)
LDNS_CD_SET(ldns_buffer_begin(buff));
LDNS_CD_SET(sldns_buffer_begin(buff));
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.
*/
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;
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 */
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 len1, len2;
int count = 0;
log_assert(qbuflen >= 15 /* 10 header, root, type, class */);
len1 = *d1++;
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;
while(len1 != 0 || len2 != 0) {
if(LABEL_IS_PTR(len1)) {
d1 = ldns_buffer_at(pkt, PTR_OFFSET(len1, *d1));
if(d1 >= ldns_buffer_at(pkt, ldns_buffer_limit(pkt)))
d1 = sldns_buffer_at(pkt, PTR_OFFSET(len1, *d1));
if(d1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt)))
return 0;
len1 = *d1++;
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");
if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c) {
/* noerror and nxdomain must have a qname in reply */
if(ldns_buffer_read_u16_at(c->buffer, 4) == 0 &&
(LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer))
if(sldns_buffer_read_u16_at(c->buffer, 4) == 0 &&
(LDNS_RCODE_WIRE(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)) {
verbose(VERB_DETAIL, "no qname in reply to check 0x20ID");
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);
error = NETEVENT_CLOSED;
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,
sq->qbuflen)) {
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;
/* and cleanup too */
pkt_dname_tolower(c->buffer,
ldns_buffer_at(c->buffer, 12));
sldns_buffer_at(c->buffer, 12));
} else {
verbose(VERB_ALGO, "good 0x20-ID in reply qname");
/* cleanup caps, prettier cache contents. */
pkt_dname_tolower(c->buffer,
ldns_buffer_at(c->buffer, 12));
sldns_buffer_at(c->buffer, 12));
}
}
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.
* use secondary buffer to store the query.
* This is a data copy, but faster than packet to server */
backlen = ldns_buffer_limit(c->buffer);
backup_p = memdup(ldns_buffer_begin(c->buffer), backlen);
backlen = sldns_buffer_limit(c->buffer);
backup_p = memdup(sldns_buffer_begin(c->buffer), backlen);
if(!backup_p) {
log_err("malloc failure in serviced query callbacks");
error = NETEVENT_CLOSED;
@ -1510,9 +1510,9 @@ serviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c,
while((p=sq->cblist) != NULL) {
sq->cblist = p->next; /* remove this element */
if(dobackup && c) {
ldns_buffer_clear(c->buffer);
ldns_buffer_write(c->buffer, backup_p, backlen);
ldns_buffer_flip(c->buffer);
sldns_buffer_clear(c->buffer);
sldns_buffer_write(c->buffer, backup_p, backlen);
sldns_buffer_flip(c->buffer);
}
fptr_ok(fptr_whitelist_serviced_query(p->cb));
(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,
sq->addrlen, sq->zone, sq->zonelen);
if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS &&
(LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) ==
LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(ldns_buffer_begin(
(LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(sldns_buffer_begin(
c->buffer)) == LDNS_RCODE_NOTIMPL) ) {
/* attempt to fallback to nonEDNS */
sq->status = serviced_query_TCP_EDNS_fallback;
@ -1550,10 +1550,10 @@ serviced_tcp_callback(struct comm_point* c, void* arg, int error,
return 0;
} else if(error==NETEVENT_NOERROR &&
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_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN
|| LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer))
sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN
|| LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
== LDNS_RCODE_YXDOMAIN)) {
/* the fallback produced a result that looks promising, note
* 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
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",
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 */
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;
uint8_t edns_lame_known;
@ -1697,9 +1697,9 @@ serviced_udp_callback(struct comm_point* c, void* arg, int error,
if(!fallback_tcp) {
if( (sq->status == serviced_query_UDP_EDNS
||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_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 */
verbose(VERB_ALGO, "serviced query: attempt without EDNS");
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;
} else if(sq->status == serviced_query_UDP_EDNS_fallback &&
!sq->edns_lame_known && (LDNS_RCODE_WIRE(
ldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOERROR ||
LDNS_RCODE_WIRE(ldns_buffer_begin(c->buffer)) ==
LDNS_RCODE_NXDOMAIN || LDNS_RCODE_WIRE(ldns_buffer_begin(
sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOERROR ||
LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
LDNS_RCODE_NXDOMAIN || LDNS_RCODE_WIRE(sldns_buffer_begin(
c->buffer)) == LDNS_RCODE_YXDOMAIN)) {
/* the fallback produced a result that looks promising, note
* 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 */
/* perform TC flag check and TCP fallback after updating our
* 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 */
/* this discards partial UDP contents */
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,
int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen,
uint8_t* zone, size_t zonelen, comm_point_callback_t* callback,
void* callback_arg, ldns_buffer* buff)
void* callback_arg, sldns_buffer* buff)
{
struct serviced_query* sq;
struct service_callback* cb;
@ -1925,7 +1925,7 @@ size_t outnet_get_mem(struct outside_network* outnet)
struct port_comm* pc;
size_t s = sizeof(*outnet) + sizeof(*outnet->base) +
sizeof(*outnet->udp_buff) +
ldns_buffer_capacity(outnet->udp_buff);
sldns_buffer_capacity(outnet->udp_buff);
/* second buffer is not ours */
for(pc = outnet->unused_fds; pc; pc = pc->next) {
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 port_comm;
struct port_if;
struct ldns_buffer;
struct sldns_buffer;
/**
* 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
datagram at any time. */
struct ldns_buffer* udp_buff;
struct sldns_buffer* udp_buff;
/** serviced_callbacks malloc overhead when processing multiple
* identical serviced queries to the same server. */
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.
*/
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,
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.
*/
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,
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,
int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen,
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.

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));
env.cfg = cfg;
env.scratch = regional_create();
env.scratch_buffer = ldns_buffer_new(BUFSIZ);
env.scratch_buffer = sldns_buffer_new(BUFSIZ);
if(!env.scratch || !env.scratch_buffer)
fatal_exit("out of memory");
if(!(*fb->init)(&env, 0)) {
fatal_exit("bad config for %s module", fb->name);
}
(*fb->deinit)(&env, 0);
ldns_buffer_free(env.scratch_buffer);
sldns_buffer_free(env.scratch_buffer);
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)
{
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 &&
strcmp(t, "") != 0) {
fprintf(stderr, "error unknown type %s\n", t);
@ -192,7 +192,7 @@ static int
massage_class(const char* 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 &&
strcmp(c, "") != 0) {
fprintf(stderr, "error unknown class %s\n", c);
@ -217,7 +217,7 @@ static void
pretty_type(char* s, size_t len, int t)
{
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);
}
@ -226,7 +226,7 @@ static void
pretty_class(char* s, size_t len, int c)
{
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);
}
@ -235,7 +235,7 @@ static void
pretty_rcode(char* s, size_t len, int r)
{
char d[16];
ldns_wire2str_rcode_buf(r, d, sizeof(d));
sldns_wire2str_rcode_buf(r, d, sizeof(d));
snprintf(s, len, "%s", d);
}
@ -244,7 +244,7 @@ static void
print_rd(int t, char* data, size_t len)
{
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);
}
@ -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)
printf(" has no mail handler record");
else if(t == LDNS_RR_TYPE_ANY) {
char* s = ldns_wire2str_pkt(
char* s = sldns_wire2str_pkt(
result->answer_packet,
(size_t)result->answer_len);
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),
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))
{
log_assert(0);
}
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))
{
log_assert(0);
}
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))
{
log_assert(0);

60
testcode/delayer.c
View file

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

106
testcode/fake_event.c
View file

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

38
testcode/perf.c
View file

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

74
testcode/pktview.c
View file

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

14
testcode/readhex.c
View file

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

4
testcode/readhex.h
View file

@ -40,13 +40,13 @@
#ifndef TESTCODE_READHEX_H
#define TESTCODE_READHEX_H
struct ldns_buffer;
struct sldns_buffer;
/**
* Helper to convert hex string to packet buffer.
* @param pkt: buffer to put result in.
* @param hex: string of hex data. Spaces and ';...' comments are skipped.
*/
void hex_to_buf(struct ldns_buffer* pkt, const char* hex);
void hex_to_buf(struct sldns_buffer* pkt, const char* hex);
#endif /* TESTCODE_READHEX_H */

6
testcode/replay.c
View file

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

6
testcode/replay.h
View file

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

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

48
testcode/streamtcp.c
View file

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

2
testcode/testbound.c
View file

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

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

8
testcode/testpkts.h
View file

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

10
testcode/unitanchor.c
View file

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

180
testcode/unitdname.c
View file

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

4
testcode/unitmain.c
View file

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

114
testcode/unitmsgparse.c
View file

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

42
testcode/unitverify.c
View file

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

6
util/alloc.c
View file

@ -601,13 +601,13 @@ char* unbound_lite_wrapstr(char* s)
return n;
}
#undef ldns_pkt2wire
ldns_status unbound_lite_pkt2wire(uint8_t **dest, const ldns_pkt *p,
#undef sldns_pkt2wire
sldns_status unbound_lite_pkt2wire(uint8_t **dest, const sldns_pkt *p,
size_t *size)
{
uint8_t* md = NULL;
size_t ms = 0;
ldns_status s = ldns_pkt2wire(&md, p, &ms);
sldns_status s = sldns_pkt2wire(&md, p, &ms);
if(md) {
*dest = unbound_stat_malloc_lite(ms, __FILE__, __LINE__,
__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,
const char* func);
char* unbound_lite_wrapstr(char* s);
# define ldns_rr2str(rr) unbound_lite_wrapstr(ldns_rr2str(rr))
# define ldns_rdf2str(rdf) unbound_lite_wrapstr(ldns_rdf2str(rdf))
# define ldns_rr_type2str(t) unbound_lite_wrapstr(ldns_rr_type2str(t))
# define ldns_rr_class2str(c) unbound_lite_wrapstr(ldns_rr_class2str(c))
# define ldns_rr_list2str(r) unbound_lite_wrapstr(ldns_rr_list2str(r))
# define ldns_pkt2str(p) unbound_lite_wrapstr(ldns_pkt2str(p))
# define ldns_pkt_rcode2str(r) unbound_lite_wrapstr(ldns_pkt_rcode2str(r))
# define ldns_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);
# define sldns_rr2str(rr) unbound_lite_wrapstr(sldns_rr2str(rr))
# define sldns_rdf2str(rdf) unbound_lite_wrapstr(sldns_rdf2str(rdf))
# define sldns_rr_type2str(t) unbound_lite_wrapstr(sldns_rr_type2str(t))
# define sldns_rr_class2str(c) unbound_lite_wrapstr(sldns_rr_class2str(c))
# define sldns_rr_list2str(r) unbound_lite_wrapstr(sldns_rr_list2str(r))
# define sldns_pkt2str(p) unbound_lite_wrapstr(sldns_pkt2str(p))
# define sldns_pkt_rcode2str(r) unbound_lite_wrapstr(sldns_pkt_rcode2str(r))
# define sldns_pkt2wire(a, r, s) unbound_lite_pkt2wire(a, r, s)
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)
int unbound_lite_i2d_DSA_SIG(DSA_SIG* dsasig, unsigned char** sig);
#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_sec < 0 || tm.tm_sec > 59) return 0;
/* call ldns conversion function */
t = ldns_mktime_from_utc(&tm);
t = sldns_mktime_from_utc(&tm);
return t;
}
@ -1521,8 +1521,8 @@ char* errinf_to_str(struct module_qstate* qstate)
struct config_strlist* s;
char dname[LDNS_MAX_DOMAINLEN+1];
char t[16], c[16];
ldns_wire2str_type_buf(qstate->qinfo.qtype, t, sizeof(t));
ldns_wire2str_class_buf(qstate->qinfo.qclass, c, sizeof(c));
sldns_wire2str_type_buf(qstate->qinfo.qtype, t, sizeof(t));
sldns_wire2str_class_buf(qstate->qinfo.qclass, c, sizeof(c));
dname_str(qstate->qinfo.qname, dname);
snprintf(p, left, "validation failure <%s %s %s>:", dname, t, c);
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];
if(qstate->env->cfg->val_log_level < 2 || !rr)
return;
ldns_wire2str_type_buf(ntohs(rr->rk.type), t, sizeof(t));
ldns_wire2str_class_buf(ntohs(rr->rk.rrset_class), c, sizeof(c));
sldns_wire2str_type_buf(ntohs(rr->rk.type), t, sizeof(t));
sldns_wire2str_class_buf(ntohs(rr->rk.rrset_class), c, sizeof(c));
dname_str(rr->rk.dname, dname);
snprintf(buf, sizeof(buf), "for <%s %s %s>", dname, t, c);
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 */
size_t
query_dname_len(ldns_buffer* query)
query_dname_len(sldns_buffer* query)
{
size_t len = 0;
size_t labellen;
while(1) {
if(ldns_buffer_remaining(query) < 1)
if(sldns_buffer_remaining(query) < 1)
return 0; /* parse error, need label len */
labellen = ldns_buffer_read_u8(query);
labellen = sldns_buffer_read_u8(query);
if(labellen&0xc0)
return 0; /* no compression allowed in queries */
len += labellen + 1;
@ -64,9 +64,9 @@ query_dname_len(ldns_buffer* query)
return 0; /* too long */
if(labellen == 0)
return len;
if(ldns_buffer_remaining(query) < labellen)
if(sldns_buffer_remaining(query) < labellen)
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
pkt_dname_tolower(ldns_buffer* pkt, uint8_t* dname)
pkt_dname_tolower(sldns_buffer* pkt, uint8_t* dname)
{
uint8_t lablen;
int count = 0;
if(dname >= ldns_buffer_end(pkt))
if(dname >= sldns_buffer_end(pkt))
return;
lablen = *dname++;
while(lablen) {
if(LABEL_IS_PTR(lablen)) {
if((size_t)PTR_OFFSET(lablen, *dname)
>= ldns_buffer_limit(pkt))
>= sldns_buffer_limit(pkt))
return;
dname = ldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
dname = sldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
lablen = *dname++;
if(count++ > MAX_COMPRESS_PTRS)
return;
continue;
}
if(dname+lablen >= ldns_buffer_end(pkt))
if(dname+lablen >= sldns_buffer_end(pkt))
return;
while(lablen--) {
*dname = (uint8_t)tolower((int)*dname);
dname++;
}
if(dname >= ldns_buffer_end(pkt))
if(dname >= sldns_buffer_end(pkt))
return;
lablen = *dname++;
}
@ -178,7 +178,7 @@ pkt_dname_tolower(ldns_buffer* pkt, uint8_t* dname)
size_t
pkt_dname_len(ldns_buffer* pkt)
pkt_dname_len(sldns_buffer* pkt)
{
size_t len = 0;
int ptrcount = 0;
@ -189,22 +189,22 @@ pkt_dname_len(ldns_buffer* pkt)
/* check compression pointers, loops, out of bounds */
while(1) {
/* read next label */
if(ldns_buffer_remaining(pkt) < 1)
if(sldns_buffer_remaining(pkt) < 1)
return 0;
labellen = ldns_buffer_read_u8(pkt);
labellen = sldns_buffer_read_u8(pkt);
if(LABEL_IS_PTR(labellen)) {
/* compression ptr */
uint16_t ptr;
if(ldns_buffer_remaining(pkt) < 1)
if(sldns_buffer_remaining(pkt) < 1)
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)
return 0; /* loop! */
if(ldns_buffer_limit(pkt) <= ptr)
if(sldns_buffer_limit(pkt) <= ptr)
return 0; /* out of bounds! */
if(!endpos)
endpos = ldns_buffer_position(pkt);
ldns_buffer_set_position(pkt, ptr);
endpos = sldns_buffer_position(pkt);
sldns_buffer_set_position(pkt, ptr);
} else {
/* label contents */
if(labellen > 0x3f)
@ -216,19 +216,19 @@ pkt_dname_len(ldns_buffer* pkt)
/* end of dname */
break;
}
if(ldns_buffer_remaining(pkt) < labellen)
if(sldns_buffer_remaining(pkt) < labellen)
return 0;
ldns_buffer_skip(pkt, (ssize_t)labellen);
sldns_buffer_skip(pkt, (ssize_t)labellen);
}
}
if(endpos)
ldns_buffer_set_position(pkt, endpos);
sldns_buffer_set_position(pkt, endpos);
return len;
}
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;
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 ) {
/* resolve ptrs */
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++;
continue;
}
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++;
continue;
}
@ -291,7 +291,7 @@ dname_query_hash(uint8_t* dname, hashvalue_t h)
}
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 lablen;
@ -302,7 +302,7 @@ dname_pkt_hash(ldns_buffer* pkt, uint8_t* dname, hashvalue_t h)
while(lablen) {
if(LABEL_IS_PTR(lablen)) {
/* follow pointer */
dname = ldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
dname = sldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
lablen = *dname++;
continue;
}
@ -318,7 +318,7 @@ dname_pkt_hash(ldns_buffer* pkt, uint8_t* dname, hashvalue_t 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 */
size_t len = 0;
@ -327,7 +327,7 @@ void dname_pkt_copy(ldns_buffer* pkt, uint8_t* to, uint8_t* dname)
while(lablen) {
if(LABEL_IS_PTR(lablen)) {
/* follow pointer */
dname = ldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
dname = sldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
lablen = *dname++;
continue;
}
@ -348,7 +348,7 @@ void dname_pkt_copy(ldns_buffer* pkt, uint8_t* to, uint8_t* dname)
*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;
if(!out) out = stdout;
@ -364,7 +364,7 @@ void dname_print(FILE* out, struct ldns_buffer* pkt, uint8_t* dname)
fputs("??compressionptr??", out);
return;
}
dname = ldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
dname = sldns_buffer_at(pkt, PTR_OFFSET(lablen, *dname));
lablen = *dname++;
continue;
}
@ -518,21 +518,21 @@ dname_lab_cmp(uint8_t* d1, int labs1, uint8_t* d2, int labs2, int* mlabs)
}
int
dname_buffer_write(ldns_buffer* pkt, uint8_t* dname)
dname_buffer_write(sldns_buffer* pkt, uint8_t* dname)
{
uint8_t lablen;
if(ldns_buffer_remaining(pkt) < 1)
if(sldns_buffer_remaining(pkt) < 1)
return 0;
lablen = *dname++;
ldns_buffer_write_u8(pkt, lablen);
sldns_buffer_write_u8(pkt, lablen);
while(lablen) {
if(ldns_buffer_remaining(pkt) < (size_t)lablen+1)
if(sldns_buffer_remaining(pkt) < (size_t)lablen+1)
return 0;
ldns_buffer_write(pkt, dname, lablen);
sldns_buffer_write(pkt, dname, lablen);
dname += lablen;
lablen = *dname++;
ldns_buffer_write_u8(pkt, lablen);
sldns_buffer_write_u8(pkt, lablen);
}
return 1;
}

18
util/data/dname.h
View file

@ -45,7 +45,7 @@
#ifndef UTIL_DATA_DNAME_H
#define UTIL_DATA_DNAME_H
#include "util/storage/lruhash.h"
struct ldns_buffer;
struct sldns_buffer;
/** max number of compression ptrs to follow */
#define MAX_COMPRESS_PTRS 256
@ -56,7 +56,7 @@ struct ldns_buffer;
* at end, position is at end of the 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.
@ -75,7 +75,7 @@ void query_dname_tolower(uint8_t* dname);
* is unchanged.
* @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
@ -107,7 +107,7 @@ int query_dname_compare(uint8_t* d1, uint8_t* d2);
* Compression pointers are followed and checked for loops.
* 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.
@ -118,7 +118,7 @@ size_t pkt_dname_len(struct ldns_buffer* pkt);
* @return: -1, 0, or +1 depending on comparison results.
* 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.
@ -139,7 +139,7 @@ hashvalue_t dname_query_hash(uint8_t* dname, hashvalue_t h);
* @return: result hash value.
* 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.
@ -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 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.
@ -155,7 +155,7 @@ void dname_pkt_copy(struct ldns_buffer* pkt, uint8_t* to, uint8_t* dname);
* @param dname: dname to copy.
* @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.
@ -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 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

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 */
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)
{
/* compress it */
@ -253,32 +253,32 @@ write_compressed_dname(ldns_buffer* pkt, uint8_t* dname, int labs,
if(labs == 1) {
/* write root label */
if(ldns_buffer_remaining(pkt) < 1)
if(sldns_buffer_remaining(pkt) < 1)
return 0;
ldns_buffer_write_u8(pkt, 0);
sldns_buffer_write_u8(pkt, 0);
return 1;
}
/* copy the first couple of labels */
while(labcopy--) {
lablen = *dname++;
if(ldns_buffer_remaining(pkt) < (size_t)lablen+1)
if(sldns_buffer_remaining(pkt) < (size_t)lablen+1)
return 0;
ldns_buffer_write_u8(pkt, lablen);
ldns_buffer_write(pkt, dname, lablen);
sldns_buffer_write_u8(pkt, lablen);
sldns_buffer_write(pkt, dname, lablen);
dname += lablen;
}
/* insert compression ptr */
if(ldns_buffer_remaining(pkt) < 2)
if(sldns_buffer_remaining(pkt) < 2)
return 0;
ptr = PTR_CREATE(p->offset);
ldns_buffer_write_u16(pkt, ptr);
sldns_buffer_write_u16(pkt, ptr);
return 1;
}
/** compress owner name of RR, return RETVAL_OUTMEM RETVAL_TRUNC */
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,
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))
return RETVAL_TRUNC;
/* 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;
} else {
/* 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;
ldns_buffer_write(pkt, key->rk.dname,
sldns_buffer_write(pkt, key->rk.dname,
key->rk.dname_len);
if(owner_pos <= PTR_MAX_OFFSET)
*owner_ptr = htons(PTR_CREATE(owner_pos));
@ -313,13 +313,13 @@ compress_owner(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
} else {
/* always compress 2nd-further RRs in RRset */
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;
ldns_buffer_write_u8(pkt, 0);
sldns_buffer_write_u8(pkt, 0);
} else {
if(ldns_buffer_remaining(pkt) < 2+4+4+2)
if(sldns_buffer_remaining(pkt) < 2+4+4+2)
return RETVAL_TRUNC;
ldns_buffer_write(pkt, owner_ptr, 2);
sldns_buffer_write(pkt, owner_ptr, 2);
}
}
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_* */
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 compress_tree_node* p;
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(!write_compressed_dname(pkt, dname, labs, p))
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 */
static const ldns_rr_descriptor*
static const sldns_rr_descriptor*
type_rdata_compressable(struct ub_packed_rrset_key* key)
{
uint16_t t = ntohs(key->rk.type);
if(ldns_rr_descript(t) &&
ldns_rr_descript(t)->_compress == LDNS_RR_COMPRESS)
return ldns_rr_descript(t);
if(sldns_rr_descript(t) &&
sldns_rr_descript(t)->_compress == LDNS_RR_COMPRESS)
return sldns_rr_descript(t);
return 0;
}
/** compress domain names in rdata, return RETVAL_* */
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,
const ldns_rr_descriptor* desc)
const sldns_rr_descriptor* desc)
{
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;
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 */
rdata += 2;
todolen -= 2;
@ -390,9 +390,9 @@ compress_rdata(ldns_buffer* pkt, uint8_t* rdata, size_t todolen,
}
if(len) {
/* copy over */
if(ldns_buffer_remaining(pkt) < len)
if(sldns_buffer_remaining(pkt) < len)
return RETVAL_TRUNC;
ldns_buffer_write(pkt, rdata, len);
sldns_buffer_write(pkt, rdata, len);
todolen -= len;
rdata += len;
}
@ -400,19 +400,19 @@ compress_rdata(ldns_buffer* pkt, uint8_t* rdata, size_t todolen,
}
/* copy remainder */
if(todolen > 0) {
if(ldns_buffer_remaining(pkt) < todolen)
if(sldns_buffer_remaining(pkt) < todolen)
return RETVAL_TRUNC;
ldns_buffer_write(pkt, rdata, todolen);
sldns_buffer_write(pkt, rdata, todolen);
}
/* 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;
}
/** Returns true if RR type should be included */
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)
{
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_* */
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,
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;
int r, owner_labs;
@ -456,10 +456,10 @@ packed_rrset_encode(struct ub_packed_rrset_key* key, ldns_buffer* pkt,
return RETVAL_OK;
owner_labs = dname_count_labels(key->rk.dname);
owner_pos = ldns_buffer_position(pkt);
owner_pos = sldns_buffer_position(pkt);
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++) {
/* rrset roundrobin */
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))
!= RETVAL_OK)
return r;
ldns_buffer_write(pkt, &key->rk.type, 2);
ldns_buffer_write(pkt, &key->rk.rrset_class, 2);
sldns_buffer_write(pkt, &key->rk.type, 2);
sldns_buffer_write(pkt, &key->rk.rrset_class, 2);
if(data->rr_ttl[j] < timenow)
ldns_buffer_write_u32(pkt, 0);
else ldns_buffer_write_u32(pkt,
sldns_buffer_write_u32(pkt, 0);
else sldns_buffer_write_u32(pkt,
data->rr_ttl[j]-timenow);
if(c) {
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)
return r;
} else {
if(ldns_buffer_remaining(pkt) < data->rr_len[j])
if(sldns_buffer_remaining(pkt) < data->rr_len[j])
return RETVAL_TRUNC;
ldns_buffer_write(pkt, data->rr_data[j],
sldns_buffer_write(pkt, data->rr_data[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;
for(i=data->count; i<total; i++) {
if(owner_ptr && owner_labs != 1) {
if(ldns_buffer_remaining(pkt) <
if(sldns_buffer_remaining(pkt) <
2+4+4+data->rr_len[i])
return RETVAL_TRUNC;
ldns_buffer_write(pkt, &owner_ptr, 2);
sldns_buffer_write(pkt, &owner_ptr, 2);
} else {
if((r=compress_any_dname(key->rk.dname,
pkt, owner_labs, region, tree))
!= RETVAL_OK)
return r;
if(ldns_buffer_remaining(pkt) <
if(sldns_buffer_remaining(pkt) <
4+4+data->rr_len[i])
return RETVAL_TRUNC;
}
ldns_buffer_write_u16(pkt, LDNS_RR_TYPE_RRSIG);
ldns_buffer_write(pkt, &key->rk.rrset_class, 2);
sldns_buffer_write_u16(pkt, LDNS_RR_TYPE_RRSIG);
sldns_buffer_write(pkt, &key->rk.rrset_class, 2);
if(data->rr_ttl[i] < timenow)
ldns_buffer_write_u32(pkt, 0);
else ldns_buffer_write_u32(pkt,
sldns_buffer_write_u32(pkt, 0);
else sldns_buffer_write_u32(pkt,
data->rr_ttl[i]-timenow);
/* rrsig rdata cannot be compressed, perform 100+ byte
* memcopy. */
ldns_buffer_write(pkt, data->rr_data[i],
sldns_buffer_write(pkt, data->rr_data[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_* */
static int
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,
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;
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)
dnssec = 1; /* include all types in ANY answer */
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],
pkt, num_rrs, timenow, region, 1, 1, tree,
s, qtype, dnssec, rr_offset))
!= RETVAL_OK) {
/* Bad, but if due to size must set TC bit */
/* trim off the rrset neatly. */
ldns_buffer_set_position(pkt, setstart);
sldns_buffer_set_position(pkt, setstart);
return r;
}
}
} else {
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],
pkt, num_rrs, timenow, region, 1, 0, tree,
s, qtype, dnssec, rr_offset))
!= RETVAL_OK) {
ldns_buffer_set_position(pkt, setstart);
sldns_buffer_set_position(pkt, setstart);
return r;
}
}
if(dnssec)
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],
pkt, num_rrs, timenow, region, 0, 1, tree,
s, qtype, dnssec, rr_offset))
!= RETVAL_OK) {
ldns_buffer_set_position(pkt, setstart);
sldns_buffer_set_position(pkt, setstart);
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 */
static int
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)
return RETVAL_TRUNC; /* buffer too small */
/* the query is the first name inserted into the tree */
if(!compress_tree_store(qinfo->qname,
dname_count_labels(qinfo->qname),
ldns_buffer_position(buffer), region, NULL, tree))
sldns_buffer_position(buffer), region, NULL, tree))
return RETVAL_OUTMEM;
if(ldns_buffer_current(buffer) == qinfo->qname)
ldns_buffer_skip(buffer, (ssize_t)qinfo->qname_len);
else ldns_buffer_write(buffer, qinfo->qname, qinfo->qname_len);
ldns_buffer_write_u16(buffer, qinfo->qtype);
ldns_buffer_write_u16(buffer, qinfo->qclass);
if(sldns_buffer_current(buffer) == qinfo->qname)
sldns_buffer_skip(buffer, (ssize_t)qinfo->qname_len);
else sldns_buffer_write(buffer, qinfo->qname, qinfo->qname_len);
sldns_buffer_write_u16(buffer, qinfo->qtype);
sldns_buffer_write_u16(buffer, qinfo->qclass);
return RETVAL_OK;
}
@ -624,7 +624,7 @@ positive_answer(struct reply_info* rep, uint16_t qtype) {
int
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)
{
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;
size_t rr_offset;
ldns_buffer_clear(buffer);
if(udpsize < ldns_buffer_limit(buffer))
ldns_buffer_set_limit(buffer, udpsize);
if(ldns_buffer_remaining(buffer) < LDNS_HEADER_SIZE)
sldns_buffer_clear(buffer);
if(udpsize < sldns_buffer_limit(buffer))
sldns_buffer_set_limit(buffer, udpsize);
if(sldns_buffer_remaining(buffer) < LDNS_HEADER_SIZE)
return 0;
ldns_buffer_write(buffer, &id, sizeof(uint16_t));
ldns_buffer_write_u16(buffer, flags);
ldns_buffer_write_u16(buffer, rep->qdcount);
sldns_buffer_write(buffer, &id, sizeof(uint16_t));
sldns_buffer_write_u16(buffer, flags);
sldns_buffer_write_u16(buffer, rep->qdcount);
/* 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 */
if(rep->qdcount) {
@ -650,9 +650,9 @@ reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
RETVAL_OK) {
if(r == RETVAL_TRUNC) {
/* create truncated message */
ldns_buffer_write_u16_at(buffer, 4, 0);
LDNS_TC_SET(ldns_buffer_begin(buffer));
ldns_buffer_flip(buffer);
sldns_buffer_write_u16_at(buffer, 4, 0);
LDNS_TC_SET(sldns_buffer_begin(buffer));
sldns_buffer_flip(buffer);
return 1;
}
return 0;
@ -668,14 +668,14 @@ reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
dnssec, rr_offset)) != RETVAL_OK) {
if(r == RETVAL_TRUNC) {
/* create truncated message */
ldns_buffer_write_u16_at(buffer, 6, ancount);
LDNS_TC_SET(ldns_buffer_begin(buffer));
ldns_buffer_flip(buffer);
sldns_buffer_write_u16_at(buffer, 6, ancount);
LDNS_TC_SET(sldns_buffer_begin(buffer));
sldns_buffer_flip(buffer);
return 1;
}
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( ! (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) {
if(r == RETVAL_TRUNC) {
/* create truncated message */
ldns_buffer_write_u16_at(buffer, 8, nscount);
LDNS_TC_SET(ldns_buffer_begin(buffer));
ldns_buffer_flip(buffer);
sldns_buffer_write_u16_at(buffer, 8, nscount);
LDNS_TC_SET(sldns_buffer_begin(buffer));
sldns_buffer_flip(buffer);
return 1;
}
return 0;
}
ldns_buffer_write_u16_at(buffer, 8, nscount);
sldns_buffer_write_u16_at(buffer, 8, nscount);
/* insert add section */
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) {
if(r == RETVAL_TRUNC) {
/* no need to set TC bit, this is the additional */
ldns_buffer_write_u16_at(buffer, 10, arcount);
ldns_buffer_flip(buffer);
sldns_buffer_write_u16_at(buffer, 10, arcount);
sldns_buffer_flip(buffer);
return 1;
}
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;
}
@ -724,31 +724,31 @@ calc_edns_field_size(struct edns_data* edns)
}
void
attach_edns_record(ldns_buffer* pkt, struct edns_data* edns)
attach_edns_record(sldns_buffer* pkt, struct edns_data* edns)
{
size_t len;
if(!edns || !edns->edns_present)
return;
/* inc additional count */
ldns_buffer_write_u16_at(pkt, 10,
ldns_buffer_read_u16_at(pkt, 10) + 1);
len = ldns_buffer_limit(pkt);
ldns_buffer_clear(pkt);
ldns_buffer_set_position(pkt, len);
sldns_buffer_write_u16_at(pkt, 10,
sldns_buffer_read_u16_at(pkt, 10) + 1);
len = sldns_buffer_limit(pkt);
sldns_buffer_clear(pkt);
sldns_buffer_set_position(pkt, len);
/* write EDNS record */
ldns_buffer_write_u8(pkt, 0); /* '.' label */
ldns_buffer_write_u16(pkt, LDNS_RR_TYPE_OPT); /* type */
ldns_buffer_write_u16(pkt, edns->udp_size); /* class */
ldns_buffer_write_u8(pkt, edns->ext_rcode); /* ttl */
ldns_buffer_write_u8(pkt, edns->edns_version);
ldns_buffer_write_u16(pkt, edns->bits);
ldns_buffer_write_u16(pkt, 0); /* rdatalen */
ldns_buffer_flip(pkt);
sldns_buffer_write_u8(pkt, 0); /* '.' label */
sldns_buffer_write_u16(pkt, LDNS_RR_TYPE_OPT); /* type */
sldns_buffer_write_u16(pkt, edns->udp_size); /* class */
sldns_buffer_write_u8(pkt, edns->ext_rcode); /* ttl */
sldns_buffer_write_u8(pkt, edns->edns_version);
sldns_buffer_write_u16(pkt, edns->bits);
sldns_buffer_write_u16(pkt, 0); /* rdatalen */
sldns_buffer_flip(pkt);
}
int
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,
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
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 */
ldns_buffer_clear(pkt);
log_assert(ldns_buffer_remaining(pkt) >= 12+255+4/*max query*/);
ldns_buffer_skip(pkt, 2); /* id done later */
ldns_buffer_write_u16(pkt, flags);
ldns_buffer_write_u16(pkt, 1); /* query count */
ldns_buffer_write(pkt, "\000\000\000\000\000\000", 6); /* counts */
ldns_buffer_write(pkt, qinfo->qname, qinfo->qname_len);
ldns_buffer_write_u16(pkt, qinfo->qtype);
ldns_buffer_write_u16(pkt, qinfo->qclass);
ldns_buffer_flip(pkt);
sldns_buffer_clear(pkt);
log_assert(sldns_buffer_remaining(pkt) >= 12+255+4/*max query*/);
sldns_buffer_skip(pkt, 2); /* id done later */
sldns_buffer_write_u16(pkt, flags);
sldns_buffer_write_u16(pkt, 1); /* query count */
sldns_buffer_write(pkt, "\000\000\000\000\000\000", 6); /* counts */
sldns_buffer_write(pkt, qinfo->qname, qinfo->qname_len);
sldns_buffer_write_u16(pkt, qinfo->qtype);
sldns_buffer_write_u16(pkt, qinfo->qclass);
sldns_buffer_flip(pkt);
}
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 flags;
ldns_buffer_clear(buf);
ldns_buffer_write(buf, &qid, sizeof(uint16_t));
sldns_buffer_clear(buf);
sldns_buffer_write(buf, &qid, sizeof(uint16_t));
flags = (uint16_t)(BIT_QR | BIT_RA | r); /* QR and retcode*/
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;
else flags = 0;
ldns_buffer_write_u16(buf, flags);
sldns_buffer_write_u16(buf, flags);
flags = 0;
ldns_buffer_write(buf, &flags, sizeof(uint16_t));
ldns_buffer_write(buf, &flags, sizeof(uint16_t));
ldns_buffer_write(buf, &flags, sizeof(uint16_t));
sldns_buffer_write(buf, &flags, sizeof(uint16_t));
sldns_buffer_write(buf, &flags, sizeof(uint16_t));
sldns_buffer_write(buf, &flags, sizeof(uint16_t));
if(qinfo) {
if(ldns_buffer_current(buf) == qinfo->qname)
ldns_buffer_skip(buf, (ssize_t)qinfo->qname_len);
else ldns_buffer_write(buf, qinfo->qname, qinfo->qname_len);
ldns_buffer_write_u16(buf, qinfo->qtype);
ldns_buffer_write_u16(buf, qinfo->qclass);
if(sldns_buffer_current(buf) == qinfo->qname)
sldns_buffer_skip(buf, (ssize_t)qinfo->qname_len);
else sldns_buffer_write(buf, qinfo->qname, qinfo->qname_len);
sldns_buffer_write_u16(buf, qinfo->qtype);
sldns_buffer_write_u16(buf, qinfo->qclass);
}
ldns_buffer_flip(buf);
sldns_buffer_flip(buf);
if(edns) {
struct edns_data es = *edns;
es.edns_version = EDNS_ADVERTISED_VERSION;
es.udp_size = EDNS_ADVERTISED_SIZE;
es.ext_rcode = 0;
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)
return;
attach_edns_record(buf, &es);

12
util/data/msgencode.h
View file

@ -42,7 +42,7 @@
#ifndef UTIL_DATA_MSGENCODE_H
#define UTIL_DATA_MSGENCODE_H
struct ldns_buffer;
struct sldns_buffer;
struct query_info;
struct reply_info;
struct regional;
@ -67,7 +67,7 @@ struct edns_data;
* @return: 0 on error (server failure).
*/
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,
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).
*/
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);
/**
@ -97,7 +97,7 @@ int reply_info_encode(struct query_info* qinfo, struct reply_info* rep,
* @param pkt: where to store the packet.
* @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.
@ -112,7 +112,7 @@ uint16_t calc_edns_field_size(struct edns_data* edns);
* @param pkt: packet added to.
* @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.
@ -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,
* 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);
#endif /* UTIL_DATA_MSGENCODE_H */

242
util/data/msgparse.c
View file

@ -49,12 +49,12 @@
/** smart comparison of (compressed, valid) dnames from packet */
static int
smart_compare(ldns_buffer* pkt, uint8_t* dnow,
smart_compare(sldns_buffer* pkt, uint8_t* dnow,
uint8_t* dprfirst, uint8_t* dprlast)
{
if(LABEL_IS_PTR(*dnow)) {
/* 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 )
return 0;
/* 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*
new_rrset(struct msg_parse* msg, uint8_t* dname, size_t dnamelen,
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 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 */
static int
nsec_at_apex(ldns_buffer* pkt)
nsec_at_apex(sldns_buffer* pkt)
{
/* we are at ttl position in packet. */
size_t pos = ldns_buffer_position(pkt);
size_t pos = sldns_buffer_position(pkt);
uint16_t rdatalen;
if(ldns_buffer_remaining(pkt) < 7) /* ttl+len+root */
if(sldns_buffer_remaining(pkt) < 7) /* ttl+len+root */
return 0; /* eek! */
ldns_buffer_skip(pkt, 4); /* ttl */;
rdatalen = ldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < rdatalen) {
ldns_buffer_set_position(pkt, pos);
sldns_buffer_skip(pkt, 4); /* ttl */;
rdatalen = sldns_buffer_read_u16(pkt);
if(sldns_buffer_remaining(pkt) < rdatalen) {
sldns_buffer_set_position(pkt, pos);
return 0; /* parse error happens later */
}
/* must validate the nsec next domain name format */
if(pkt_dname_len(pkt) == 0) {
ldns_buffer_set_position(pkt, pos);
sldns_buffer_set_position(pkt, pos);
return 0; /* parse error */
}
/* 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 */
uint8_t win, blen, bits;
/* need: windownum, bitmap len, firstbyte */
if(ldns_buffer_position(pkt)+3 > pos+4+rdatalen) {
ldns_buffer_set_position(pkt, pos);
if(sldns_buffer_position(pkt)+3 > pos+4+rdatalen) {
sldns_buffer_set_position(pkt, pos);
return 0; /* malformed nsec */
}
win = ldns_buffer_read_u8(pkt);
blen = ldns_buffer_read_u8(pkt);
bits = ldns_buffer_read_u8(pkt);
win = sldns_buffer_read_u8(pkt);
blen = sldns_buffer_read_u8(pkt);
bits = sldns_buffer_read_u8(pkt);
/* 0window always first window. bitlen >=1 or parse
error really. bit 0x2 is SOA. */
if(win == 0 && blen >= 1 && (bits & 0x02)) {
ldns_buffer_set_position(pkt, pos);
sldns_buffer_set_position(pkt, pos);
return 1;
}
}
ldns_buffer_set_position(pkt, pos);
sldns_buffer_set_position(pkt, pos);
return 0;
}
/** Calculate rrset flags */
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;
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
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)
{
/* 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 */
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 */
/* 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 */
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,
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*
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,
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 */
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);
ldns_buffer_set_position(pkt, (size_t)(here-ldns_buffer_begin(pkt)));
size_t pos = sldns_buffer_position(pkt);
sldns_buffer_set_position(pkt, (size_t)(here-sldns_buffer_begin(pkt)));
/* 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;
ldns_buffer_skip(pkt, 4); /* ttl */
if(ldns_buffer_read_u16(pkt) < 19) /* too short */ {
ldns_buffer_set_position(pkt, pos);
sldns_buffer_skip(pkt, 4); /* ttl */
if(sldns_buffer_read_u16(pkt) < 19) /* too short */ {
sldns_buffer_set_position(pkt, pos);
return 0;
}
*type = ldns_buffer_read_u16(pkt);
ldns_buffer_set_position(pkt, pos);
*type = sldns_buffer_read_u16(pkt);
sldns_buffer_set_position(pkt, pos);
return 1;
}
/** true if covered type equals prevtype */
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;
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 */
static void
change_section(struct msg_parse* msg, struct rrset_parse* rrset,
ldns_pkt_section section)
sldns_pkt_section section)
{
struct rrset_parse *p, *prev;
/* 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 */
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 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 */
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 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 */
static struct rrset_parse*
change_rrsig_rrset(struct rrset_parse* sigset, struct msg_parse* msg,
ldns_buffer* pkt, uint16_t datatype, uint32_t rrset_flags,
int hasother, ldns_pkt_section section, struct regional* region)
sldns_buffer* pkt, uint16_t datatype, uint32_t rrset_flags,
int hasother, sldns_pkt_section section, struct regional* region)
{
struct rrset_parse* dataset = sigset;
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.
*/
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,
uint32_t* rrset_flags,
uint8_t** prev_dname_first, uint8_t** prev_dname_last,
size_t* prev_dnamelen, uint16_t* prev_type,
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);
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 */
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) &&
smart_compare(pkt, dname, *prev_dname_first,
*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(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,
*rrset_flags);
*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.
*/
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)
return 0;
if(msg->qdcount > 1)
return LDNS_RCODE_FORMERR;
log_assert(msg->qdcount == 1);
if(ldns_buffer_remaining(pkt) <= 0)
if(sldns_buffer_remaining(pkt) <= 0)
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)
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;
msg->qtype = ldns_buffer_read_u16(pkt);
msg->qclass = ldns_buffer_read_u16(pkt);
msg->qtype = sldns_buffer_read_u16(pkt);
msg->qclass = sldns_buffer_read_u16(pkt);
return 0;
}
size_t
get_rdf_size(ldns_rdf_type rdf)
get_rdf_size(sldns_rdf_type rdf)
{
switch(rdf) {
case LDNS_RDF_TYPE_CLASS:
@ -626,16 +626,16 @@ get_rdf_size(ldns_rdf_type rdf)
/** calculate the size of one rr */
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 */
rr->size = sizeof(uint16_t); /* the rdatalen */
ldns_buffer_skip(pkt, 4); /* skip ttl */
pkt_len = ldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < pkt_len)
sldns_buffer_skip(pkt, 4); /* skip ttl */
pkt_len = sldns_buffer_read_u16(pkt);
if(sldns_buffer_remaining(pkt) < pkt_len)
return 0;
desc = ldns_rr_descript(type);
desc = sldns_rr_descript(type);
if(pkt_len > 0 && desc && desc->_dname_count > 0) {
int count = (int)desc->_dname_count;
int rdf = 0;
@ -646,12 +646,12 @@ calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr)
switch(desc->_wireformat[rdf]) {
case LDNS_RDF_TYPE_DNAME:
/* decompress every domain name */
oldpos = ldns_buffer_position(pkt);
oldpos = sldns_buffer_position(pkt);
if((len = pkt_dname_len(pkt)) == 0)
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 */
pkt_len -= ldns_buffer_position(pkt)-oldpos;
pkt_len -= sldns_buffer_position(pkt)-oldpos;
rr->size += len;
count--;
len = 0;
@ -661,7 +661,7 @@ calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr)
/* NOTREACHED, due to 'while(>0)' */
return 0; /* len byte exceeds rdata */
}
len = ldns_buffer_current(pkt)[0] + 1;
len = sldns_buffer_current(pkt)[0] + 1;
break;
default:
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)
return 0; /* exceeds rdata */
pkt_len -= len;
ldns_buffer_skip(pkt, (ssize_t)len);
sldns_buffer_skip(pkt, (ssize_t)len);
rr->size += len;
}
rdf++;
@ -678,41 +678,41 @@ calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr)
}
/* remaining rdata */
rr->size += pkt_len;
ldns_buffer_skip(pkt, (ssize_t)pkt_len);
sldns_buffer_skip(pkt, (ssize_t)pkt_len);
return 1;
}
/** skip rr ttl and rdata */
static int
skip_ttl_rdata(ldns_buffer* pkt)
skip_ttl_rdata(sldns_buffer* pkt)
{
uint16_t rdatalen;
if(ldns_buffer_remaining(pkt) < 6) /* ttl + rdatalen */
if(sldns_buffer_remaining(pkt) < 6) /* ttl + rdatalen */
return 0;
ldns_buffer_skip(pkt, 4); /* ttl */
rdatalen = ldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < rdatalen)
sldns_buffer_skip(pkt, 4); /* ttl */
rdatalen = sldns_buffer_read_u16(pkt);
if(sldns_buffer_remaining(pkt) < rdatalen)
return 0;
ldns_buffer_skip(pkt, (ssize_t)rdatalen);
sldns_buffer_skip(pkt, (ssize_t)rdatalen);
return 1;
}
/** see if RRSIG is a duplicate of another */
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;
size_t pos = ldns_buffer_position(pkt);
size_t pos = sldns_buffer_position(pkt);
struct rr_parse* sig;
if(ldns_buffer_remaining(pkt) < 6)
if(sldns_buffer_remaining(pkt) < 6)
return 0;
ldns_buffer_skip(pkt, 4); /* ttl */
rlen = ldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < rlen) {
ldns_buffer_set_position(pkt, pos);
sldns_buffer_skip(pkt, 4); /* ttl */
rlen = sldns_buffer_read_u16(pkt);
if(sldns_buffer_remaining(pkt) < rlen) {
sldns_buffer_set_position(pkt, pos);
return 0;
}
ldns_buffer_set_position(pkt, pos);
sldns_buffer_set_position(pkt, pos);
sig = rrset->rrsig_first;
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 */
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,
ldns_pkt_section section, uint16_t type)
sldns_pkt_section section, uint16_t type)
{
struct rr_parse* rr;
/* 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 ||
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))
return LDNS_RCODE_FORMERR;
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))))
return LDNS_RCODE_SERVFAIL;
rr->outside_packet = 0;
rr->ttl_data = ldns_buffer_current(pkt);
rr->ttl_data = sldns_buffer_current(pkt);
rr->next = 0;
if(type == LDNS_RR_TYPE_RRSIG && rrset->type != LDNS_RR_TYPE_RRSIG) {
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.
*/
static int
parse_section(ldns_buffer* pkt, struct msg_parse* msg,
struct regional* region, ldns_pkt_section section,
parse_section(sldns_buffer* pkt, struct msg_parse* msg,
struct regional* region, sldns_pkt_section section,
uint16_t num_rrs, size_t* num_rrsets)
{
uint16_t i;
@ -829,38 +829,38 @@ parse_section(ldns_buffer* pkt, struct msg_parse* msg,
if(num_rrs == 0)
return 0;
if(ldns_buffer_remaining(pkt) <= 0)
if(sldns_buffer_remaining(pkt) <= 0)
return LDNS_RCODE_FORMERR;
for(i=0; i<num_rrs; i++) {
/* parse this RR. */
dname = ldns_buffer_current(pkt);
dname = sldns_buffer_current(pkt);
if((dnamelen = pkt_dname_len(pkt)) == 0)
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;
type = ldns_buffer_read_u16(pkt);
ldns_buffer_read(pkt, &dclass, sizeof(dclass));
type = sldns_buffer_read_u16(pkt);
sldns_buffer_read(pkt, &dclass, sizeof(dclass));
if(0) { /* debug show what is being parsed. */
if(type == LDNS_RR_TYPE_RRSIG) {
uint16_t t;
if(pkt_rrsig_covered(pkt,
ldns_buffer_current(pkt), &t))
sldns_buffer_current(pkt), &t))
fprintf(stderr, "parse of %s(%d) [%s(%d)]",
ldns_rr_descript(type)?
ldns_rr_descript(type)->_name: "??",
sldns_rr_descript(type)?
sldns_rr_descript(type)->_name: "??",
(int)type,
ldns_rr_descript(t)?
ldns_rr_descript(t)->_name: "??",
sldns_rr_descript(t)?
sldns_rr_descript(t)->_name: "??",
(int)t);
} else
fprintf(stderr, "parse of %s(%d)",
ldns_rr_descript(type)?
ldns_rr_descript(type)->_name: "??",
sldns_rr_descript(type)?
sldns_rr_descript(type)->_name: "??",
(int)type);
fprintf(stderr, " %s(%d) ",
ldns_lookup_by_id(sldns_rr_classes,
(int)ntohs(dclass))?ldns_lookup_by_id(
sldns_lookup_by_id(sldns_rr_classes,
(int)ntohs(dclass))?sldns_lookup_by_id(
sldns_rr_classes, (int)ntohs(dclass))->name:
"??", (int)ntohs(dclass));
dname_print(stderr, pkt, dname);
@ -885,8 +885,8 @@ parse_section(ldns_buffer* pkt, struct msg_parse* msg,
fprintf(stderr, "is part of existing: ");
dname_print(stderr, pkt, rrset->dname);
fprintf(stderr, " type %s(%d)\n",
ldns_rr_descript(rrset->type)?
ldns_rr_descript(rrset->type)->_name: "??",
sldns_rr_descript(rrset->type)?
sldns_rr_descript(rrset->type)->_name: "??",
(int)rrset->type);
}
/* add to rrset. */
@ -898,18 +898,18 @@ parse_section(ldns_buffer* pkt, struct msg_parse* msg,
}
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;
if(ldns_buffer_remaining(pkt) < LDNS_HEADER_SIZE)
if(sldns_buffer_remaining(pkt) < LDNS_HEADER_SIZE)
return LDNS_RCODE_FORMERR;
/* read the header */
ldns_buffer_read(pkt, &msg->id, sizeof(uint16_t));
msg->flags = ldns_buffer_read_u16(pkt);
msg->qdcount = ldns_buffer_read_u16(pkt);
msg->ancount = ldns_buffer_read_u16(pkt);
msg->nscount = ldns_buffer_read_u16(pkt);
msg->arcount = ldns_buffer_read_u16(pkt);
sldns_buffer_read(pkt, &msg->id, sizeof(uint16_t));
msg->flags = sldns_buffer_read_u16(pkt);
msg->qdcount = sldns_buffer_read_u16(pkt);
msg->ancount = sldns_buffer_read_u16(pkt);
msg->nscount = sldns_buffer_read_u16(pkt);
msg->arcount = sldns_buffer_read_u16(pkt);
if(msg->qdcount > 1)
return LDNS_RCODE_FORMERR;
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,
msg->nscount, &msg->ns_rrsets)) != 0)
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.
* so, we do too. */
} else if((ret = parse_section(pkt, msg, region,
LDNS_SECTION_ADDITIONAL, msg->arcount, &msg->ar_rrsets)) != 0)
return ret;
/* if(ldns_buffer_remaining(pkt) > 0) { */
/* if(sldns_buffer_remaining(pkt) > 0) { */
/* there is spurious data at end of packet. ignore */
/* } */
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->ext_rcode = found->rr_last->ttl_data[0];
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);
/* ignore rdata and rrsigs */
return 0;
}
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_ANCOUNT(ldns_buffer_begin(pkt)) == 0);
log_assert(LDNS_NSCOUNT(ldns_buffer_begin(pkt)) == 0);
log_assert(LDNS_QDCOUNT(sldns_buffer_begin(pkt)) == 1);
log_assert(LDNS_ANCOUNT(sldns_buffer_begin(pkt)) == 0);
log_assert(LDNS_NSCOUNT(sldns_buffer_begin(pkt)) == 0);
/* 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;
}
if(LDNS_ARCOUNT(ldns_buffer_begin(pkt)) == 0) {
if(LDNS_ARCOUNT(sldns_buffer_begin(pkt)) == 0) {
memset(edns, 0, sizeof(*edns));
edns->udp_size = 512;
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. */
if(pkt_dname_len(pkt) != 1)
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;
if(ldns_buffer_read_u16(pkt) != LDNS_RR_TYPE_OPT)
if(sldns_buffer_read_u16(pkt) != LDNS_RR_TYPE_OPT)
return LDNS_RCODE_FORMERR;
edns->edns_present = 1;
edns->udp_size = ldns_buffer_read_u16(pkt); /* class is udp size */
edns->ext_rcode = ldns_buffer_read_u8(pkt); /* ttl used for bits */
edns->edns_version = ldns_buffer_read_u8(pkt);
edns->bits = ldns_buffer_read_u16(pkt);
edns->udp_size = sldns_buffer_read_u16(pkt); /* class is udp size */
edns->ext_rcode = sldns_buffer_read_u8(pkt); /* ttl used for bits */
edns->edns_version = sldns_buffer_read_u8(pkt);
edns->bits = sldns_buffer_read_u16(pkt);
/* ignore rdata and rrsigs */
return 0;
}

14
util/data/msgparse.h
View file

@ -65,7 +65,7 @@
#include "util/storage/lruhash.h"
#include "ldns/pkthdr.h"
#include "ldns/rrdef.h"
struct ldns_buffer;
struct sldns_buffer;
struct rrset_parse;
struct rr_parse;
struct regional;
@ -139,7 +139,7 @@ struct rrset_parse {
/** which section was it found in: one of
* LDNS_SECTION_ANSWER, LDNS_SECTION_AUTHORITY, LDNS_SECTION_ADDITIONAL
*/
ldns_pkt_section section;
sldns_pkt_section section;
/** start of (possibly compressed) dname in packet */
uint8_t* dname;
/** length of the dname uncompressed wireformat */
@ -221,7 +221,7 @@ struct edns_data {
* @param rdf: the rdf type from the descriptor.
* @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.
@ -231,7 +231,7 @@ size_t get_rdf_size(ldns_rdf_type rdf);
* @param region: how to alloc results.
* @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);
/**
@ -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.
* 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.
@ -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).
* @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);
/**
@ -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.
*/
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);
/**

74
util/data/msgreply.c
View file

@ -60,7 +60,7 @@ time_t MIN_TTL = 0;
/** allocate qinfo, return 0 on error */
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)
{
if(msg->qname) {
@ -154,13 +154,13 @@ repinfo_alloc_rrset_keys(struct reply_info* rep, struct alloc_cache* alloc,
/** do the rdata copy */
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)
{
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. */
if(*rr_ttl & 0x80000000U)
*rr_ttl = 0;
@ -175,18 +175,18 @@ rdata_copy(ldns_buffer* pkt, struct packed_rrset_data* data, uint8_t* to,
return 1;
}
ldns_buffer_set_position(pkt, (size_t)
(rr->ttl_data - ldns_buffer_begin(pkt) + sizeof(uint32_t)));
sldns_buffer_set_position(pkt, (size_t)
(rr->ttl_data - sldns_buffer_begin(pkt) + sizeof(uint32_t)));
/* insert decompressed size into rdata len stored in memory */
/* -2 because rdatalen bytes are not included. */
pkt_len = htons(rr->size - 2);
memmove(to, &pkt_len, sizeof(uint16_t));
to += 2;
/* read packet rdata len */
pkt_len = ldns_buffer_read_u16(pkt);
if(ldns_buffer_remaining(pkt) < pkt_len)
pkt_len = sldns_buffer_read_u16(pkt);
if(sldns_buffer_remaining(pkt) < pkt_len)
return 0;
desc = ldns_rr_descript(type);
desc = sldns_rr_descript(type);
if(pkt_len > 0 && desc && desc->_dname_count > 0) {
int count = (int)desc->_dname_count;
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) {
switch(desc->_wireformat[rdf]) {
case LDNS_RDF_TYPE_DNAME:
oldpos = ldns_buffer_position(pkt);
oldpos = sldns_buffer_position(pkt);
dname_pkt_copy(pkt, to,
ldns_buffer_current(pkt));
sldns_buffer_current(pkt));
to += pkt_dname_len(pkt);
pkt_len -= ldns_buffer_position(pkt)-oldpos;
pkt_len -= sldns_buffer_position(pkt)-oldpos;
count--;
len = 0;
break;
case LDNS_RDF_TYPE_STR:
len = ldns_buffer_current(pkt)[0] + 1;
len = sldns_buffer_current(pkt)[0] + 1;
break;
default:
len = get_rdf_size(desc->_wireformat[rdf]);
break;
}
if(len) {
memmove(to, ldns_buffer_current(pkt), len);
memmove(to, sldns_buffer_current(pkt), len);
to += len;
ldns_buffer_skip(pkt, (ssize_t)len);
sldns_buffer_skip(pkt, (ssize_t)len);
log_assert(len <= pkt_len);
pkt_len -= len;
}
@ -223,14 +223,14 @@ rdata_copy(ldns_buffer* pkt, struct packed_rrset_data* data, uint8_t* to,
}
/* copy remaining rdata */
if(pkt_len > 0)
memmove(to, ldns_buffer_current(pkt), pkt_len);
memmove(to, sldns_buffer_current(pkt), pkt_len);
return 1;
}
/** copy over the data into packed rrset */
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)
{
size_t i;
@ -273,7 +273,7 @@ parse_rr_copy(ldns_buffer* pkt, struct rrset_parse* pset,
/** create rrset return 0 on failure */
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)
{
/* allocate */
@ -333,7 +333,7 @@ get_rrset_trust(struct msg_parse* msg, struct rrset_parse* rrset)
}
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 ub_packed_rrset_key* pk)
{
@ -371,7 +371,7 @@ parse_copy_decompress_rrset(ldns_buffer* pkt, struct msg_parse* msg,
* @return 0 on failure.
*/
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)
{
size_t i;
@ -398,7 +398,7 @@ parse_copy_decompress(ldns_buffer* pkt, struct msg_parse* msg,
}
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 reply_info** rep, struct regional* region)
{
@ -414,7 +414,7 @@ parse_create_msg(ldns_buffer* pkt, struct msg_parse* msg,
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 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));
ldns_buffer_set_position(pkt, 0);
sldns_buffer_set_position(pkt, 0);
if((ret = parse_packet(pkt, msg, region)) != 0) {
return ret;
}
@ -497,23 +497,23 @@ reply_info_parsedelete(struct reply_info* rep, struct alloc_cache* alloc)
}
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 */
if(ldns_buffer_limit(query) < LDNS_HEADER_SIZE + 5)
if(sldns_buffer_limit(query) < LDNS_HEADER_SIZE + 5)
return 0;
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;
ldns_buffer_skip(query, LDNS_HEADER_SIZE);
m->qname = ldns_buffer_current(query);
sldns_buffer_skip(query, LDNS_HEADER_SIZE);
m->qname = sldns_buffer_current(query);
if((m->qname_len = query_dname_len(query)) == 0)
return 0; /* parse error */
if(ldns_buffer_remaining(query) < 4)
if(sldns_buffer_remaining(query) < 4)
return 0; /* need qtype, qclass */
m->qtype = ldns_buffer_read_u16(query);
m->qclass = ldns_buffer_read_u16(query);
m->qtype = sldns_buffer_read_u16(query);
m->qclass = sldns_buffer_read_u16(query);
return 1;
}
@ -765,23 +765,23 @@ void
log_dns_msg(const char* str, struct query_info* qinfo, struct reply_info* rep)
{
/* 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();
if(!reply_info_encode(qinfo, rep, 0, rep->flags, buf, 0,
region, 65535, 1)) {
log_info("%s: log_dns_msg: out of memory", str);
} else {
char* str = ldns_wire2str_pkt(ldns_buffer_begin(buf),
ldns_buffer_limit(buf));
char* str = sldns_wire2str_pkt(sldns_buffer_begin(buf),
sldns_buffer_limit(buf));
if(!str) {
log_info("%s: log_dns_msg: ldns tostr failed", str);
} else {
log_info("%s %s",
str, (char*)ldns_buffer_begin(buf));
str, (char*)sldns_buffer_begin(buf));
}
free(str);
}
ldns_buffer_free(buf);
sldns_buffer_free(buf);
regional_destroy(region);
}

10
util/data/msgreply.h
View file

@ -43,7 +43,7 @@
#define UTIL_DATA_MSGREPLY_H
#include "util/storage/lruhash.h"
#include "util/data/packed_rrset.h"
struct ldns_buffer;
struct sldns_buffer;
struct comm_reply;
struct alloc_cache;
struct iovec;
@ -202,7 +202,7 @@ struct msgreply_entry {
* @param query: the wireformat packet query. starts with ID.
* @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.
@ -219,7 +219,7 @@ int query_info_parse(struct query_info* m, struct ldns_buffer* query);
* o FORMERR for parse 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 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.
* @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 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.
* @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 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;
if(d->rr_len[0] < 3) /* at least rdatalen + 0byte root label */
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))
return;
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);
if(i < d->count)
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);
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));
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);
dest[0] = 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);
}
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)
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

6
util/log.h
View file

@ -41,7 +41,7 @@
#ifndef UTIL_LOG_H
#define UTIL_LOG_H
struct ldns_buffer;
struct sldns_buffer;
/**
* 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);
/**
* 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
* verbosity setting.
* @param msg: string desc to print
* @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.

4
util/module.h
View file

@ -44,7 +44,7 @@
#include "util/storage/lruhash.h"
#include "util/data/msgreply.h"
#include "util/data/msgparse.h"
struct ldns_buffer;
struct sldns_buffer;
struct alloc_cache;
struct rrset_cache;
struct key_cache;
@ -177,7 +177,7 @@ struct module_env {
/** region for temporary usage. May be cleared after operate() call. */
struct regional* scratch;
/** 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. */
struct worker* worker;
/** 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_MAILA) ts = "MAILA";
else if(type == LDNS_RR_TYPE_ANY) ts = "ANY";
else if(ldns_rr_descript(type) && ldns_rr_descript(type)->_name)
ts = ldns_rr_descript(type)->_name;
else if(sldns_rr_descript(type) && sldns_rr_descript(type)->_name)
ts = sldns_rr_descript(type)->_name;
else {
snprintf(t, sizeof(t), "TYPE%d", (int)type);
ts = t;
}
if(ldns_lookup_by_id(SLDNS(_rr_classes), (int)dclass) &&
ldns_lookup_by_id(SLDNS(_rr_classes), (int)dclass)->name)
cs = ldns_lookup_by_id(SLDNS(_rr_classes), (int)dclass)->name;
if(sldns_lookup_by_id(sldns_rr_classes, (int)dclass) &&
sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name)
cs = sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name;
else {
snprintf(c, sizeof(c), "CLASS%d", (int)dclass);
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 */
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)
{
ssize_t sent;
log_assert(c->fd != -1);
#ifdef UNBOUND_DEBUG
if(ldns_buffer_remaining(packet) == 0)
if(sldns_buffer_remaining(packet) == 0)
log_err("error: send empty UDP packet");
#endif
log_assert(addr && addrlen > 0);
sent = sendto(c->fd, (void*)ldns_buffer_begin(packet),
ldns_buffer_remaining(packet), 0,
sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
sldns_buffer_remaining(packet), 0,
addr, addrlen);
if(sent == -1) {
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",
(struct sockaddr_storage*)addr, addrlen);
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",
(int)sent, (int)ldns_buffer_remaining(packet));
(int)sent, (int)sldns_buffer_remaining(packet));
return 0;
}
return 1;
@ -461,7 +461,7 @@ static void p_ancil(const char* str, struct comm_reply* r)
/** send a UDP reply over specified interface*/
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)
{
#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);
#ifdef UNBOUND_DEBUG
if(ldns_buffer_remaining(packet) == 0)
if(sldns_buffer_remaining(packet) == 0)
log_err("error: send empty UDP packet");
#endif
log_assert(addr && addrlen > 0);
msg.msg_name = addr;
msg.msg_namelen = addrlen;
iov[0].iov_base = ldns_buffer_begin(packet);
iov[0].iov_len = ldns_buffer_remaining(packet);
iov[0].iov_base = sldns_buffer_begin(packet);
iov[0].iov_len = sldns_buffer_remaining(packet);
msg.msg_iov = iov;
msg.msg_iovlen = 1;
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",
(struct sockaddr_storage*)addr, addrlen);
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",
(int)sent, (int)ldns_buffer_remaining(packet));
(int)sent, (int)sldns_buffer_remaining(packet));
return 0;
}
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);
comm_base_now(rep.c->ev->base);
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);
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_namelen = (socklen_t)sizeof(rep.addr);
iov[0].iov_base = ldns_buffer_begin(rep.c->buffer);
iov[0].iov_len = ldns_buffer_remaining(rep.c->buffer);
iov[0].iov_base = sldns_buffer_begin(rep.c->buffer);
iov[0].iov_len = sldns_buffer_remaining(rep.c->buffer);
msg.msg_iov = iov;
msg.msg_iovlen = 1;
msg.msg_control = ancil;
@ -605,8 +605,8 @@ comm_point_udp_ancil_callback(int fd, short event, void* arg)
return;
}
rep.addrlen = msg.msg_namelen;
ldns_buffer_skip(rep.c->buffer, rcv);
ldns_buffer_flip(rep.c->buffer);
sldns_buffer_skip(rep.c->buffer, rcv);
sldns_buffer_flip(rep.c->buffer);
rep.srctype = 0;
#ifndef S_SPLINT_S
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);
comm_base_now(rep.c->ev->base);
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);
log_assert(fd != -1);
log_assert(ldns_buffer_remaining(rep.c->buffer) > 0);
rcv = recvfrom(fd, (void*)ldns_buffer_begin(rep.c->buffer),
ldns_buffer_remaining(rep.c->buffer), 0,
log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
rcv = recvfrom(fd, (void*)sldns_buffer_begin(rep.c->buffer),
sldns_buffer_remaining(rep.c->buffer), 0,
(struct sockaddr*)&rep.addr, &rep.addrlen);
if(rcv == -1) {
#ifndef USE_WINSOCK
@ -691,8 +691,8 @@ comm_point_udp_callback(int fd, short event, void* arg)
#endif
return;
}
ldns_buffer_skip(rep.c->buffer, rcv);
ldns_buffer_flip(rep.c->buffer);
sldns_buffer_skip(rep.c->buffer, rcv);
sldns_buffer_flip(rep.c->buffer);
rep.srctype = 0;
fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
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->fd == -1);
ldns_buffer_clear(c->buffer);
sldns_buffer_clear(c->buffer);
c->tcp_is_reading = 1;
c->tcp_byte_count = 0;
comm_point_start_listening(c, fd, TCP_QUERY_TIMEOUT);
@ -914,7 +914,7 @@ static void
tcp_callback_writer(struct comm_point* c)
{
log_assert(c->type == comm_tcp);
ldns_buffer_clear(c->buffer);
sldns_buffer_clear(c->buffer);
if(c->tcp_do_toggle_rw)
c->tcp_is_reading = 1;
c->tcp_byte_count = 0;
@ -928,7 +928,7 @@ static void
tcp_callback_reader(struct comm_point* c)
{
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)
c->tcp_is_reading = 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)) {
/* read length bytes */
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))) <= 0) {
int want = SSL_get_error(c->ssl, r);
@ -1045,24 +1045,24 @@ ssl_handle_read(struct comm_point* c)
c->tcp_byte_count += r;
if(c->tcp_byte_count != sizeof(uint16_t))
return 1;
if(ldns_buffer_read_u16_at(c->buffer, 0) >
ldns_buffer_capacity(c->buffer)) {
if(sldns_buffer_read_u16_at(c->buffer, 0) >
sldns_buffer_capacity(c->buffer)) {
verbose(VERB_QUERY, "ssl: dropped larger than buffer");
return 0;
}
ldns_buffer_set_limit(c->buffer,
ldns_buffer_read_u16_at(c->buffer, 0));
if(ldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
sldns_buffer_set_limit(c->buffer,
sldns_buffer_read_u16_at(c->buffer, 0));
if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
verbose(VERB_QUERY, "ssl: dropped bogus too short.");
return 0;
}
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();
r = SSL_read(c->ssl, (void*)ldns_buffer_current(c->buffer),
(int)ldns_buffer_remaining(c->buffer));
r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
(int)sldns_buffer_remaining(c->buffer));
if(r <= 0) {
int want = SSL_get_error(c->ssl, r);
if(want == SSL_ERROR_ZERO_RETURN) {
@ -1082,8 +1082,8 @@ ssl_handle_read(struct comm_point* c)
log_crypto_err("could not SSL_read");
return 0;
}
ldns_buffer_skip(c->buffer, (ssize_t)r);
if(ldns_buffer_remaining(c->buffer) <= 0) {
sldns_buffer_skip(c->buffer, (ssize_t)r);
if(sldns_buffer_remaining(c->buffer) <= 0) {
tcp_callback_reader(c);
}
return 1;
@ -1108,7 +1108,7 @@ ssl_handle_write(struct comm_point* c)
/* ignore return, if fails we may simply block */
(void)SSL_set_mode(c->ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
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();
r = SSL_write(c->ssl,
(void*)(((uint8_t*)&len)+c->tcp_byte_count),
@ -1135,17 +1135,17 @@ ssl_handle_write(struct comm_point* c)
c->tcp_byte_count += r;
if(c->tcp_byte_count < sizeof(uint16_t))
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));
if(ldns_buffer_remaining(c->buffer) == 0) {
if(sldns_buffer_remaining(c->buffer) == 0) {
tcp_callback_writer(c);
return 1;
}
}
log_assert(ldns_buffer_remaining(c->buffer) > 0);
log_assert(sldns_buffer_remaining(c->buffer) > 0);
ERR_clear_error();
r = SSL_write(c->ssl, (void*)ldns_buffer_current(c->buffer),
(int)ldns_buffer_remaining(c->buffer));
r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
(int)sldns_buffer_remaining(c->buffer));
if(r <= 0) {
int want = SSL_get_error(c->ssl, r);
if(want == SSL_ERROR_ZERO_RETURN) {
@ -1165,9 +1165,9 @@ ssl_handle_write(struct comm_point* c)
log_crypto_err("could not SSL_write");
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);
}
return 1;
@ -1205,7 +1205,7 @@ comm_point_tcp_handle_read(int fd, struct comm_point* c, int short_ok)
log_assert(fd != -1);
if(c->tcp_byte_count < sizeof(uint16_t)) {
/* 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);
if(r == 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;
if(c->tcp_byte_count != sizeof(uint16_t))
return 1;
if(ldns_buffer_read_u16_at(c->buffer, 0) >
ldns_buffer_capacity(c->buffer)) {
if(sldns_buffer_read_u16_at(c->buffer, 0) >
sldns_buffer_capacity(c->buffer)) {
verbose(VERB_QUERY, "tcp: dropped larger than buffer");
return 0;
}
ldns_buffer_set_limit(c->buffer,
ldns_buffer_read_u16_at(c->buffer, 0));
sldns_buffer_set_limit(c->buffer,
sldns_buffer_read_u16_at(c->buffer, 0));
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.");
return 0;
}
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);
r = recv(fd, (void*)ldns_buffer_current(c->buffer),
ldns_buffer_remaining(c->buffer), 0);
log_assert(sldns_buffer_remaining(c->buffer) > 0);
r = recv(fd, (void*)sldns_buffer_current(c->buffer),
sldns_buffer_remaining(c->buffer), 0);
if(r == 0) {
return 0;
} 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);
return 0;
}
ldns_buffer_skip(c->buffer, r);
if(ldns_buffer_remaining(c->buffer) <= 0) {
sldns_buffer_skip(c->buffer, r);
if(sldns_buffer_remaining(c->buffer) <= 0) {
tcp_callback_reader(c);
}
return 1;
@ -1344,13 +1344,13 @@ comm_point_tcp_handle_write(int fd, struct comm_point* c)
return ssl_handle_it(c);
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
struct iovec iov[2];
iov[0].iov_base = (uint8_t*)&len + 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_len = ldns_buffer_limit(c->buffer);
iov[1].iov_base = sldns_buffer_begin(c->buffer);
iov[1].iov_len = sldns_buffer_limit(c->buffer);
log_assert(iov[0].iov_len > 0);
log_assert(iov[1].iov_len > 0);
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;
if(c->tcp_byte_count < sizeof(uint16_t))
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));
if(ldns_buffer_remaining(c->buffer) == 0) {
if(sldns_buffer_remaining(c->buffer) == 0) {
tcp_callback_writer(c);
return 1;
}
}
log_assert(ldns_buffer_remaining(c->buffer) > 0);
r = send(fd, (void*)ldns_buffer_current(c->buffer),
ldns_buffer_remaining(c->buffer), 0);
log_assert(sldns_buffer_remaining(c->buffer) > 0);
r = send(fd, (void*)sldns_buffer_current(c->buffer),
sldns_buffer_remaining(c->buffer), 0);
if(r == -1) {
#ifndef USE_WINSOCK
if(errno == EINTR || errno == EAGAIN)
@ -1415,9 +1415,9 @@ comm_point_tcp_handle_write(int fd, struct comm_point* c)
c->repinfo.addrlen);
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);
}
@ -1500,7 +1500,7 @@ void comm_point_raw_handle_callback(int ATTR_UNUSED(fd),
}
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)
{
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*
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)
{
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->fd = -1;
c->buffer = ldns_buffer_new(bufsize);
c->buffer = sldns_buffer_new(bufsize);
if(!c->buffer) {
free(c->ev);
free(c);
@ -1624,7 +1624,7 @@ comm_point_create_tcp_handler(struct comm_base *base,
}
c->timeout = (struct timeval*)malloc(sizeof(struct timeval));
if(!c->timeout) {
ldns_buffer_free(c->buffer);
sldns_buffer_free(c->buffer);
free(c->ev);
free(c);
return NULL;
@ -1741,7 +1741,7 @@ comm_point_create_tcp_out(struct comm_base *base, size_t bufsize,
}
c->ev->base = base;
c->fd = -1;
c->buffer = ldns_buffer_new(bufsize);
c->buffer = sldns_buffer_new(bufsize);
if(!c->buffer) {
free(c->ev);
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)
{
log_err("could not basetset tcpout event");
ldns_buffer_free(c->buffer);
sldns_buffer_free(c->buffer);
free(c->ev);
free(c);
return NULL;
@ -1793,7 +1793,7 @@ comm_point_create_local(struct comm_base *base, int fd, size_t bufsize,
}
c->ev->base = base;
c->fd = fd;
c->buffer = ldns_buffer_new(bufsize);
c->buffer = sldns_buffer_new(bufsize);
if(!c->buffer) {
free(c->ev);
free(c);
@ -1918,7 +1918,7 @@ comm_point_delete(struct comm_point* c)
}
free(c->timeout);
if(c->type == comm_tcp || c->type == comm_local)
ldns_buffer_free(c->buffer);
sldns_buffer_free(c->buffer);
free(c->ev);
free(c);
}
@ -2030,7 +2030,7 @@ size_t comm_point_get_mem(struct comm_point* c)
if(c->timeout)
s += sizeof(*c->timeout);
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) {
int i;
for(i=0; i<c->max_tcp_count; i++)

10
util/netevent.h
View file

@ -60,7 +60,7 @@
#ifndef NET_EVENT_H
#define NET_EVENT_H
struct ldns_buffer;
struct sldns_buffer;
struct comm_point;
struct comm_reply;
struct event_base;
@ -149,7 +149,7 @@ struct comm_point {
struct timeval* timeout;
/** buffer pointer. Either to perthread, or own buffer or NULL */
struct ldns_buffer* buffer;
struct sldns_buffer* buffer;
/* -------- TCP Handler -------- */
/** 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.
*/
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);
/**
@ -383,7 +383,7 @@ struct comm_point* comm_point_create_udp(struct comm_base* base,
* Sets timeout to NULL. Turns off TCP options.
*/
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);
/**
@ -477,7 +477,7 @@ void comm_point_drop_reply(struct comm_reply* repinfo);
* @param addrlen: length of addr.
* @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);
/**

102
validator/autotrust.c
View file

@ -144,10 +144,10 @@ verbose_key(struct autr_ta* ta, enum verbosity_value level,
va_list args;
va_start(args, format);
if(verbosity >= level) {
char* str = ldns_wire2str_dname(ta->rr, ta->dname_len);
int keytag = (int)ldns_calc_keytag_raw(ldns_wirerr_get_rdata(
char* str = sldns_wire2str_dname(ta->rr, ta->dname_len);
int keytag = (int)sldns_calc_keytag_raw(sldns_wirerr_get_rdata(
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));
char msg[MAXSYSLOGMSGLEN];
vsnprintf(msg, sizeof(msg), format, args);
@ -299,9 +299,9 @@ static int
ta_is_dnskey_sep(struct autr_ta* ta)
{
return (dnskey_flags(
ldns_wirerr_get_type(ta->rr, ta->rr_len, ta->dname_len),
ldns_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_type(ta->rr, ta->rr_len, ta->dname_len),
sldns_wirerr_get_rdata(ta->rr, ta->rr_len, ta->dname_len),
sldns_wirerr_get_rdatalen(ta->rr, ta->rr_len, ta->dname_len)
) & 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;
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->autr) {
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;
}
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));
lock_basic_lock(&tp->lock);
return tp;
@ -480,12 +480,12 @@ add_trustanchor_frm_str(struct val_anchors* anchors, char* str,
*skip = 1;
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)))
{
log_err("ldns error while converting string to RR at%d: %s: %s",
LDNS_WIREPARSE_OFFSET(lstatus),
ldns_get_errorstr_parse(lstatus), str);
sldns_get_errorstr_parse(lstatus), str);
return NULL;
}
free(*prev);
@ -495,8 +495,8 @@ add_trustanchor_frm_str(struct val_anchors* anchors, char* str,
log_err("malloc failure in add_trustanchor");
return NULL;
}
if(ldns_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) {
if(sldns_wirerr_get_type(rr, rr_len, dname_len)!=LDNS_RR_TYPE_DNSKEY &&
sldns_wirerr_get_type(rr, rr_len, dname_len)!=LDNS_RR_TYPE_DS) {
*skip = 1;
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)
{
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) {
*rr = (*list)->rr;
*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)
{
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)->s == AUTR_STATE_VALID ||
(*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));
if(!k)
return NULL;
k->rk.type = htons(ldns_wirerr_get_type(rr, rr_len, dname_len));
k->rk.rrset_class = htons(ldns_wirerr_get_class(rr, rr_len, dname_len));
k->rk.type = htons(sldns_wirerr_get_type(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 = memdup(rr, dname_len);
if(!k->rk.dname) {
@ -664,13 +664,13 @@ packed_rrset_heap_data(int iter(struct autr_ta**, uint8_t**, size_t*,
list_i = list;
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)
rrsig_count++;
else count++;
/* sizeof the rdlength + rdatalen */
len += 2 + ldns_wirerr_get_rdatalen(rr, rr_len, dname_len);
ttl = (time_t)ldns_wirerr_get_ttl(rr, rr_len, dname_len);
len += 2 + sldns_wirerr_get_rdatalen(rr, rr_len, dname_len);
ttl = (time_t)sldns_wirerr_get_ttl(rr, rr_len, dname_len);
}
if(count == 0 && rrsig_count == 0)
return NULL;
@ -697,12 +697,12 @@ packed_rrset_heap_data(int iter(struct autr_ta**, uint8_t**, size_t*,
list_i = list;
i = 0;
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);
if(data->rr_ttl[i] < data->ttl)
data->ttl = data->rr_ttl[i];
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++;
}
@ -717,7 +717,7 @@ packed_rrset_heap_data(int iter(struct autr_ta**, uint8_t**, size_t*,
i = 0;
while(iter(&list_i, &rr, &rr_len, &dname_len)) {
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]);
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.
* 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.
* @return false on malloc failure.
*/
@ -817,7 +817,7 @@ parse_id(struct val_anchors* anchors, char* line)
if(!next)
return NULL;
next[0] = 0;
dname = ldns_str2wire_dname(line, &dname_len);
dname = sldns_str2wire_dname(line, &dname_len);
if(!dname)
return NULL;
@ -910,7 +910,7 @@ handle_origin(char* line, uint8_t** origin, size_t* origin_len)
line += 7;
while(isspace((int)*line))
line++;
*origin = ldns_str2wire_dname(line, &len);
*origin = sldns_str2wire_dname(line, &len);
*origin_len = len;
if(!*origin)
log_warn("malloc failure or parse error in $ORIGIN");
@ -1079,7 +1079,7 @@ trustanchor_state2str(autr_state_t s)
static int
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) {
log_err("malloc failure in write to %s", fname);
return 0;
@ -1144,10 +1144,10 @@ autr_write_contents(FILE* out, char* fn, struct trust_anchor* tp)
if(ta->s == AUTR_STATE_REMOVED)
continue;
/* 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)
continue;
str = ldns_wire2str_rr(ta->rr, ta->rr_len);
str = sldns_wire2str_rr(ta->rr, ta->rr_len);
if(!str || !str[0]) {
free(str);
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) */
if(len < 2+8+4)
return 0;
return ldns_read_uint32(d+2+8);
return sldns_read_uint32(d+2+8);
}
/** Find minimum expiration interval from signatures */
@ -1296,18 +1296,18 @@ revoke_dnskey(struct autr_ta* ta, int off)
{
uint16_t flags;
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)
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;
data = ldns_wirerr_get_rdata(ta->rr, ta->rr_len, ta->dname_len);
flags = ldns_read_uint16(data);
data = sldns_wirerr_get_rdata(ta->rr, ta->rr_len, ta->dname_len);
flags = sldns_read_uint16(data);
if (off && (flags&LDNS_KEY_REVOKE_KEY))
flags ^= LDNS_KEY_REVOKE_KEY; /* flip */
else
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) */
@ -1341,20 +1341,20 @@ ta_compare(struct autr_ta* a, uint16_t t, uint8_t* b, size_t b_len)
{
if(!a) return -1;
else if(!b) return -1;
else if(ldns_wirerr_get_type(a->rr, a->rr_len, a->dname_len) != t)
return (int)ldns_wirerr_get_type(a->rr, a->rr_len,
else if(sldns_wirerr_get_type(a->rr, a->rr_len, a->dname_len) != t)
return (int)sldns_wirerr_get_type(a->rr, a->rr_len,
a->dname_len) - (int)t;
else if(t == LDNS_RR_TYPE_DNSKEY) {
return dnskey_compare_skip_revbit(
ldns_wirerr_get_rdata(a->rr, a->rr_len, a->dname_len),
ldns_wirerr_get_rdatalen(a->rr, a->rr_len,
sldns_wirerr_get_rdata(a->rr, a->rr_len, a->dname_len),
sldns_wirerr_get_rdatalen(a->rr, a->rr_len,
a->dname_len), b, b_len);
}
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)
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);
}
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
* compare keytags, with +0 or +128(REVOKE flag) */
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),
ldns_wirerr_get_rdatalen(ta->rr, ta->rr_len,
sldns_wirerr_get_rdatalen(ta->rr, ta->rr_len,
ta->dname_len)) ||
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),
ldns_wirerr_get_rdatalen(ta->rr, ta->rr_len,
sldns_wirerr_get_rdatalen(ta->rr, ta->rr_len,
ta->dname_len))); /* checks conversion*/
verbose_key(ta, VERB_ALGO, "is self-signed 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;
for(anchor = tp->autr->keys; anchor; anchor = anchor->next) {
/* 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->last_change == 0 &&
!ta_is_dnskey_sep(anchor) &&
@ -1929,7 +1929,7 @@ autr_cleanup_keys(struct trust_anchor* tp)
while(p) {
/* do we want to remove this key? */
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) {
struct autr_ta* np = p->next;
/* remove */
@ -2205,7 +2205,7 @@ static void
autr_debug_print_ta(struct autr_ta* ta)
{
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) {
log_info("out of memory in debug_print_ta");
return;
@ -2271,7 +2271,7 @@ autr_debug_print(struct val_anchors* anchors)
}
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))
{
/* 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;
uint16_t qflags = BIT_RD;
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);
if(!qinfo.qname) {
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.edns_version = 0;
edns.bits = EDNS_DO;
if(ldns_buffer_capacity(buf) < 65535)
edns.udp_size = (uint16_t)ldns_buffer_capacity(buf);
if(sldns_buffer_capacity(buf) < 65535)
edns.udp_size = (uint16_t)sldns_buffer_capacity(buf);
else edns.udp_size = 65535;
/* 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 module_env;
struct val_env;
struct ldns_buffer;
struct sldns_buffer;
/** Autotrust anchor states */
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);
/** 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);
#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;
if(!(ta=anchor_store_new_key(anchors, rr,
ldns_wirerr_get_type(rr, rl, dl),
ldns_wirerr_get_class(rr, rl, dl),
ldns_wirerr_get_rdatawl(rr, rl, dl),
ldns_wirerr_get_rdatalen(rr, rl, dl)+2))) {
sldns_wirerr_get_type(rr, rl, dl),
sldns_wirerr_get_class(rr, rl, dl),
sldns_wirerr_get_rdatawl(rr, rl, dl),
sldns_wirerr_get_rdatalen(rr, rl, dl)+2))) {
return NULL;
}
log_nametypeclass(VERB_QUERY, "adding trusted key",
rr, ldns_wirerr_get_type(rr, rl, dl),
ldns_wirerr_get_class(rr, rl, dl));
rr, sldns_wirerr_get_type(rr, rl, dl),
sldns_wirerr_get_class(rr, rl, dl));
return ta;
}
@ -381,7 +381,7 @@ anchor_insert_insecure(struct val_anchors* anchors, const char* str)
{
struct trust_anchor* ta;
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) {
log_err("parse error in domain name '%s'", str);
return NULL;
@ -393,18 +393,18 @@ anchor_insert_insecure(struct val_anchors* anchors, const char* str)
}
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)
{
struct trust_anchor* ta;
uint8_t* rr = ldns_buffer_begin(buffer);
size_t len = ldns_buffer_capacity(buffer), dname_len = 0;
int status = ldns_str2wire_rr_buf(str, rr, &len, &dname_len,
uint8_t* rr = sldns_buffer_begin(buffer);
size_t len = sldns_buffer_capacity(buffer), dname_len = 0;
int status = sldns_str2wire_rr_buf(str, rr, &len, &dname_len,
0, NULL, 0, NULL, 0);
if(status != 0) {
log_err("error parsing trust anchor %s: at %d: %s",
str, LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status));
sldns_get_errorstr_parse(status));
return NULL;
}
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.
*/
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)
{
struct trust_anchor* ta = NULL, *tanew;
struct ldns_file_parse_state pst;
struct sldns_file_parse_state pst;
int status;
size_t len, dname_len;
uint8_t* rr = ldns_buffer_begin(buffer);
uint8_t* rr = sldns_buffer_begin(buffer);
int ok = 1;
FILE* in = fopen(fname, "r");
if(!in) {
@ -441,20 +441,20 @@ anchor_read_file(struct val_anchors* anchors, ldns_buffer* buffer,
pst.default_ttl = 3600;
pst.lineno = 1;
while(!feof(in)) {
len = ldns_buffer_capacity(buffer);
len = sldns_buffer_capacity(buffer);
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 */
continue;
if(status != 0) {
log_err("parse error in %s:%d:%d : %s", fname,
pst.lineno, LDNS_WIREPARSE_OFFSET(status),
ldns_get_errorstr_parse(status));
sldns_get_errorstr_parse(status));
ok = 0;
break;
}
if(ldns_wirerr_get_type(rr, len, dname_len) !=
LDNS_RR_TYPE_DS && ldns_wirerr_get_type(rr, len,
if(sldns_wirerr_get_type(rr, len, dname_len) !=
LDNS_RR_TYPE_DS && sldns_wirerr_get_type(rr, len,
dname_len) != LDNS_RR_TYPE_DNSKEY) {
continue;
}
@ -527,7 +527,7 @@ is_bind_special(int c)
* 0 on end of file.
*/
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 numdone = 0;
@ -537,17 +537,17 @@ readkeyword_bindfile(FILE* in, ldns_buffer* buf, int* line, int comments)
(*line)++;
continue;
} else if(comments && c=='/' && numdone>0 && /* /_/ bla*/
ldns_buffer_read_u8_at(buf,
ldns_buffer_position(buf)-1) == '/') {
ldns_buffer_skip(buf, -1);
sldns_buffer_read_u8_at(buf,
sldns_buffer_position(buf)-1) == '/') {
sldns_buffer_skip(buf, -1);
numdone--;
skip_to_eol(in);
(*line)++;
continue;
} else if(comments && c=='*' && numdone>0 && /* /_* bla *_/ */
ldns_buffer_read_u8_at(buf,
ldns_buffer_position(buf)-1) == '/') {
ldns_buffer_skip(buf, -1);
sldns_buffer_read_u8_at(buf,
sldns_buffer_position(buf)-1) == '/') {
sldns_buffer_skip(buf, -1);
numdone--;
/* skip to end of comment */
while(c != EOF && (c=getc(in)) != EOF ) {
@ -577,10 +577,10 @@ readkeyword_bindfile(FILE* in, ldns_buffer* buf, int* line, int comments)
(*line)++;
}
/* 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);
}
ldns_buffer_write_u8(buf, (uint8_t)c);
sldns_buffer_write_u8(buf, (uint8_t)c);
numdone++;
if(isspace(c)) {
/* collate whitespace into ' ' */
@ -602,17 +602,17 @@ readkeyword_bindfile(FILE* in, ldns_buffer* buf, int* line, int comments)
/** skip through file to { or ; */
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;
ldns_buffer_clear(buf);
sldns_buffer_clear(buf);
while((rdlen=readkeyword_bindfile(in, buf, line, 1))) {
if(rdlen == 1 && isspace((int)*ldns_buffer_begin(buf))) {
ldns_buffer_clear(buf);
if(rdlen == 1 && isspace((int)*sldns_buffer_begin(buf))) {
sldns_buffer_clear(buf);
continue;
}
if(rdlen != 1 || *ldns_buffer_begin(buf) != (uint8_t)spec) {
ldns_buffer_write_u8(buf, 0);
if(rdlen != 1 || *sldns_buffer_begin(buf) != (uint8_t)spec) {
sldns_buffer_write_u8(buf, 0);
log_err("trusted-keys, line %d, expected %c",
*line, spec);
return 0;
@ -632,7 +632,7 @@ skip_to_special(FILE* in, ldns_buffer* buf, int* line, int spec)
* @return 0 on error.
*/
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)
{
/* loop over contents, collate strings before ; */
@ -645,41 +645,41 @@ process_bind_contents(struct val_anchors* anchors, ldns_buffer* buf,
int comments = 1;
int rdlen;
char* str = 0;
ldns_buffer_clear(buf);
sldns_buffer_clear(buf);
while((rdlen=readkeyword_bindfile(in, buf, line, comments))) {
if(rdlen == 1 && ldns_buffer_position(buf) == 1
&& isspace((int)*ldns_buffer_begin(buf))) {
if(rdlen == 1 && sldns_buffer_position(buf) == 1
&& isspace((int)*sldns_buffer_begin(buf))) {
/* starting whitespace is removed */
ldns_buffer_clear(buf);
sldns_buffer_clear(buf);
continue;
} else if(rdlen == 1 && ldns_buffer_current(buf)[-1] == '"') {
} else if(rdlen == 1 && sldns_buffer_current(buf)[-1] == '"') {
/* remove " from the string */
if(contnum == 0) {
quoted = 1;
comments = 0;
}
ldns_buffer_skip(buf, -1);
sldns_buffer_skip(buf, -1);
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);
return 0;
}
ldns_buffer_write(buf, " DNSKEY ", 8);
sldns_buffer_write(buf, " DNSKEY ", 8);
quoted = 0;
comments = 1;
} else if(contnum > 0)
comments = !comments;
continue;
} else if(rdlen == 1 && ldns_buffer_current(buf)[-1] == ';') {
} else if(rdlen == 1 && sldns_buffer_current(buf)[-1] == ';') {
if(contnum < 5) {
ldns_buffer_write_u8(buf, 0);
sldns_buffer_write_u8(buf, 0);
log_err("line %d, bad key", *line);
return 0;
}
ldns_buffer_skip(buf, -1);
ldns_buffer_write_u8(buf, 0);
str = strdup((char*)ldns_buffer_begin(buf));
sldns_buffer_skip(buf, -1);
sldns_buffer_write_u8(buf, 0);
str = strdup((char*)sldns_buffer_begin(buf));
if(!str) {
log_err("line %d, allocation failure", *line);
return 0;
@ -690,30 +690,30 @@ process_bind_contents(struct val_anchors* anchors, ldns_buffer* buf,
return 0;
}
free(str);
ldns_buffer_clear(buf);
sldns_buffer_clear(buf);
contnum = 0;
quoted = 0;
comments = 1;
continue;
} else if(rdlen == 1 && ldns_buffer_current(buf)[-1] == '}') {
} else if(rdlen == 1 && sldns_buffer_current(buf)[-1] == '}') {
if(contnum > 0) {
ldns_buffer_write_u8(buf, 0);
sldns_buffer_write_u8(buf, 0);
log_err("line %d, bad key before }", *line);
return 0;
}
return 1;
} else if(rdlen == 1 &&
isspace((int)ldns_buffer_current(buf)[-1])) {
isspace((int)sldns_buffer_current(buf)[-1])) {
/* leave whitespace here */
} else {
/* not space or whatnot, so actual content */
contnum ++;
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);
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.
*/
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)
{
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);
/* 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) {
if(rdlen != 12 || strncmp((char*)ldns_buffer_begin(buffer),
if(rdlen != 12 || strncmp((char*)sldns_buffer_begin(buffer),
"trusted-keys", 12) != 0) {
ldns_buffer_clear(buffer);
sldns_buffer_clear(buffer);
/* ignore everything but trusted-keys */
continue;
}
@ -766,7 +766,7 @@ anchor_read_bind_file(struct val_anchors* anchors, ldns_buffer* buffer,
fclose(in);
return 0;
}
ldns_buffer_clear(buffer);
sldns_buffer_clear(buffer);
}
fclose(in);
return 1;
@ -781,7 +781,7 @@ anchor_read_bind_file(struct val_anchors* anchors, ldns_buffer* buffer,
* @return false on error.
*/
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)
{
#ifdef HAVE_GLOB
@ -1039,13 +1039,13 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
{
struct config_strlist* f;
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) {
if(!f->str || f->str[0] == 0) /* empty "" */
continue;
if(!anchor_insert_insecure(anchors, f->str)) {
log_err("error in domain-insecure: %s", f->str);
ldns_buffer_free(parsebuf);
sldns_buffer_free(parsebuf);
return 0;
}
}
@ -1058,7 +1058,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
nm += strlen(cfg->chrootdir);
if(!anchor_read_file(anchors, parsebuf, nm, 0)) {
log_err("error reading trust-anchor-file: %s", f->str);
ldns_buffer_free(parsebuf);
sldns_buffer_free(parsebuf);
return 0;
}
}
@ -1071,7 +1071,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
nm += strlen(cfg->chrootdir);
if(!anchor_read_bind_file_wild(anchors, parsebuf, nm)) {
log_err("error reading trusted-keys-file: %s", f->str);
ldns_buffer_free(parsebuf);
sldns_buffer_free(parsebuf);
return 0;
}
}
@ -1080,7 +1080,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
continue;
if(!anchor_store_str(anchors, parsebuf, f->str)) {
log_err("error in trust-anchor: \"%s\"", f->str);
ldns_buffer_free(parsebuf);
sldns_buffer_free(parsebuf);
return 0;
}
}
@ -1094,7 +1094,7 @@ anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg)
nm, 1))) {
log_err("error reading dlv-anchor-file: %s",
cfg->dlv_anchor_file);
ldns_buffer_free(parsebuf);
sldns_buffer_free(parsebuf);
return 0;
}
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(
anchors, parsebuf, f->str))) {
log_err("error in dlv-anchor: \"%s\"", f->str);
ldns_buffer_free(parsebuf);
sldns_buffer_free(parsebuf);
return 0;
}
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)) {
log_err("error reading auto-trust-anchor-file: %s",
f->str);
ldns_buffer_free(parsebuf);
sldns_buffer_free(parsebuf);
return 0;
}
}
/* first assemble, since it may delete useless anchors */
anchors_assemble_rrsets(anchors);
init_parents(anchors);
ldns_buffer_free(parsebuf);
sldns_buffer_free(parsebuf);
if(verbosity >= VERB_ALGO) autr_debug_print(anchors);
return 1;
}

4
validator/val_anchor.h
View file

@ -48,7 +48,7 @@ struct config_file;
struct ub_packed_rrset_key;
struct autr_point_data;
struct autr_global_data;
struct ldns_buffer;
struct sldns_buffer;
/**
* Trust anchor store.
@ -185,7 +185,7 @@ struct trust_anchor* anchor_find(struct val_anchors* anchors,
* @return NULL on error.
*/
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

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];
pk = (unsigned char*)data->rr_data[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 */

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 */
static struct val_neg_data*
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;
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*/
static struct dns_msg*
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 dns_msg* msg;
@ -1390,7 +1390,7 @@ static int add_soa(struct rrset_cache* rrset_cache, time_t now,
struct dns_msg*
val_neg_getmsg(struct val_neg_cache* neg, struct query_info* qinfo,
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 ub_packed_rrset_key* rrset;

4
validator/val_neg.h
View file

@ -46,7 +46,7 @@
#define VALIDATOR_VAL_NEG_H
#include "util/locks.h"
#include "util/rbtree.h"
struct ldns_buffer;
struct sldns_buffer;
struct val_neg_data;
struct config_file;
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 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);

100
validator/val_nsec3.c
View file

@ -68,13 +68,13 @@
* 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.
*/
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);
/**
* 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.
*/
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);
/**
@ -260,7 +260,7 @@ size_t nsec3_hash_to_b32(uint8_t* hash, size_t hashlen, uint8_t* zone,
int ret;
if(max < hashlen*2+1) /* quick approx of b32, as if hexb16 */
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)
return 0;
buf[0] = (uint8_t)ret; /* length of b32 label */
@ -535,16 +535,16 @@ nsec3_hash_cmp(const void* c1, const void* c2)
}
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 i, hash_len;
/* prepare buffer for first iteration */
ldns_buffer_clear(buf);
ldns_buffer_write(buf, nm, nmlen);
query_dname_tolower(ldns_buffer_begin(buf));
ldns_buffer_write(buf, salt, saltlen);
ldns_buffer_flip(buf);
sldns_buffer_clear(buf);
sldns_buffer_write(buf, nm, nmlen);
query_dname_tolower(sldns_buffer_begin(buf));
sldns_buffer_write(buf, salt, saltlen);
sldns_buffer_flip(buf);
switch(algo) {
#if defined(HAVE_EVP_SHA1) || defined(HAVE_NSS)
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)
return 0;
# ifdef HAVE_SSL
(void)SHA1((unsigned char*)ldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf),
(void)SHA1((unsigned char*)sldns_buffer_begin(buf),
(unsigned long)sldns_buffer_limit(buf),
(unsigned char*)res);
# else
(void)HASH_HashBuf(HASH_AlgSHA1, (unsigned char*)res,
(unsigned char*)ldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf));
(unsigned char*)sldns_buffer_begin(buf),
(unsigned long)sldns_buffer_limit(buf));
# endif
for(i=0; i<iter; i++) {
ldns_buffer_clear(buf);
ldns_buffer_write(buf, res, hash_len);
ldns_buffer_write(buf, salt, saltlen);
ldns_buffer_flip(buf);
sldns_buffer_clear(buf);
sldns_buffer_write(buf, res, hash_len);
sldns_buffer_write(buf, salt, saltlen);
sldns_buffer_flip(buf);
# ifdef HAVE_SSL
(void)SHA1(
(unsigned char*)ldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf),
(unsigned char*)sldns_buffer_begin(buf),
(unsigned long)sldns_buffer_limit(buf),
(unsigned char*)res);
# else
(void)HASH_HashBuf(HASH_AlgSHA1,
(unsigned char*)res,
(unsigned char*)ldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf));
(unsigned char*)sldns_buffer_begin(buf),
(unsigned long)sldns_buffer_limit(buf));
# endif
}
break;
@ -592,7 +592,7 @@ nsec3_get_hashed(ldns_buffer* buf, uint8_t* nm, size_t nmlen, int algo,
/** perform hash of name */
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)
{
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))
return -1;
/* prepare buffer for first iteration */
ldns_buffer_clear(buf);
ldns_buffer_write(buf, c->dname, c->dname_len);
query_dname_tolower(ldns_buffer_begin(buf));
ldns_buffer_write(buf, salt, saltlen);
ldns_buffer_flip(buf);
sldns_buffer_clear(buf);
sldns_buffer_write(buf, c->dname, c->dname_len);
query_dname_tolower(sldns_buffer_begin(buf));
sldns_buffer_write(buf, salt, saltlen);
sldns_buffer_flip(buf);
switch(algo) {
#if defined(HAVE_EVP_SHA1) || defined(HAVE_NSS)
case NSEC3_HASH_SHA1:
@ -620,30 +620,30 @@ nsec3_calc_hash(struct regional* region, ldns_buffer* buf,
if(!c->hash)
return 0;
# ifdef HAVE_SSL
(void)SHA1((unsigned char*)ldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf),
(void)SHA1((unsigned char*)sldns_buffer_begin(buf),
(unsigned long)sldns_buffer_limit(buf),
(unsigned char*)c->hash);
# else
(void)HASH_HashBuf(HASH_AlgSHA1,
(unsigned char*)c->hash,
(unsigned char*)ldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf));
(unsigned char*)sldns_buffer_begin(buf),
(unsigned long)sldns_buffer_limit(buf));
# endif
for(i=0; i<iter; i++) {
ldns_buffer_clear(buf);
ldns_buffer_write(buf, c->hash, c->hash_len);
ldns_buffer_write(buf, salt, saltlen);
ldns_buffer_flip(buf);
sldns_buffer_clear(buf);
sldns_buffer_write(buf, c->hash, c->hash_len);
sldns_buffer_write(buf, salt, saltlen);
sldns_buffer_flip(buf);
# ifdef HAVE_SSL
(void)SHA1(
(unsigned char*)ldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf),
(unsigned char*)sldns_buffer_begin(buf),
(unsigned long)sldns_buffer_limit(buf),
(unsigned char*)c->hash);
# else
(void)HASH_HashBuf(HASH_AlgSHA1,
(unsigned char*)c->hash,
(unsigned char*)ldns_buffer_begin(buf),
(unsigned long)ldns_buffer_limit(buf));
(unsigned char*)sldns_buffer_begin(buf),
(unsigned long)sldns_buffer_limit(buf));
# endif
}
break;
@ -657,19 +657,19 @@ nsec3_calc_hash(struct regional* region, ldns_buffer* buf,
/** perform b32 encoding of hash */
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)
{
int r;
ldns_buffer_clear(buf);
r = ldns_b32_ntop_extended_hex(c->hash, c->hash_len,
(char*)ldns_buffer_begin(buf), ldns_buffer_limit(buf));
sldns_buffer_clear(buf);
r = sldns_b32_ntop_extended_hex(c->hash, c->hash_len,
(char*)sldns_buffer_begin(buf), sldns_buffer_limit(buf));
if(r < 1) {
log_err("b32_ntop_extended_hex: error in encoding: %d", r);
return 0;
}
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);
if(!c->b32)
return 0;
@ -677,7 +677,7 @@ nsec3_calc_b32(struct regional* region, ldns_buffer* buf,
}
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,
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
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;
size_t nextlen;
@ -841,10 +841,10 @@ nsec3_covers(uint8_t* zone, struct nsec3_cached_hash* hash,
return 1;
/* convert owner name from text to binary */
ldns_buffer_clear(buf);
owner = ldns_buffer_begin(buf);
len = ldns_b32_pton_extended_hex((char*)rrset->rk.dname+1,
hash->b32_len, owner, ldns_buffer_limit(buf));
sldns_buffer_clear(buf);
owner = sldns_buffer_begin(buf);
len = sldns_b32_pton_extended_hex((char*)rrset->rk.dname+1,
hash->b32_len, owner, sldns_buffer_limit(buf));
if(len<1)
return 0; /* bad owner name in some way */
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 query_info;
struct key_entry_key;
struct ldns_buffer;
struct sldns_buffer;
/**
* 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).
*/
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);
/**
@ -329,7 +329,7 @@ int nsec3_get_params(struct ub_packed_rrset_key* rrset, int r,
* @param max: maximum space for result.
* @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,
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.
*/
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 */

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");
if(!md)
return 0;
return ldns_digest_evp(data, (unsigned int)len, dest, md);
return sldns_digest_evp(data, (unsigned int)len, dest, md);
}
#endif
@ -174,7 +174,7 @@ dnskey_algo_id_is_supported(int id)
#ifdef USE_GOST
case LDNS_ECC_GOST:
/* we support GOST if it can be loaded */
return ldns_key_EVP_load_gost_id();
return sldns_key_EVP_load_gost_id();
#endif
default:
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");
return 0;
}
dsa = ldns_key_buf2dsa_raw(key, keylen);
dsa = sldns_key_buf2dsa_raw(key, keylen);
if(!dsa) {
verbose(VERB_QUERY, "verify: "
"ldns_key_buf2dsa_raw failed");
"sldns_key_buf2dsa_raw failed");
return 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");
return 0;
}
rsa = ldns_key_buf2rsa_raw(key, keylen);
rsa = sldns_key_buf2rsa_raw(key, keylen);
if(!rsa) {
verbose(VERB_QUERY, "verify: "
"ldns_key_buf2rsa_raw SHA failed");
"sldns_key_buf2rsa_raw SHA failed");
return 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");
return 0;
}
rsa = ldns_key_buf2rsa_raw(key, keylen);
rsa = sldns_key_buf2rsa_raw(key, keylen);
if(!rsa) {
verbose(VERB_QUERY, "verify: "
"ldns_key_buf2rsa_raw MD5 failed");
"sldns_key_buf2rsa_raw MD5 failed");
return 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;
#ifdef USE_GOST
case LDNS_ECC_GOST:
*evp_key = ldns_gost2pkey_raw(key, keylen);
*evp_key = sldns_gost2pkey_raw(key, keylen);
if(!*evp_key) {
verbose(VERB_QUERY, "verify: "
"ldns_gost2pkey_raw failed");
"sldns_gost2pkey_raw failed");
return 0;
}
*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
#ifdef USE_ECDSA
case LDNS_ECDSAP256SHA256:
*evp_key = ldns_ecdsa2pkey_raw(key, keylen,
*evp_key = sldns_ecdsa2pkey_raw(key, keylen,
LDNS_ECDSAP256SHA256);
if(!*evp_key) {
verbose(VERB_QUERY, "verify: "
"ldns_ecdsa2pkey_raw failed");
"sldns_ecdsa2pkey_raw failed");
return 0;
}
#ifdef USE_ECDSA_EVP_WORKAROUND
@ -424,11 +424,11 @@ setup_key_digest(int algo, EVP_PKEY** evp_key, const EVP_MD** digest_type,
#endif
break;
case LDNS_ECDSAP384SHA384:
*evp_key = ldns_ecdsa2pkey_raw(key, keylen,
*evp_key = sldns_ecdsa2pkey_raw(key, keylen,
LDNS_ECDSAP384SHA384);
if(!*evp_key) {
verbose(VERB_QUERY, "verify: "
"ldns_ecdsa2pkey_raw failed");
"sldns_ecdsa2pkey_raw failed");
return 0;
}
#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.
*/
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,
char** reason)
{
@ -520,8 +520,8 @@ verify_canonrrset(ldns_buffer* buf, int algo, unsigned char* sigblock,
if(dofree) free(sigblock);
return sec_status_unchecked;
}
if(EVP_VerifyUpdate(&ctx, (unsigned char*)ldns_buffer_begin(buf),
(unsigned int)ldns_buffer_limit(buf)) == 0) {
if(EVP_VerifyUpdate(&ctx, (unsigned char*)sldns_buffer_begin(buf),
(unsigned int)sldns_buffer_limit(buf)) == 0) {
verbose(VERB_QUERY, "verify: EVP_VerifyUpdate failed");
EVP_PKEY_free(evp_key);
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.
*/
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,
char** reason)
{
@ -1021,8 +1021,8 @@ verify_canonrrset(ldns_buffer* buf, int algo, unsigned char* sigblock,
SECKEY_DestroyPublicKey(pubkey);
return sec_status_unchecked;
}
if(HASH_HashBuf(htype, hash, (unsigned char*)ldns_buffer_begin(buf),
(unsigned int)ldns_buffer_limit(buf)) != SECSuccess) {
if(HASH_HashBuf(htype, hash, (unsigned char*)sldns_buffer_begin(buf),
(unsigned int)sldns_buffer_limit(buf)) != SECSuccess) {
verbose(VERB_QUERY, "verify: HASH_HashBuf failed");
SECKEY_DestroyPublicKey(pubkey);
return sec_status_unchecked;

4
validator/val_secalgo.h
View file

@ -42,7 +42,7 @@
#ifndef 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.
@ -77,7 +77,7 @@ int dnskey_algo_id_is_supported(int id);
* @return secure if verification succeeded, bogus on crypto failure,
* 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* key, unsigned int keylen, char** reason);

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