From: Wouter Wijngaards <wouter@nlnetlabs.nl>
Date: Tue, 3 Dec 2013 09:11:16 +0000 (+0000)
Subject: - Fix sldns to use sldns_ prefix for all ldns_ variables.
X-Git-Tag: release-1.4.22rc1~70
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=d3cbd76546057fee41cc3c3f23a1f5925ffd003e;p=thirdparty%2Funbound.git

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


git-svn-id: file:///svn/unbound/trunk@3022 be551aaa-1e26-0410-a405-d3ace91eadb9
---

diff --git a/config.h.in b/config.h.in
index 17cf28bdf..6b25e99ed 100644
--- a/config.h.in
+++ b/config.h.in
@@ -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
diff --git a/configure.ac b/configure.ac
index bc47dbf5e..dae06103d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -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
diff --git a/daemon/cachedump.c b/daemon/cachedump.c
index 622371a19..a5d04a76f 100644
--- a/daemon/cachedump.c
+++ b/daemon/cachedump.c
@@ -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;
 	}
diff --git a/daemon/daemon.c b/daemon/daemon.c
index 753ee76f8..2df2de1cb 100644
--- a/daemon/daemon.c
+++ b/daemon/daemon.c
@@ -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
diff --git a/daemon/remote.c b/daemon/remote.c
index 3c4980937..404ff5f38 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -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);
diff --git a/daemon/stats.c b/daemon/stats.c
index c80115e58..2002182f9 100644
--- a/daemon/stats.c
+++ b/daemon/stats.c
@@ -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 ++;
 	}
 }
diff --git a/daemon/stats.h b/daemon/stats.h
index b8513afdb..83e7adc31 100644
--- a/daemon/stats.h
+++ b/daemon/stats.h
@@ -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 */
diff --git a/daemon/worker.c b/daemon/worker.c
index 394bc2137..a07f2a46e 100644
--- a/daemon/worker.c
+++ b/daemon/worker.c
@@ -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);
diff --git a/doc/Changelog b/doc/Changelog
index f7e6e714e..84d142375 100644
--- a/doc/Changelog
+++ b/doc/Changelog
@@ -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_ .
diff --git a/iterator/iter_delegpt.c b/iterator/iter_delegpt.c
index 7a5aea493..1e54a6aa3 100644
--- a/iterator/iter_delegpt.c
+++ b/iterator/iter_delegpt.c
@@ -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))
diff --git a/iterator/iter_fwd.c b/iterator/iter_fwd.c
index 75e7a9f12..9441fbe1f 100644
--- a/iterator/iter_fwd.c
+++ b/iterator/iter_fwd.c
@@ -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;
diff --git a/iterator/iter_hints.c b/iterator/iter_hints.c
index 960c98e05..048d1c0a7 100644
--- a/iterator/iter_hints.c
+++ b/iterator/iter_hints.c
@@ -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);
diff --git a/iterator/iter_priv.c b/iterator/iter_priv.c
index 37cd35d89..edd29c996 100644
--- a/iterator/iter_priv.c
+++ b/iterator/iter_priv.c
@@ -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;
diff --git a/iterator/iter_priv.h b/iterator/iter_priv.h
index 19b3cbc3f..b0839bfd1 100644
--- a/iterator/iter_priv.h
+++ b/iterator/iter_priv.h
@@ -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);
 
 /**
diff --git a/iterator/iter_scrub.c b/iterator/iter_scrub.c
index 0b1a02ae0..a18d1edb4 100644
--- a/iterator/iter_scrub.c
+++ b/iterator/iter_scrub.c
@@ -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)
 {
diff --git a/iterator/iter_scrub.h b/iterator/iter_scrub.h
index 7ef14ded3..594cd8395 100644
--- a/iterator/iter_scrub.h
+++ b/iterator/iter_scrub.h
@@ -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);
 
diff --git a/iterator/iter_utils.c b/iterator/iter_utils.c
index 6bea745ae..728e47ae2 100644
--- a/iterator/iter_utils.c
+++ b/iterator/iter_utils.c
@@ -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);
diff --git a/iterator/iter_utils.h b/iterator/iter_utils.h
index d660772db..2c7a02839 100644
--- a/iterator/iter_utils.h
+++ b/iterator/iter_utils.h
@@ -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);
 
 /**
diff --git a/iterator/iterator.c b/iterator/iterator.c
index df6135798..ff93e0f39 100644
--- a/iterator/iterator.c
+++ b/iterator/iterator.c
@@ -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;
diff --git a/ldns/keyraw.c b/ldns/keyraw.c
index a20783590..fe650aada 100644
--- a/ldns/keyraw.c
+++ b/ldns/keyraw.c
@@ -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;
diff --git a/ldns/keyraw.h b/ldns/keyraw.h
index 9314891cb..8abe23509 100644
--- a/ldns/keyraw.h
+++ b/ldns/keyraw.h
@@ -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 */
diff --git a/ldns/parse.c b/ldns/parse.c
index e5edc1b44..1592c4c25 100644
--- a/ldns/parse.c
+++ b/ldns/parse.c
@@ -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);
diff --git a/ldns/parse.h b/ldns/parse.h
index 1ddd013d2..7b7456dd2 100644
--- a/ldns/parse.h
+++ b/ldns/parse.h
@@ -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
 }
diff --git a/ldns/parseutil.c b/ldns/parseutil.c
index 61fa6385b..55e3a5b1a 100644
--- a/ldns/parseutil.c
+++ b/ldns/parseutil.c
@@ -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;
diff --git a/ldns/parseutil.h b/ldns/parseutil.h
index 9808ef3cc..dfa1c2a2b 100644
--- a/ldns/parseutil.h
+++ b/ldns/parseutil.h
@@ -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 */
diff --git a/ldns/pkthdr.h b/ldns/pkthdr.h
index 30177cdc0..de9952ea7 100644
--- a/ldns/pkthdr.h
+++ b/ldns/pkthdr.h
@@ -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
 }
diff --git a/ldns/rrdef.c b/ldns/rrdef.c
index ae54ca97b..20aaeaa88 100644
--- a/ldns/rrdef.c
+++ b/ldns/rrdef.c
@@ -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;
 	}
diff --git a/ldns/rrdef.h b/ldns/rrdef.h
index 6b61fdcf2..508d6c62b 100644
--- a/ldns/rrdef.h
+++ b/ldns/rrdef.h
@@ -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
 }
diff --git a/ldns/sbuffer.c b/ldns/sbuffer.c
index 0561752d8..b0b2efdcf 100644
--- a/ldns/sbuffer.c
+++ b/ldns/sbuffer.c
@@ -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);
 }
diff --git a/ldns/sbuffer.h b/ldns/sbuffer.h
index dd66dfe55..2436763d3 100644
--- a/ldns/sbuffer.h
+++ b/ldns/sbuffer.h
@@ -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
 }
diff --git a/ldns/str2wire.c b/ldns/str2wire.c
index 83edf4b39..7ae496053 100644
--- a/ldns/str2wire.c
+++ b/ldns/str2wire.c
@@ -37,7 +37,7 @@
  * @param rel: true if the domain is not absolute (not terminated in .).
  * 	The output is then still terminated with a '0' rootlabel.
  */
