From: Wouter Wijngaards Date: Sat, 30 Nov 2013 11:03:55 +0000 (+0000) Subject: Fix linking of sldns and ldns, unique identifiers for global variables. X-Git-Tag: release-1.4.22rc1~71 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=3de090dadb5d3db7a9bc1fff750638ff41567174;p=thirdparty%2Funbound.git Fix linking of sldns and ldns, unique identifiers for global variables. git-svn-id: file:///svn/unbound/trunk@3021 be551aaa-1e26-0410-a405-d3ace91eadb9 --- diff --git a/daemon/remote.c b/daemon/remote.c index 3b76c0e29..3c4980937 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -792,7 +792,7 @@ print_ext(SSL* ssl, struct stats_info* s) for(i=0; isvr.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; isvr.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; isvr.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 { diff --git a/doc/Changelog b/doc/Changelog index 9e9a378ae..f7e6e714e 100644 --- a/doc/Changelog +++ b/doc/Changelog @@ -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. diff --git a/iterator/iterator.c b/iterator/iterator.c index c4254c17a..df6135798 100644 --- a/iterator/iterator.c +++ b/iterator/iterator.c @@ -231,8 +231,8 @@ static int error_response(struct module_qstate* qstate, int id, int rcode) { verbose(VERB_QUERY, "return error response %s", - ldns_lookup_by_id(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"); diff --git a/ldns/rrdef.c b/ldns/rrdef.c index 4043dd2fd..ae54ca97b 100644 --- a/ldns/rrdef.c +++ b/ldns/rrdef.c @@ -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; diff --git a/ldns/rrdef.h b/ldns/rrdef.h index 45ffa32df..6b61fdcf2 100644 --- a/ldns/rrdef.h +++ b/ldns/rrdef.h @@ -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. diff --git a/ldns/str2wire.c b/ldns/str2wire.c index b6ee053cc..83edf4b39 100644 --- a/ldns/str2wire.c +++ b/ldns/str2wire.c @@ -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) { diff --git a/ldns/wire2str.c b/ldns/wire2str.c index 375458cbd..ce176aa50 100644 --- a/ldns/wire2str.c +++ b/ldns/wire2str.c @@ -34,7 +34,7 @@ /* lookup tables for standard DNS stuff */ /* Taken from RFC 2535, section 7. */ -static ldns_lookup_table 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; iname) 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; iname) w += ldns_str_print(s, sl, " %s", lt->name); else w += ldns_str_print(s, sl, " %d", (int)data[i]); diff --git a/ldns/wire2str.h b/ldns/wire2str.h index 339a30c3f..5448e6115 100644 --- a/ldns/wire2str.h +++ b/ldns/wire2str.h @@ -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 diff --git a/testcode/asynclook.c b/testcode/asynclook.c index 05f15dcf5..2e9e0d243 100644 --- a/testcode/asynclook.c +++ b/testcode/asynclook.c @@ -335,6 +335,11 @@ ext_thread(void* arg) r = ub_wait(inf->ctx); checkerr("ub_ctx_wait", r); } + if(async_ids) { + for(i=0; inumq; 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 */ diff --git a/testcode/pktview.c b/testcode/pktview.c index d9895856d..7be2476fa 100644 --- a/testcode/pktview.c +++ b/testcode/pktview.c @@ -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"); diff --git a/util/data/msgparse.c b/util/data/msgparse.c index 29299bfd5..e6068eafe 100644 --- a/util/data/msgparse.c +++ b/util/data/msgparse.c @@ -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"); diff --git a/util/net_help.c b/util/net_help.c index a238f1548..597759e68 100644 --- a/util/net_help.c +++ b/util/net_help.c @@ -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; diff --git a/validator/val_sigcrypt.c b/validator/val_sigcrypt.c index 4de738a47..2ddad587c 100644 --- a/validator/val_sigcrypt.c +++ b/validator/val_sigcrypt.c @@ -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,