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

Fix linking of sldns and ldns, unique identifiers for global variables.

Browse source 
git-svn-id: file:///svn/unbound/trunk@3021 be551aaa-1e26-0410-a405-d3ace91eadb9
This commit is contained in:
Wouter Wijngaards 2013-11-30 11:03:55 +00:00
parent 17935c9144
commit 3de090dadb
13 changed files with 85 additions and 51 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
daemon/remote.c
View file

@ -792,7 +792,7 @@ print_ext(SSL* ssl, struct stats_info* s)
for(i=0; i<STATS_QCLASS_NUM; i++) {
if(inhibit_zero && s->svr.qclass[i] == 0)
continue;
lt = ldns_lookup_by_id(ldns_rr_classes, i);
lt = ldns_lookup_by_id(SLDNS(_rr_classes), i);
if(lt && lt->name) {
snprintf(nm, sizeof(nm), "%s", lt->name);
} else {
@ -809,7 +809,7 @@ print_ext(SSL* ssl, struct stats_info* s)
for(i=0; i<STATS_OPCODE_NUM; i++) {
if(inhibit_zero && s->svr.qopcode[i] == 0)
continue;
lt = ldns_lookup_by_id(ldns_opcodes, i);
lt = ldns_lookup_by_id(SLDNS(_opcodes), i);
if(lt && lt->name) {
snprintf(nm, sizeof(nm), "%s", lt->name);
} else {
@ -849,7 +849,7 @@ print_ext(SSL* ssl, struct stats_info* s)
for(i=0; i<STATS_RCODE_NUM; i++) {
if(inhibit_zero && s->svr.ans_rcode[i] == 0)
continue;
lt = ldns_lookup_by_id(ldns_rcodes, i);
lt = ldns_lookup_by_id(SLDNS(_rcodes), i);
if(lt && lt->name) {
snprintf(nm, sizeof(nm), "%s", lt->name);
} else {

4
doc/Changelog
View file

@ -1,3 +1,7 @@
30 Nov 2013: Wouter
- Fix sldns to make globals use sldns_ prefix. This fixes
linking with libldns that uses global variables ldns_ .
13 Nov 2013: Wouter
- Fix bug#537: compile python plugin without ldns library.

8
iterator/iterator.c
View file

@ -231,8 +231,8 @@ static int
error_response(struct module_qstate* qstate, int id, int rcode)
{
verbose(VERB_QUERY, "return error response %s",
ldns_lookup_by_id(ldns_rcodes, rcode)?
ldns_lookup_by_id(ldns_rcodes, rcode)->name:"??");
ldns_lookup_by_id(SLDNS(_rcodes), rcode)?
ldns_lookup_by_id(SLDNS(_rcodes), rcode)->name:"??");
qstate->return_rcode = rcode;
qstate->return_msg = NULL;
qstate->ext_state[id] = module_finished;
@ -543,8 +543,8 @@ prime_root(struct module_qstate* qstate, struct iter_qstate* iq, int id,
struct delegpt* dp;
struct module_qstate* subq;
verbose(VERB_DETAIL, "priming . %s NS",
ldns_lookup_by_id(ldns_rr_classes, (int)qclass)?
ldns_lookup_by_id(ldns_rr_classes, (int)qclass)->name:"??");
ldns_lookup_by_id(SLDNS(_rr_classes), (int)qclass)?
ldns_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");

12
ldns/rrdef.c
View file

@ -17,7 +17,11 @@
#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
{ LDNS_RR_CLASS_IN, "IN" },
{ LDNS_RR_CLASS_CH, "CH" },
{ LDNS_RR_CLASS_HS, "HS" },
@ -25,7 +29,11 @@ static ldns_lookup_table ldns_rr_classes_data[] = {
{ LDNS_RR_CLASS_ANY, "ANY" },
{ 0, NULL }
};
#ifdef USE_SLDNS
ldns_lookup_table* sldns_rr_classes = sldns_rr_classes_data;
#else
ldns_lookup_table* ldns_rr_classes = ldns_rr_classes_data;
#endif
/* types */
static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
@ -768,7 +776,11 @@ ldns_get_rr_class_by_name(const char *name)
}
/* Normal types */
#ifdef USE_SLDNS
lt = ldns_lookup_by_name(sldns_rr_classes, name);
#else
lt = ldns_lookup_by_name(ldns_rr_classes, name);
#endif
if (lt) {
return lt->id;

6
ldns/rrdef.h
View file

@ -40,8 +40,12 @@ extern "C" {
/* The first fields are contiguous and can be referenced instantly */
#define LDNS_RDATA_FIELD_DESCRIPTORS_COMMON 258
/** lookuptable for rr types */
/** 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
/**
* The different RR classes.

7
ldns/str2wire.c
View file

@ -739,7 +739,7 @@ uint8_t* ldns_wirerr_get_rdatawl(uint8_t* rr, size_t len, size_t dname_len)
const char* ldns_get_errorstr_parse(int e)
{
ldns_lookup_table *lt;
lt = ldns_lookup_by_id(ldns_wireparse_errors, LDNS_WIREPARSE_ERROR(e));
lt = ldns_lookup_by_id(SLDNS(_wireparse_errors), LDNS_WIREPARSE_ERROR(e));
return lt?lt->name:"unknown error";
}
@ -1206,7 +1206,8 @@ int ldns_str2wire_class_buf(const char* str, uint8_t* rd, size_t* len)
* or by its symbolic name. Handle both */
int ldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len)
{
ldns_lookup_table *lt = ldns_lookup_by_name(ldns_cert_algorithms, str);
ldns_lookup_table *lt = ldns_lookup_by_name(SLDNS(_cert_algorithms),
str);
if(*len < 2)
return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
if(lt) {
@ -1225,7 +1226,7 @@ int ldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len)
* or by its symbolic name. Handle both */
int ldns_str2wire_alg_buf(const char* str, uint8_t* rd, size_t* len)
{
ldns_lookup_table *lt = ldns_lookup_by_name(ldns_algorithms, str);
ldns_lookup_table *lt = ldns_lookup_by_name(SLDNS(_algorithms), str);
if(*len < 1)
return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
if(lt) {

46
ldns/wire2str.c
View file

@ -34,7 +34,7 @@
/* lookup tables for standard DNS stuff */
/* Taken from RFC 2535, section 7. */
static ldns_lookup_table ldns_algorithms_data[] = {
static ldns_lookup_table SLDNS(_algorithms_data)[] = {
{ LDNS_RSAMD5, "RSAMD5" },
{ LDNS_DH, "DH" },
{ LDNS_DSA, "DSA" },
@ -52,20 +52,20 @@ static ldns_lookup_table ldns_algorithms_data[] = {
{ LDNS_PRIVATEOID, "PRIVATEOID" },
{ 0, NULL }
};
ldns_lookup_table* ldns_algorithms = ldns_algorithms_data;
ldns_lookup_table* SLDNS(_algorithms) = SLDNS(_algorithms_data);
/* hash algorithms in DS record */
static ldns_lookup_table ldns_hashes_data[] = {
static ldns_lookup_table SLDNS(_hashes_data)[] = {
{ LDNS_SHA1, "SHA1" },
{ LDNS_SHA256, "SHA256" },
{ LDNS_HASH_GOST, "HASH-GOST" },
{ LDNS_SHA384, "SHA384" },
{ 0, NULL }
};
ldns_lookup_table* ldns_hashes = ldns_hashes_data;
ldns_lookup_table* SLDNS(_hashes) = SLDNS(_hashes_data);
/* Taken from RFC 4398 */
static ldns_lookup_table ldns_cert_algorithms_data[] = {
static ldns_lookup_table SLDNS(_cert_algorithms_data)[] = {
{ LDNS_CERT_PKIX, "PKIX" },
{ LDNS_CERT_SPKI, "SPKI" },
{ LDNS_CERT_PGP, "PGP" },
@ -78,10 +78,10 @@ static ldns_lookup_table ldns_cert_algorithms_data[] = {
{ LDNS_CERT_OID, "OID" },
{ 0, NULL }
};
ldns_lookup_table* ldns_cert_algorithms = ldns_cert_algorithms_data;
ldns_lookup_table* SLDNS(_cert_algorithms) = SLDNS(_cert_algorithms_data);
/* if these are used elsewhere */
static ldns_lookup_table ldns_rcodes_data[] = {
static ldns_lookup_table SLDNS(_rcodes_data)[] = {
{ LDNS_RCODE_NOERROR, "NOERROR" },
{ LDNS_RCODE_FORMERR, "FORMERR" },
{ LDNS_RCODE_SERVFAIL, "SERVFAIL" },
@ -95,9 +95,9 @@ static ldns_lookup_table ldns_rcodes_data[] = {
{ LDNS_RCODE_NOTZONE, "NOTZONE" },
{ 0, NULL }
};
ldns_lookup_table* ldns_rcodes = ldns_rcodes_data;
ldns_lookup_table* SLDNS(_rcodes) = SLDNS(_rcodes_data);
static ldns_lookup_table ldns_opcodes_data[] = {
static ldns_lookup_table SLDNS(_opcodes_data)[] = {
{ LDNS_PACKET_QUERY, "QUERY" },
{ LDNS_PACKET_IQUERY, "IQUERY" },
{ LDNS_PACKET_STATUS, "STATUS" },
@ -105,9 +105,9 @@ static ldns_lookup_table ldns_opcodes_data[] = {
{ LDNS_PACKET_UPDATE, "UPDATE" },
{ 0, NULL }
};
ldns_lookup_table* ldns_opcodes = ldns_opcodes_data;
ldns_lookup_table* SLDNS(_opcodes) = SLDNS(_opcodes_data);
static ldns_lookup_table ldns_wireparse_errors_data[] = {
static ldns_lookup_table SLDNS(_wireparse_errors_data)[] = {
{ LDNS_WIREPARSE_ERR_OK, "no parse error" },
{ LDNS_WIREPARSE_ERR_GENERAL, "parse error" },
{ LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, "Domainname length overflow" },
@ -148,15 +148,15 @@ static ldns_lookup_table ldns_wireparse_errors_data[] = {
{ LDNS_WIREPARSE_ERR_PARENTHESIS, "Parse error, parenthesis mismatch" },
{ 0, NULL }
};
ldns_lookup_table* ldns_wireparse_errors = ldns_wireparse_errors_data;
ldns_lookup_table* SLDNS(_wireparse_errors) = SLDNS(_wireparse_errors_data);
static ldns_lookup_table ldns_edns_flags_data[] = {
static ldns_lookup_table SLDNS(_edns_flags_data)[] = {
{ 3600, "do"},
{ 0, NULL}
};
ldns_lookup_table* ldns_edns_flags = ldns_edns_flags_data;
ldns_lookup_table* SLDNS(_edns_flags) = SLDNS(_edns_flags_data);
static ldns_lookup_table ldns_edns_options_data[] = {
static ldns_lookup_table SLDNS(_edns_options_data)[] = {
{ 1, "LLQ" },
{ 2, "UL" },
{ 3, "NSID" },
@ -167,7 +167,7 @@ static ldns_lookup_table ldns_edns_options_data[] = {
{ 8, "edns-client-subnet" },
{ 0, NULL}
};
ldns_lookup_table* ldns_edns_options = ldns_edns_options_data;
ldns_lookup_table* SLDNS(_edns_options) = SLDNS(_edns_options_data);
char* ldns_wire2str_pkt(uint8_t* data, size_t len)
{
@ -806,7 +806,7 @@ int ldns_wire2str_dname_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
int ldns_wire2str_opcode_print(char** s, size_t* slen, int opcode)
{
ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
ldns_lookup_table *lt = ldns_lookup_by_id(SLDNS(_opcodes), opcode);
if (lt && lt->name) {
return ldns_str_print(s, slen, "%s", lt->name);
}
@ -815,7 +815,7 @@ int ldns_wire2str_opcode_print(char** s, size_t* slen, int opcode)
int ldns_wire2str_rcode_print(char** s, size_t* slen, int rcode)
{
ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
ldns_lookup_table *lt = ldns_lookup_by_id(SLDNS(_rcodes), rcode);
if (lt && lt->name) {
return ldns_str_print(s, slen, "%s", lt->name);
}
@ -824,7 +824,7 @@ int ldns_wire2str_rcode_print(char** s, size_t* slen, int rcode)
int ldns_wire2str_class_print(char** s, size_t* slen, uint16_t rrclass)
{
ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rr_classes,
ldns_lookup_table *lt = ldns_lookup_by_id(SLDNS(_rr_classes),
(int)rrclass);
if (lt && lt->name) {
return ldns_str_print(s, slen, "%s", lt->name);
@ -844,7 +844,7 @@ int ldns_wire2str_type_print(char** s, size_t* slen, uint16_t rrtype)
int ldns_wire2str_edns_option_code_print(char** s, size_t* slen,
uint16_t opcode)
{
ldns_lookup_table *lt = ldns_lookup_by_id(ldns_edns_options,
ldns_lookup_table *lt = ldns_lookup_by_id(SLDNS(_edns_options),
(int)opcode);
if (lt && lt->name) {
return ldns_str_print(s, slen, "%s", lt->name);
@ -1254,7 +1254,7 @@ int ldns_wire2str_cert_alg_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
int data, w;
if(*dl < 2) return -1;
data = (int)ldns_read_uint16(*d);
lt = ldns_lookup_by_id(ldns_cert_algorithms, data);
lt = ldns_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);
@ -1694,7 +1694,7 @@ int ldns_wire2str_edns_dau_print(char** s, size_t* sl, uint8_t* data,
size_t i;
int w = 0;
for(i=0; i<len; i++) {
lt = ldns_lookup_by_id(ldns_algorithms, (int)data[i]);
lt = ldns_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]);
@ -1709,7 +1709,7 @@ int ldns_wire2str_edns_dhu_print(char** s, size_t* sl, uint8_t* data,
size_t i;
int w = 0;
for(i=0; i<len; i++) {
lt = ldns_lookup_by_id(ldns_hashes, (int)data[i]);
lt = ldns_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]);

24
ldns/wire2str.h
View file

@ -21,23 +21,31 @@ 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
/* lookup tables for standard DNS stuff */
/** Taken from RFC 2535, section 7. */
extern struct ldns_struct_lookup_table* ldns_algorithms;
extern struct ldns_struct_lookup_table* SLDNS(_algorithms);
/** DS record hash algorithms */
extern struct ldns_struct_lookup_table* ldns_hashes;
extern struct ldns_struct_lookup_table* SLDNS(_hashes);
/** Taken from RFC 2538, section 2.1. */
extern struct ldns_struct_lookup_table* ldns_cert_algorithms;
extern struct ldns_struct_lookup_table* SLDNS(_cert_algorithms);
/** Response codes */
extern struct ldns_struct_lookup_table* ldns_rcodes;
extern struct ldns_struct_lookup_table* SLDNS(_rcodes);
/** Operation codes */
extern struct ldns_struct_lookup_table* ldns_opcodes;
extern struct ldns_struct_lookup_table* SLDNS(_opcodes);
/** EDNS flags */
extern struct ldns_struct_lookup_table* ldns_edns_flags;
extern struct ldns_struct_lookup_table* SLDNS(_edns_flags);
/** EDNS option codes */
extern struct ldns_struct_lookup_table* ldns_edns_options;
extern struct ldns_struct_lookup_table* SLDNS(_edns_options);
/** error string from wireparse */
extern struct ldns_struct_lookup_table* ldns_wireparse_errors;
extern struct ldns_struct_lookup_table* SLDNS(_wireparse_errors);
/**
* Convert wireformat packet to a string representation

7
testcode/asynclook.c
View file

@ -335,6 +335,11 @@ ext_thread(void* arg)
r = ub_wait(inf->ctx);
checkerr("ub_ctx_wait", r);
}
if(async_ids) {
for(i=0; i<inf->numq; i++) {
lock_basic_destroy(&async_ids[i].lock);
}
}
free(async_ids);
return NULL;
@ -355,7 +360,7 @@ ext_test(struct ub_ctx* ctx, int argc, char** argv)
inf[i].ctx = ctx;
inf[i].argc = argc;
inf[i].argv = argv;
inf[i].numq = 1000;
inf[i].numq = 100;
ub_thread_create(&inf[i].tid, ext_thread, &inf[i]);
}
/* the work happens here */

4
testcode/pktview.c
View file

@ -134,8 +134,8 @@ static void analyze_rr(ldns_buffer* pkt, int q)
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(ldns_rr_classes,
(int)dclass)?ldns_lookup_by_id( ldns_rr_classes,
printf(" class %s(%d) ", ldns_lookup_by_id(sldns_rr_classes,
(int)dclass)?ldns_lookup_by_id(sldns_rr_classes,
(int)dclass)->name:"??", (int)dclass);
if(q) {
printf("\n");

4
util/data/msgparse.c
View file

@ -859,9 +859,9 @@ parse_section(ldns_buffer* pkt, struct msg_parse* msg,
ldns_rr_descript(type)->_name: "??",
(int)type);
fprintf(stderr, " %s(%d) ",
ldns_lookup_by_id(ldns_rr_classes,
ldns_lookup_by_id(sldns_rr_classes,
(int)ntohs(dclass))?ldns_lookup_by_id(
ldns_rr_classes, (int)ntohs(dclass))->name:
sldns_rr_classes, (int)ntohs(dclass))->name:
"??", (int)ntohs(dclass));
dname_print(stderr, pkt, dname);
fprintf(stderr, "\n");

6
util/net_help.c
View file

@ -287,9 +287,9 @@ log_nametypeclass(enum verbosity_value v, const char* str, uint8_t* name,
snprintf(t, sizeof(t), "TYPE%d", (int)type);
ts = t;
}
if(ldns_lookup_by_id(ldns_rr_classes, (int)dclass) &&
ldns_lookup_by_id(ldns_rr_classes, (int)dclass)->name)
cs = ldns_lookup_by_id(ldns_rr_classes, (int)dclass)->name;
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;
else {
snprintf(c, sizeof(c), "CLASS%d", (int)dclass);
cs = c;

2
validator/val_sigcrypt.c
View file

@ -534,7 +534,7 @@ dnskeyset_verify_rrset(struct module_env* env, struct val_env* ve,
void algo_needs_reason(struct module_env* env, int alg, char** reason, char* s)
{
char buf[256];
ldns_lookup_table *t = ldns_lookup_by_id(ldns_algorithms, alg);
ldns_lookup_table *t = ldns_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,