-static int ldns_str2wire_dname_buf_rel(const char* str, uint8_t* buf,
+static int sldns_str2wire_dname_buf_rel(const char* str, uint8_t* buf,
 	size_t* olen, int* rel)
 {
 	size_t len;
@@ -99,7 +99,7 @@ static int ldns_str2wire_dname_buf_rel(const char* str, uint8_t* buf,
 		case '\\':
 			/* octet value or literal char */
 			s += 1;
-			if (!ldns_parse_escape(q, &s)) {
+			if (!sldns_parse_escape(q, &s)) {
 				*q = 0;
 				return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE, q-buf);
 			}
@@ -136,17 +136,17 @@ static int ldns_str2wire_dname_buf_rel(const char* str, uint8_t* buf,
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
-	return ldns_str2wire_dname_buf_rel(str, buf, len, NULL);
+	return sldns_str2wire_dname_buf_rel(str, buf, len, NULL);
 }
 
-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)
 {
 	size_t dlen = *len;
 	int rel = 0;
-	int s = ldns_str2wire_dname_buf_rel(str, buf, &dlen, &rel);
+	int s = sldns_str2wire_dname_buf_rel(str, buf, &dlen, &rel);
 	if(s) return s;
 
 	if(rel && origin && dlen > 0) {
@@ -163,11 +163,11 @@ int ldns_str2wire_dname_buf_origin(const char* str, uint8_t* buf, size_t* len,
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-uint8_t* ldns_str2wire_dname(const char* str, size_t* len)
+uint8_t* sldns_str2wire_dname(const char* str, size_t* len)
 {
 	uint8_t dname[LDNS_MAX_DOMAINLEN+1];
 	*len = sizeof(dname);
-	if(ldns_str2wire_dname_buf(str, dname, len) == 0) {
+	if(sldns_str2wire_dname_buf(str, dname, len) == 0) {
 		uint8_t* r = (uint8_t*)malloc(*len);
 		if(r) return memcpy(r, dname, *len);
 	}
@@ -177,14 +177,14 @@ uint8_t* ldns_str2wire_dname(const char* str, size_t* len)
 
 /** read owner name */
 static int
-rrinternal_get_owner(ldns_buffer* strbuf, uint8_t* rr, size_t* len,
+rrinternal_get_owner(sldns_buffer* strbuf, uint8_t* rr, size_t* len,
 	size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev,
 	size_t prev_len, char* token, size_t token_len)
 {
 	/* split the rr in its parts -1 signals trouble */
-	if(ldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
+	if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
 		return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX,
-			ldns_buffer_position(strbuf));
+			sldns_buffer_position(strbuf));
 	}
 
 	if(strcmp(token, "@") == 0) {
@@ -202,7 +202,7 @@ rrinternal_get_owner(ldns_buffer* strbuf, uint8_t* rr, size_t* len,
 		}
 		if(*len < *dname_len)
 			return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-				ldns_buffer_position(strbuf));
+				sldns_buffer_position(strbuf));
 		memmove(rr, tocopy, *dname_len);
 	} else if(strlen(token) == 0) {
 		/* no ownername was given, try prev, if that fails
@@ -220,14 +220,14 @@ rrinternal_get_owner(ldns_buffer* strbuf, uint8_t* rr, size_t* len,
 		}
 		if(*len < *dname_len)
 			return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-				ldns_buffer_position(strbuf));
+				sldns_buffer_position(strbuf));
 		memmove(rr, tocopy, *dname_len);
 	} else {
 		size_t dlen = *len;
-		int s = ldns_str2wire_dname_buf_origin(token, rr, &dlen,
+		int s = sldns_str2wire_dname_buf_origin(token, rr, &dlen,
 			origin, origin_len);
 		if(s) return RET_ERR_SHIFT(s,
-			ldns_buffer_position(strbuf)-strlen(token));
+			sldns_buffer_position(strbuf)-strlen(token));
 		*dname_len = dlen;
 	}
 	return LDNS_WIREPARSE_ERR_OK;
@@ -235,15 +235,15 @@ rrinternal_get_owner(ldns_buffer* strbuf, uint8_t* rr, size_t* len,
 
 /** read ttl */
 static int
-rrinternal_get_ttl(ldns_buffer* strbuf, char* token, size_t token_len,
+rrinternal_get_ttl(sldns_buffer* strbuf, char* token, size_t token_len,
 	int* not_there, uint32_t* ttl, uint32_t default_ttl)
 {
 	const char* endptr;
-	if(ldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
+	if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
 		return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TTL,
-			ldns_buffer_position(strbuf));
+			sldns_buffer_position(strbuf));
 	}
-	*ttl = (uint32_t) ldns_str2period(token, &endptr);
+	*ttl = (uint32_t) sldns_str2period(token, &endptr);
 
 	if (strlen(token) > 0 && !isdigit((int)token[0])) {
 		*not_there = 1;
@@ -259,18 +259,18 @@ rrinternal_get_ttl(ldns_buffer* strbuf, char* token, size_t token_len,
 
 /** read class */
 static int
-rrinternal_get_class(ldns_buffer* strbuf, char* token, size_t token_len,
+rrinternal_get_class(sldns_buffer* strbuf, char* token, size_t token_len,
 	int* not_there, uint16_t* cl)
 {
 	/* if 'not_there' then we got token from previous parse routine */
 	if(!*not_there) {
 		/* parse new token for class */
-		if(ldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
+		if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
 			return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_CLASS,
-				ldns_buffer_position(strbuf));
+				sldns_buffer_position(strbuf));
 		}
 	} else *not_there = 0;
-	*cl = ldns_get_rr_class_by_name(token);
+	*cl = sldns_get_rr_class_by_name(token);
 	/* class can be left out too, assume IN, current token must be type */
 	if(*cl == 0 && strcmp(token, "CLASS0") != 0) {
 		*not_there = 1;
@@ -281,54 +281,54 @@ rrinternal_get_class(ldns_buffer* strbuf, char* token, size_t token_len,
 
 /** read type */
 static int
-rrinternal_get_type(ldns_buffer* strbuf, char* token, size_t token_len,
+rrinternal_get_type(sldns_buffer* strbuf, char* token, size_t token_len,
 	int* not_there, uint16_t* tp)
 {
 	/* if 'not_there' then we got token from previous parse routine */
 	if(!*not_there) {
 		/* parse new token for type */
-		if(ldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
+		if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) {
 			return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE,
-				ldns_buffer_position(strbuf));
+				sldns_buffer_position(strbuf));
 		}
 	}
-	*tp = ldns_get_rr_type_by_name(token);
+	*tp = sldns_get_rr_type_by_name(token);
 	if(*tp == 0 && strcmp(token, "TYPE0") != 0) {
 		return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE,
-			ldns_buffer_position(strbuf));
+			sldns_buffer_position(strbuf));
 	}
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
 /** put type, class, ttl into rr buffer */
 static int
-rrinternal_writetype(ldns_buffer* strbuf, uint8_t* rr, size_t len,
+rrinternal_writetype(sldns_buffer* strbuf, uint8_t* rr, size_t len,
 	size_t dname_len, uint16_t tp, uint16_t cl, uint32_t ttl, int question)
 {
 	if(question) {
 		/* question is : name, type, class */
 		if(dname_len + 4 > len)
 			return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-				ldns_buffer_position(strbuf));
-		ldns_write_uint16(rr+dname_len, tp);
-		ldns_write_uint16(rr+dname_len+2, cl);
+				sldns_buffer_position(strbuf));
+		sldns_write_uint16(rr+dname_len, tp);
+		sldns_write_uint16(rr+dname_len+2, cl);
 		return LDNS_WIREPARSE_ERR_OK;
 	}
 
 	/* type(2), class(2), ttl(4), rdatalen(2 (later)) = 10 */
 	if(dname_len + 10 > len)
 		return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-			ldns_buffer_position(strbuf));
-	ldns_write_uint16(rr+dname_len, tp);
-	ldns_write_uint16(rr+dname_len+2, cl);
-	ldns_write_uint32(rr+dname_len+4, ttl);
-	ldns_write_uint16(rr+dname_len+8, 0); /* rdatalen placeholder */
+			sldns_buffer_position(strbuf));
+	sldns_write_uint16(rr+dname_len, tp);
+	sldns_write_uint16(rr+dname_len+2, cl);
+	sldns_write_uint32(rr+dname_len+4, ttl);
+	sldns_write_uint16(rr+dname_len+8, 0); /* rdatalen placeholder */
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
 /** find delimiters for type */
 static const char*
-rrinternal_get_delims(ldns_rdf_type rdftype, uint16_t r_cnt, uint16_t r_max)
+rrinternal_get_delims(sldns_rdf_type rdftype, uint16_t r_cnt, uint16_t r_max)
 {
 	switch(rdftype) {
 	case LDNS_RDF_TYPE_B64        :
@@ -345,9 +345,9 @@ rrinternal_get_delims(ldns_rdf_type rdftype, uint16_t r_cnt, uint16_t r_max)
 	return "\n\t "; 
 }
 
-/* Syntactic sugar for ldns_rr_new_frm_str_internal */
+/* Syntactic sugar for sldns_rr_new_frm_str_internal */
 static int
-ldns_rdf_type_maybe_quoted(ldns_rdf_type rdf_type)
+sldns_rdf_type_maybe_quoted(sldns_rdf_type rdf_type)
 {
 	return  rdf_type == LDNS_RDF_TYPE_STR ||
 		rdf_type == LDNS_RDF_TYPE_LONG_STR;
@@ -355,22 +355,22 @@ ldns_rdf_type_maybe_quoted(ldns_rdf_type rdf_type)
 
 /** see if rdata is quoted */
 static int
-rrinternal_get_quoted(ldns_buffer* strbuf, const char** delimiters,
-	ldns_rdf_type rdftype)
+rrinternal_get_quoted(sldns_buffer* strbuf, const char** delimiters,
+	sldns_rdf_type rdftype)
 {
-	if(ldns_rdf_type_maybe_quoted(rdftype) &&
-		ldns_buffer_remaining(strbuf) > 0) {
+	if(sldns_rdf_type_maybe_quoted(rdftype) &&
+		sldns_buffer_remaining(strbuf) > 0) {
 
 		/* skip spaces */
-		while(ldns_buffer_remaining(strbuf) > 0 &&
-			*(ldns_buffer_current(strbuf)) == ' ') {
-			ldns_buffer_skip(strbuf, 1);
+		while(sldns_buffer_remaining(strbuf) > 0 &&
+			*(sldns_buffer_current(strbuf)) == ' ') {
+			sldns_buffer_skip(strbuf, 1);
 		}
 
-		if(ldns_buffer_remaining(strbuf) > 0 &&
-			*(ldns_buffer_current(strbuf)) == '\"') {
+		if(sldns_buffer_remaining(strbuf) > 0 &&
+			*(sldns_buffer_current(strbuf)) == '\"') {
 			*delimiters = "\"\0";
-			ldns_buffer_skip(strbuf, 1);
+			sldns_buffer_skip(strbuf, 1);
 			return 1;
 		}
 	}
@@ -401,10 +401,10 @@ rrinternal_spool_hex(char* token, uint8_t* rr, size_t rr_len,
 		/* see if 16s or 1s */
 		if( ((*cur_hex_data_size)&1) == 0) {
 			rr[rr_cur_len+(*cur_hex_data_size)/2] =
-				(uint8_t)ldns_hexdigit_to_int(*p)*16;
+				(uint8_t)sldns_hexdigit_to_int(*p)*16;
 		} else {
 			rr[rr_cur_len+(*cur_hex_data_size)/2] =
-				(uint8_t)ldns_hexdigit_to_int(*p);
+				(uint8_t)sldns_hexdigit_to_int(*p);
 		}
 		(*cur_hex_data_size)++;
 	}
@@ -413,7 +413,7 @@ rrinternal_spool_hex(char* token, uint8_t* rr, size_t rr_len,
 
 /** read unknown rr type format */
 static int
-rrinternal_parse_unknown(ldns_buffer* strbuf, char* token, size_t token_len,
+rrinternal_parse_unknown(sldns_buffer* strbuf, char* token, size_t token_len,
         uint8_t* rr, size_t* rr_len, size_t* rr_cur_len, size_t pre_data_pos)
 {
 	const char* delim = "\n\t ";
@@ -421,36 +421,36 @@ rrinternal_parse_unknown(ldns_buffer* strbuf, char* token, size_t token_len,
 	/* go back to before \#
 	 * and skip it while setting delimiters better
 	 */
-	ldns_buffer_set_position(strbuf, pre_data_pos);
-	if(ldns_bget_token(strbuf, token, delim, token_len) == -1)
+	sldns_buffer_set_position(strbuf, pre_data_pos);
+	if(sldns_bget_token(strbuf, token, delim, token_len) == -1)
 		return LDNS_WIREPARSE_ERR_GENERAL; /* should not fail */
 	/* read rdata octet length */
-	if(ldns_bget_token(strbuf, token, delim, token_len) == -1) {
+	if(sldns_bget_token(strbuf, token, delim, token_len) == -1) {
 		/* something goes very wrong here */
 		return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA,
-			ldns_buffer_position(strbuf));
+			sldns_buffer_position(strbuf));
 	}
 	hex_data_size = (size_t)atoi(token);
 	if(hex_data_size > LDNS_MAX_RDFLEN || 
 		*rr_cur_len + hex_data_size > *rr_len) {
 		return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-			ldns_buffer_position(strbuf));
+			sldns_buffer_position(strbuf));
 	}
 	/* copy hex chars into hex str (2 chars per byte) */
 	hex_data_size *= 2;
 	cur_hex_data_size = 0;
 	while(cur_hex_data_size < hex_data_size) {
 		int status;
-		ssize_t c = ldns_bget_token(strbuf, token, delim, token_len);
+		ssize_t c = sldns_bget_token(strbuf, token, delim, token_len);
 		if((status = rrinternal_spool_hex(token, rr, *rr_len,
 			*rr_cur_len, &cur_hex_data_size, hex_data_size)) != 0)
 			return RET_ERR_SHIFT(status,
-				ldns_buffer_position(strbuf)-strlen(token));
+				sldns_buffer_position(strbuf)-strlen(token));
 		if(c == -1) {
 			if(cur_hex_data_size != hex_data_size)
 				return RET_ERR(
 					LDNS_WIREPARSE_ERR_SYNTAX_RDATA,
-					ldns_buffer_position(strbuf));
+					sldns_buffer_position(strbuf));
 			break;
 		}
 	}
@@ -460,8 +460,8 @@ rrinternal_parse_unknown(ldns_buffer* strbuf, char* token, size_t token_len,
 
 /** parse normal RR rdata element */
 static int
-rrinternal_parse_rdf(ldns_buffer* strbuf, char* token, size_t token_len,
-	uint8_t* rr, size_t rr_len, size_t* rr_cur_len, ldns_rdf_type rdftype,
+rrinternal_parse_rdf(sldns_buffer* strbuf, char* token, size_t token_len,
+	uint8_t* rr, size_t rr_len, size_t* rr_cur_len, sldns_rdf_type rdftype,
 	uint16_t rr_type, uint16_t r_cnt, uint16_t r_max, size_t dname_len,
 	uint8_t* origin, size_t origin_len)
 {
@@ -487,15 +487,15 @@ rrinternal_parse_rdf(ldns_buffer* strbuf, char* token, size_t token_len,
 			if((*rr_cur_len) + copylen > rr_len)
 				return RET_ERR(
 					LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-					ldns_buffer_position(strbuf));
+					sldns_buffer_position(strbuf));
 			memmove(rr+*rr_cur_len, tocopy, copylen);
 			(*rr_cur_len) += copylen;
 		} else {
 			size_t dlen = rr_len - (*rr_cur_len);
-			int s = ldns_str2wire_dname_buf_origin(token,
+			int s = sldns_str2wire_dname_buf_origin(token,
 				rr+*rr_cur_len, &dlen, origin, origin_len);
 			if(s) return RET_ERR_SHIFT(s,
-				ldns_buffer_position(strbuf)-strlen(token));
+				sldns_buffer_position(strbuf)-strlen(token));
 			(*rr_cur_len) += dlen;
 		}
 		return LDNS_WIREPARSE_ERR_OK;
@@ -507,7 +507,7 @@ rrinternal_parse_rdf(ldns_buffer* strbuf, char* token, size_t token_len,
 		 * rdf types may contain spaces). */
 		if(r_cnt == r_max - 1) {
 			size_t tlen = strlen(token);
-			(void)ldns_bget_token(strbuf, token+tlen, "\n",
+			(void)sldns_bget_token(strbuf, token+tlen, "\n",
 				token_len - tlen);
 		}
 		break;
@@ -516,50 +516,50 @@ rrinternal_parse_rdf(ldns_buffer* strbuf, char* token, size_t token_len,
 	}
 
 	len = rr_len - (*rr_cur_len);
-	if((status=ldns_str2wire_rdf_buf(token, rr+(*rr_cur_len), &len,
+	if((status=sldns_str2wire_rdf_buf(token, rr+(*rr_cur_len), &len,
 		rdftype)) != 0)
 		return RET_ERR_SHIFT(status,
-			ldns_buffer_position(strbuf)-strlen(token));
+			sldns_buffer_position(strbuf)-strlen(token));
 	*rr_cur_len += len;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
 /** parse rdata from string into rr buffer(-remainder after dname). */
 static int
-rrinternal_parse_rdata(ldns_buffer* strbuf, char* token, size_t token_len,
+rrinternal_parse_rdata(sldns_buffer* strbuf, char* token, size_t token_len,
 	uint8_t* rr, size_t* rr_len, size_t dname_len, uint16_t rr_type,
 	uint8_t* origin, size_t origin_len)
 {
-	const ldns_rr_descriptor *desc = ldns_rr_descript((uint16_t)rr_type);
+	const sldns_rr_descriptor *desc = sldns_rr_descript((uint16_t)rr_type);
 	uint16_t r_cnt, r_min, r_max;
 	size_t rr_cur_len = dname_len + 10, pre_data_pos, token_strlen;
 	int was_unknown_rr_format = 0, parens = 0, status, quoted;
 	const char* delimiters;
-	ldns_rdf_type rdftype;
+	sldns_rdf_type rdftype;
 	/* a desc is always returned */
 	if(!desc) return LDNS_WIREPARSE_ERR_GENERAL;
-	r_max = ldns_rr_descriptor_maximum(desc);
-	r_min = ldns_rr_descriptor_minimum(desc);
+	r_max = sldns_rr_descriptor_maximum(desc);
+	r_min = sldns_rr_descriptor_minimum(desc);
 	/* robust check */
 	if(rr_cur_len > *rr_len)
 		return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-			ldns_buffer_position(strbuf));
+			sldns_buffer_position(strbuf));
 
 	/* because number of fields can be variable, we can't rely on
 	 * _maximum() only */
 	for(r_cnt=0; r_cnt < r_max; r_cnt++) {
-		rdftype = ldns_rr_descriptor_field_type(desc, r_cnt);
+		rdftype = sldns_rr_descriptor_field_type(desc, r_cnt);
 		delimiters = rrinternal_get_delims(rdftype, r_cnt, r_max);
 		quoted = rrinternal_get_quoted(strbuf, &delimiters, rdftype);
 
 		/* skip spaces */
-		while(ldns_buffer_remaining(strbuf) > 0 && !quoted &&
-			*(ldns_buffer_current(strbuf)) == ' ') {
-			ldns_buffer_skip(strbuf, 1);
+		while(sldns_buffer_remaining(strbuf) > 0 && !quoted &&
+			*(sldns_buffer_current(strbuf)) == ' ') {
+			sldns_buffer_skip(strbuf, 1);
 		}
 
-		pre_data_pos = ldns_buffer_position(strbuf);
-		if(ldns_bget_token_par(strbuf, token, delimiters, token_len,
+		pre_data_pos = sldns_buffer_position(strbuf);
+		if(sldns_bget_token_par(strbuf, token, delimiters, token_len,
 			&parens, quoted?NULL:" \t") == -1) {
 			break;
 		}
@@ -586,30 +586,30 @@ rrinternal_parse_rdata(ldns_buffer* strbuf, char* token, size_t token_len,
 			}
 		}
 		if(quoted) {
-			if(ldns_buffer_available(strbuf, 1))
-				ldns_buffer_skip(strbuf, 1);
+			if(sldns_buffer_available(strbuf, 1))
+				sldns_buffer_skip(strbuf, 1);
 			else 	break;
 		}
 	}
 	if(!was_unknown_rr_format && r_cnt+1 < r_min) {
 		return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_MISSING_VALUE,
-			ldns_buffer_position(strbuf));
+			sldns_buffer_position(strbuf));
 	}
 	while(parens != 0) {
 		/* read remainder, must be "" */
-		if(ldns_bget_token_par(strbuf, token, "\n", token_len,
+		if(sldns_bget_token_par(strbuf, token, "\n", token_len,
 			&parens, " \t") == -1) {
 			if(parens != 0)
 				return RET_ERR(LDNS_WIREPARSE_ERR_PARENTHESIS,
-					ldns_buffer_position(strbuf));
+					sldns_buffer_position(strbuf));
 			break;
 		}
 		if(strcmp(token, "") != 0)
 			return RET_ERR(LDNS_WIREPARSE_ERR_PARENTHESIS,
-				ldns_buffer_position(strbuf));
+				sldns_buffer_position(strbuf));
 	}
 	/* write rdata length */
-	ldns_write_uint16(rr+dname_len+8, rr_cur_len-dname_len-10);
+	sldns_write_uint16(rr+dname_len+8, rr_cur_len-dname_len-10);
 	*rr_len = rr_cur_len;
 	return LDNS_WIREPARSE_ERR_OK;
 }
@@ -629,7 +629,7 @@ rrinternal_parse_rdata(ldns_buffer* strbuf, char* token, size_t token_len,
  * miek.nl. IN MX 10 elektron.atoom.net
  */
 static int
-ldns_str2wire_rr_buf_internal(const char* str, uint8_t* rr, size_t* len,
+sldns_str2wire_rr_buf_internal(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, int question)
 {
@@ -641,8 +641,8 @@ ldns_str2wire_rr_buf_internal(const char* str, uint8_t* rr, size_t* len,
 	size_t ddlen = 0;
 
 	/* string in buffer */
-	ldns_buffer strbuf;
-	ldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
+	sldns_buffer strbuf;
+	sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
 	if(!dname_len) dname_len = &ddlen;
 
 	/* parse the owner */
@@ -678,79 +678,79 @@ ldns_str2wire_rr_buf_internal(const char* str, uint8_t* rr, size_t* len,
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
-	return ldns_str2wire_rr_buf_internal(str, rr, len, dname_len,
+	return sldns_str2wire_rr_buf_internal(str, rr, len, dname_len,
 		default_ttl, origin, origin_len, prev, prev_len, 0);
 }
 
-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)
 {
-	return ldns_str2wire_rr_buf_internal(str, rr, len, dname_len,
+	return sldns_str2wire_rr_buf_internal(str, rr, len, dname_len,
 		0, origin, origin_len, prev, prev_len, 1);
 }
 
-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)
 {
 	if(len < dname_len+2)
 		return 0;
-	return ldns_read_uint16(rr+dname_len);
+	return sldns_read_uint16(rr+dname_len);
 }
 
-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)
 {
 	if(len < dname_len+4)
 		return 0;
-	return ldns_read_uint16(rr+dname_len+2);
+	return sldns_read_uint16(rr+dname_len+2);
 }
 
-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)
 {
 	if(len < dname_len+8)
 		return 0;
-	return ldns_read_uint32(rr+dname_len+4);
+	return sldns_read_uint32(rr+dname_len+4);
 }
 
-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)
 {
 	if(len < dname_len+10)
 		return 0;
-	return ldns_read_uint16(rr+dname_len+8);
+	return sldns_read_uint16(rr+dname_len+8);
 }
 
-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)
 {
 	if(len < dname_len+10)
 		return NULL;
 	return rr+dname_len+10;
 }
 
-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)
 {
 	if(len < dname_len+10)
 		return NULL;
 	return rr+dname_len+8;
 }
 
-const char* ldns_get_errorstr_parse(int e)
+const char* sldns_get_errorstr_parse(int e)
 {
-	ldns_lookup_table *lt;
-	lt = ldns_lookup_by_id(SLDNS(_wireparse_errors), LDNS_WIREPARSE_ERROR(e));
+	sldns_lookup_table *lt;
+	lt = sldns_lookup_by_id(sldns_wireparse_errors, LDNS_WIREPARSE_ERROR(e));
 	return lt?lt->name:"unknown error";
 }
 
-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)
 {
 	char line[LDNS_RR_BUF_SIZE+1];
 	ssize_t size;
 
 	/* read an entire line in from the file */
-	if((size = ldns_fget_token_l(in, line, LDNS_PARSE_SKIP_SPACE,
+	if((size = sldns_fget_token_l(in, line, LDNS_PARSE_SKIP_SPACE,
 		LDNS_RR_BUF_SIZE, parse_state?&parse_state->lineno:NULL))
 		== -1) {
 		/* if last line was empty, we are now at feof, which is not
@@ -777,7 +777,7 @@ int ldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len,
 		while(isspace(line[off]))
 			off++;
 		parse_state->origin_len = sizeof(parse_state->origin);
-		s = ldns_str2wire_dname_buf(line+off, parse_state->origin,
+		s = sldns_str2wire_dname_buf(line+off, parse_state->origin,
 			&parse_state->origin_len);
 		if(s) parse_state->origin_len = 0;
 		return s;
@@ -789,13 +789,13 @@ int ldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len,
 		if(!parse_state) return LDNS_WIREPARSE_ERR_OK;
 		while(isspace(line[off]))
 			off++;
-		parse_state->default_ttl = ldns_str2period(line+off, &end);
+		parse_state->default_ttl = sldns_str2period(line+off, &end);
 	} else if (strncmp(line, "$INCLUDE", 8) == 0) {
 		*len = 0;
 		*dname_len = 0;
 		return LDNS_WIREPARSE_ERR_INCLUDE;
 	} else {
-		return ldns_str2wire_rr_buf(line, rr, len, dname_len,
+		return sldns_str2wire_rr_buf(line, rr, len, dname_len,
 			parse_state?parse_state->default_ttl:0,
 			(parse_state&&parse_state->origin_len)?
 				parse_state->origin:NULL,
@@ -807,72 +807,72 @@ int ldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len,
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	switch (rdftype) {
 	case LDNS_RDF_TYPE_DNAME:
-		return ldns_str2wire_dname_buf(str, rd, len);
+		return sldns_str2wire_dname_buf(str, rd, len);
 	case LDNS_RDF_TYPE_INT8:
-		return ldns_str2wire_int8_buf(str, rd, len);
+		return sldns_str2wire_int8_buf(str, rd, len);
 	case LDNS_RDF_TYPE_INT16:
-		return ldns_str2wire_int16_buf(str, rd, len);
+		return sldns_str2wire_int16_buf(str, rd, len);
 	case LDNS_RDF_TYPE_INT32:
-		return ldns_str2wire_int32_buf(str, rd, len);
+		return sldns_str2wire_int32_buf(str, rd, len);
 	case LDNS_RDF_TYPE_A:
-		return ldns_str2wire_a_buf(str, rd, len);
+		return sldns_str2wire_a_buf(str, rd, len);
 	case LDNS_RDF_TYPE_AAAA:
-		return ldns_str2wire_aaaa_buf(str, rd, len);
+		return sldns_str2wire_aaaa_buf(str, rd, len);
 	case LDNS_RDF_TYPE_STR:
-		return ldns_str2wire_str_buf(str, rd, len);
+		return sldns_str2wire_str_buf(str, rd, len);
 	case LDNS_RDF_TYPE_APL:
-		return ldns_str2wire_apl_buf(str, rd, len);
+		return sldns_str2wire_apl_buf(str, rd, len);
 	case LDNS_RDF_TYPE_B64:
-		return ldns_str2wire_b64_buf(str, rd, len);
+		return sldns_str2wire_b64_buf(str, rd, len);
 	case LDNS_RDF_TYPE_B32_EXT:
-		return ldns_str2wire_b32_ext_buf(str, rd, len);
+		return sldns_str2wire_b32_ext_buf(str, rd, len);
 	case LDNS_RDF_TYPE_HEX:
-		return ldns_str2wire_hex_buf(str, rd, len);
+		return sldns_str2wire_hex_buf(str, rd, len);
 	case LDNS_RDF_TYPE_NSEC:
-		return ldns_str2wire_nsec_buf(str, rd, len);
+		return sldns_str2wire_nsec_buf(str, rd, len);
 	case LDNS_RDF_TYPE_TYPE:
-		return ldns_str2wire_type_buf(str, rd, len);
+		return sldns_str2wire_type_buf(str, rd, len);
 	case LDNS_RDF_TYPE_CLASS:
-		return ldns_str2wire_class_buf(str, rd, len);
+		return sldns_str2wire_class_buf(str, rd, len);
 	case LDNS_RDF_TYPE_CERT_ALG:
-		return ldns_str2wire_cert_alg_buf(str, rd, len);
+		return sldns_str2wire_cert_alg_buf(str, rd, len);
 	case LDNS_RDF_TYPE_ALG:
-		return ldns_str2wire_alg_buf(str, rd, len);
+		return sldns_str2wire_alg_buf(str, rd, len);
 	case LDNS_RDF_TYPE_TIME:
-		return ldns_str2wire_time_buf(str, rd, len);
+		return sldns_str2wire_time_buf(str, rd, len);
 	case LDNS_RDF_TYPE_PERIOD:
-		return ldns_str2wire_period_buf(str, rd, len);
+		return sldns_str2wire_period_buf(str, rd, len);
 	case LDNS_RDF_TYPE_LOC:
-		return ldns_str2wire_loc_buf(str, rd, len);
+		return sldns_str2wire_loc_buf(str, rd, len);
 	case LDNS_RDF_TYPE_WKS:
-		return ldns_str2wire_wks_buf(str, rd, len);
+		return sldns_str2wire_wks_buf(str, rd, len);
 	case LDNS_RDF_TYPE_NSAP:
-		return ldns_str2wire_nsap_buf(str, rd, len);
+		return sldns_str2wire_nsap_buf(str, rd, len);
 	case LDNS_RDF_TYPE_ATMA:
-		return ldns_str2wire_atma_buf(str, rd, len);
+		return sldns_str2wire_atma_buf(str, rd, len);
 	case LDNS_RDF_TYPE_IPSECKEY:
-		return ldns_str2wire_ipseckey_buf(str, rd, len);
+		return sldns_str2wire_ipseckey_buf(str, rd, len);
 	case LDNS_RDF_TYPE_NSEC3_SALT:
-		return ldns_str2wire_nsec3_salt_buf(str, rd, len);
+		return sldns_str2wire_nsec3_salt_buf(str, rd, len);
 	case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
-		return ldns_str2wire_b32_ext_buf(str, rd, len);
+		return sldns_str2wire_b32_ext_buf(str, rd, len);
 	case LDNS_RDF_TYPE_ILNP64:
-		return ldns_str2wire_ilnp64_buf(str, rd, len);
+		return sldns_str2wire_ilnp64_buf(str, rd, len);
 	case LDNS_RDF_TYPE_EUI48:
-		return ldns_str2wire_eui48_buf(str, rd, len);
+		return sldns_str2wire_eui48_buf(str, rd, len);
 	case LDNS_RDF_TYPE_EUI64:
-		return ldns_str2wire_eui64_buf(str, rd, len);
+		return sldns_str2wire_eui64_buf(str, rd, len);
 	case LDNS_RDF_TYPE_TAG:
-		return ldns_str2wire_tag_buf(str, rd, len);
+		return sldns_str2wire_tag_buf(str, rd, len);
 	case LDNS_RDF_TYPE_LONG_STR:
-		return ldns_str2wire_long_str_buf(str, rd, len);
+		return sldns_str2wire_long_str_buf(str, rd, len);
 	case LDNS_RDF_TYPE_INT16_DATA:
-		return ldns_str2wire_int16_data_buf(str, rd, len);
+		return sldns_str2wire_int16_data_buf(str, rd, len);
 	case LDNS_RDF_TYPE_UNKNOWN:
 	case LDNS_RDF_TYPE_SERVICE:
 		return LDNS_WIREPARSE_ERR_NOT_IMPL;
@@ -883,7 +883,7 @@ int ldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len,
 	return LDNS_WIREPARSE_ERR_GENERAL;
 }
 
-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)
 {
 	char* end;
 	uint8_t r = (uint8_t)strtol((char*)str, &end, 10);
@@ -896,7 +896,7 @@ int ldns_str2wire_int8_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	char* end;
 	uint16_t r = (uint16_t)strtol((char*)str, &end, 10);
@@ -904,12 +904,12 @@ int ldns_str2wire_int16_buf(const char* str, uint8_t* rd, size_t* len)
 		return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str);
 	if(*len < 2)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
-	ldns_write_uint16(rd, r);
+	sldns_write_uint16(rd, r);
 	*len = 2;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	char* end;
 	uint32_t r;
@@ -924,12 +924,12 @@ int ldns_str2wire_int32_buf(const char* str, uint8_t* rd, size_t* len)
 		return LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW;
 	if(*len < 4)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
-	ldns_write_uint32(rd, r);
+	sldns_write_uint32(rd, r);
 	*len = 4;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	struct in_addr address;
 	if(inet_pton(AF_INET, (char*)str, &address) != 1)
@@ -941,7 +941,7 @@ int ldns_str2wire_a_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 #ifdef AF_INET6
 	uint8_t address[LDNS_IP6ADDRLEN + 1];
@@ -957,7 +957,7 @@ int ldns_str2wire_aaaa_buf(const char* str, uint8_t* rd, size_t* len)
 #endif
 }
 
-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)
 {
 	uint8_t ch = 0;
 	size_t sl = 0;
@@ -967,7 +967,7 @@ int ldns_str2wire_str_buf(const char* str, uint8_t* rd, size_t* len)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
 	
 	/* read characters */
-	while(ldns_parse_char(&ch, &s)) {
+	while(sldns_parse_char(&ch, &s)) {
 		if(sl >= 255)
 			return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, s-str);
 		if(*len < sl+1)
@@ -982,7 +982,7 @@ int ldns_str2wire_str_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	const char *my_str = str;
 
@@ -1047,7 +1047,7 @@ int ldns_str2wire_apl_buf(const char* str, uint8_t* rd, size_t* len)
 	my_str = strchr(my_str, '/') + 1;
 	prefix = (uint8_t) atoi(my_str);
 
-	ldns_write_uint16(data, family);
+	sldns_write_uint16(data, family);
 	data[2] = prefix;
 	data[3] = (uint8_t)adflength;
 	if (negation) {
@@ -1062,35 +1062,35 @@ int ldns_str2wire_apl_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
-	size_t sz = ldns_b64_pton_calculate_size(strlen(str));
+	size_t sz = sldns_b64_pton_calculate_size(strlen(str));
 	int n;
 	if(*len < sz)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
-	n = ldns_b64_pton(str, rd, *len);
+	n = sldns_b64_pton(str, rd, *len);
 	if(n < 0)
 		return LDNS_WIREPARSE_ERR_SYNTAX_B64;
 	*len = (size_t)n;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	size_t slen = strlen(str);
-	size_t sz = ldns_b32_pton_calculate_size(slen);
+	size_t sz = sldns_b32_pton_calculate_size(slen);
 	int n;
 	if(*len < 1+sz)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
 	rd[0] = (uint8_t)sz;
-	n = ldns_b32_pton_extended_hex(str, slen, rd+1, *len-1);
+	n = sldns_b32_pton_extended_hex(str, slen, rd+1, *len-1);
 	if(n < 0)
 		return LDNS_WIREPARSE_ERR_SYNTAX_B32_EXT;
 	*len = (size_t)n+1;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	const char* s = str;
 	size_t dlen = 0; /* number of hexdigits parsed */
@@ -1105,8 +1105,8 @@ int ldns_str2wire_hex_buf(const char* str, uint8_t* rd, size_t* len)
 			return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
 				s-str);
 		if((dlen&1)==0)
-			rd[dlen/2] = (uint8_t)ldns_hexdigit_to_int(*s++) * 16;
-		else	rd[dlen/2] += (uint8_t)ldns_hexdigit_to_int(*s++);
+			rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16;
+		else	rd[dlen/2] += (uint8_t)sldns_hexdigit_to_int(*s++);
 		dlen++;
 	}
 	if((dlen&1)!=0)
@@ -1115,7 +1115,7 @@ int ldns_str2wire_hex_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	const char *delim = "\n\t ";
 	char token[64]; /* for a type name */
@@ -1127,20 +1127,20 @@ int ldns_str2wire_nsec_buf(const char* str, uint8_t* rd, size_t* len)
 	uint8_t window_in_use[256];
 
 	/* string in buffer */
-	ldns_buffer strbuf;
-	ldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
+	sldns_buffer strbuf;
+	sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
 
 	/* parse the types */
 	memset(typebits, 0, sizeof(typebits));
 	memset(window_in_use, 0, sizeof(window_in_use));
-	while(ldns_buffer_remaining(&strbuf) > 0 &&
-		ldns_bget_token(&strbuf, token, delim, sizeof(token)) != -1) {
-		uint16_t t = ldns_get_rr_type_by_name(token);
+	while(sldns_buffer_remaining(&strbuf) > 0 &&
+		sldns_bget_token(&strbuf, token, delim, sizeof(token)) != -1) {
+		uint16_t t = sldns_get_rr_type_by_name(token);
 		if(token[0] == 0)
 			continue;
 		if(t == 0 && strcmp(token, "TYPE0") != 0)
 			return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE,
-				ldns_buffer_position(&strbuf));
+				sldns_buffer_position(&strbuf));
 		typebits[t/8] |= (0x80>>(t%8));
 		window_in_use[t/256] = 1;
 		type_count++;
@@ -1178,44 +1178,44 @@ int ldns_str2wire_nsec_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
-	uint16_t t = ldns_get_rr_type_by_name(str);
+	uint16_t t = sldns_get_rr_type_by_name(str);
 	if(t == 0 && strcmp(str, "TYPE0") != 0)
 		return LDNS_WIREPARSE_ERR_SYNTAX_TYPE;
 	if(*len < 2)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
-	ldns_write_uint16(rd, t);
+	sldns_write_uint16(rd, t);
 	*len = 2;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
-	uint16_t c = ldns_get_rr_class_by_name(str);
+	uint16_t c = sldns_get_rr_class_by_name(str);
 	if(c == 0 && strcmp(str, "CLASS0") != 0)
 		return LDNS_WIREPARSE_ERR_SYNTAX_CLASS;
 	if(*len < 2)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
-	ldns_write_uint16(rd, c);
+	sldns_write_uint16(rd, c);
 	*len = 2;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
 /* An certificate alg field can either be specified as a 8 bits number
  * or by its symbolic name. Handle both */
-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)
 {
-	ldns_lookup_table *lt = ldns_lookup_by_name(SLDNS(_cert_algorithms),
+	sldns_lookup_table *lt = sldns_lookup_by_name(sldns_cert_algorithms,
 		str);
 	if(*len < 2)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
 	if(lt) {
-		ldns_write_uint16(rd, (uint16_t)lt->id);
+		sldns_write_uint16(rd, (uint16_t)lt->id);
 	} else {
-		int s = ldns_str2wire_int16_buf(str, rd, len);
+		int s = sldns_str2wire_int16_buf(str, rd, len);
 		if(s) return s;
-		if(ldns_read_uint16(rd) == 0)
+		if(sldns_read_uint16(rd) == 0)
 			return LDNS_WIREPARSE_ERR_CERT_BAD_ALGORITHM;
 	}
 	*len = 2;
@@ -1224,9 +1224,9 @@ int ldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len)
 
 /* An alg field can either be specified as a 8 bits number
  * or by its symbolic name. Handle both */
-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)
 {
-	ldns_lookup_table *lt = ldns_lookup_by_name(SLDNS(_algorithms), str);
+	sldns_lookup_table *lt = sldns_lookup_by_name(sldns_algorithms, str);
 	if(*len < 1)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
 	if(lt) {
@@ -1234,12 +1234,12 @@ int ldns_str2wire_alg_buf(const char* str, uint8_t* rd, size_t* len)
 		*len = 1;
 	} else {
 		/* try as-is (a number) */
-		return ldns_str2wire_int8_buf(str, rd, len);
+		return sldns_str2wire_int8_buf(str, rd, len);
 	}
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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 a time YYYYDDMMHHMMSS to wireformat */
 	struct tm tm;
@@ -1267,7 +1267,7 @@ int ldns_str2wire_time_buf(const char* str, uint8_t* rd, size_t* len)
 		if (tm.tm_sec < 0 || tm.tm_sec > 59)
 			return LDNS_WIREPARSE_ERR_SYNTAX_TIME;
 
-		ldns_write_uint32(rd, ldns_mktime_from_utc(&tm));
+		sldns_write_uint32(rd, sldns_mktime_from_utc(&tm));
 	} else {
 		/* handle it as 32 bits timestamp */
 		char *end;
@@ -1275,21 +1275,21 @@ int ldns_str2wire_time_buf(const char* str, uint8_t* rd, size_t* len)
 		if(*end != 0)
 			return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TIME,
 				end-(char*)str);
-		ldns_write_uint32(rd, l);
+		sldns_write_uint32(rd, l);
 	}
 	*len = 4;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	const char* end;
-	uint32_t p = ldns_str2period(str, &end);
+	uint32_t p = sldns_str2period(str, &end);
 	if(*end != 0)
 		return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_PERIOD, end-str);
 	if(*len < 4)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
-	ldns_write_uint32(rd, p);
+	sldns_write_uint32(rd, p);
 	*len = 4;
 	return LDNS_WIREPARSE_ERR_OK;
 }
@@ -1329,7 +1329,7 @@ loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
 	return 1;
 }
 
-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)
 {
 	uint32_t latitude = 0;
 	uint32_t longitude = 0;
@@ -1489,27 +1489,27 @@ east:
 	rd[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
 	rd[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
 	rd[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
-	ldns_write_uint32(rd + 4, latitude);
-	ldns_write_uint32(rd + 8, longitude);
-	ldns_write_uint32(rd + 12, altitude);
+	sldns_write_uint32(rd + 4, latitude);
+	sldns_write_uint32(rd + 8, longitude);
+	sldns_write_uint32(rd + 12, altitude);
 	*len = 16;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	int rd_len = 1;
 	int have_proto = 0;
 	char token[50], proto_str[50];
-	ldns_buffer strbuf;
-	ldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
+	sldns_buffer strbuf;
+	sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
 	proto_str[0]=0;
 
 	/* check we have one byte for proto */
 	if(*len < 1)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
 
-	while(ldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) > 0) {
+	while(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) > 0) {
 		if(!have_proto) {
 			struct protoent *p = getprotobyname(token);
 			have_proto = 1;
@@ -1524,17 +1524,17 @@ int ldns_str2wire_wks_buf(const char* str, uint8_t* rd, size_t* len)
 				serv_port = atoi(token);
 				if(serv_port == 0 && strcmp(token, "0") != 0)
 					return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX,
-						ldns_buffer_position(&strbuf));
+						sldns_buffer_position(&strbuf));
 				if(serv_port < 0 || serv_port > 65535)
 					return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX,
-						ldns_buffer_position(&strbuf));
+						sldns_buffer_position(&strbuf));
 			}
 			if(rd_len < 1+serv_port/8+1) {
 				/* bitmap is larger, init new bytes at 0 */
 				if(*len < 1+(size_t)serv_port/8+1)
 					return RET_ERR(
 					LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-					ldns_buffer_position(&strbuf));
+					sldns_buffer_position(&strbuf));
 				memset(rd+rd_len, 0, 1+(size_t)serv_port/8+1-rd_len);
 				rd_len = 1+serv_port/8+1;
 			}
@@ -1552,7 +1552,7 @@ int ldns_str2wire_wks_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	const char* s = str;
 	size_t slen;
@@ -1576,8 +1576,8 @@ int ldns_str2wire_nsap_buf(const char* str, uint8_t* rd, size_t* len)
 			return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
 				s-str);
 		if((dlen&1)==0)
-			rd[dlen/2] += ldns_hexdigit_to_int(*s++) * 16;
-		else	rd[dlen/2] += ldns_hexdigit_to_int(*s++);
+			rd[dlen/2] += sldns_hexdigit_to_int(*s++) * 16;
+		else	rd[dlen/2] += sldns_hexdigit_to_int(*s++);
 		dlen++;
 	}
 	if((dlen&1)!=0)
@@ -1586,7 +1586,7 @@ int ldns_str2wire_nsap_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	const char* s = str;
 	size_t slen = strlen(str);
@@ -1607,8 +1607,8 @@ int ldns_str2wire_atma_buf(const char* str, uint8_t* rd, size_t* len)
 			return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
 				s-str);
 		if((dlen&1)==0)
-			rd[dlen/2] += ldns_hexdigit_to_int(*s++) * 16;
-		else	rd[dlen/2] += ldns_hexdigit_to_int(*s++);
+			rd[dlen/2] += sldns_hexdigit_to_int(*s++) * 16;
+		else	rd[dlen/2] += sldns_hexdigit_to_int(*s++);
 		dlen++;
 	}
 	if((dlen&1)!=0)
@@ -1617,80 +1617,80 @@ int ldns_str2wire_atma_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	size_t gwlen = 0, keylen = 0;
 	int s;
 	uint8_t gwtype;
 	char token[512];
-	ldns_buffer strbuf;
-	ldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
+	sldns_buffer strbuf;
+	sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
 
 	if(*len < 3)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
 	/* precedence */
-	if(ldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
+	if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
 		return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
-			ldns_buffer_position(&strbuf));
+			sldns_buffer_position(&strbuf));
 	rd[0] = (uint8_t)atoi(token);
 	/* gateway_type */
-	if(ldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
+	if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
 		return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
-			ldns_buffer_position(&strbuf));
+			sldns_buffer_position(&strbuf));
 	rd[1] = (uint8_t)atoi(token);
 	gwtype = rd[1];
 	/* algorithm */
-	if(ldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
+	if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
 		return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
-			ldns_buffer_position(&strbuf));
+			sldns_buffer_position(&strbuf));
 	rd[2] = (uint8_t)atoi(token);
 
 	/* gateway */
-	if(ldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
+	if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
 		return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
-			ldns_buffer_position(&strbuf));
+			sldns_buffer_position(&strbuf));
 	if(gwtype == 0) {
 		/* NOGATEWAY */
 		if(strcmp(token, ".") != 0)
 			return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
-				ldns_buffer_position(&strbuf));
+				sldns_buffer_position(&strbuf));
 		gwlen = 0;
 	} else if(gwtype == 1) {
 		/* IP4 */
 		gwlen = *len - 3;
-		s = ldns_str2wire_a_buf(token, rd+3, &gwlen);
-		if(s) return RET_ERR_SHIFT(s, ldns_buffer_position(&strbuf));
+		s = sldns_str2wire_a_buf(token, rd+3, &gwlen);
+		if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
 	} else if(gwtype == 2) {
 		/* IP6 */
 		gwlen = *len - 3;
-		s = ldns_str2wire_aaaa_buf(token, rd+3, &gwlen);
-		if(s) return RET_ERR_SHIFT(s, ldns_buffer_position(&strbuf));
+		s = sldns_str2wire_aaaa_buf(token, rd+3, &gwlen);
+		if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
 	} else if(gwtype == 3) {
 		/* DNAME */
 		gwlen = *len - 3;
-		s = ldns_str2wire_dname_buf(token, rd+3, &gwlen);
-		if(s) return RET_ERR_SHIFT(s, ldns_buffer_position(&strbuf));
+		s = sldns_str2wire_dname_buf(token, rd+3, &gwlen);
+		if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
 	} else {
 		/* unknown gateway type */
 		return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
-			ldns_buffer_position(&strbuf));
+			sldns_buffer_position(&strbuf));
 	}
 	/* double check for size */
 	if(*len < 3 + gwlen)
 		return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
