/** Use small-ldns codebase */
#define USE_SLDNS 1
+#define SLDNS sldns_
#ifdef HAVE_SSL
# define LDNS_BUILD_CONFIG_HAVE_SSL 1
#endif
/** Use small-ldns codebase */
#define USE_SLDNS 1
+#define SLDNS sldns_
#ifdef HAVE_SSL
# define LDNS_BUILD_CONFIG_HAVE_SSL 1
#endif
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);
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);
/** 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)
{
/* 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;
/* 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) {
/** 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;
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;
}
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) {
/** 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;
/** 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;
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;
}
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
/* 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
{
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) {
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 {
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 {
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 {
*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);
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);
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);
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);
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));
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);
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))
}
}
-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 ++;
}
}
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
* @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 */
+ 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)
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,
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");
* @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;
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:
* @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;
*/
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)
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;
}
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);
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;
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]++;
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;
}
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;
}
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)
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;
}
/* 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);
/* 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 >=
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;
}
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) {
/* 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;
}
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");
}
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);
}
void libworker_fg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
- ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
+ sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus))
{
log_assert(0);
}
void libworker_bg_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
- ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
+ sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus))
{
log_assert(0);
}
void libworker_event_done_cb(void* ATTR_UNUSED(arg), int ATTR_UNUSED(rcode),
- ldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
+ sldns_buffer* ATTR_UNUSED(buf), enum sec_status ATTR_UNUSED(s),
char* ATTR_UNUSED(why_bogus))
{
log_assert(0);
+3 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_ .
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))
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;
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);
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;
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;
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;
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);
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;
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);
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,
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);
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,
}
} 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);
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;
* @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;
/** 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) {
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)
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;
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;
#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;
* @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);
/**
/** 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
/** 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;
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;
/** 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. */
/** 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;
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));
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;
/** 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];
/** 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);
/** 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);
* @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;
* @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;
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;
* @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)
{
}
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)
{
#ifndef ITERATOR_ITER_SCRUB_H
#define ITERATOR_ITER_SCRUB_H
-struct ldns_buffer;
+struct sldns_buffer;
struct msg_parse;
struct query_info;
struct regional;
* @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);
}
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,
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);
#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;
* @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);
/**
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;
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");
{
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;
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;
#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 */
uint16_t exp;
uint16_t int16;
- switch ((ldns_algorithm)alg) {
+ switch ((sldns_algorithm)alg) {
case LDNS_DSA:
case LDNS_DSA_NSEC3:
if (len > 0) {
}
}
-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;
#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;
}
/* 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;
}
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;
#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,
#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;
#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;
* \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);
/**
* \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
/**
* 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.
* \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.
* \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.
* \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 */
#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" },
/* 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 */
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;
}
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 */
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;
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 {
}
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;
quoted = 1;
}
- while ((c = ldns_bgetc(b)) != EOF) {
+ while ((c = sldns_bgetc(b)) != EOF) {
if (c == '\r') /* carriage return */
c = ' ';
if (c == '(' && lc != '\\' && !quoted) {
return (ssize_t)i;
tokenread:
- ldns_bskipcs(b, del);
+ sldns_bskipcs(b, del);
*t = '\0';
if (!par && p != 0) {
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) {
}
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;
}
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 */
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 */
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);
#ifndef LDNS_PARSE_H
#define LDNS_PARSE_H
-struct ldns_buffer;
+struct sldns_buffer;
#ifdef __cplusplus
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.
* \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.
* \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.
* 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.
* \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
* \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
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
* \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.
* \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
* \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
* \param[in] *s characters to skip
* \return void
*/
-void ldns_fskipcs(FILE *fp, const char *s);
+void sldns_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
}
#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)
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)
* 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);
#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;
};
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) ?
}
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)
}
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);
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;
#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;
}
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;
}
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;
/** 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;
* (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)
}
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;
}
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);
}
*
* 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) {
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;
* 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.
* \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.
* \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).
* \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
* \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.
* \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);
/*
*
* @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,
* @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 */
#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,
/** 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,
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
}
#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" },
{ 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,
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,
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,
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,
* 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
* 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 */
#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) {
}
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;
}
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) {
}
}
-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);
}
}
-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) {
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) {
}
/* 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;
}
#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,
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,
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
/**
* The different types of RDATA fields.
*/
-enum ldns_enum_rdf_type
+enum sldns_enum_rdf_type
{
/** none */
LDNS_RDF_TYPE_NONE,
/* 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,
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,
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 */
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
*
* 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. */
/** 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.
* \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.
* \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.
* \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
}
/**
* \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;
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);
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;
}
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);
}
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;
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;
}
}
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;
}
void
-ldns_buffer_free(ldns_buffer *buffer)
+sldns_buffer_free(sldns_buffer *buffer)
{
if (!buffer) {
return;
}
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);
}
* (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);
}
INLINE uint32_t
-ldns_read_uint32(const void *src)
+sldns_read_uint32(const void *src)
{
#ifdef ALLOW_UNALIGNED_ACCESSES
return ntohl(*(uint32_t *) 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);
}
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);
/**
* \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;
* 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);
* \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
* \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.
* \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? */
* \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;
* 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;
}
* \return the current position
*/
INLINE size_t
-ldns_buffer_position(ldns_buffer *buffer)
+sldns_buffer_position(sldns_buffer *buffer)
{
return buffer->_position;
}
* \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;
* \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;
* \return the size
*/
INLINE size_t
-ldns_buffer_limit(ldns_buffer *buffer)
+sldns_buffer_limit(sldns_buffer *buffer)
{
return buffer->_limit;
}
* \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;
* \return the number of bytes
*/
INLINE size_t
-ldns_buffer_capacity(ldns_buffer *buffer)
+sldns_buffer_capacity(sldns_buffer *buffer)
{
return buffer->_capacity;
}
* \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
* \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.
* \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;
* \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);
}
/**
* \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);
}
/**
* \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);
}
/**
* \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;
}
* \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);
}
/**
* \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);
}
/**
* \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);
}
/**
* \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);
}
* \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;
}
* \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));
}
/**
* \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));
}
/**
* \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;
}
* \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);
}
* \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);
}
/**
* \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);
}
* \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);
}
/**
* \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);
}
* \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);
}
* \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;
}
* \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];
}
* \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;
}
* \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);
}
/**
* \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;
}
* \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);
}
/**
* \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;
}
* \return the status
*/
INLINE int
-ldns_buffer_status(ldns_buffer *buffer)
+sldns_buffer_status(sldns_buffer *buffer)
{
return (int)buffer->_status_err;
}
* \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;
}
* 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);
/**
* \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
* \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
* \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
}
* @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;
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);
}
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) {
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);
}
/** 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) {
}
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
}
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;
/** 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;
/** 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;
/** 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 :
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;
/** 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;
}
}
/* 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)++;
}
/** 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 ";
/* 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;
}
}
/** 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)
{
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;
* 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;
}
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;
}
}
}
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;
}
* 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)
{
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 */
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
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;
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,
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;
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);
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);
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;
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)
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];
#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;
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)
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;
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) {
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 */
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)
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 */
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++;
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;
/* 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) {
*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;
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;
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;
}
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;
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;
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;
}
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;
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)
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);
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)
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] == '-') {
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);
}
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];
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;
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;
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;
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;
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;
}
#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 */
/*
* 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
*/
* @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
* @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);
/**
* @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.
* @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.
* @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
* @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);
* @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.
* @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.
* @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.
* @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.
* @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.
* @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
#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
* @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. */
* 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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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
}
/* 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" },
{ 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" },
{ 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" },
{ 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" },
{ 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" },
{ 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" },
{ 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) {
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;
}
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;
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;
} 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;
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;
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;
}
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;
}
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 */
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) {
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 */
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;
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;
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;
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;
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 */
/* 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;
(*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;
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;
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];
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;
{
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)++;
}
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;
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);
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;
}
/** 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;
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;
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);
}
}
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;
(*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;
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;
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;
}
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;
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';
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) {
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;
(*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++) {
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);
}
}
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*/
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;
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;
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;
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;
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 */
/* 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;
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) {
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 */
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 */
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;
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)
(*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;
}
(*data) += rdatalen;
(*data_len) -= rdatalen;
}
- w += ldns_str_print(str, str_len, "\n");
+ w += sldns_str_print(str, str_len, "\n");
return w;
}
#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
* @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.
* @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.
* @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.
* @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.
* @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);
/**
* @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);
/**
* 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.
* @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.
* @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.
* @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);
/**
* @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
* @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.
* @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);
* @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.
* @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.
* @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.
* @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.
* @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);
/**
* @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);
/**
* @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);
/**
* @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);
/**
* @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);
/**
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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);
/**
* @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);
/**
* @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);
/**
* @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);
/**
* @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);
/**
* @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);
/**
* @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);
/**
* @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);
/**
* @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.
* @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
*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;
}
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));
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);
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;
}
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
* 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;
}
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(
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;
}
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;
}
if(!p)
return NULL;
*len = sizeof(uint32_t);
- ldns_write_uint32(p, UB_LIBCMD_QUIT);
+ sldns_write_uint32(p, UB_LIBCMD_QUIT);
return p;
}
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;
}
#include "util/data/packed_rrset.h"
struct libworker;
struct tube;
-struct ldns_buffer;
+struct sldns_buffer;
struct event_base;
/**
* @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
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;
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);
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);
/** 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;
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)) {
/** 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;
/** 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)
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 */
}
}
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;
{
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;
}
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;
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);
}
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;
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);
/** 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;
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);
}
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;
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);
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,
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,
struct comm_reply;
struct regional;
struct tube;
-struct ldns_buffer;
+struct sldns_buffer;
struct event_base;
/**
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);
/**
* 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 */
}
/* 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;
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;
* 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
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 ++;
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;
if(!front)
return;
listen_list_delete(front->cps);
- ldns_buffer_free(front->udp_buff);
+ sldns_buffer_free(front->udp_buff);
free(front);
}
{
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);
struct listen_list;
struct config_file;
struct addrinfo;
-struct ldns_buffer;
+struct sldns_buffer;
/**
* Listening for queries structure.
/** 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;
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);
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);
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;
}
{
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;
/** 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;
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;
*/
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) {
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 */
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;
}
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
struct config_file;
struct edns_data;
struct query_info;
-struct ldns_buffer;
+struct sldns_buffer;
/**
* Local zone type
* 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.
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");
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);
}
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 */
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");
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;
}
}
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);
(*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;
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) {
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++;
}
}
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,
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);
#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;
/** 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 */
* 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*);
/**
/** 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);
* @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);
/**
* @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);
/**
* 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.
/** 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)
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);
/* 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);
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;
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);
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)) {
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) {
/** 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 */
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;
}
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)
{
/* 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);
}
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)
{
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;
}
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;
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;
/** 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;
/** 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)
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);
/** 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;
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);
}
}
* @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;
/** 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)
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",
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");
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) {
* 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;
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);
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;
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 */
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":"");
/** 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;
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;
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 */
} /* 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 ||
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;
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);
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.
/** 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;
* @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);
* @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);
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.
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);
}
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);
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);
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);
}
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);
}
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);
}
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);
}
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) {
}
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);
/** 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) {
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 */
/** 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 */
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) {
/** 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;
(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
#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;
/** 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)
#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
/** 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) {
/** 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)
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
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);
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)
}
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");
/** 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;
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;
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;
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 ||
closesocket(s);
closesocket(listen_s);
#endif
- ldns_buffer_free(pkt);
+ sldns_buffer_free(pkt);
ring_delete(ring);
}
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 {
if(!pend)
return;
free(pend->zone);
- ldns_buffer_free(pend->buffer);
+ sldns_buffer_free(pend->buffer);
free(pend->pkt);
free(pend);
}
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);
* 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;
}
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);
}
/**
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;
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 */
}
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;
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;
fatal_exit("unexpected: pending callback returned 1");
}
/* delete the pending item. */
- ldns_buffer_free(c.buffer);
+ sldns_buffer_free(c.buffer);
}
/** pass time */
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),
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;
{
if(!listen)
return;
- ldns_buffer_free(listen->udp_buff);
+ sldns_buffer_free(listen->udp_buff);
free(listen);
}
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);
}
{
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);
}
}
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;
{
if(!outnet)
return;
- ldns_buffer_free(outnet->udp_buff);
+ sldns_buffer_free(outnet->udp_buff);
free(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)
{
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;
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);
}
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))
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;
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);
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,
(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;
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);*/
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);
/** 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;
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));
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);
}
{
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]);
}
/** 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;
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));
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 ++;
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 */
/* do the performance test */
perfmain(&info);
- ldns_buffer_free(info.buf);
+ sldns_buffer_free(info.buf);
#ifdef USE_WINSOCK
WSACleanup();
#endif
}
/** 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;
}
/** 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;
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++;
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)
/** 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);
}
read_input(pkt, stdin);
analyze(pkt);
- ldns_buffer_free(pkt);
+ sldns_buffer_free(pkt);
return 0;
}
}
/* 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);
}
#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 */
*/
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));
*/
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));
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;
struct fake_timer;
struct replay_var;
struct infra_cache;
-struct ldns_buffer;
+struct sldns_buffer;
/**
* A replay scenario.
*/
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 */
/** 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 */
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;
}
}
/** 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;
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 ||
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);
/** 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);
}
}
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);
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 */
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 */
/** 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 */
/* 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) {
}
}
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
/** 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;
}
}
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");
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");
}
} 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
#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);
}
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;
#else
closesocket(fd);
#endif
- ldns_buffer_free(buf);
+ sldns_buffer_free(buf);
printf("orderly exit\n");
}
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 {
}
/** 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
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)) {
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");
}
/** 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;
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;
/* 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);
}
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 */
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) {
}
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),
}
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,
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));
}
/** 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;
/* 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 */
/* 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;
}
/* 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 */
/* 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;
/* 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;
}
}
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);
}
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);
}
}
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;
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++;
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;
}
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) {
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);
}
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;
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) {
(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);
}
* 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;
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);
}
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;
}
#ifndef TESTPKTS_H
#define TESTPKTS_H
-struct ldns_buffer;
-struct ldns_file_parse_state;
+struct sldns_buffer;
+struct sldns_file_parse_state;
/**
* \file
/** 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;
};
* @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.
/** 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;
/** 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;
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);
}
#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);
/** 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 */
/** 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"
"\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"
"\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 );
}
/** 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);
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);
}
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)
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();
/** 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);
}
}
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);
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;
/** 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;
((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;
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);
/** 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;
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);
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);
}
}
/** 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,
/** 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");
/** 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");
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);
/* cleanup */
alloc_clear(&alloc);
alloc_clear(&super_a);
- ldns_buffer_free(pkt);
- ldns_buffer_free(out);
+ sldns_buffer_free(pkt);
+ sldns_buffer_free(out);
}
/** 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;
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);
}
/** 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;
/** 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)
{
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);
/** 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;
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);
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;
delete_entry(list);
regional_destroy(region);
alloc_clear(&alloc);
- ldns_buffer_free(buf);
+ sldns_buffer_free(buf);
}
/** verify DS matches DNSKEY from a file */
*/
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;
delete_entry(list);
regional_destroy(region);
alloc_clear(&alloc);
- ldns_buffer_free(buf);
+ sldns_buffer_free(buf);
}
/** helper for unittest of NSEC routines */
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;
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);
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);
delete_entry(list);
regional_destroy(region);
alloc_clear(&alloc);
- ldns_buffer_free(buf);
+ sldns_buffer_free(buf);
}
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
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__);
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 */
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;
}
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);
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);
/* 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;
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);
}
}
}
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++;
}
size_t
-pkt_dname_len(ldns_buffer* pkt)
+pkt_dname_len(sldns_buffer* pkt)
{
size_t len = 0;
int ptrcount = 0;
/* 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)
/* 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);
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;
}
}
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;
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;
}
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;
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;
}
*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;
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;
}
}
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;
}
#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
* 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.
* 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
* 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.
* @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.
* @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.
* @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.
* @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.
* @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
/** 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 */
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)
{
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));
} 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;
/** 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;
}
/** 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;
}
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;
}
}
/* 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)
/** 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;
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;
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],
!= 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]);
}
}
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]);
}
}
/** 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;
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;
}
}
/** 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;
}
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;
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) {
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;
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)) ) {
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,
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;
}
}
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)
{
}
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);
#ifndef UTIL_DATA_MSGENCODE_H
#define UTIL_DATA_MSGENCODE_H
-struct ldns_buffer;
+struct sldns_buffer;
struct query_info;
struct reply_info;
struct regional;
* @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);
* 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);
/**
* @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.
* @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.
* @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 */
/** 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. */
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));
/** 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)) {
}
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 */
/** 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 */
/** 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)
{
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)
{
/** 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)
/** 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 */
/** 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;
/** 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;
/** 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,
* @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;
}
/* 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) {
/* 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,
* @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:
/** 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;
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;
/* 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]);
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++;
}
/* 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) {
/** 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. */
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;
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)
* @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;
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);
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. */
}
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)
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;
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;
/* 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;
}
#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;
/** 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 */
* @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.
* @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);
/**
* @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.
* @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);
/**
* @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);
/**
/** 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) {
/** 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;
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;
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;
}
}
/* 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;
/** 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 */
}
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)
{
* @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;
}
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)
{
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)
{
}
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;
}
}
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;
}
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);
}
#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;
* @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.
* 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);
* 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);
* 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);
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)
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;
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
#ifndef UTIL_LOG_H
#define UTIL_LOG_H
-struct ldns_buffer;
+struct sldns_buffer;
/**
* verbosity value:
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.
#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;
/** 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 */
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;
/* 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))
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;
/** 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)
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;
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;
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;
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;
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
#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)) {
{
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);
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;
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;
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);
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) {
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;
/* 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),
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) {
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;
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;
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) {
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;
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);
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)
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);
}
}
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,
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,
}
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);
}
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;
}
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);
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;
}
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);
}
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);
}
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++)
#ifndef NET_EVENT_H
#define NET_EVENT_H
-struct ldns_buffer;
+struct sldns_buffer;
struct comm_point;
struct comm_reply;
struct event_base;
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 */
* 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);
/**
* 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);
/**
* @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);
/**
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);
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);
}
{
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");
}
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;
*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);
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 */
}
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;
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)) {
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) {
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;
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++;
}
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++;
}
/**
* 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.
*/
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;
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");
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;
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);
/* 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 */
{
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) */
{
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;
/* 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)
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) &&
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 */
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;
}
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,
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");
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 */
struct ub_packed_rrset_key;
struct module_env;
struct val_env;
-struct ldns_buffer;
+struct sldns_buffer;
/** Autotrust anchor states */
typedef enum {
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 */
{
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;
}
{
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;
}
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))) {
* @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) {
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;
}
* 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;
(*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 ) {
(*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 ' ' */
/** 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;
* @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 ; */
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;
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);
}
}
}
* @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;
}
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;
}
fclose(in);
return 0;
}
- ldns_buffer_clear(buffer);
+ sldns_buffer_clear(buffer);
}
fclose(in);
return 1;
* @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
{
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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);
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);
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;
}
struct ub_packed_rrset_key;
struct autr_point_data;
struct autr_global_data;
-struct ldns_buffer;
+struct sldns_buffer;
/**
* Trust anchor store.
* @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
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 */
/** 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];
/** 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;
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;
#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;
*/
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);
* 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);
/**
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 */
}
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:
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;
/** 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);
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:
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;
/** 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;
}
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)
{
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;
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)
struct reply_info;
struct query_info;
struct key_entry_key;
-struct ldns_buffer;
+struct sldns_buffer;
/**
* 0 1 2 3 4 5 6 7
* -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);
/**
* @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);
* @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 */
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
#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;
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) {
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) {
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) {
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");
#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
#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
* 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)
{
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);
* 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)
{
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;
#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.
* @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);
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);
/* 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);
}
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,
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,
*/
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.
{
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;
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);
* @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;
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);
}
}
* @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:
* @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)
{
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");
}
/* 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;
}
}
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,
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
* 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);
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;
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);
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));
}
/** 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;
}
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");
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 */
projects / thirdparty / unbound.git / commitdiff
