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 3b76c0e298611a85014a9cf6bb6a6f4a2a94b33a..3c4980937a33a285d3e0b4c85354f22e5903fe00 100644 (file)
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -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 {

diff --git a/doc/Changelog b/doc/Changelog
index 9e9a378aefee2e680ccc64781e4e566bbbf4d63f..f7e6e714e4e205884a2a0de1ce2460df4059b15a 100644 (file)
--- 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 c4254c17ab04f8a6f03c17e6aaf74d583491cca6..df61357980934ff62452f2e46c8d58e61e11f2e0 100644 (file)
--- 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 4043dd2fd1523724181c149418e7cff915bda694..ae54ca97b05c08307dd6fc36f6d06131d5cda49e 100644 (file)
--- 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 45ffa32dfca0c740da29c9c8f049ed126a838eec..6b61fdcf2df976e01bcfc5980568d09da7c09c29 100644 (file)
--- 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 b6ee053cc3c0837d276e75fba0cee58e84c74d71..83edf4b394a8e3c37323ae1947cff950470e6598 100644 (file)
--- 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 375458cbd42fb1d5b1324b974a92ca1f3d42d8f7..ce176aa50812c602d5ce0e2ccc8b196ec97010a9 100644 (file)
--- 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; 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]);

diff --git a/ldns/wire2str.h b/ldns/wire2str.h
index 339a30c3fd0c53d5e8be1690076564c6b04fb690..5448e611589052f1ec8ac33e3ef31e1517bfa6ed 100644 (file)
--- 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 05f15dcf515e718c35b5237137f6a22e5c8adda3..2e9e0d2436df8f463eae8be5030a9f918a38b297 100644 (file)
--- 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; 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 */

diff --git a/testcode/pktview.c b/testcode/pktview.c
index d9895856d93f6f14d6f1faa801f91b08b4db2da2..7be2476fa4deeec4a5e108f68988ccbc9bf759b6 100644 (file)
--- 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 29299bfd5517e61a6df183dcc2b34e03194762d9..e6068eafed52a627bef4b20850633b1c32552364 100644 (file)
--- 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 a238f1548cfe0628ebc78ccd3a898e80df4d2846..597759e68277c2f71e2c9d3098d53206b53c424b 100644 (file)
--- 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 4de738a470c93ad18555696a97eaacd497541a5d..2ddad587c637e22c4d9fd6f8d165ae871325b414 100644 (file)
--- 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,