-			ldns_buffer_position(&strbuf));
+			sldns_buffer_position(&strbuf));
 
 	/* publickey in remainder of strbuf */
 	keylen = *len - 3 - gwlen;
-	s = ldns_str2wire_b64_buf((const char*)ldns_buffer_current(&strbuf),
+	s = sldns_str2wire_b64_buf((const char*)sldns_buffer_current(&strbuf),
 		rd+3+gwlen, &keylen);
-	if(s) return RET_ERR_SHIFT(s, ldns_buffer_position(&strbuf));
+	if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
 
 	*len = 3 + gwlen + keylen;
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	int i, salt_length_str = (int)strlen(str);
 	if (salt_length_str == 1 && str[0] == '-') {
@@ -1705,8 +1705,8 @@ int ldns_str2wire_nsec3_salt_buf(const char* str, uint8_t* rd, size_t* len)
 	rd[0] = (uint8_t) (salt_length_str / 2);
 	for (i = 0; i < salt_length_str; i += 2) {
 		if (isxdigit((int)str[i]) && isxdigit((int)str[i+1])) {
-			rd[1+i/2] = (uint8_t)(ldns_hexdigit_to_int(str[i])*16
-				+ ldns_hexdigit_to_int(str[i+1]));
+			rd[1+i/2] = (uint8_t)(sldns_hexdigit_to_int(str[i])*16
+				+ sldns_hexdigit_to_int(str[i+1]));
 		} else {
 			return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, i);
 		}
@@ -1715,7 +1715,7 @@ int ldns_str2wire_nsec3_salt_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	unsigned int a, b, c, d;
 	uint16_t shorts[4];
@@ -1738,7 +1738,7 @@ int ldns_str2wire_ilnp64_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	unsigned int a, b, c, d, e, f;
 	int l;
@@ -1762,7 +1762,7 @@ int ldns_str2wire_eui48_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	unsigned int a, b, c, d, e, f, g, h;
 	int l;
@@ -1788,7 +1788,7 @@ int ldns_str2wire_eui64_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	size_t slen = strlen(str);
 	const char* ptr;
@@ -1807,14 +1807,14 @@ int ldns_str2wire_tag_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
 	uint8_t ch = 0;
 	const char* pstr = str;
 	size_t length = 0;
 
 	/* Fill data with parsed bytes */
-	while (ldns_parse_char(&ch, &pstr)) {
+	while (sldns_parse_char(&ch, &pstr)) {
 		if(*len < length+1)
 			return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
 		rd[length++] = ch;
@@ -1825,18 +1825,18 @@ int ldns_str2wire_long_str_buf(const char* str, uint8_t* rd, size_t* len)
 	return LDNS_WIREPARSE_ERR_OK;
 }
 
-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)
 {
-	size_t sz = ldns_b64_pton_calculate_size(strlen(str));
+	size_t sz = sldns_b64_pton_calculate_size(strlen(str));
 	int n;
 	if(*len < sz+2)
 		return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
 	if(sz > 65535)
 		return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW;
-	n = ldns_b64_pton(str, rd+2, (*len)-2);
+	n = sldns_b64_pton(str, rd+2, (*len)-2);
 	if(n < 0)
 		return LDNS_WIREPARSE_ERR_SYNTAX_B64;
-	ldns_write_uint16(rd, (uint16_t)n);
+	sldns_write_uint16(rd, (uint16_t)n);
 	*len = (size_t)n;
 	return LDNS_WIREPARSE_ERR_OK;
 }
diff --git a/ldns/str2wire.h b/ldns/str2wire.h
index 8746bfc65..990c9fcbb 100644
--- a/ldns/str2wire.h
+++ b/ldns/str2wire.h
@@ -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
 }
diff --git a/ldns/wire2str.c b/ldns/wire2str.c
index ce176aa50..a61c17648 100644
--- a/ldns/wire2str.c
+++ b/ldns/wire2str.c
@@ -34,7 +34,7 @@
 
 /* lookup tables for standard DNS stuff  */
 /* Taken from RFC 2535, section 7.  */
-static ldns_lookup_table SLDNS(_algorithms_data)[] = {
+static sldns_lookup_table sldns_algorithms_data[] = {
 	{ LDNS_RSAMD5, "RSAMD5" },
 	{ LDNS_DH, "DH" },
 	{ LDNS_DSA, "DSA" },
@@ -52,20 +52,20 @@ static ldns_lookup_table SLDNS(_algorithms_data)[] = {
 	{ LDNS_PRIVATEOID, "PRIVATEOID" },
 	{ 0, NULL }
 };
-ldns_lookup_table* SLDNS(_algorithms) = SLDNS(_algorithms_data);
+sldns_lookup_table* sldns_algorithms = sldns_algorithms_data;
 
 /* hash algorithms in DS record */
-static ldns_lookup_table SLDNS(_hashes_data)[] = {
+static sldns_lookup_table sldns_hashes_data[] = {
 	{ LDNS_SHA1, "SHA1" },
 	{ LDNS_SHA256, "SHA256" },
 	{ LDNS_HASH_GOST, "HASH-GOST" },
 	{ LDNS_SHA384, "SHA384" },
 	{ 0, NULL }
 };
-ldns_lookup_table* SLDNS(_hashes) = SLDNS(_hashes_data);
+sldns_lookup_table* sldns_hashes = sldns_hashes_data;
 
 /* Taken from RFC 4398  */
-static ldns_lookup_table SLDNS(_cert_algorithms_data)[] = {
+static sldns_lookup_table sldns_cert_algorithms_data[] = {
 	{ LDNS_CERT_PKIX, "PKIX" },
 	{ LDNS_CERT_SPKI, "SPKI" },
 	{ LDNS_CERT_PGP, "PGP" },
@@ -78,10 +78,10 @@ static ldns_lookup_table SLDNS(_cert_algorithms_data)[] = {
 	{ LDNS_CERT_OID, "OID" },
 	{ 0, NULL }
 };
-ldns_lookup_table* SLDNS(_cert_algorithms) = SLDNS(_cert_algorithms_data);
+sldns_lookup_table* sldns_cert_algorithms = sldns_cert_algorithms_data;
 
 /* if these are used elsewhere */
-static ldns_lookup_table SLDNS(_rcodes_data)[] = {
+static sldns_lookup_table sldns_rcodes_data[] = {
 	{ LDNS_RCODE_NOERROR, "NOERROR" },
 	{ LDNS_RCODE_FORMERR, "FORMERR" },
 	{ LDNS_RCODE_SERVFAIL, "SERVFAIL" },
@@ -95,9 +95,9 @@ static ldns_lookup_table SLDNS(_rcodes_data)[] = {
 	{ LDNS_RCODE_NOTZONE, "NOTZONE" },
 	{ 0, NULL }
 };
-ldns_lookup_table* SLDNS(_rcodes) = SLDNS(_rcodes_data);
+sldns_lookup_table* sldns_rcodes = sldns_rcodes_data;
 
-static ldns_lookup_table SLDNS(_opcodes_data)[] = {
+static sldns_lookup_table sldns_opcodes_data[] = {
 	{ LDNS_PACKET_QUERY, "QUERY" },
 	{ LDNS_PACKET_IQUERY, "IQUERY" },
 	{ LDNS_PACKET_STATUS, "STATUS" },
@@ -105,9 +105,9 @@ static ldns_lookup_table SLDNS(_opcodes_data)[] = {
 	{ LDNS_PACKET_UPDATE, "UPDATE" },
 	{ 0, NULL }
 };
-ldns_lookup_table* SLDNS(_opcodes) = SLDNS(_opcodes_data);
+sldns_lookup_table* sldns_opcodes = sldns_opcodes_data;
 
-static ldns_lookup_table SLDNS(_wireparse_errors_data)[] = {
+static sldns_lookup_table sldns_wireparse_errors_data[] = {
 	{ LDNS_WIREPARSE_ERR_OK, "no parse error" },
 	{ LDNS_WIREPARSE_ERR_GENERAL, "parse error" },
 	{ LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, "Domainname length overflow" },
@@ -148,15 +148,15 @@ static ldns_lookup_table SLDNS(_wireparse_errors_data)[] = {
 	{ LDNS_WIREPARSE_ERR_PARENTHESIS, "Parse error, parenthesis mismatch" },
 	{ 0, NULL }
 };
-ldns_lookup_table* SLDNS(_wireparse_errors) = SLDNS(_wireparse_errors_data);
+sldns_lookup_table* sldns_wireparse_errors = sldns_wireparse_errors_data;
 
-static ldns_lookup_table SLDNS(_edns_flags_data)[] = {
+static sldns_lookup_table sldns_edns_flags_data[] = {
 	{ 3600, "do"},
 	{ 0, NULL}
 };
-ldns_lookup_table* SLDNS(_edns_flags) = SLDNS(_edns_flags_data);
+sldns_lookup_table* sldns_edns_flags = sldns_edns_flags_data;
 
-static ldns_lookup_table SLDNS(_edns_options_data)[] = {
+static sldns_lookup_table sldns_edns_options_data[] = {
 	{ 1, "LLQ" },
 	{ 2, "UL" },
 	{ 3, "NSID" },
@@ -167,115 +167,115 @@ static ldns_lookup_table SLDNS(_edns_options_data)[] = {
 	{ 8, "edns-client-subnet" },
 	{ 0, NULL}
 };
-ldns_lookup_table* SLDNS(_edns_options) = SLDNS(_edns_options_data);
+sldns_lookup_table* sldns_edns_options = sldns_edns_options_data;
 
-char* ldns_wire2str_pkt(uint8_t* data, size_t len)
+char* sldns_wire2str_pkt(uint8_t* data, size_t len)
 {
-	size_t slen = (size_t)ldns_wire2str_pkt_buf(data, len, NULL, 0);
+	size_t slen = (size_t)sldns_wire2str_pkt_buf(data, len, NULL, 0);
 	char* result = (char*)malloc(slen+1);
 	if(!result) return NULL;
-	ldns_wire2str_pkt_buf(data, len, result, slen+1);
+	sldns_wire2str_pkt_buf(data, len, result, slen+1);
 	return result;
 }
 
-char* ldns_wire2str_rr(uint8_t* rr, size_t len)
+char* sldns_wire2str_rr(uint8_t* rr, size_t len)
 {
-	size_t slen = (size_t)ldns_wire2str_rr_buf(rr, len, NULL, 0);
+	size_t slen = (size_t)sldns_wire2str_rr_buf(rr, len, NULL, 0);
 	char* result = (char*)malloc(slen+1);
 	if(!result) return NULL;
-	ldns_wire2str_rr_buf(rr, len, result, slen+1);
+	sldns_wire2str_rr_buf(rr, len, result, slen+1);
 	return result;
 }
 
-char* ldns_wire2str_type(uint16_t rrtype)
+char* sldns_wire2str_type(uint16_t rrtype)
 {
 	char buf[16];
-	ldns_wire2str_type_buf(rrtype, buf, sizeof(buf));
+	sldns_wire2str_type_buf(rrtype, buf, sizeof(buf));
 	return strdup(buf);
 }
 
-char* ldns_wire2str_class(uint16_t rrclass)
+char* sldns_wire2str_class(uint16_t rrclass)
 {
 	char buf[16];
-	ldns_wire2str_class_buf(rrclass, buf, sizeof(buf));
+	sldns_wire2str_class_buf(rrclass, buf, sizeof(buf));
 	return strdup(buf);
 }
 
-char* ldns_wire2str_dname(uint8_t* dname, size_t dname_len)
+char* sldns_wire2str_dname(uint8_t* dname, size_t dname_len)
 {
-	size_t slen=(size_t)ldns_wire2str_dname_buf(dname, dname_len, NULL, 0);
+	size_t slen=(size_t)sldns_wire2str_dname_buf(dname, dname_len, NULL, 0);
 	char* result = (char*)malloc(slen+1);
 	if(!result) return NULL;
-	ldns_wire2str_dname_buf(dname, dname_len, result, slen+1);
+	sldns_wire2str_dname_buf(dname, dname_len, result, slen+1);
 	return result;
 }
 
-char* ldns_wire2str_rcode(int rcode)
+char* sldns_wire2str_rcode(int rcode)
 {
 	char buf[16];
-	ldns_wire2str_rcode_buf(rcode, buf, sizeof(buf));
+	sldns_wire2str_rcode_buf(rcode, buf, sizeof(buf));
 	return strdup(buf);
 }
 
-int ldns_wire2str_pkt_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
+int sldns_wire2str_pkt_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
 {
 	/* use arguments as temporary variables */
-	return ldns_wire2str_pkt_scan(&d, &dlen, &s, &slen);
+	return sldns_wire2str_pkt_scan(&d, &dlen, &s, &slen);
 }
 
-int ldns_wire2str_rr_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
+int sldns_wire2str_rr_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
 {
 	/* use arguments as temporary variables */
-	return ldns_wire2str_rr_scan(&d, &dlen, &s, &slen, NULL, 0);
+	return sldns_wire2str_rr_scan(&d, &dlen, &s, &slen, NULL, 0);
 }
 
-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)
 {
 	/* use arguments as temporary variables */
-	return ldns_wire2str_rdata_scan(&rdata, &rdata_len, &str, &str_len,
+	return sldns_wire2str_rdata_scan(&rdata, &rdata_len, &str, &str_len,
 		rrtype, NULL, 0);
 }
 
-int ldns_wire2str_rr_unknown_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
+int sldns_wire2str_rr_unknown_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
 {
 	/* use arguments as temporary variables */
-	return ldns_wire2str_rr_unknown_scan(&d, &dlen, &s, &slen, NULL, 0);
+	return sldns_wire2str_rr_unknown_scan(&d, &dlen, &s, &slen, NULL, 0);
 }
 
-int ldns_wire2str_rr_comment_buf(uint8_t* rr, size_t rrlen, size_t dname_len,
+int sldns_wire2str_rr_comment_buf(uint8_t* rr, size_t rrlen, size_t dname_len,
 	char* s, size_t slen)
 {
-	uint16_t rrtype = ldns_wirerr_get_type(rr, rrlen, dname_len);
-	return ldns_wire2str_rr_comment_print(&s, &slen, rr, rrlen, dname_len,
+	uint16_t rrtype = sldns_wirerr_get_type(rr, rrlen, dname_len);
+	return sldns_wire2str_rr_comment_print(&s, &slen, rr, rrlen, dname_len,
 		rrtype);
 }
 
-int ldns_wire2str_type_buf(uint16_t rrtype, char* s, size_t slen)
+int sldns_wire2str_type_buf(uint16_t rrtype, char* s, size_t slen)
 {
 	/* use arguments as temporary variables */
-	return ldns_wire2str_type_print(&s, &slen, rrtype);
+	return sldns_wire2str_type_print(&s, &slen, rrtype);
 }
 
-int ldns_wire2str_class_buf(uint16_t rrclass, char* s, size_t slen)
+int sldns_wire2str_class_buf(uint16_t rrclass, char* s, size_t slen)
 {
 	/* use arguments as temporary variables */
-	return ldns_wire2str_class_print(&s, &slen, rrclass);
+	return sldns_wire2str_class_print(&s, &slen, rrclass);
 }
 
-int ldns_wire2str_rcode_buf(int rcode, char* s, size_t slen)
+int sldns_wire2str_rcode_buf(int rcode, char* s, size_t slen)
 {
 	/* use arguments as temporary variables */
-	return ldns_wire2str_rcode_print(&s, &slen, rcode);
+	return sldns_wire2str_rcode_print(&s, &slen, rcode);
 }
 
-int ldns_wire2str_dname_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
+int sldns_wire2str_dname_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
 {
 	/* use arguments as temporary variables */
-	return ldns_wire2str_dname_scan(&d, &dlen, &s, &slen, NULL, 0);
+	return sldns_wire2str_dname_scan(&d, &dlen, &s, &slen, NULL, 0);
 }
 
-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)
 {
 	int w = vsnprintf(*str, *slen, format, args);
 	if(w < 0) {
@@ -291,12 +291,12 @@ int ldns_str_vprint(char** str, size_t* slen, const char* format, va_list args)
 	return w;
 }
 
-int ldns_str_print(char** str, size_t* slen, const char* format, ...)
+int sldns_str_print(char** str, size_t* slen, const char* format, ...)
 {
 	int w;
 	va_list args;
 	va_start(args, format);
-	w = ldns_str_vprint(str, slen, format, args);
+	w = sldns_str_vprint(str, slen, format, args);
 	va_end(args);
 	return w;
 }
@@ -307,7 +307,7 @@ static int print_hex_buf(char** s, size_t* slen, uint8_t* buf, size_t len)
 	const char* hex = "0123456789ABCDEF";
 	size_t i;
 	for(i=0; i<len; i++) {
-		(void)ldns_str_print(s, slen, "%c%c", hex[(buf[i]&0xf0)>>4],
+		(void)sldns_str_print(s, slen, "%c%c", hex[(buf[i]&0xf0)>>4],
 			hex[buf[i]&0x0f]);
 	}
 	return (int)len*2;
@@ -318,14 +318,14 @@ static int print_remainder_hex(const char* pref, uint8_t** d, size_t* dlen,
 	char** s, size_t* slen)
 {
 	int w = 0;
-	w += ldns_str_print(s, slen, "%s", pref);
+	w += sldns_str_print(s, slen, "%s", pref);
 	w += print_hex_buf(s, slen, *d, *dlen);
 	*d += *dlen;
 	*dlen = 0;
 	return w;
 }
 
-int ldns_wire2str_pkt_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
+int sldns_wire2str_pkt_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 {
 	int w = 0;
 	unsigned qdcount, ancount, nscount, arcount, i;
@@ -339,44 +339,44 @@ int ldns_wire2str_pkt_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 	} else {
 		qdcount = ancount = nscount = arcount = 0;
 	}
-	w += ldns_wire2str_header_scan(d, dlen, s, slen);
-	w += ldns_str_print(s, slen, "\n");
-	w += ldns_str_print(s, slen, ";; QUESTION SECTION:\n");
+	w += sldns_wire2str_header_scan(d, dlen, s, slen);
+	w += sldns_str_print(s, slen, "\n");
+	w += sldns_str_print(s, slen, ";; QUESTION SECTION:\n");
 	for(i=0; i<qdcount; i++) {
-		w += ldns_wire2str_rrquestion_scan(d, dlen, s, slen,
+		w += sldns_wire2str_rrquestion_scan(d, dlen, s, slen,
 			pkt, pktlen);
 		if(!*dlen) break;
 	}
-	w += ldns_str_print(s, slen, "\n");
-	w += ldns_str_print(s, slen, ";; ANSWER SECTION:\n");
+	w += sldns_str_print(s, slen, "\n");
+	w += sldns_str_print(s, slen, ";; ANSWER SECTION:\n");
 	for(i=0; i<ancount; i++) {
-		w += ldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
+		w += sldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
 		if(!*dlen) break;
 	}
-	w += ldns_str_print(s, slen, "\n");
-	w += ldns_str_print(s, slen, ";; AUTHORITY SECTION:\n");
+	w += sldns_str_print(s, slen, "\n");
+	w += sldns_str_print(s, slen, ";; AUTHORITY SECTION:\n");
 	for(i=0; i<nscount; i++) {
-		w += ldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
+		w += sldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
 		if(!*dlen) break;
 	}
-	w += ldns_str_print(s, slen, "\n");
-	w += ldns_str_print(s, slen, ";; ADDITIONAL SECTION:\n");
+	w += sldns_str_print(s, slen, "\n");
+	w += sldns_str_print(s, slen, ";; ADDITIONAL SECTION:\n");
 	for(i=0; i<arcount; i++) {
-		w += ldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
+		w += sldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
 		if(!*dlen) break;
 	}
 	/* other fields: WHEN(time), SERVER(IP) not available here. */
-	w += ldns_str_print(s, slen, ";; MSG SIZE  rcvd: %d\n", (int)pktlen);
+	w += sldns_str_print(s, slen, ";; MSG SIZE  rcvd: %d\n", (int)pktlen);
 	if(*dlen > 0) {
 		w += print_remainder_hex(";; trailing garbage 0x",
 			d, dlen, s, slen);
-		w += ldns_str_print(s, slen, "\n");
+		w += sldns_str_print(s, slen, "\n");
 	}
 	return w;
 }
 
 /** scan type, class and ttl and printout, for rr */
-static int ldns_rr_tcttl_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+static int sldns_rr_tcttl_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w = 0;
 	uint16_t t, c;
@@ -386,31 +386,31 @@ static int ldns_rr_tcttl_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 			return w + print_remainder_hex("; Error malformed 0x",
 				d, dl, s, sl);
 		/* these print values or 0x.. if none left */
-		t = ldns_read_uint16(*d);
-		c = ldns_read_uint16((*d)+2);
+		t = sldns_read_uint16(*d);
+		c = sldns_read_uint16((*d)+2);
 		(*d)+=4;
 		(*dl)-=4;
-		w += ldns_wire2str_class_print(s, sl, c);
-		w += ldns_str_print(s, sl, "\t");
-		w += ldns_wire2str_type_print(s, sl, t);
+		w += sldns_wire2str_class_print(s, sl, c);
+		w += sldns_str_print(s, sl, "\t");
+		w += sldns_wire2str_type_print(s, sl, t);
 		if(*dl == 0)
-			return w + ldns_str_print(s, sl, "; Error no ttl");
+			return w + sldns_str_print(s, sl, "; Error no ttl");
 		return w + print_remainder_hex(
 			"; Error malformed ttl 0x", d, dl, s, sl);
 	}
-	t = ldns_read_uint16(*d);
-	c = ldns_read_uint16((*d)+2);
-	ttl = ldns_read_uint32((*d)+4);
+	t = sldns_read_uint16(*d);
+	c = sldns_read_uint16((*d)+2);
+	ttl = sldns_read_uint32((*d)+4);
 	(*d)+=8;
 	(*dl)-=8;
-	w += ldns_str_print(s, sl, "%lu\t", (unsigned long)ttl);
-	w += ldns_wire2str_class_print(s, sl, c);
-	w += ldns_str_print(s, sl, "\t");
-	w += ldns_wire2str_type_print(s, sl, t);
+	w += sldns_str_print(s, sl, "%lu\t", (unsigned long)ttl);
+	w += sldns_wire2str_class_print(s, sl, c);
+	w += sldns_str_print(s, sl, "\t");
+	w += sldns_wire2str_type_print(s, sl, t);
 	return w;
 }
 
-int ldns_wire2str_rr_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
+int sldns_wire2str_rr_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 	uint8_t* pkt, size_t pktlen)
 {
 	int w = 0;
@@ -419,121 +419,121 @@ int ldns_wire2str_rr_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 	uint16_t rrtype = 0;
 	
 	if(*dlen >= 3 && (*d)[0]==0 &&
-		ldns_read_uint16((*d)+1)==LDNS_RR_TYPE_OPT) {
+		sldns_read_uint16((*d)+1)==LDNS_RR_TYPE_OPT) {
 		/* perform EDNS OPT processing */
-		return ldns_wire2str_edns_scan(d, dlen, s, slen, pkt, pktlen);
+		return sldns_wire2str_edns_scan(d, dlen, s, slen, pkt, pktlen);
 	}
 
 	/* try to scan the rdata with pretty-printing, but if that fails, then
 	 * scan the rdata as an unknown RR type */
-	w += ldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
-	w += ldns_str_print(s, slen, "\t");
+	w += sldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
+	w += sldns_str_print(s, slen, "\t");
 	dname_off = rrlen-(*dlen);
 	if(*dlen == 4) {
 		/* like a question-RR */
-		uint16_t t = ldns_read_uint16(*d);
-		uint16_t c = ldns_read_uint16((*d)+2);
+		uint16_t t = sldns_read_uint16(*d);
+		uint16_t c = sldns_read_uint16((*d)+2);
 		(*d)+=4;
 		(*dlen)-=4;
-		w += ldns_wire2str_class_print(s, slen, c);
-		w += ldns_str_print(s, slen, "\t");
-		w += ldns_wire2str_type_print(s, slen, t);
-		w += ldns_str_print(s, slen, " ; Error no ttl,rdata\n");
+		w += sldns_wire2str_class_print(s, slen, c);
+		w += sldns_str_print(s, slen, "\t");
+		w += sldns_wire2str_type_print(s, slen, t);
+		w += sldns_str_print(s, slen, " ; Error no ttl,rdata\n");
 		return w;
 	}
 	if(*dlen < 8) {
 		if(*dlen == 0)
-			return w + ldns_str_print(s, slen, ";Error missing RR\n");
+			return w + sldns_str_print(s, slen, ";Error missing RR\n");
 		w += print_remainder_hex(";Error partial RR 0x", d, dlen, s, slen);
-		return w + ldns_str_print(s, slen, "\n");
+		return w + sldns_str_print(s, slen, "\n");
 	}
-	rrtype = ldns_read_uint16(*d);
-	w += ldns_rr_tcttl_scan(d, dlen, s, slen);
-	w += ldns_str_print(s, slen, "\t");
+	rrtype = sldns_read_uint16(*d);
+	w += sldns_rr_tcttl_scan(d, dlen, s, slen);
+	w += sldns_str_print(s, slen, "\t");
 
 	/* rdata */
 	if(*dlen < 2) {
 		if(*dlen == 0)
-			return w + ldns_str_print(s, slen, ";Error missing rdatalen\n");
+			return w + sldns_str_print(s, slen, ";Error missing rdatalen\n");
 		w += print_remainder_hex(";Error missing rdatalen 0x",
 			d, dlen, s, slen);
-		return w + ldns_str_print(s, slen, "\n");
+		return w + sldns_str_print(s, slen, "\n");
 	}
-	rdlen = ldns_read_uint16(*d);
+	rdlen = sldns_read_uint16(*d);
 	ordlen = rdlen;
 	(*d)+=2;
 	(*dlen)-=2;
 	if(*dlen < rdlen) {
-		w += ldns_str_print(s, slen, "\\# %u ", (unsigned)rdlen);
+		w += sldns_str_print(s, slen, "\\# %u ", (unsigned)rdlen);
 		if(*dlen == 0)
-			return w + ldns_str_print(s, slen, ";Error missing rdata\n");
+			return w + sldns_str_print(s, slen, ";Error missing rdata\n");
 		w += print_remainder_hex(";Error partial rdata 0x", d, dlen, s, slen);
-		return w + ldns_str_print(s, slen, "\n");
+		return w + sldns_str_print(s, slen, "\n");
 	}
-	w += ldns_wire2str_rdata_scan(d, &rdlen, s, slen, rrtype, pkt, pktlen);
+	w += sldns_wire2str_rdata_scan(d, &rdlen, s, slen, rrtype, pkt, pktlen);
 	(*dlen) -= (ordlen-rdlen);
 
 	/* default comment */
-	w += ldns_wire2str_rr_comment_print(s, slen, rr, rrlen, dname_off,
+	w += sldns_wire2str_rr_comment_print(s, slen, rr, rrlen, dname_off,
 		rrtype);
-	w += ldns_str_print(s, slen, "\n");
+	w += sldns_str_print(s, slen, "\n");
 	return w;
 }
 
-int ldns_wire2str_rrquestion_scan(uint8_t** d, size_t* dlen, char** s,
+int sldns_wire2str_rrquestion_scan(uint8_t** d, size_t* dlen, char** s,
 	size_t* slen, uint8_t* pkt, size_t pktlen)
 {
 	int w = 0;
 	uint16_t t, c;
-	w += ldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
-	w += ldns_str_print(s, slen, "\t");
+	w += sldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
+	w += sldns_str_print(s, slen, "\t");
 	if(*dlen < 4) {
 		if(*dlen == 0)
-			return w + ldns_str_print(s, slen, "Error malformed\n");
+			return w + sldns_str_print(s, slen, "Error malformed\n");
 		w += print_remainder_hex("Error malformed 0x", d, dlen, s, slen);
-		return w + ldns_str_print(s, slen, "\n");
+		return w + sldns_str_print(s, slen, "\n");
 	}
-	t = ldns_read_uint16(*d);
-	c = ldns_read_uint16((*d)+2);
+	t = sldns_read_uint16(*d);
+	c = sldns_read_uint16((*d)+2);
 	(*d)+=4;
 	(*dlen)-=4;
-	w += ldns_wire2str_class_print(s, slen, c);
-	w += ldns_str_print(s, slen, "\t");
-	w += ldns_wire2str_type_print(s, slen, t);
-	w += ldns_str_print(s, slen, "\n");
+	w += sldns_wire2str_class_print(s, slen, c);
+	w += sldns_str_print(s, slen, "\t");
+	w += sldns_wire2str_type_print(s, slen, t);
+	w += sldns_str_print(s, slen, "\n");
 	return w;
 }
 
-int ldns_wire2str_rr_unknown_scan(uint8_t** d, size_t* dlen, char** s,
+int sldns_wire2str_rr_unknown_scan(uint8_t** d, size_t* dlen, char** s,
 	size_t* slen, uint8_t* pkt, size_t pktlen)
 {
 	size_t rdlen, ordlen;
 	int w = 0;
-	w += ldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
-	w += ldns_str_print(s, slen, "\t");
-	w += ldns_rr_tcttl_scan(d, dlen, s, slen);
-	w += ldns_str_print(s, slen, "\t");
+	w += sldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
+	w += sldns_str_print(s, slen, "\t");
+	w += sldns_rr_tcttl_scan(d, dlen, s, slen);
+	w += sldns_str_print(s, slen, "\t");
 	if(*dlen < 2) {
 		if(*dlen == 0)
-			return w + ldns_str_print(s, slen, ";Error missing rdatalen\n");
+			return w + sldns_str_print(s, slen, ";Error missing rdatalen\n");
 		w += print_remainder_hex(";Error missing rdatalen 0x",
 			d, dlen, s, slen);
-		return w + ldns_str_print(s, slen, "\n");
+		return w + sldns_str_print(s, slen, "\n");
 	}
-	rdlen = ldns_read_uint16(*d);
+	rdlen = sldns_read_uint16(*d);
 	ordlen = rdlen;
 	(*d) += 2;
 	(*dlen) -= 2;
 	if(*dlen < rdlen) {
-		w += ldns_str_print(s, slen, "\\# %u ", (unsigned)rdlen);
+		w += sldns_str_print(s, slen, "\\# %u ", (unsigned)rdlen);
 		if(*dlen == 0)
-			return w + ldns_str_print(s, slen, ";Error missing rdata\n");
+			return w + sldns_str_print(s, slen, ";Error missing rdata\n");
 		w += print_remainder_hex(";Error partial rdata 0x", d, dlen, s, slen);
-		return w + ldns_str_print(s, slen, "\n");
+		return w + sldns_str_print(s, slen, "\n");
 	}
-	w += ldns_wire2str_rdata_unknown_scan(d, &rdlen, s, slen);
+	w += sldns_wire2str_rdata_unknown_scan(d, &rdlen, s, slen);
 	(*dlen) -= (ordlen-rdlen);
-	w += ldns_str_print(s, slen, "\n");
+	w += sldns_str_print(s, slen, "\n");
 	return w;
 }
 
@@ -545,32 +545,32 @@ static int rr_comment_dnskey(char** s, size_t* slen, uint8_t* rr,
 	uint8_t* rdata;
 	int flags, w = 0;
 	if(rrlen < dname_off + 10) return 0;
-	rdlen = ldns_read_uint16(rr+dname_off+8);
+	rdlen = sldns_read_uint16(rr+dname_off+8);
 	if(rrlen < dname_off + 10 + rdlen) return 0;
 	rdata = rr + dname_off + 10;
-	flags = (int)ldns_read_uint16(rdata);
-	w += ldns_str_print(s, slen, " ;{");
+	flags = (int)sldns_read_uint16(rdata);
+	w += sldns_str_print(s, slen, " ;{");
 
 	/* id */
-	w += ldns_str_print(s, slen, "id = %u",
-		ldns_calc_keytag_raw(rdata, rdlen));
+	w += sldns_str_print(s, slen, "id = %u",
+		sldns_calc_keytag_raw(rdata, rdlen));
 
 	/* flags */
 	if((flags&LDNS_KEY_ZONE_KEY)) {
 		if((flags&LDNS_KEY_SEP_KEY))
-			w += ldns_str_print(s, slen, " (ksk)");
-		else 	w += ldns_str_print(s, slen, " (zsk)");
+			w += sldns_str_print(s, slen, " (ksk)");
+		else 	w += sldns_str_print(s, slen, " (zsk)");
 	}
 
 	/* keysize */
 	if(rdlen > 4) {
-		w += ldns_str_print(s, slen, ", ");
-		w += ldns_str_print(s, slen, "size = %db",
-			(int)ldns_rr_dnskey_key_size_raw(
+		w += sldns_str_print(s, slen, ", ");
+		w += sldns_str_print(s, slen, "size = %db",
+			(int)sldns_rr_dnskey_key_size_raw(
 			(unsigned char*)rdata+4, rdlen-4, (int)(rdata[3])));
 	}
 
-	w += ldns_str_print(s, slen, "}");
+	w += sldns_str_print(s, slen, "}");
 	return w;
 }
 
@@ -581,12 +581,12 @@ static int rr_comment_rrsig(char** s, size_t* slen, uint8_t* rr,
 	size_t rdlen;
 	uint8_t* rdata;
 	if(rrlen < dname_off + 10) return 0;
-	rdlen = ldns_read_uint16(rr+dname_off+8);
+	rdlen = sldns_read_uint16(rr+dname_off+8);
 	if(rrlen < dname_off + 10 + rdlen) return 0;
 	rdata = rr + dname_off + 10;
 	if(rdlen < 18) return 0;
-	return ldns_str_print(s, slen, " ;{id = %d}",
-		(int)ldns_read_uint16(rdata+16));
+	return sldns_str_print(s, slen, " ;{id = %d}",
+		(int)sldns_read_uint16(rdata+16));
 }
 
 /** print rr comment for type NSEC3 */
@@ -597,16 +597,16 @@ static int rr_comment_nsec3(char** s, size_t* slen, uint8_t* rr,
 	uint8_t* rdata;
 	int w = 0;
 	if(rrlen < dname_off + 10) return 0;
-	rdlen = ldns_read_uint16(rr+dname_off+8);
+	rdlen = sldns_read_uint16(rr+dname_off+8);
 	if(rrlen < dname_off + 10 + rdlen) return 0;
 	rdata = rr + dname_off + 10;
 	if(rdlen < 2) return 0;
 	if((rdata[1] & LDNS_NSEC3_VARS_OPTOUT_MASK))
-		w += ldns_str_print(s, slen, " ;{flags: optout}");
+		w += sldns_str_print(s, slen, " ;{flags: optout}");
 	return w;
 }
 
-int ldns_wire2str_rr_comment_print(char** s, size_t* slen, uint8_t* rr,
+int sldns_wire2str_rr_comment_print(char** s, size_t* slen, uint8_t* rr,
 	size_t rrlen, size_t dname_off, uint16_t rrtype)
 {
 	if(rrtype == LDNS_RR_TYPE_DNSKEY) {
@@ -619,47 +619,47 @@ int ldns_wire2str_rr_comment_print(char** s, size_t* slen, uint8_t* rr,
 	return 0;
 }
 
-int ldns_wire2str_header_scan(uint8_t** d, size_t* dlen, char** s,
+int sldns_wire2str_header_scan(uint8_t** d, size_t* dlen, char** s,
 	size_t* slen)
 {
 	int w = 0;
 	int opcode, rcode;
-	w += ldns_str_print(s, slen, ";; ->>HEADER<<- ");
+	w += sldns_str_print(s, slen, ";; ->>HEADER<<- ");
 	if(*dlen == 0)
-		return w+ldns_str_print(s, slen, "Error empty packet");
+		return w+sldns_str_print(s, slen, "Error empty packet");
 	if(*dlen < 4)
 		return w+print_remainder_hex("Error header too short 0x", d, dlen, s, slen);
 	opcode = (int)LDNS_OPCODE_WIRE(*d);
 	rcode = (int)LDNS_RCODE_WIRE(*d);
-	w += ldns_str_print(s, slen, "opcode: ");
-	w += ldns_wire2str_opcode_print(s, slen, opcode);
-	w += ldns_str_print(s, slen, ", ");
-	w += ldns_str_print(s, slen, "rcode: ");
-	w += ldns_wire2str_rcode_print(s, slen, rcode);
-	w += ldns_str_print(s, slen, ", ");
-	w += ldns_str_print(s, slen, "id: %d\n", (int)LDNS_ID_WIRE(*d));
-	w += ldns_str_print(s, slen, ";; flags:");
-	if(LDNS_QR_WIRE(*d)) w += ldns_str_print(s, slen, " qr");
-	if(LDNS_AA_WIRE(*d)) w += ldns_str_print(s, slen, " aa");
-	if(LDNS_TC_WIRE(*d)) w += ldns_str_print(s, slen, " tc");
-	if(LDNS_RD_WIRE(*d)) w += ldns_str_print(s, slen, " rd");
-	if(LDNS_CD_WIRE(*d)) w += ldns_str_print(s, slen, " cd");
-	if(LDNS_RA_WIRE(*d)) w += ldns_str_print(s, slen, " ra");
-	if(LDNS_AD_WIRE(*d)) w += ldns_str_print(s, slen, " ad");
-	if(LDNS_Z_WIRE(*d))  w += ldns_str_print(s, slen, " z");
-	w += ldns_str_print(s, slen, " ; ");
+	w += sldns_str_print(s, slen, "opcode: ");
+	w += sldns_wire2str_opcode_print(s, slen, opcode);
+	w += sldns_str_print(s, slen, ", ");
+	w += sldns_str_print(s, slen, "rcode: ");
+	w += sldns_wire2str_rcode_print(s, slen, rcode);
+	w += sldns_str_print(s, slen, ", ");
+	w += sldns_str_print(s, slen, "id: %d\n", (int)LDNS_ID_WIRE(*d));
+	w += sldns_str_print(s, slen, ";; flags:");
+	if(LDNS_QR_WIRE(*d)) w += sldns_str_print(s, slen, " qr");
+	if(LDNS_AA_WIRE(*d)) w += sldns_str_print(s, slen, " aa");
+	if(LDNS_TC_WIRE(*d)) w += sldns_str_print(s, slen, " tc");
+	if(LDNS_RD_WIRE(*d)) w += sldns_str_print(s, slen, " rd");
+	if(LDNS_CD_WIRE(*d)) w += sldns_str_print(s, slen, " cd");
+	if(LDNS_RA_WIRE(*d)) w += sldns_str_print(s, slen, " ra");
+	if(LDNS_AD_WIRE(*d)) w += sldns_str_print(s, slen, " ad");
+	if(LDNS_Z_WIRE(*d))  w += sldns_str_print(s, slen, " z");
+	w += sldns_str_print(s, slen, " ; ");
 	if(*dlen < LDNS_HEADER_SIZE)
 		return w+print_remainder_hex("Error header too short 0x", d, dlen, s, slen);
-	w += ldns_str_print(s, slen, "QUERY: %d, ", (int)LDNS_QDCOUNT(*d));
-	w += ldns_str_print(s, slen, "ANSWER: %d, ", (int)LDNS_ANCOUNT(*d));
-	w += ldns_str_print(s, slen, "AUTHORITY: %d, ", (int)LDNS_NSCOUNT(*d));
-	w += ldns_str_print(s, slen, "ADDITIONAL: %d ", (int)LDNS_ARCOUNT(*d));
+	w += sldns_str_print(s, slen, "QUERY: %d, ", (int)LDNS_QDCOUNT(*d));
+	w += sldns_str_print(s, slen, "ANSWER: %d, ", (int)LDNS_ANCOUNT(*d));
+	w += sldns_str_print(s, slen, "AUTHORITY: %d, ", (int)LDNS_NSCOUNT(*d));
+	w += sldns_str_print(s, slen, "ADDITIONAL: %d ", (int)LDNS_ARCOUNT(*d));
 	*d += LDNS_HEADER_SIZE;
 	*dlen -= LDNS_HEADER_SIZE;
 	return w;
 }
 
-int ldns_wire2str_rdata_scan(uint8_t** d, size_t* dlen, char** s,
+int sldns_wire2str_rdata_scan(uint8_t** d, size_t* dlen, char** s,
 	size_t* slen, uint16_t rrtype, uint8_t* pkt, size_t pktlen)
 {
 	/* try to prettyprint, but if that fails, use unknown format */
@@ -667,32 +667,32 @@ int ldns_wire2str_rdata_scan(uint8_t** d, size_t* dlen, char** s,
 	char* origs = *s;
 	size_t origdlen = *dlen, origslen = *slen;
 	uint16_t r_cnt, r_max;
-	ldns_rdf_type rdftype;
+	sldns_rdf_type rdftype;
 	int w = 0, n;
 
-	const ldns_rr_descriptor *desc = ldns_rr_descript(rrtype);
+	const sldns_rr_descriptor *desc = sldns_rr_descript(rrtype);
 	if(!desc) /* unknown format */
-		return ldns_wire2str_rdata_unknown_scan(d, dlen, s, slen);
+		return sldns_wire2str_rdata_unknown_scan(d, dlen, s, slen);
 	/* dlen equals the rdatalen for the rdata */
 
-	r_max = ldns_rr_descriptor_maximum(desc);
+	r_max = sldns_rr_descriptor_maximum(desc);
 	for(r_cnt=0; r_cnt < r_max; r_cnt++) {
 		if(*dlen == 0) {
-			if(r_cnt < ldns_rr_descriptor_minimum(desc))
+			if(r_cnt < sldns_rr_descriptor_minimum(desc))
 				goto failed;
 			break; /* nothing more to print */
 		}
-		rdftype = ldns_rr_descriptor_field_type(desc, r_cnt);
+		rdftype = sldns_rr_descriptor_field_type(desc, r_cnt);
 		if(r_cnt != 0)
-			w += ldns_str_print(s, slen, " ");
-		n = ldns_wire2str_rdf_scan(d, dlen, s, slen, rdftype,
+			w += sldns_str_print(s, slen, " ");
+		n = sldns_wire2str_rdf_scan(d, dlen, s, slen, rdftype,
 			pkt, pktlen);
 		if(n == -1) {
 		failed:
 			/* failed, use unknown format */
 			*d = origd; *s = origs;
 			*dlen = origdlen; *slen = origslen;
-			return ldns_wire2str_rdata_unknown_scan(d, dlen,
+			return sldns_wire2str_rdata_unknown_scan(d, dlen,
 				s, slen);
 		}
 		w += n;
@@ -700,17 +700,17 @@ int ldns_wire2str_rdata_scan(uint8_t** d, size_t* dlen, char** s,
 	return w;
 }
 
-int ldns_wire2str_rdata_unknown_scan(uint8_t** d, size_t* dlen, char** s,
+int sldns_wire2str_rdata_unknown_scan(uint8_t** d, size_t* dlen, char** s,
 	size_t* slen)
 {
 	int w = 0;
 
 	/* print length */
-	w += ldns_str_print(s, slen, "\\# %u", (unsigned)*dlen);
+	w += sldns_str_print(s, slen, "\\# %u", (unsigned)*dlen);
 
 	/* print rdlen in hex */
 	if(*dlen != 0)
-		w += ldns_str_print(s, slen, " ");
+		w += sldns_str_print(s, slen, " ");
 	w += print_hex_buf(s, slen, *d, *dlen);
 	(*d) += *dlen;
 	(*dlen) = 0;
@@ -721,9 +721,9 @@ int ldns_wire2str_rdata_unknown_scan(uint8_t** d, size_t* dlen, char** s,
 static int dname_char_print(char** s, size_t* slen, char c)
 {
 	if(c == '.' || c == ';' || c == '(' || c == ')' || c == '\\')
-		return ldns_str_print(s, slen, "\\%c", c);
+		return sldns_str_print(s, slen, "\\%c", c);
 	else if(!(isascii((int)c) && isgraph((int)c)))
-		return ldns_str_print(s, slen, "\\%03u", (unsigned)c);
+		return sldns_str_print(s, slen, "\\%03u", (unsigned)c);
 	/* plain printout */
 	if(*slen) {
 		**s = c;
@@ -733,7 +733,7 @@ static int dname_char_print(char** s, size_t* slen, char c)
 	return 1;
 }
 
-int ldns_wire2str_dname_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
+int sldns_wire2str_dname_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 	uint8_t* pkt, size_t pktlen)
 {
 	int w = 0;
@@ -742,11 +742,11 @@ int ldns_wire2str_dname_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 	unsigned i, counter=0;
 	const unsigned maxcompr = 1000; /* loop detection, max compr ptrs */
 	int in_buf = 1;
-	if(*dlen == 0) return ldns_str_print(s, slen, "ErrorMissingDname");
+	if(*dlen == 0) return sldns_str_print(s, slen, "ErrorMissingDname");
 	if(*pos == 0) {
 		(*d)++;
 		(*dlen)--;
-		return ldns_str_print(s, slen, ".");
+		return sldns_str_print(s, slen, ".");
 	}
 	while(*pos) {
 		/* read label length */
@@ -758,26 +758,26 @@ int ldns_wire2str_dname_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 			/* compressed */
 			uint16_t target = 0;
 			if(in_buf && *dlen == 0)
-				return w + ldns_str_print(s, slen,
+				return w + sldns_str_print(s, slen,
 					"ErrorPartialDname");
 			else if(!in_buf && pos+1 > pkt+pktlen)
-				return w + ldns_str_print(s, slen,
+				return w + sldns_str_print(s, slen,
 					"ErrorPartialDname");
 			target = ((labellen&0x3f)<<8) | *pos;
 			if(in_buf) { (*d)++; (*dlen)--; }
 			/* move to target, if possible */
 			if(!pkt || target >= pktlen)
-				return w + ldns_str_print(s, slen,
+				return w + sldns_str_print(s, slen,
 					"ErrorComprPtrOutOfBounds");
 			if(counter++ > maxcompr)
-				return w + ldns_str_print(s, slen,
+				return w + sldns_str_print(s, slen,
 					"ErrorComprPtrLooped");
 			in_buf = 0;
 			pos = pkt+target;
 			continue;
 		} else if((labellen&0xc0)) {
 			/* notimpl label type */
-			w += ldns_str_print(s, slen,
+			w += sldns_str_print(s, slen,
 				"ErrorLABELTYPE%xIsUnknown",
 				(int)(labellen&0xc0));
 			return w;
@@ -795,97 +795,97 @@ int ldns_wire2str_dname_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 			(*dlen) -= labellen;
 			if(*dlen == 0) break;
 		}
-		w += ldns_str_print(s, slen, ".");
+		w += sldns_str_print(s, slen, ".");
 	}
 	/* skip over final root label */
 	if(in_buf && *dlen > 0) { (*d)++; (*dlen)--; }
 	/* in case we printed no labels, terminate dname */
-	if(w == 0) w += ldns_str_print(s, slen, ".");
+	if(w == 0) w += sldns_str_print(s, slen, ".");
 	return w;
 }
 
-int ldns_wire2str_opcode_print(char** s, size_t* slen, int opcode)
+int sldns_wire2str_opcode_print(char** s, size_t* slen, int opcode)
 {
-	ldns_lookup_table *lt = ldns_lookup_by_id(SLDNS(_opcodes), opcode);
+	sldns_lookup_table *lt = sldns_lookup_by_id(sldns_opcodes, opcode);
 	if (lt && lt->name) {
-		return ldns_str_print(s, slen, "%s", lt->name);
+		return sldns_str_print(s, slen, "%s", lt->name);
 	}
-	return ldns_str_print(s, slen, "OPCODE%u", (unsigned)opcode);
+	return sldns_str_print(s, slen, "OPCODE%u", (unsigned)opcode);
 }
 
-int ldns_wire2str_rcode_print(char** s, size_t* slen, int rcode)
+int sldns_wire2str_rcode_print(char** s, size_t* slen, int rcode)
 {
-	ldns_lookup_table *lt = ldns_lookup_by_id(SLDNS(_rcodes), rcode);
+	sldns_lookup_table *lt = sldns_lookup_by_id(sldns_rcodes, rcode);
 	if (lt && lt->name) {
-		return ldns_str_print(s, slen, "%s", lt->name);
+		return sldns_str_print(s, slen, "%s", lt->name);
 	}
-	return ldns_str_print(s, slen, "RCODE%u", (unsigned)rcode);
+	return sldns_str_print(s, slen, "RCODE%u", (unsigned)rcode);
 }
 
-int ldns_wire2str_class_print(char** s, size_t* slen, uint16_t rrclass)
+int sldns_wire2str_class_print(char** s, size_t* slen, uint16_t rrclass)
 {
-	ldns_lookup_table *lt = ldns_lookup_by_id(SLDNS(_rr_classes),
+	sldns_lookup_table *lt = sldns_lookup_by_id(sldns_rr_classes,
 		(int)rrclass);
 	if (lt && lt->name) {
-		return ldns_str_print(s, slen, "%s", lt->name);
+		return sldns_str_print(s, slen, "%s", lt->name);
 	}
-	return ldns_str_print(s, slen, "CLASS%u", (unsigned)rrclass);
+	return sldns_str_print(s, slen, "CLASS%u", (unsigned)rrclass);
 }
 
-int ldns_wire2str_type_print(char** s, size_t* slen, uint16_t rrtype)
+int sldns_wire2str_type_print(char** s, size_t* slen, uint16_t rrtype)
 {
-	const ldns_rr_descriptor *descriptor = ldns_rr_descript(rrtype);
+	const sldns_rr_descriptor *descriptor = sldns_rr_descript(rrtype);
 	if (descriptor && descriptor->_name) {
-		return ldns_str_print(s, slen, "%s", descriptor->_name);
+		return sldns_str_print(s, slen, "%s", descriptor->_name);
 	}
-	return ldns_str_print(s, slen, "TYPE%u", (unsigned)rrtype);
+	return sldns_str_print(s, slen, "TYPE%u", (unsigned)rrtype);
 }
 
-int ldns_wire2str_edns_option_code_print(char** s, size_t* slen,
+int sldns_wire2str_edns_option_code_print(char** s, size_t* slen,
 	uint16_t opcode)
 {
-	ldns_lookup_table *lt = ldns_lookup_by_id(SLDNS(_edns_options),
+	sldns_lookup_table *lt = sldns_lookup_by_id(sldns_edns_options,
 		(int)opcode);
 	if (lt && lt->name) {
-		return ldns_str_print(s, slen, "%s", lt->name);
+		return sldns_str_print(s, slen, "%s", lt->name);
 	}
-	return ldns_str_print(s, slen, "OPT%u", (unsigned)opcode);
+	return sldns_str_print(s, slen, "OPT%u", (unsigned)opcode);
 }
 
-int ldns_wire2str_class_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
+int sldns_wire2str_class_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 {
 	uint16_t c;
 	if(*dlen == 0) return 0;
 	if(*dlen < 2) return print_remainder_hex("Error malformed 0x", d, dlen, s, slen);
-	c = ldns_read_uint16(*d);
+	c = sldns_read_uint16(*d);
 	(*d)+=2;
 	(*dlen)-=2;
-	return ldns_wire2str_class_print(s, slen, c);
+	return sldns_wire2str_class_print(s, slen, c);
 }
 
-int ldns_wire2str_type_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
+int sldns_wire2str_type_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 {
 	uint16_t t;
 	if(*dlen == 0) return 0;
 	if(*dlen < 2) return print_remainder_hex("Error malformed 0x", d, dlen, s, slen);
-	t = ldns_read_uint16(*d);
+	t = sldns_read_uint16(*d);
 	(*d)+=2;
 	(*dlen)-=2;
-	return ldns_wire2str_type_print(s, slen, t);
+	return sldns_wire2str_type_print(s, slen, t);
 }
 
-int ldns_wire2str_ttl_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
+int sldns_wire2str_ttl_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 {
 	uint32_t ttl;
 	if(*dlen == 0) return 0;
 	if(*dlen < 4) return print_remainder_hex("Error malformed 0x", d, dlen, s, slen);
-	ttl = ldns_read_uint32(*d);
+	ttl = sldns_read_uint32(*d);
 	(*d)+=4;
 	(*dlen)-=4;
-	return ldns_str_print(s, slen, "%u", (unsigned)ttl);
+	return sldns_str_print(s, slen, "%u", (unsigned)ttl);
 }
 
-int ldns_wire2str_rdf_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
+int sldns_wire2str_rdf_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 	int rdftype, uint8_t* pkt, size_t pktlen)
 {
 	if(*dlen == 0) return 0;
@@ -893,119 +893,119 @@ int ldns_wire2str_rdf_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 	case LDNS_RDF_TYPE_NONE:
 		return 0;
 	case LDNS_RDF_TYPE_DNAME:
-		return ldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
+		return sldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
 	case LDNS_RDF_TYPE_INT8:
-		return ldns_wire2str_int8_scan(d, dlen, s, slen);
+		return sldns_wire2str_int8_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_INT16:
-		return ldns_wire2str_int16_scan(d, dlen, s, slen);
+		return sldns_wire2str_int16_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_INT32:
-		return ldns_wire2str_int32_scan(d, dlen, s, slen);
+		return sldns_wire2str_int32_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_PERIOD:
-		return ldns_wire2str_period_scan(d, dlen, s, slen);
+		return sldns_wire2str_period_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_TSIGTIME:
-		return ldns_wire2str_tsigtime_scan(d, dlen, s, slen);
+		return sldns_wire2str_tsigtime_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_A:
-		return ldns_wire2str_a_scan(d, dlen, s, slen);
+		return sldns_wire2str_a_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_AAAA:
-		return ldns_wire2str_aaaa_scan(d, dlen, s, slen);
+		return sldns_wire2str_aaaa_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_STR:
-		return ldns_wire2str_str_scan(d, dlen, s, slen);
+		return sldns_wire2str_str_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_APL:
-		return ldns_wire2str_apl_scan(d, dlen, s, slen);
+		return sldns_wire2str_apl_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_B32_EXT:
-		return ldns_wire2str_b32_ext_scan(d, dlen, s, slen);
+		return sldns_wire2str_b32_ext_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_B64:
-		return ldns_wire2str_b64_scan(d, dlen, s, slen);
+		return sldns_wire2str_b64_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_HEX:
-		return ldns_wire2str_hex_scan(d, dlen, s, slen);
+		return sldns_wire2str_hex_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_NSEC:
-		return ldns_wire2str_nsec_scan(d, dlen, s, slen);
+		return sldns_wire2str_nsec_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_NSEC3_SALT:
-		return ldns_wire2str_nsec3_salt_scan(d, dlen, s, slen);
+		return sldns_wire2str_nsec3_salt_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_TYPE:
-		return ldns_wire2str_type_scan(d, dlen, s, slen);
+		return sldns_wire2str_type_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_CLASS:
-		return ldns_wire2str_class_scan(d, dlen, s, slen);
+		return sldns_wire2str_class_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_CERT_ALG:
-		return ldns_wire2str_cert_alg_scan(d, dlen, s, slen);
+		return sldns_wire2str_cert_alg_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_ALG:
-		return ldns_wire2str_alg_scan(d, dlen, s, slen);
+		return sldns_wire2str_alg_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_UNKNOWN:
-		return ldns_wire2str_unknown_scan(d, dlen, s, slen);
+		return sldns_wire2str_unknown_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_TIME:
-		return ldns_wire2str_time_scan(d, dlen, s, slen);
+		return sldns_wire2str_time_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_LOC:
-		return ldns_wire2str_loc_scan(d, dlen, s, slen);
+		return sldns_wire2str_loc_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_WKS:
 	case LDNS_RDF_TYPE_SERVICE:
-		return ldns_wire2str_wks_scan(d, dlen, s, slen);
+		return sldns_wire2str_wks_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_NSAP:
-		return ldns_wire2str_nsap_scan(d, dlen, s, slen);
+		return sldns_wire2str_nsap_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_ATMA:
-		return ldns_wire2str_atma_scan(d, dlen, s, slen);
+		return sldns_wire2str_atma_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_IPSECKEY:
-		return ldns_wire2str_ipseckey_scan(d, dlen, s, slen, pkt,
+		return sldns_wire2str_ipseckey_scan(d, dlen, s, slen, pkt,
 			pktlen);
 	case LDNS_RDF_TYPE_INT16_DATA:
-		return ldns_wire2str_int16_data_scan(d, dlen, s, slen);
+		return sldns_wire2str_int16_data_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
-		return ldns_wire2str_b32_ext_scan(d, dlen, s, slen);
+		return sldns_wire2str_b32_ext_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_ILNP64:
-		return ldns_wire2str_ilnp64_scan(d, dlen, s, slen);
+		return sldns_wire2str_ilnp64_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_EUI48:
-		return ldns_wire2str_eui48_scan(d, dlen, s, slen);
+		return sldns_wire2str_eui48_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_EUI64:
-		return ldns_wire2str_eui64_scan(d, dlen, s, slen);
+		return sldns_wire2str_eui64_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_TAG:
-		return ldns_wire2str_tag_scan(d, dlen, s, slen);
+		return sldns_wire2str_tag_scan(d, dlen, s, slen);
 	case LDNS_RDF_TYPE_LONG_STR:
-		return ldns_wire2str_long_str_scan(d, dlen, s, slen);
+		return sldns_wire2str_long_str_scan(d, dlen, s, slen);
 	}
 	/* unknown rdf type */
 	return -1;
 }
 
-int ldns_wire2str_int8_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_int8_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w;
 	if(*dl < 1) return -1;
-	w = ldns_str_print(s, sl, "%u", (unsigned)**d);
+	w = sldns_str_print(s, sl, "%u", (unsigned)**d);
 	(*d)++;
 	(*dl)--;
 	return w;
 }
 
-int ldns_wire2str_int16_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_int16_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w;
 	if(*dl < 2) return -1;
-	w = ldns_str_print(s, sl, "%lu", (unsigned long)ldns_read_uint16(*d));
+	w = sldns_str_print(s, sl, "%lu", (unsigned long)sldns_read_uint16(*d));
 	(*d)+=2;
 	(*dl)-=2;
 	return w;
 }
 
-int ldns_wire2str_int32_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_int32_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w;
 	if(*dl < 4) return -1;
-	w = ldns_str_print(s, sl, "%lu", (unsigned long)ldns_read_uint32(*d));
+	w = sldns_str_print(s, sl, "%lu", (unsigned long)sldns_read_uint32(*d));
 	(*d)+=4;
 	(*dl)-=4;
 	return w;
 }
 
-int ldns_wire2str_period_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_period_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w;
 	if(*dl < 4) return -1;
-	w = ldns_str_print(s, sl, "%u", (unsigned)ldns_read_uint32(*d));
+	w = sldns_str_print(s, sl, "%u", (unsigned)sldns_read_uint32(*d));
 	(*d)+=4;
 	(*dl)-=4;
 	return w;
 }
 
-int ldns_wire2str_tsigtime_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_tsigtime_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	/* tsigtime is 48 bits network order unsigned integer */
 	int w;
@@ -1019,26 +1019,26 @@ int ldns_wire2str_tsigtime_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	d4 = (*d)[4];
 	d5 = (*d)[5];
 	tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5;
-	w = ldns_str_print(s, sl, "%llu", (long long)tsigtime);
+	w = sldns_str_print(s, sl, "%llu", (long long)tsigtime);
 	(*d)+=6;
 	(*dl)-=6;
 	return w;
 }
 
-int ldns_wire2str_a_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_a_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	char buf[32];
 	int w;
 	if(*dl < 4) return -1;
 	if(!inet_ntop(AF_INET, *d, buf, (socklen_t)sizeof(buf)))
 		return -1;
-	w = ldns_str_print(s, sl, "%s", buf);
+	w = sldns_str_print(s, sl, "%s", buf);
 	(*d)+=4;
 	(*dl)-=4;
 	return w;
 }
 
-int ldns_wire2str_aaaa_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_aaaa_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 #ifdef AF_INET6
 	char buf[64];
@@ -1046,7 +1046,7 @@ int ldns_wire2str_aaaa_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	if(*dl < 16) return -1;
 	if(!inet_ntop(AF_INET6, *d, buf, (socklen_t)sizeof(buf)))
 		return -1;
-	w = ldns_str_print(s, sl, "%s", buf);
+	w = sldns_str_print(s, sl, "%s", buf);
 	(*d)+=16;
 	(*dl)-=16;
 	return w;
@@ -1060,7 +1060,7 @@ static int str_char_print(char** s, size_t* sl, char c)
 {
 	if(isprint((int)c) || c == '\t') {
 		if(c == '\"' || c == '\\')
-			return ldns_str_print(s, sl, "\\%c", c);
+			return sldns_str_print(s, sl, "\\%c", c);
 		if(*sl) {
 			**s = c;
 			(*s)++;
@@ -1068,10 +1068,10 @@ static int str_char_print(char** s, size_t* sl, char c)
 		}
 		return 1;
 	}
-	return ldns_str_print(s, sl, "\\%03u", (unsigned)c);
+	return sldns_str_print(s, sl, "\\%03u", (unsigned)c);
 }
 
-int ldns_wire2str_str_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_str_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w = 0;
 	size_t i, len;
@@ -1080,22 +1080,22 @@ int ldns_wire2str_str_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	if(*dl < 1+len) return -1;
 	(*d)++;
 	(*dl)--;
-	w += ldns_str_print(s, sl, "\"");
+	w += sldns_str_print(s, sl, "\"");
 	for(i=0; i<len; i++)
 		w += str_char_print(s, sl, (char)(*d)[i]);
-	w += ldns_str_print(s, sl, "\"");
+	w += sldns_str_print(s, sl, "\"");
 	(*d)+=len;
 	(*dl)-=len;
 	return w;
 }
 
-int ldns_wire2str_apl_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_apl_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int i, w = 0;
 	uint16_t family;
 	uint8_t negation, prefix, adflength;
 	if(*dl < 4) return -1;
-	family = ldns_read_uint16(*d);
+	family = sldns_read_uint16(*d);
 	prefix = (*d)[2];
 	negation = ((*d)[3] & LDNS_APL_NEGATION);
 	adflength = ((*d)[3] & LDNS_APL_MASK);
@@ -1103,50 +1103,50 @@ int ldns_wire2str_apl_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	if(family != LDNS_APL_IP4 && family != LDNS_APL_IP6)
 		return -1; /* unknown address family */
 	if(negation)
-		w += ldns_str_print(s, sl, "!");
-	w += ldns_str_print(s, sl, "%u:", (unsigned)family);
+		w += sldns_str_print(s, sl, "!");
+	w += sldns_str_print(s, sl, "%u:", (unsigned)family);
 	if(family == LDNS_APL_IP4) {
 		/* check if prefix <32 ? */
 		/* address is variable length 0 - 4 */
 		for(i=0; i<4; i++) {
 			if(i > 0)
-				w += ldns_str_print(s, sl, ".");
+				w += sldns_str_print(s, sl, ".");
 			if(i < (int)adflength)
-				w += ldns_str_print(s, sl, "%d", (*d)[4+i]);
-			else	w += ldns_str_print(s, sl, "0");
+				w += sldns_str_print(s, sl, "%d", (*d)[4+i]);
+			else	w += sldns_str_print(s, sl, "0");
 		}
 	} else if(family == LDNS_APL_IP6) {
 		/* check if prefix <128 ? */
 		/* address is variable length 0 - 16 */
 		for(i=0; i<16; i++) {
 			if(i%2 == 0 && i>0)
-				w += ldns_str_print(s, sl, ":");
+				w += sldns_str_print(s, sl, ":");
 			if(i < (int)adflength)
-				w += ldns_str_print(s, sl, "%02x", (*d)[4+i]);
-			else	w += ldns_str_print(s, sl, "00");
+				w += sldns_str_print(s, sl, "%02x", (*d)[4+i]);
+			else	w += sldns_str_print(s, sl, "00");
 		}
 	}
-	w += ldns_str_print(s, sl, "/%u", (unsigned)prefix);
+	w += sldns_str_print(s, sl, "/%u", (unsigned)prefix);
 	(*d) += 4+adflength;
 	(*dl) -= 4+adflength;
 	return w;
 }
 
-int ldns_wire2str_b32_ext_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_b32_ext_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	size_t datalen;
 	size_t sz;
 	if(*dl < 1) return -1;
 	datalen = (*d)[0];
 	if(*dl < 1+datalen) return -1;
-	sz = ldns_b32_ntop_calculate_size(datalen);
+	sz = sldns_b32_ntop_calculate_size(datalen);
 	if(*sl < sz+1) {
 		(*d) += datalen+1;
 		(*dl) -= (datalen+1);
 		return (int)sz; /* out of space really, but would need buffer
 			in order to truncate the output */
 	}
-	ldns_b32_ntop_extended_hex((*d)+1, datalen, *s, *sl);
+	sldns_b32_ntop_extended_hex((*d)+1, datalen, *s, *sl);
 	(*d) += datalen+1;
 	(*dl) -= (datalen+1);
 	(*s) += sz;
@@ -1155,18 +1155,18 @@ int ldns_wire2str_b32_ext_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 }
 
 /** scan number of bytes from wire into b64 presentation format */
-static int ldns_wire2str_b64_scan_num(uint8_t** d, size_t* dl, char** s,
+static int sldns_wire2str_b64_scan_num(uint8_t** d, size_t* dl, char** s,
 	size_t* sl, size_t num)
 {
 	/* b64_ntop_calculate size includes null at the end */
-	size_t sz = ldns_b64_ntop_calculate_size(num)-1;
+	size_t sz = sldns_b64_ntop_calculate_size(num)-1;
 	if(*sl < sz+1) {
 		(*d) += num;
 		(*dl) -= num;
 		return (int)sz; /* out of space really, but would need buffer
 			in order to truncate the output */
 	}
-	ldns_b64_ntop(*d, num, *s, *sl);
+	sldns_b64_ntop(*d, num, *s, *sl);
 	(*d) += num;
 	(*dl) -= num;
 	(*s) += sz;
@@ -1174,17 +1174,17 @@ static int ldns_wire2str_b64_scan_num(uint8_t** d, size_t* dl, char** s,
 	return (int)sz;
 }
 
-int ldns_wire2str_b64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_b64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
-	return ldns_wire2str_b64_scan_num(d, dl, s, sl, *dl);
+	return sldns_wire2str_b64_scan_num(d, dl, s, sl, *dl);
 }
 
-int ldns_wire2str_hex_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_hex_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	return print_remainder_hex("", d, dl, s, sl);
 }
 
-int ldns_wire2str_nsec_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_nsec_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	uint8_t* p = *d;
 	size_t pl = *dl;
@@ -1216,8 +1216,8 @@ int ldns_wire2str_nsec_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 			t = ((window)<<8) | (i << 3);
 			for(bit=0; bit<8; bit++) {
 				if((p[i]&(0x80>>bit))) {
-					if(w) w += ldns_str_print(s, sl, " ");
-					w += ldns_wire2str_type_print(s, sl,
+					if(w) w += sldns_str_print(s, sl, " ");
+					w += sldns_wire2str_type_print(s, sl,
 						t+bit);
 				}
 			}
@@ -1230,7 +1230,7 @@ int ldns_wire2str_nsec_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	return w;
 }
 
-int ldns_wire2str_nsec3_salt_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_nsec3_salt_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	size_t salt_len;
 	int w;
@@ -1240,7 +1240,7 @@ int ldns_wire2str_nsec3_salt_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	(*d)++;
 	(*dl)--;
 	if(salt_len == 0) {
-		return ldns_str_print(s, sl, "-");
+		return sldns_str_print(s, sl, "-");
 	}
 	w = print_hex_buf(s, sl, *d, salt_len);
 	(*dl)-=salt_len;
@@ -1248,34 +1248,34 @@ int ldns_wire2str_nsec3_salt_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	return w;
 }
 
-int ldns_wire2str_cert_alg_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_cert_alg_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
-	ldns_lookup_table *lt;
+	sldns_lookup_table *lt;
 	int data, w;
 	if(*dl < 2) return -1;
-	data = (int)ldns_read_uint16(*d);
-	lt = ldns_lookup_by_id(SLDNS(_cert_algorithms), data);
+	data = (int)sldns_read_uint16(*d);
+	lt = sldns_lookup_by_id(sldns_cert_algorithms, data);
 	if(lt && lt->name)
-		w = ldns_str_print(s, sl, "%s", lt->name);
-	else 	w = ldns_str_print(s, sl, "%d", data);
+		w = sldns_str_print(s, sl, "%s", lt->name);
+	else 	w = sldns_str_print(s, sl, "%d", data);
 	(*dl)-=2;
 	(*d)+=2;
 	return w;
 }
 
-int ldns_wire2str_alg_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_alg_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	/* don't use algorithm mnemonics in the presentation format
 	 * this kind of got sneaked into the rfc's */
-	return ldns_wire2str_int8_scan(d, dl, s, sl);
+	return sldns_wire2str_int8_scan(d, dl, s, sl);
 }
 
-int ldns_wire2str_unknown_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_unknown_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
-	return ldns_wire2str_rdata_unknown_scan(d, dl, s, sl);
+	return sldns_wire2str_rdata_unknown_scan(d, dl, s, sl);
 }
 
-int ldns_wire2str_time_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_time_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	/* create a YYYYMMDDHHMMSS string if possible */
 	struct tm tm;
@@ -1283,13 +1283,13 @@ int ldns_wire2str_time_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	uint32_t t;
 	memset(&tm, 0, sizeof(tm));
 	if(*dl < 4) return -1;
-	t = ldns_read_uint32(*d);
+	t = sldns_read_uint32(*d);
 	date_buf[15]=0;
-	if(ldns_serial_arithmitics_gmtime_r(t, time(NULL), &tm) &&
+	if(sldns_serial_arithmitics_gmtime_r(t, time(NULL), &tm) &&
 		strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
 		(*d) += 4;
 		(*dl) -= 4;
-		return ldns_str_print(s, sl, "%s", date_buf);
+		return sldns_str_print(s, sl, "%s", date_buf);
 	}
 	return -1;
 }
@@ -1303,16 +1303,16 @@ loc_cm_print(char** str, size_t* sl, uint8_t mantissa, uint8_t exponent)
 	if(exponent < 2) {
 		if(exponent == 1)
 			mantissa *= 10;
-		return ldns_str_print(str, sl, "0.%02ld", (long)mantissa);
+		return sldns_str_print(str, sl, "0.%02ld", (long)mantissa);
 	}
 	/* always <digit><string of zeros> */
-	w += ldns_str_print(str, sl, "%d", (int)mantissa);
+	w += sldns_str_print(str, sl, "%d", (int)mantissa);
 	for(i=0; i<exponent-2; i++)
-		w += ldns_str_print(str, sl, "0");
+		w += sldns_str_print(str, sl, "0");
 	return w;
 }
 
-int ldns_wire2str_loc_scan(uint8_t** d, size_t* dl, char** str, size_t* sl)
+int sldns_wire2str_loc_scan(uint8_t** d, size_t* dl, char** str, size_t* sl)
 {
 	/* we could do checking (ie degrees < 90 etc)? */
 	uint8_t version;
@@ -1333,14 +1333,14 @@ int ldns_wire2str_loc_scan(uint8_t** d, size_t* dl, char** str, size_t* sl)
 	if(*dl < 16) return -1;
 	version = (*d)[0];
 	if(version != 0)
-		return ldns_wire2str_hex_scan(d, dl, str, sl);
+		return sldns_wire2str_hex_scan(d, dl, str, sl);
 	size = (*d)[1];
 	horizontal_precision = (*d)[2];
 	vertical_precision = (*d)[3];
 
-	latitude = ldns_read_uint32((*d)+4);
-	longitude = ldns_read_uint32((*d)+8);
-	altitude = ldns_read_uint32((*d)+12);
+	latitude = sldns_read_uint32((*d)+4);
+	longitude = sldns_read_uint32((*d)+8);
+	altitude = sldns_read_uint32((*d)+12);
 
 	if (latitude > equator) {
 		northerness = 'N';
@@ -1354,7 +1354,7 @@ int ldns_wire2str_loc_scan(uint8_t** d, size_t* dl, char** str, size_t* sl)
 	m = latitude / (1000 * 60);
 	latitude = latitude % (1000 * 60);
 	s = (double) latitude / 1000.0;
-	w += ldns_str_print(str, sl, "%02u %02u %0.3f %c ",
+	w += sldns_str_print(str, sl, "%02u %02u %0.3f %c ",
 		h, m, s, northerness);
 
 	if (longitude > equator) {
@@ -1369,36 +1369,36 @@ int ldns_wire2str_loc_scan(uint8_t** d, size_t* dl, char** str, size_t* sl)
 	m = longitude / (1000 * 60);
 	longitude = longitude % (1000 * 60);
 	s = (double) longitude / (1000.0);
-	w += ldns_str_print(str, sl, "%02u %02u %0.3f %c ",
+	w += sldns_str_print(str, sl, "%02u %02u %0.3f %c ",
 		h, m, s, easterness);
 
 	s = ((double) altitude) / 100;
 	s -= 100000;
 
 	if(altitude%100 != 0)
-		w += ldns_str_print(str, sl, "%.2f", s);
+		w += sldns_str_print(str, sl, "%.2f", s);
 	else
-		w += ldns_str_print(str, sl, "%.0f", s);
+		w += sldns_str_print(str, sl, "%.0f", s);
 
-	w += ldns_str_print(str, sl, "m ");
+	w += sldns_str_print(str, sl, "m ");
 
 	w += loc_cm_print(str, sl, (size & 0xf0) >> 4, size & 0x0f);
-	w += ldns_str_print(str, sl, "m ");
+	w += sldns_str_print(str, sl, "m ");
 
 	w += loc_cm_print(str, sl, (horizontal_precision & 0xf0) >> 4,
 		horizontal_precision & 0x0f);
-	w += ldns_str_print(str, sl, "m ");
+	w += sldns_str_print(str, sl, "m ");
 
 	w += loc_cm_print(str, sl, (vertical_precision & 0xf0) >> 4,
 		vertical_precision & 0x0f);
-	w += ldns_str_print(str, sl, "m");
+	w += sldns_str_print(str, sl, "m");
 
 	(*d)+=16;
 	(*dl)-=16;
 	return w;
 }
 
-int ldns_wire2str_wks_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_wks_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	/* protocol, followed by bitmap of services */
 	const char* proto_name = NULL;
@@ -1415,10 +1415,10 @@ int ldns_wire2str_wks_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	(*dl)--;
 	protocol = getprotobynumber((int)protocol_nr);
 	if(protocol && (protocol->p_name != NULL)) {
-		w += ldns_str_print(s, sl, "%s", protocol->p_name);
+		w += sldns_str_print(s, sl, "%s", protocol->p_name);
 		proto_name = protocol->p_name;
 	} else	{
-		w += ldns_str_print(s, sl, "%u", (unsigned)protocol_nr);
+		w += sldns_str_print(s, sl, "%u", (unsigned)protocol_nr);
 	}
 
 	for(i=0; i<*dl; i++) {
@@ -1431,9 +1431,9 @@ int ldns_wire2str_wks_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 			service = getservbyport((int)htons((uint16_t)port),
 				proto_name);
 			if(service && service->s_name)
-				w += ldns_str_print(s, sl, " %s",
+				w += sldns_str_print(s, sl, " %s",
 					service->s_name);
-			else 	w += ldns_str_print(s, sl, " %u",
+			else 	w += sldns_str_print(s, sl, " %u",
 					(unsigned)port);
 		}
 	}
@@ -1449,18 +1449,18 @@ int ldns_wire2str_wks_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	return w;
 }
 
-int ldns_wire2str_nsap_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_nsap_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	return print_remainder_hex("0x", d, dl, s, sl);
 }
 
-int ldns_wire2str_atma_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_atma_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	return print_remainder_hex("", d, dl, s, sl);
 }
 
 /* internal scan routine that can modify arguments on failure */
-static int ldns_wire2str_ipseckey_scan_internal(uint8_t** d, size_t* dl,
+static int sldns_wire2str_ipseckey_scan_internal(uint8_t** d, size_t* dl,
 	char** s, size_t* sl, uint8_t* pkt, size_t pktlen)
 {
 	/* http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt*/
@@ -1476,21 +1476,21 @@ static int ldns_wire2str_ipseckey_scan_internal(uint8_t** d, size_t* dl,
 		return -1; /* unknown */
 	(*d)+=3;
 	(*dl)-=3;
-	w += ldns_str_print(s, sl, "%d %d %d ",
+	w += sldns_str_print(s, sl, "%d %d %d ",
 		(int)precedence, (int)gateway_type, (int)algorithm);
 
 	switch(gateway_type) {
 	case 0: /* no gateway */
-		w += ldns_str_print(s, sl, ".");
+		w += sldns_str_print(s, sl, ".");
 		break;
 	case 1: /* ip4 */
-		w += ldns_wire2str_a_scan(d, dl, s, sl);
+		w += sldns_wire2str_a_scan(d, dl, s, sl);
 		break;
 	case 2: /* ip6 */
-		w += ldns_wire2str_aaaa_scan(d, dl, s, sl);
+		w += sldns_wire2str_aaaa_scan(d, dl, s, sl);
 		break;
 	case 3: /* dname */
-		w += ldns_wire2str_dname_scan(d, dl, s, sl, pkt, pktlen);
+		w += sldns_wire2str_dname_scan(d, dl, s, sl, pkt, pktlen);
 		break;
 	default: /* unknown */
 		return -1;
@@ -1503,17 +1503,17 @@ static int ldns_wire2str_ipseckey_scan_internal(uint8_t** d, size_t* dl,
 		return -1;
 	(*d)++;
 	(*dl)--;
-	w += ldns_wire2str_b64_scan_num(d, dl, s, sl, public_key_size);
+	w += sldns_wire2str_b64_scan_num(d, dl, s, sl, public_key_size);
 	return w;
 }
 
-int ldns_wire2str_ipseckey_scan(uint8_t** d, size_t* dl, char** s, size_t* sl,
+int sldns_wire2str_ipseckey_scan(uint8_t** d, size_t* dl, char** s, size_t* sl,
 	uint8_t* pkt, size_t pktlen)
 {
 	uint8_t* od = *d;
 	char* os = *s;
 	size_t odl = *dl, osl = *sl;
-	int w=ldns_wire2str_ipseckey_scan_internal(d, dl, s, sl, pkt, pktlen);
+	int w=sldns_wire2str_ipseckey_scan_internal(d, dl, s, sl, pkt, pktlen);
 	if(w == -1) {
 		*d = od;
 		*s = os;
@@ -1524,56 +1524,56 @@ int ldns_wire2str_ipseckey_scan(uint8_t** d, size_t* dl, char** s, size_t* sl,
 	return w;
 }
 
-int ldns_wire2str_int16_data_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_int16_data_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	uint16_t n;
 	if(*dl < 2)
 		return -1;
-	n = ldns_read_uint16(*d);
+	n = sldns_read_uint16(*d);
 	if(*dl < 2+(size_t)n)
 		return -1;
 	(*d)+=2;
 	(*dl)-=2;
-	return ldns_wire2str_b64_scan_num(d, dl, s, sl, n);
+	return sldns_wire2str_b64_scan_num(d, dl, s, sl, n);
 }
 
-int ldns_wire2str_nsec3_next_owner_scan(uint8_t** d, size_t* dl, char** s,
+int sldns_wire2str_nsec3_next_owner_scan(uint8_t** d, size_t* dl, char** s,
 	size_t* sl)
 {
-	return ldns_wire2str_b32_ext_scan(d, dl, s, sl);
+	return sldns_wire2str_b32_ext_scan(d, dl, s, sl);
 }
 
-int ldns_wire2str_ilnp64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_ilnp64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w;
 	if(*dl < 8)
 		return -1;
-	w = ldns_str_print(s, sl, "%.4x:%.4x:%.4x:%.4x",
-		ldns_read_uint16(*d), ldns_read_uint16((*d)+2),
-		ldns_read_uint16((*d)+4), ldns_read_uint16((*d)+6));
+	w = sldns_str_print(s, sl, "%.4x:%.4x:%.4x:%.4x",
+		sldns_read_uint16(*d), sldns_read_uint16((*d)+2),
+		sldns_read_uint16((*d)+4), sldns_read_uint16((*d)+6));
 	(*d)+=8;
 	(*dl)-=8;
 	return w;
 }
 
-int ldns_wire2str_eui48_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_eui48_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w;
 	if(*dl < 6)
 		return -1;
-	w = ldns_str_print(s, sl, "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+	w = sldns_str_print(s, sl, "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
 		(*d)[0], (*d)[1], (*d)[2], (*d)[3], (*d)[4], (*d)[5]);
 	(*d)+=6;
 	(*dl)-=6;
 	return w;
 }
 
-int ldns_wire2str_eui64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_eui64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	int w;
 	if(*dl < 8)
 		return -1;
-	w = ldns_str_print(s, sl, "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+	w = sldns_str_print(s, sl, "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
 		(*d)[0], (*d)[1], (*d)[2], (*d)[3], (*d)[4], (*d)[5],
 		(*d)[6], (*d)[7]);
 	(*d)+=8;
@@ -1581,7 +1581,7 @@ int ldns_wire2str_eui64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 	return w;
 }
 
-int ldns_wire2str_tag_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_tag_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	size_t i, n;
 	int w = 0;
@@ -1594,26 +1594,26 @@ int ldns_wire2str_tag_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 		if(!isalnum((int)(*d)[i]))
 			return -1;
 	for(i=0; i<n; i++)
-		w += ldns_str_print(s, sl, "%c", (char)(*d)[i]);
+		w += sldns_str_print(s, sl, "%c", (char)(*d)[i]);
 	(*d)+=n+1;
 	(*dl)-=(n+1);
 	return w;
 }
 
-int ldns_wire2str_long_str_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
+int sldns_wire2str_long_str_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 {
 	size_t i;
 	int w = 0;
-	w += ldns_str_print(s, sl, "\"");
+	w += sldns_str_print(s, sl, "\"");
 	for(i=0; i<*dl; i++)
 		w += str_char_print(s, sl, (char)(*d)[i]);
-	w += ldns_str_print(s, sl, "\"");
+	w += sldns_str_print(s, sl, "\"");
 	(*d)+=*dl;
 	(*dl)=0;
 	return w;
 }
 
-int ldns_wire2str_edns_llq_print(char** s, size_t* sl, uint8_t* data,
+int sldns_wire2str_edns_llq_print(char** s, size_t* sl, uint8_t* data,
 	size_t len)
 {
 	/* LLQ constants */
@@ -1629,45 +1629,45 @@ int ldns_wire2str_edns_llq_print(char** s, size_t* sl, uint8_t* data,
 
 	/* read the record */
 	if(len != 18) {
-		w += ldns_str_print(s, sl, "malformed LLQ ");
+		w += sldns_str_print(s, sl, "malformed LLQ ");
 		w += print_hex_buf(s, sl, data, len);
 		return w;
 	}
-	version = ldns_read_uint16(data);
-	llq_opcode = ldns_read_uint16(data+2);
-	error_code = ldns_read_uint16(data+4);
+	version = sldns_read_uint16(data);
+	llq_opcode = sldns_read_uint16(data+2);
+	error_code = sldns_read_uint16(data+4);
 	memmove(&llq_id, data+6, sizeof(llq_id));
-	lease_life = ldns_read_uint32(data+14);
+	lease_life = sldns_read_uint32(data+14);
 
 	/* print it */
-	w += ldns_str_print(s, sl, "v%d ", (int)version);
+	w += sldns_str_print(s, sl, "v%d ", (int)version);
 	if(llq_opcode < llq_opcodes_num)
-		w += ldns_str_print(s, sl, "%s", llq_opcodes[llq_opcode]);
-	else	w += ldns_str_print(s, sl, "opcode %d", (int)llq_opcode);
+		w += sldns_str_print(s, sl, "%s", llq_opcodes[llq_opcode]);
+	else	w += sldns_str_print(s, sl, "opcode %d", (int)llq_opcode);
 	if(error_code < llq_errors_num)
-		w += ldns_str_print(s, sl, " %s", llq_errors[error_code]);
-	else	w += ldns_str_print(s, sl, " error %d", (int)error_code);
-	w += ldns_str_print(s, sl, " id %llx lease-life %lu",
+		w += sldns_str_print(s, sl, " %s", llq_errors[error_code]);
+	else	w += sldns_str_print(s, sl, " error %d", (int)error_code);
+	w += sldns_str_print(s, sl, " id %llx lease-life %lu",
 		(unsigned long long)llq_id, (unsigned long)lease_life);
 	return w;
 }
 
-int ldns_wire2str_edns_ul_print(char** s, size_t* sl, uint8_t* data,
+int sldns_wire2str_edns_ul_print(char** s, size_t* sl, uint8_t* data,
 	size_t len)
 {
 	uint32_t lease;
 	int w = 0;
 	if(len != 4) {
-		w += ldns_str_print(s, sl, "malformed UL ");
+		w += sldns_str_print(s, sl, "malformed UL ");
 		w += print_hex_buf(s, sl, data, len);
 		return w;
 	}
-	lease = ldns_read_uint32(data);
-	w += ldns_str_print(s, sl, "lease %lu", (unsigned long)lease);
+	lease = sldns_read_uint32(data);
+	w += sldns_str_print(s, sl, "lease %lu", (unsigned long)lease);
 	return w;
 }
 
-int ldns_wire2str_edns_nsid_print(char** s, size_t* sl, uint8_t* data,
+int sldns_wire2str_edns_nsid_print(char** s, size_t* sl, uint8_t* data,
 	size_t len)
 {
 	int w = 0;
@@ -1676,72 +1676,72 @@ int ldns_wire2str_edns_nsid_print(char** s, size_t* sl, uint8_t* data,
 	for(i=0; i<len; i++) {
 		if(isprint((int)data[i]) || data[i] == '\t') {
 			if(!printed) {
-				w += ldns_str_print(s, sl, " (");
+				w += sldns_str_print(s, sl, " (");
 				printed = 1;
 			}
-			w += ldns_str_print(s, sl, "%c", (char)data[i]);
+			w += sldns_str_print(s, sl, "%c", (char)data[i]);
 		}
 	}
 	if(printed)
-		w += ldns_str_print(s, sl, ")");
+		w += sldns_str_print(s, sl, ")");
 	return w;
 }
 
-int ldns_wire2str_edns_dau_print(char** s, size_t* sl, uint8_t* data,
+int sldns_wire2str_edns_dau_print(char** s, size_t* sl, uint8_t* data,
 	size_t len)
 {
-	ldns_lookup_table *lt;
+	sldns_lookup_table *lt;
 	size_t i;
 	int w = 0;
 	for(i=0; i<len; i++) {
-		lt = ldns_lookup_by_id(SLDNS(_algorithms), (int)data[i]);
+		lt = sldns_lookup_by_id(sldns_algorithms, (int)data[i]);
 		if(lt && lt->name)
-			w += ldns_str_print(s, sl, " %s", lt->name);
-		else 	w += ldns_str_print(s, sl, " %d", (int)data[i]);
+			w += sldns_str_print(s, sl, " %s", lt->name);
+		else 	w += sldns_str_print(s, sl, " %d", (int)data[i]);
 	}
 	return w;
 }
 
-int ldns_wire2str_edns_dhu_print(char** s, size_t* sl, uint8_t* data,
+int sldns_wire2str_edns_dhu_print(char** s, size_t* sl, uint8_t* data,
 	size_t len)
 {
-	ldns_lookup_table *lt;
+	sldns_lookup_table *lt;
 	size_t i;
 	int w = 0;
 	for(i=0; i<len; i++) {
-		lt = ldns_lookup_by_id(SLDNS(_hashes), (int)data[i]);
+		lt = sldns_lookup_by_id(sldns_hashes, (int)data[i]);
 		if(lt && lt->name)
-			w += ldns_str_print(s, sl, " %s", lt->name);
-		else 	w += ldns_str_print(s, sl, " %d", (int)data[i]);
+			w += sldns_str_print(s, sl, " %s", lt->name);
+		else 	w += sldns_str_print(s, sl, " %d", (int)data[i]);
 	}
 	return w;
 }
 
-int ldns_wire2str_edns_n3u_print(char** s, size_t* sl, uint8_t* data,
+int sldns_wire2str_edns_n3u_print(char** s, size_t* sl, uint8_t* data,
 	size_t len)
 {
 	size_t i;
 	int w = 0;
 	for(i=0; i<len; i++) {
 		if(data[i] == 1)
-			w += ldns_str_print(s, sl, " SHA1");
-		else 	w += ldns_str_print(s, sl, " %d", (int)data[i]);
+			w += sldns_str_print(s, sl, " SHA1");
+		else 	w += sldns_str_print(s, sl, " %d", (int)data[i]);
 	}
 	return w;
 }
 
-int ldns_wire2str_edns_subnet_print(char** s, size_t* sl, uint8_t* data,
+int sldns_wire2str_edns_subnet_print(char** s, size_t* sl, uint8_t* data,
 	size_t len)
 {
 	int w = 0;
 	uint16_t family;
 	uint8_t source, scope;
 	if(len < 4) {
-		w += ldns_str_print(s, sl, "malformed subnet ");
+		w += sldns_str_print(s, sl, "malformed subnet ");
 		w += print_hex_buf(s, sl, data, len);
 		return w;
 	}
-	family = ldns_read_uint16(data);
+	family = sldns_read_uint16(data);
 	source = data[2];
 	scope = data[3];
 	if(family == 1) {
@@ -1750,17 +1750,17 @@ int ldns_wire2str_edns_subnet_print(char** s, size_t* sl, uint8_t* data,
 		uint8_t ip4[4];
 		memset(ip4, 0, sizeof(ip4));
 		if(len-4 > 4) {
-			w += ldns_str_print(s, sl, "trailingdata:");
+			w += sldns_str_print(s, sl, "trailingdata:");
 			w += print_hex_buf(s, sl, data+4+4, len-4-4);
-			w += ldns_str_print(s, sl, " ");
+			w += sldns_str_print(s, sl, " ");
 			len = 4+4;
 		}
 		memmove(ip4, data+4, len-4);
 		if(!inet_ntop(AF_INET, ip4, buf, (socklen_t)sizeof(buf))) {
-			w += ldns_str_print(s, sl, "ip4ntoperror ");
+			w += sldns_str_print(s, sl, "ip4ntoperror ");
 			w += print_hex_buf(s, sl, data+4+4, len-4-4);
 		} else {
-			w += ldns_str_print(s, sl, "%s", buf);
+			w += sldns_str_print(s, sl, "%s", buf);
 		}
 	} else if(family == 2) {
 		/* IP6 */
@@ -1768,59 +1768,59 @@ int ldns_wire2str_edns_subnet_print(char** s, size_t* sl, uint8_t* data,
 		uint8_t ip6[16];
 		memset(ip6, 0, sizeof(ip6));
 		if(len-4 > 16) {
-			w += ldns_str_print(s, sl, "trailingdata:");
+			w += sldns_str_print(s, sl, "trailingdata:");
 			w += print_hex_buf(s, sl, data+4+16, len-4-16);
-			w += ldns_str_print(s, sl, " ");
+			w += sldns_str_print(s, sl, " ");
 			len = 4+16;
 		}
 		memmove(ip6, data+4, len-4);
 #ifdef AF_INET6
 		if(!inet_ntop(AF_INET6, ip6, buf, (socklen_t)sizeof(buf))) {
-			w += ldns_str_print(s, sl, "ip6ntoperror ");
+			w += sldns_str_print(s, sl, "ip6ntoperror ");
 			w += print_hex_buf(s, sl, data+4+4, len-4-4);
 		} else {
-			w += ldns_str_print(s, sl, "%s", buf);
+			w += sldns_str_print(s, sl, "%s", buf);
 		}
 #else
 		w += print_hex_buf(s, sl, data+4+4, len-4-4);
 #endif
 	} else {
 		/* unknown */
-		w += ldns_str_print(s, sl, "family %d ",
+		w += sldns_str_print(s, sl, "family %d ",
 			(int)family);
 		w += print_hex_buf(s, sl, data, len);
 	}
-	w += ldns_str_print(s, sl, "/%d scope /%d", (int)source, (int)scope);
+	w += sldns_str_print(s, sl, "/%d scope /%d", (int)source, (int)scope);
 	return w;
 }
 
-int ldns_wire2str_edns_option_print(char** s, size_t* sl,
+int sldns_wire2str_edns_option_print(char** s, size_t* sl,
 	uint16_t option_code, uint8_t* optdata, size_t optlen)
 {
 	int w = 0;
-	w += ldns_wire2str_edns_option_code_print(s, sl, option_code);
-	w += ldns_str_print(s, sl, ": ");
+	w += sldns_wire2str_edns_option_code_print(s, sl, option_code);
+	w += sldns_str_print(s, sl, ": ");
 	switch(option_code) {
 	case LDNS_EDNS_LLQ:
-		w += ldns_wire2str_edns_llq_print(s, sl, optdata, optlen);
+		w += sldns_wire2str_edns_llq_print(s, sl, optdata, optlen);
 		break;
 	case LDNS_EDNS_UL:
-		w += ldns_wire2str_edns_ul_print(s, sl, optdata, optlen);
+		w += sldns_wire2str_edns_ul_print(s, sl, optdata, optlen);
 		break;
 	case LDNS_EDNS_NSID:
-		w += ldns_wire2str_edns_nsid_print(s, sl, optdata, optlen);
+		w += sldns_wire2str_edns_nsid_print(s, sl, optdata, optlen);
 		break;
 	case LDNS_EDNS_DAU:
-		w += ldns_wire2str_edns_dau_print(s, sl, optdata, optlen);
+		w += sldns_wire2str_edns_dau_print(s, sl, optdata, optlen);
 		break;
 	case LDNS_EDNS_DHU:
-		w += ldns_wire2str_edns_dhu_print(s, sl, optdata, optlen);
+		w += sldns_wire2str_edns_dhu_print(s, sl, optdata, optlen);
 		break;
 	case LDNS_EDNS_N3U:
-		w += ldns_wire2str_edns_n3u_print(s, sl, optdata, optlen);
+		w += sldns_wire2str_edns_n3u_print(s, sl, optdata, optlen);
 		break;
 	case LDNS_EDNS_CLIENT_SUBNET:
-		w += ldns_wire2str_edns_subnet_print(s, sl, optdata, optlen);
+		w += sldns_wire2str_edns_subnet_print(s, sl, optdata, optlen);
 		break;
 	default:
 		/* unknown option code */
@@ -1839,26 +1839,26 @@ print_edns_opts(char** s, size_t* sl, uint8_t* rdata, size_t rdatalen)
 	while(rdatalen > 0) {
 		/* option name */
 		if(rdatalen < 4) {
-			w += ldns_str_print(s, sl, " ; malformed: ");
+			w += sldns_str_print(s, sl, " ; malformed: ");
 			w += print_hex_buf(s, sl, rdata, rdatalen);
 			return w;
 		}
-		option_code = ldns_read_uint16(rdata);
-		option_len = ldns_read_uint16(rdata+2);
+		option_code = sldns_read_uint16(rdata);
+		option_len = sldns_read_uint16(rdata+2);
 		rdata += 4;
 		rdatalen -= 4;
 
 		/* option value */
 		if(rdatalen < (size_t)option_len) {
-			w += ldns_str_print(s, sl, " ; malformed ");
-			w += ldns_wire2str_edns_option_code_print(s, sl,
+			w += sldns_str_print(s, sl, " ; malformed ");
+			w += sldns_wire2str_edns_option_code_print(s, sl,
 				option_code);
-			w += ldns_str_print(s, sl, ": ");
+			w += sldns_str_print(s, sl, ": ");
 			w += print_hex_buf(s, sl, rdata, rdatalen);
 			return w;
 		}
-		w += ldns_str_print(s, sl, " ; ");
-		w += ldns_wire2str_edns_option_print(s, sl, option_code,
+		w += sldns_str_print(s, sl, " ; ");
+		w += sldns_wire2str_edns_option_print(s, sl, option_code,
 			rdata, option_len);
 		rdata += option_len;
 		rdatalen -= option_len;
@@ -1866,13 +1866,13 @@ print_edns_opts(char** s, size_t* sl, uint8_t* rdata, size_t rdatalen)
 	return w;
 }
 
-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)
 {
 	int w = 0;
 	uint8_t ext_rcode, edns_version;
 	uint16_t udpsize, edns_bits, rdatalen;
-	w += ldns_str_print(str, str_len, "; EDNS:");
+	w += sldns_str_print(str, str_len, "; EDNS:");
 
 	/* some input checks, domain name */
 	if(*data_len < 1+10)
@@ -1886,36 +1886,36 @@ int ldns_wire2str_edns_scan(uint8_t** data, size_t* data_len, char** str,
 	(*data_len)--;
 
 	/* check type and read fixed contents */
-	if(ldns_read_uint16((*data)) != LDNS_RR_TYPE_OPT) {
+	if(sldns_read_uint16((*data)) != LDNS_RR_TYPE_OPT) {
 		return w + print_remainder_hex("Error nottypeOPT 0x",
 			data, data_len, str, str_len);
 	}
-	udpsize = ldns_read_uint16((*data)+2);
+	udpsize = sldns_read_uint16((*data)+2);
 	ext_rcode = (*data)[4];
 	edns_version = (*data)[5];
-	edns_bits = ldns_read_uint16((*data)+6);
-	rdatalen = ldns_read_uint16((*data)+8);
+	edns_bits = sldns_read_uint16((*data)+6);
+	rdatalen = sldns_read_uint16((*data)+8);
 	(*data)+=10;
 	(*data_len)-=10;
 
-	w += ldns_str_print(str, str_len, " version: %u;",
+	w += sldns_str_print(str, str_len, " version: %u;",
 		(unsigned)edns_version);
-	w += ldns_str_print(str, str_len, " flags:");
+	w += sldns_str_print(str, str_len, " flags:");
 	if((edns_bits & LDNS_EDNS_MASK_DO_BIT))
-		w += ldns_str_print(str, str_len, " do");
+		w += sldns_str_print(str, str_len, " do");
 	/* the extended rcode is the value set, shifted four bits,
 	 * and or'd with the original rcode */
 	if(ext_rcode) {
 		int rc = ((int)ext_rcode)<<4;
 		if(pkt && pktlen >= LDNS_HEADER_SIZE)
 			rc |= LDNS_RCODE_WIRE(pkt);
-		w += ldns_str_print(str, str_len, " ; ext-rcode: %d", rc);
+		w += sldns_str_print(str, str_len, " ; ext-rcode: %d", rc);
 	}
-	w += ldns_str_print(str, str_len, " ; udp: %u", (unsigned)udpsize);
+	w += sldns_str_print(str, str_len, " ; udp: %u", (unsigned)udpsize);
 
 	if(rdatalen) {
 		if(*data_len < rdatalen) {
-			w += ldns_str_print(str, str_len,
+			w += sldns_str_print(str, str_len,
 				" ; Error EDNS rdata too short; ");
 			rdatalen = *data_len;
 		}
@@ -1923,6 +1923,6 @@ int ldns_wire2str_edns_scan(uint8_t** data, size_t* data_len, char** str,
 		(*data) += rdatalen;
 		(*data_len) -= rdatalen;
 	}
-	w += ldns_str_print(str, str_len, "\n");
+	w += sldns_str_print(str, str_len, "\n");
 	return w;
 }
diff --git a/ldns/wire2str.h b/ldns/wire2str.h
index 5448e6115..072d01292 100644
--- a/ldns/wire2str.h
+++ b/ldns/wire2str.h
@@ -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
diff --git a/libunbound/context.c b/libunbound/context.c
index 44862648b..12858e262 100644
--- a/libunbound/context.c
+++ b/libunbound/context.c
@@ -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;
 }
diff --git a/libunbound/context.h b/libunbound/context.h
index a08353982..34374337b 100644
--- a/libunbound/context.h
+++ b/libunbound/context.h
@@ -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
diff --git a/libunbound/libunbound.c b/libunbound/libunbound.c
index 3ec9196fe..dfcce0f8f 100644
--- a/libunbound/libunbound.c
+++ b/libunbound/libunbound.c
@@ -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;
diff --git a/libunbound/libworker.c b/libunbound/libworker.c
index 74a6476e3..2f20d830e 100644
--- a/libunbound/libworker.c
+++ b/libunbound/libworker.c
@@ -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, 
diff --git a/libunbound/libworker.h b/libunbound/libworker.h
index 509ffd026..6bd9fe9b0 100644
--- a/libunbound/libworker.h
+++ b/libunbound/libworker.h
@@ -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 */
diff --git a/pythonmod/pythonmod_utils.c b/pythonmod/pythonmod_utils.c
index 966cbc6d6..2f3848008 100644
--- a/pythonmod/pythonmod_utils.c
+++ b/pythonmod/pythonmod_utils.c
@@ -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;
diff --git a/pythonmod/pythonmod_utils.h b/pythonmod/pythonmod_utils.h
index a1641d308..a901f391a 100644
--- a/pythonmod/pythonmod_utils.h
+++ b/pythonmod/pythonmod_utils.h
@@ -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
diff --git a/services/cache/dns.c b/services/cache/dns.c
index 9e9222c65..d930b4709 100644
--- a/services/cache/dns.c
+++ b/services/cache/dns.c
@@ -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 ++;
diff --git a/services/listen_dnsport.c b/services/listen_dnsport.c
index b27c9fff9..f37c3fc26 100644
--- a/services/listen_dnsport.c
+++ b/services/listen_dnsport.c
@@ -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);
diff --git a/services/listen_dnsport.h b/services/listen_dnsport.h
index 106ad8423..28274c937 100644
--- a/services/listen_dnsport.h
+++ b/services/listen_dnsport.h
@@ -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;
diff --git a/services/localzone.c b/services/localzone.c
index ef138b9e0..29df15fae 100644
--- a/services/localzone.c
+++ b/services/localzone.c
@@ -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 
diff --git a/services/localzone.h b/services/localzone.h
index ec707a338..68100ea7f 100644
--- a/services/localzone.h
+++ b/services/localzone.h
@@ -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.
diff --git a/services/mesh.c b/services/mesh.c
index e225e6162..c40efdb23 100644
--- a/services/mesh.c
+++ b/services/mesh.c
@@ -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);
diff --git a/services/mesh.h b/services/mesh.h
index dc9e6a1e2..1a4cfb524 100644
--- a/services/mesh.h
+++ b/services/mesh.h
@@ -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.
diff --git a/services/outside_network.c b/services/outside_network.c
index b5e3b3ae6..ebb35156a 100644
--- a/services/outside_network.c
+++ b/services/outside_network.c
@@ -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);
diff --git a/services/outside_network.h b/services/outside_network.h
index 3d294155f..ece06c093 100644
--- a/services/outside_network.h
+++ b/services/outside_network.h
@@ -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.
diff --git a/smallapp/unbound-checkconf.c b/smallapp/unbound-checkconf.c
index 77d2e2e1f..47c1d2a9d 100644
--- a/smallapp/unbound-checkconf.c
+++ b/smallapp/unbound-checkconf.c
@@ -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);
 }
 
diff --git a/smallapp/unbound-host.c b/smallapp/unbound-host.c
index c3fb58a12..d7748857d 100644
--- a/smallapp/unbound-host.c
+++ b/smallapp/unbound-host.c
@@ -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) {
diff --git a/smallapp/worker_cb.c b/smallapp/worker_cb.c
index ccf9b5910..2d4a3576a 100644
--- a/smallapp/worker_cb.c
+++ b/smallapp/worker_cb.c
@@ -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);
diff --git a/testcode/delayer.c b/testcode/delayer.c
index 0c15b5e31..db705cf96 100644
--- a/testcode/delayer.c
+++ b/testcode/delayer.c
@@ -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);
 }
 
diff --git a/testcode/fake_event.c b/testcode/fake_event.c
index d16c0dcc2..c52456bdf 100644
--- a/testcode/fake_event.c
+++ b/testcode/fake_event.c
@@ -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);
diff --git a/testcode/perf.c b/testcode/perf.c
index 19ce20509..32121219e 100644
--- a/testcode/perf.c
+++ b/testcode/perf.c
@@ -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
diff --git a/testcode/pktview.c b/testcode/pktview.c
index 7be2476fa..87962c5f7 100644
--- a/testcode/pktview.c
+++ b/testcode/pktview.c
@@ -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;
 }
diff --git a/testcode/readhex.c b/testcode/readhex.c
index 886920a91..eb59e71a6 100644
--- a/testcode/readhex.c
+++ b/testcode/readhex.c
@@ -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);
 }
 
diff --git a/testcode/readhex.h b/testcode/readhex.h
index eb053d26f..867f797ff 100644
--- a/testcode/readhex.h
+++ b/testcode/readhex.h
@@ -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 */
diff --git a/testcode/replay.c b/testcode/replay.c
index b589e1347..41c01c69f 100644
--- a/testcode/replay.c
+++ b/testcode/replay.c
@@ -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;
diff --git a/testcode/replay.h b/testcode/replay.h
index 09ec9a6e1..9d56313dd 100644
--- a/testcode/replay.h
+++ b/testcode/replay.h
@@ -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 */
diff --git a/testcode/signit.c b/testcode/signit.c
index 7b40bb46c..0523d3a96 100644
--- a/testcode/signit.c
+++ b/testcode/signit.c
@@ -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 */
diff --git a/testcode/streamtcp.c b/testcode/streamtcp.c
index 7d4bd8cb8..735a96cb9 100644
--- a/testcode/streamtcp.c
+++ b/testcode/streamtcp.c
@@ -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");
 }
 
diff --git a/testcode/testbound.c b/testcode/testbound.c
index 9a53fe118..46a4859f9 100644
--- a/testcode/testbound.c
+++ b/testcode/testbound.c
@@ -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 {
diff --git a/testcode/testpkts.c b/testcode/testpkts.c
index 3ad24727a..c5aa24453 100644
--- a/testcode/testpkts.c
+++ b/testcode/testpkts.c
@@ -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;
 	}
diff --git a/testcode/testpkts.h b/testcode/testpkts.h
index 77293eedd..864f33fee 100644
--- a/testcode/testpkts.h
+++ b/testcode/testpkts.h
@@ -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.
diff --git a/testcode/unitanchor.c b/testcode/unitanchor.c
index e8ee0f7a8..23511b091 100644
--- a/testcode/unitanchor.c
+++ b/testcode/unitanchor.c
@@ -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);
 }
diff --git a/testcode/unitdname.c b/testcode/unitdname.c
index 50f082353..7fdaece14 100644
--- a/testcode/unitdname.c
+++ b/testcode/unitdname.c
@@ -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);
-
-	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(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);
+
+	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);
 }
diff --git a/testcode/unitmain.c b/testcode/unitmain.c
index 40cf29623..7ac370bc3 100644
--- a/testcode/unitmain.c
+++ b/testcode/unitmain.c
@@ -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();
diff --git a/testcode/unitmsgparse.c b/testcode/unitmsgparse.c
index 9de637897..14777aa90 100644
--- a/testcode/unitmsgparse.c
+++ b/testcode/unitmsgparse.c
@@ -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);
 }
diff --git a/testcode/unitverify.c b/testcode/unitverify.c
index a26497513..8719ef96b 100644
--- a/testcode/unitverify.c
+++ b/testcode/unitverify.c
@@ -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
diff --git a/util/alloc.c b/util/alloc.c
index b5ccd96b4..08f1ed48e 100644
--- a/util/alloc.c
+++ b/util/alloc.c
@@ -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__);
diff --git a/util/alloc.h b/util/alloc.h
index cb8d6b1bc..3ffebd3c5 100644
--- a/util/alloc.h
+++ b/util/alloc.h
@@ -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 */
diff --git a/util/config_file.c b/util/config_file.c
index a804877d4..e01d0991f 100644
--- a/util/config_file.c
+++ b/util/config_file.c
@@ -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);
diff --git a/util/data/dname.c b/util/data/dname.c
index 8ee9d8a2d..458dac088 100644
--- a/util/data/dname.c
+++ b/util/data/dname.c
@@ -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;
 }
diff --git a/util/data/dname.h b/util/data/dname.h
index d7163289d..b3581d64f 100644
--- a/util/data/dname.h
+++ b/util/data/dname.h
@@ -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
diff --git a/util/data/msgencode.c b/util/data/msgencode.c
index 66c45dfd0..c14561f9f 100644
--- a/util/data/msgencode.c
+++ b/util/data/msgencode.c
@@ -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);
diff --git a/util/data/msgencode.h b/util/data/msgencode.h
index a55693976..ed5dc9812 100644
--- a/util/data/msgencode.h
+++ b/util/data/msgencode.h
@@ -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 */
diff --git a/util/data/msgparse.c b/util/data/msgparse.c
index e6068eafe..7f2e1e1e7 100644
--- a/util/data/msgparse.c
+++ b/util/data/msgparse.c
@@ -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;
 }
diff --git a/util/data/msgparse.h b/util/data/msgparse.h
index d0f6bb5aa..ed0271686 100644
--- a/util/data/msgparse.h
+++ b/util/data/msgparse.h
@@ -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);
 
 /**
diff --git a/util/data/msgreply.c b/util/data/msgreply.c
index 25f0af155..a3d206576 100644
--- a/util/data/msgreply.c
+++ b/util/data/msgreply.c
@@ -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);
 }
 
diff --git a/util/data/msgreply.h b/util/data/msgreply.h
index a894d3287..4dc339e16 100644
--- a/util/data/msgreply.h
+++ b/util/data/msgreply.h
@@ -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);
 
diff --git a/util/data/packed_rrset.c b/util/data/packed_rrset.c
index d9c2f308a..cc5455a79 100644
--- a/util/data/packed_rrset.c
+++ b/util/data/packed_rrset.c
@@ -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;
diff --git a/util/log.c b/util/log.c
index 91387161c..f4b63cbad 100644
--- a/util/log.c
+++ b/util/log.c
@@ -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
diff --git a/util/log.h b/util/log.h
index 2ca88d0b6..c3f0999ea 100644
--- a/util/log.h
+++ b/util/log.h
@@ -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.
diff --git a/util/module.h b/util/module.h
index f1f03b190..370eb972f 100644
--- a/util/module.h
+++ b/util/module.h
@@ -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 */
diff --git a/util/net_help.c b/util/net_help.c
index 597759e68..079efb1a9 100644
--- a/util/net_help.c
+++ b/util/net_help.c
@@ -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;
diff --git a/util/netevent.c b/util/netevent.c
index 1a30a6145..4ba521447 100644
--- a/util/netevent.c
+++ b/util/netevent.c
@@ -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++)
diff --git a/util/netevent.h b/util/netevent.h
index de00cc063..a6ab0596e 100644
--- a/util/netevent.h
+++ b/util/netevent.h
@@ -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);
 
 /**
diff --git a/validator/autotrust.c b/validator/autotrust.c
index 176fa153d..c31415429 100644
--- a/validator/autotrust.c
+++ b/validator/autotrust.c
@@ -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 */
diff --git a/validator/autotrust.h b/validator/autotrust.h
index c5dc3bab9..3dbd1ee56 100644
--- a/validator/autotrust.h
+++ b/validator/autotrust.h
@@ -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 */
diff --git a/validator/val_anchor.c b/validator/val_anchor.c
index b3a72b2c5..a3cb1b578 100644
--- a/validator/val_anchor.c
+++ b/validator/val_anchor.c
@@ -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;
 }
diff --git a/validator/val_anchor.h b/validator/val_anchor.h
index 59f754375..2736c6b93 100644
--- a/validator/val_anchor.h
+++ b/validator/val_anchor.h
@@ -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
diff --git a/validator/val_kentry.c b/validator/val_kentry.c
index 6885e8483..0f93d159b 100644
--- a/validator/val_kentry.c
+++ b/validator/val_kentry.c
@@ -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 */
diff --git a/validator/val_neg.c b/validator/val_neg.c
index 31e1197cd..781a5c275 100644
--- a/validator/val_neg.c
+++ b/validator/val_neg.c
@@ -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;
diff --git a/validator/val_neg.h b/validator/val_neg.h
index deed680fb..b26a048c9 100644
--- a/validator/val_neg.h
+++ b/validator/val_neg.h
@@ -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);
 
 
diff --git a/validator/val_nsec3.c b/validator/val_nsec3.c
index 1167776d8..c1283aab3 100644
--- a/validator/val_nsec3.c
+++ b/validator/val_nsec3.c
@@ -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)
diff --git a/validator/val_nsec3.h b/validator/val_nsec3.h
index 48cec2bf7..bf3a0fa86 100644
--- a/validator/val_nsec3.h
+++ b/validator/val_nsec3.h
@@ -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 */
diff --git a/validator/val_secalgo.c b/validator/val_secalgo.c
index c61a22234..fc45b01d6 100644
--- a/validator/val_secalgo.c
+++ b/validator/val_secalgo.c
@@ -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;
diff --git a/validator/val_secalgo.h b/validator/val_secalgo.h
index 593b7af4f..b1e00e86b 100644
--- a/validator/val_secalgo.h
+++ b/validator/val_secalgo.h
@@ -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);
 
diff --git a/validator/val_sigcrypt.c b/validator/val_sigcrypt.c
index 2ddad587c..c259586be 100644
--- a/validator/val_sigcrypt.c
+++ b/validator/val_sigcrypt.c
@@ -290,7 +290,7 @@ ds_create_dnskey_digest(struct module_env* env,
 	struct ub_packed_rrset_key* ds_rrset, size_t ds_idx,
 	uint8_t* digest)
 {
-	ldns_buffer* b = env->scratch_buffer;
+	sldns_buffer* b = env->scratch_buffer;
 	uint8_t* dnskey_rdata;
 	size_t dnskey_len;
 	rrset_get_rdata(dnskey_rrset, dnskey_idx, &dnskey_rdata, &dnskey_len);
@@ -298,15 +298,15 @@ ds_create_dnskey_digest(struct module_env* env,
 	/* create digest source material in buffer 
 	 * digest = digest_algorithm( DNSKEY owner name | DNSKEY RDATA);
 	 *	DNSKEY RDATA = Flags | Protocol | Algorithm | Public Key. */
-	ldns_buffer_clear(b);
-	ldns_buffer_write(b, dnskey_rrset->rk.dname, 
+	sldns_buffer_clear(b);
+	sldns_buffer_write(b, dnskey_rrset->rk.dname, 
 		dnskey_rrset->rk.dname_len);
-	query_dname_tolower(ldns_buffer_begin(b));
-	ldns_buffer_write(b, dnskey_rdata+2, dnskey_len-2); /* skip rdatalen*/
-	ldns_buffer_flip(b);
+	query_dname_tolower(sldns_buffer_begin(b));
+	sldns_buffer_write(b, dnskey_rdata+2, dnskey_len-2); /* skip rdatalen*/
+	sldns_buffer_flip(b);
 	
 	return secalgo_ds_digest(ds_get_digest_algo(ds_rrset, ds_idx),
-		(unsigned char*)ldns_buffer_begin(b), ldns_buffer_limit(b),
+		(unsigned char*)sldns_buffer_begin(b), sldns_buffer_limit(b),
 		(unsigned char*)digest);
 }
 
@@ -370,7 +370,7 @@ dnskey_calc_keytag(struct ub_packed_rrset_key* dnskey_rrset, size_t dnskey_idx)
 	size_t len;
 	rrset_get_rdata(dnskey_rrset, dnskey_idx, &data, &len);
 	/* do not pass rdatalen to ldns */
-	return ldns_calc_keytag_raw(data+2, len-2);
+	return sldns_calc_keytag_raw(data+2, len-2);
 }
 
 int dnskey_algo_is_supported(struct ub_packed_rrset_key* dnskey_rrset,
@@ -534,7 +534,7 @@ dnskeyset_verify_rrset(struct module_env* env, struct val_env* ve,
 void algo_needs_reason(struct module_env* env, int alg, char** reason, char* s)
 {
 	char buf[256];
-	ldns_lookup_table *t = ldns_lookup_by_id(SLDNS(_algorithms), alg);
+	sldns_lookup_table *t = sldns_lookup_by_id(sldns_algorithms, alg);
 	if(t&&t->name)
 		snprintf(buf, sizeof(buf), "%s with algorithm %s", s, t->name);
 	else	snprintf(buf, sizeof(buf), "%s with algorithm ALG%u", s,
@@ -644,7 +644,7 @@ struct canon_rr {
  */
 static int
 canonical_compare_byfield(struct packed_rrset_data* d, 
-	const ldns_rr_descriptor* desc, size_t i, size_t j)
+	const sldns_rr_descriptor* desc, size_t i, size_t j)
 {
 	/* sweep across rdata, keep track of some state:
 	 * 	which rr field, and bytes left in field.
@@ -788,7 +788,7 @@ canonical_compare(struct ub_packed_rrset_key* rrset, size_t i, size_t j)
 {
 	struct packed_rrset_data* d = (struct packed_rrset_data*)
 		rrset->entry.data;
-	const ldns_rr_descriptor* desc;
+	const sldns_rr_descriptor* desc;
 	uint16_t type = ntohs(rrset->rk.type);
 	size_t minlen;
 	int c;
@@ -840,7 +840,7 @@ canonical_compare(struct ub_packed_rrset_key* rrset, size_t i, size_t j)
 		case LDNS_RR_TYPE_PX:
 		case LDNS_RR_TYPE_NAPTR:
 		case LDNS_RR_TYPE_SRV:
-			desc = ldns_rr_descript(type);
+			desc = sldns_rr_descript(type);
 			log_assert(desc);
 			/* this holds for the types that need canonicalizing */
 			log_assert(desc->_minimum == desc->_maximum);
@@ -913,15 +913,15 @@ canonical_sort(struct ub_packed_rrset_key* rrset, struct packed_rrset_data* d,
  * @param can_owner_len: length of canonical owner name.
  */
 static void
-insert_can_owner(ldns_buffer* buf, struct ub_packed_rrset_key* k,
+insert_can_owner(sldns_buffer* buf, struct ub_packed_rrset_key* k,
 	uint8_t* sig, uint8_t** can_owner, size_t* can_owner_len)
 {
 	int rrsig_labels = (int)sig[3];
 	int fqdn_labels = dname_signame_label_count(k->rk.dname);
-	*can_owner = ldns_buffer_current(buf);
+	*can_owner = sldns_buffer_current(buf);
 	if(rrsig_labels == fqdn_labels) {
 		/* no change */
-		ldns_buffer_write(buf, k->rk.dname, k->rk.dname_len);
+		sldns_buffer_write(buf, k->rk.dname, k->rk.dname_len);
 		query_dname_tolower(*can_owner);
 		*can_owner_len = k->rk.dname_len;
 		return;
@@ -937,8 +937,8 @@ insert_can_owner(ldns_buffer* buf, struct ub_packed_rrset_key* k,
 			dname_remove_label(&nm, &len);	
 		}
 		*can_owner_len = len+2;
-		ldns_buffer_write(buf, (uint8_t*)"\001*", 2);
-		ldns_buffer_write(buf, nm, len);
+		sldns_buffer_write(buf, (uint8_t*)"\001*", 2);
+		sldns_buffer_write(buf, nm, len);
 		query_dname_tolower(*can_owner);
 	}
 }
@@ -950,10 +950,10 @@ insert_can_owner(ldns_buffer* buf, struct ub_packed_rrset_key* k,
  * @param len: length of the rdata (including rdatalen uint16).
  */
 static void
-canonicalize_rdata(ldns_buffer* buf, struct ub_packed_rrset_key* rrset,
+canonicalize_rdata(sldns_buffer* buf, struct ub_packed_rrset_key* rrset,
 	size_t len)
 {
-	uint8_t* datstart = ldns_buffer_current(buf)-len+2;
+	uint8_t* datstart = sldns_buffer_current(buf)-len+2;
 	switch(ntohs(rrset->rk.type)) {
 		case LDNS_RR_TYPE_NXT: 
 		case LDNS_RR_TYPE_NS:
@@ -1120,7 +1120,7 @@ int rrset_canonical_equal(struct regional* region,
  * @return false on alloc error.
  */
 static int
-rrset_canonical(struct regional* region, ldns_buffer* buf, 
+rrset_canonical(struct regional* region, sldns_buffer* buf, 
 	struct ub_packed_rrset_key* k, uint8_t* sig, size_t siglen,
 	struct rbtree_t** sortree)
 {
@@ -1144,13 +1144,13 @@ rrset_canonical(struct regional* region, ldns_buffer* buf,
 		canonical_sort(k, d, *sortree, rrs);
 	}
 
-	ldns_buffer_clear(buf);
-	ldns_buffer_write(buf, sig, siglen);
+	sldns_buffer_clear(buf);
+	sldns_buffer_write(buf, sig, siglen);
 	/* canonicalize signer name */
-	query_dname_tolower(ldns_buffer_begin(buf)+18); 
+	query_dname_tolower(sldns_buffer_begin(buf)+18); 
 	RBTREE_FOR(walk, struct canon_rr*, (*sortree)) {
 		/* see if there is enough space left in the buffer */
-		if(ldns_buffer_remaining(buf) < can_owner_len + 2 + 2 + 4
+		if(sldns_buffer_remaining(buf) < can_owner_len + 2 + 2 + 4
 			+ d->rr_len[walk->rr_idx]) {
 			log_err("verify: failed to canonicalize, "
 				"rrset too big");
@@ -1158,17 +1158,17 @@ rrset_canonical(struct regional* region, ldns_buffer* buf,
 		}
 		/* determine canonical owner name */
 		if(can_owner)
-			ldns_buffer_write(buf, can_owner, can_owner_len);
+			sldns_buffer_write(buf, can_owner, can_owner_len);
 		else	insert_can_owner(buf, k, sig, &can_owner, 
 				&can_owner_len);
-		ldns_buffer_write(buf, &k->rk.type, 2);
-		ldns_buffer_write(buf, &k->rk.rrset_class, 2);
-		ldns_buffer_write(buf, sig+4, 4);
-		ldns_buffer_write(buf, d->rr_data[walk->rr_idx], 
+		sldns_buffer_write(buf, &k->rk.type, 2);
+		sldns_buffer_write(buf, &k->rk.rrset_class, 2);
+		sldns_buffer_write(buf, sig+4, 4);
+		sldns_buffer_write(buf, d->rr_data[walk->rr_idx], 
 			d->rr_len[walk->rr_idx]);
 		canonicalize_rdata(buf, k, d->rr_len[walk->rr_idx]);
 	}
-	ldns_buffer_flip(buf);
+	sldns_buffer_flip(buf);
 	return 1;
 }
 
@@ -1300,7 +1300,7 @@ adjust_ttl(struct val_env* ve, uint32_t unow,
 }
 
 enum sec_status 
-dnskey_verify_rrset_sig(struct regional* region, ldns_buffer* buf, 
+dnskey_verify_rrset_sig(struct regional* region, sldns_buffer* buf, 
 	struct val_env* ve, time_t now,
         struct ub_packed_rrset_key* rrset, struct ub_packed_rrset_key* dnskey,
         size_t dnskey_idx, size_t sig_idx,
diff --git a/validator/val_sigcrypt.h b/validator/val_sigcrypt.h
index c69706138..21be27e8d 100644
--- a/validator/val_sigcrypt.h
+++ b/validator/val_sigcrypt.h
@@ -49,7 +49,7 @@ struct module_env;
 struct ub_packed_rrset_key;
 struct rbtree_t;
 struct regional;
-struct ldns_buffer;
+struct sldns_buffer;
 
 /** number of entries in algorithm needs array */
 #define ALGO_NEEDS_MAX 256
@@ -299,7 +299,7 @@ enum sec_status dnskeyset_verify_rrset_sig(struct module_env* env,
  *	bogus if it did not validate.
  */
 enum sec_status dnskey_verify_rrset_sig(struct regional* region, 
-	struct ldns_buffer* buf, struct val_env* ve, time_t now,
+	struct sldns_buffer* buf, struct val_env* ve, time_t now,
 	struct ub_packed_rrset_key* rrset, struct ub_packed_rrset_key* dnskey, 
 	size_t dnskey_idx, size_t sig_idx,
 	struct rbtree_t** sortree, int* buf_canon, char** reason);
diff --git a/validator/validator.c b/validator/validator.c
index 2184df2f7..f669ce502 100644
--- a/validator/validator.c
+++ b/validator/validator.c
@@ -298,7 +298,7 @@ needs_validation(struct module_qstate* qstate, int ret_rc,
 		if(verbosity >= VERB_ALGO) {
 			char rc[16];
 			rc[0]=0;
-			(void)ldns_wire2str_rcode_buf(rcode, rc, sizeof(rc));
+			(void)sldns_wire2str_rcode_buf(rcode, rc, sizeof(rc));
 			verbose(VERB_ALGO, "cannot validate non-answer, rcode %s", rc);
 		}
 		return 0;
@@ -2350,7 +2350,7 @@ ds_response_to_ke(struct module_qstate* qstate, struct val_qstate* vq,
 	if(rcode != LDNS_RCODE_NOERROR) {
 		char rc[16];
 		rc[0]=0;
-		(void)ldns_wire2str_rcode_buf(rcode, rc, sizeof(rc));
+		(void)sldns_wire2str_rcode_buf(rcode, rc, sizeof(rc));
 		/* errors here pretty much break validation */
 		verbose(VERB_DETAIL, "DS response was error, thus bogus");
 		errinf(qstate, rc);
@@ -2528,7 +2528,7 @@ ds_response_to_ke(struct module_qstate* qstate, struct val_qstate* vq,
 		if(FLAGS_GET_RCODE(msg->rep->flags) != LDNS_RCODE_NOERROR) {
 			char rc[16];
 			rc[0]=0;
-			(void)ldns_wire2str_rcode_buf((int)FLAGS_GET_RCODE(
+			(void)sldns_wire2str_rcode_buf((int)FLAGS_GET_RCODE(
 				msg->rep->flags), rc, sizeof(rc));
 			errinf(qstate, rc);
 		} else	errinf(qstate, val_classification_to_string(subtype));
diff --git a/winrc/anchor-update.c b/winrc/anchor-update.c
index bdca174af..466632c26 100644
--- a/winrc/anchor-update.c
+++ b/winrc/anchor-update.c
@@ -80,17 +80,17 @@ do_lookup(struct ub_ctx* ctx, char* domain)
 }
 
 /** get answer into ldns rr list */
-static ldns_rr_list*
+static sldns_rr_list*
 result2answer(struct ub_result* result)
 {
-	ldns_pkt* p = NULL;
-	ldns_rr_list* a;
-	if(ldns_wire2pkt(&p, result->answer_packet, (size_t)result->answer_len) 
+	sldns_pkt* p = NULL;
+	sldns_rr_list* a;
+	if(sldns_wire2pkt(&p, result->answer_packet, (size_t)result->answer_len) 
 		!= LDNS_STATUS_OK) 
 		return NULL;
-	a = ldns_pkt_answer(p);
-	ldns_pkt_set_answer(p, NULL);
-	ldns_pkt_free(p);
+	a = sldns_pkt_answer(p);
+	sldns_pkt_set_answer(p, NULL);
+	sldns_pkt_free(p);
 	return a;
 }
 
@@ -99,7 +99,7 @@ static void
 do_print(struct ub_result* result, char* file)
 {
 	FILE* out;
-	ldns_rr_list* list = result2answer(result);
+	sldns_rr_list* list = result2answer(result);
 	if(!list) fatal("result2answer failed");
 	
 	out = fopen(file, "w");
@@ -107,9 +107,9 @@ do_print(struct ub_result* result, char* file)
 		perror(file);
 		fatal("fopen failed");
 	}
-	ldns_rr_list_print(out, list);
+	sldns_rr_list_print(out, list);
 	fclose(out);
-	ldns_rr_list_deep_free(list);
+	sldns_rr_list_deep_free(list);
 }
 
 /** update domain to file */