unit test trust anchor storage.

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

diff --git a/doc/Changelog b/doc/Changelog
index d6f2787588ec28944d685438302eefde785bccda..0086def291e4b39d79e81b927068fa511a9bc965 100644 (file)
--- a/doc/Changelog
+++ b/doc/Changelog
@@ -3,6 +3,7 @@
        - scrubber check section of lame NS set.
        - trust anchors can be in config file or read from zone file,
          DS and DNSKEY entries.
+       - unit test trust anchor storage.
 
 2 August 2007: Wouter
        - configure change for latest libevent trunk version (needs -lrt).

diff --git a/testcode/unitanchor.c b/testcode/unitanchor.c
new file mode 100644 (file)
index 0000000..5972844
--- /dev/null
+++ b/testcode/unitanchor.c
@@ -0,0 +1,118 @@
+/*
+ * testcode/unitanchor.c - unit test for trust anchor storage.
+ *
+ * Copyright (c) 2007, NLnet Labs. All rights reserved.
+ *
+ * This software is open source.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of the NLNET LABS nor the names of its contributors may
+ * be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+/**
+ * \file
+ * Calls trust anchor unit tests. Exits with code 1 on a failure. 
+ */
+
+#include "config.h"
+#include "util/log.h"
+#include "util/data/dname.h"
+#include "testcode/unitmain.h"
+#include "validator/val_anchor.h"
+
+/** test empty set */
+static void
+test_anchor_empty(struct val_anchors* a)
+{
+       uint16_t c = LDNS_RR_CLASS_IN;
+       unit_assert(anchors_lookup(a, (uint8_t*)"\000", 1, c) == NULL);
+       unit_assert(anchors_lookup(a, (uint8_t*)"\003com\000", 5, c) == NULL);
+       unit_assert(anchors_lookup(a, 
+               (uint8_t*)"\007example\003com\000", 11, c) == NULL);
+       unit_assert(anchors_lookup(a, (uint8_t*)"\002nl\000", 4, c) == NULL);
+       unit_assert(anchors_lookup(a, 
+               (uint8_t*)"\004labs\002nl\000", 9, c) == NULL);
+       unit_assert(anchors_lookup(a, 
+               (uint8_t*)"\004fabs\002nl\000", 9, c) == NULL);
+}
+
+/** test set of one anchor */
+static void
+test_anchor_one(ldns_buffer* buff, struct val_anchors* a)
+{
+       uint16_t c = LDNS_RR_CLASS_IN;
+       unit_assert(anchor_store_str(a, buff, 
+               "nl. DS 42860 5 1 14D739EB566D2B1A5E216A0BA4D17FA9B038BE4A"));
+       unit_assert(anchors_lookup(a, (uint8_t*)"\000", 1, c) == NULL);
+       unit_assert(anchors_lookup(a, (uint8_t*)"\003com\000", 5, c) == NULL);
+       unit_assert(anchors_lookup(a, 
+               (uint8_t*)"\007example\003com\000", 11, c) == NULL);
+       unit_assert(anchors_lookup(a, (uint8_t*)"\002nl\000", 4, c) != NULL);
+       unit_assert(anchors_lookup(a, 
+               (uint8_t*)"\004labs\002nl\000", 9, c) != NULL);
+       unit_assert(anchors_lookup(a, 
+               (uint8_t*)"\004fabs\002nl\000", 9, c) != NULL);
+       unit_assert(anchors_lookup(a, (uint8_t*)"\002oo\000", 4, c) == NULL);
+}
+
+/** test with several anchors */
+static void
+test_anchors(ldns_buffer* buff, struct val_anchors* a)
+{
+       struct trust_anchor* ta;
+       uint16_t c = LDNS_RR_CLASS_IN;
+       unit_assert(anchor_store_str(a, buff, 
+       "labs.nl. DS 42860 5 1 14D739EB566D2B1A5E216A0BA4D17FA9B038BE4A"));
+       unit_assert(anchors_lookup(a, (uint8_t*)"\000", 1, c) == NULL);
+       unit_assert(anchors_lookup(a, (uint8_t*)"\003com\000", 5, c) == NULL);
+       unit_assert(anchors_lookup(a, 
+               (uint8_t*)"\007example\003com\000", 11, c) == NULL);
+       unit_assert(ta = anchors_lookup(a, (uint8_t*)"\002nl\000", 4, c));
+       unit_assert(query_dname_compare(ta->name, (uint8_t*)"\002nl\000")==0);
+       unit_assert(ta = anchors_lookup(a, 
+               (uint8_t*)"\004labs\002nl\000", 9, c));
+       unit_assert(query_dname_compare(ta->name, 
+               (uint8_t*)"\004labs\002nl\000") == 0);
+       unit_assert(ta = anchors_lookup(a, 
+               (uint8_t*)"\004fabs\002nl\000", 9, c));
+       unit_assert(query_dname_compare(ta->name, 
+               (uint8_t*)"\002nl\000") == 0);
+       unit_assert(anchors_lookup(a, (uint8_t*)"\002oo\000", 4, c) == NULL);
+}
+
+void anchors_test()
+{
+       ldns_buffer* buff = ldns_buffer_new(65800);
+       struct val_anchors* a;
+       unit_assert(a = anchors_create());
+       ldns_buffer_flip(buff);
+       test_anchor_empty(a);
+       test_anchor_one(buff, a);
+       test_anchors(buff, a);
+       anchors_delete(a);
+       ldns_buffer_free(buff);
+}

diff --git a/testcode/unitmain.c b/testcode/unitmain.c
index 927a7f32f43346b82d92c3e59f1a3dc03a14e930..9cb1b5df4ab2ac3bc0f2a594d0c50e2cfcfad122 100644 (file)
--- a/testcode/unitmain.c
+++ b/testcode/unitmain.c
@@ -215,6 +215,7 @@ main(int argc, char* argv[])
        checklock_start();
        net_test();
        dname_test();
+       anchors_test();
        rtt_test();
        alloc_test();
        lruhash_test();

diff --git a/testcode/unitmain.h b/testcode/unitmain.h
index 2d0633e244eb570097aefd0d3402225db86039a5..96fe68ac44576e6e89e2eac2265c232717a8db79 100644 (file)
--- a/testcode/unitmain.h
+++ b/testcode/unitmain.h
@@ -55,5 +55,7 @@ void slabhash_test();
 void msgparse_test();
 /** unit test dname handling functions */
 void dname_test();
+/** unit test trust anchor storage functions */
+void anchors_test();
 
 #endif /* TESTCODE_UNITMAIN_H */

diff --git a/util/log.c b/util/log.c
index 9eb598d0cf908f23862628c70cbd6301fdebbba9..aae9db7b02b7065baaf520eed6054f4ae1f6a1a4 100644 (file)
--- a/util/log.c
+++ b/util/log.c
@@ -154,6 +154,7 @@ fatal_exit(const char *format, ...)
        va_start(args, format);
        log_vmsg("fatal error", format, args);
        va_end(args);
+       memset(NULL, 0, 10);
        exit(1);
 }
 

diff --git a/validator/val_anchor.c b/validator/val_anchor.c
index 770765e5ea7a6e71e8abe94ad58467232d410a8e..73b645707a9ebba0490266c958692686425a1f34 100644 (file)
--- a/validator/val_anchor.c
+++ b/validator/val_anchor.c
@@ -153,16 +153,21 @@ static struct trust_anchor*
 anchor_new_ta(struct val_anchors* anchors, uint8_t* name, int namelabs,
        size_t namelen, uint16_t dclass)
 {
+       rbnode_t* r;
        struct trust_anchor* ta = (struct trust_anchor*)region_alloc(
                anchors->region, sizeof(struct trust_anchor));
        if(!ta)
                return NULL;
        memset(ta, 0, sizeof(*ta));
        ta->node.key = ta;
-       ta->name = name;
+       ta->name = region_alloc_init(anchors->region, name, namelen);
+       if(!ta->name)
+               return NULL;
        ta->namelabs = namelabs;
        ta->namelen = namelen;
        ta->dclass = dclass;
+       r = rbtree_insert(anchors->tree, &ta->node);
+       log_assert(r != NULL);
        return ta;
 }
 
@@ -281,14 +286,7 @@ anchor_store_new_rr(struct val_anchors* anchors, ldns_buffer* buffer,
        return 1;
 }
 
-/**
- * Store one string as trust anchor RR.
- * @param anchors: anchor storage.
- * @param buffer: parsing buffer.
- * @param str: string.
- * @return false on error.
- */
-static int
+int
 anchor_store_str(struct val_anchors* anchors, ldns_buffer* buffer,
        const char* str)
 {
@@ -407,11 +405,11 @@ anchors_lookup(struct val_anchors* anchors,
        key.dclass = qclass;
        if(rbtree_find_less_equal(anchors->tree, &key, &res)) {
                /* exact */
-               result = (struct trust_anchor*)res->key;
+               result = (struct trust_anchor*)res;
        } else {
                /* smaller element (or no element) */
                int m;
-               result = (struct trust_anchor*)res->key;
+               result = (struct trust_anchor*)res;
                if(!result || result->dclass != qclass)
                        return NULL;
                /* count number of labels matched */
@@ -422,8 +420,6 @@ anchors_lookup(struct val_anchors* anchors,
                                break;
                        result = result->parent;
                }
-               if(!result)
-                       return NULL;
        }
        return result;
 }

diff --git a/validator/val_anchor.h b/validator/val_anchor.h
index c2cd40c4908a72f8cf1efd547ad0a37b1b3bf908..1fcc58c84dbb5f126ef63001664d83b6a9b917ec 100644 (file)
--- a/validator/val_anchor.h
+++ b/validator/val_anchor.h
@@ -136,4 +136,14 @@ int anchors_apply_cfg(struct val_anchors* anchors, struct config_file* cfg);
 struct trust_anchor* anchors_lookup(struct val_anchors* anchors,
        uint8_t* qname, size_t qname_len, uint16_t qclass);
 
+/**
+ * Store one string as trust anchor RR.
+ * @param anchors: anchor storage.
+ * @param buffer: parsing buffer, to generate the RR wireformat in.
+ * @param str: string.
+ * @return false on error.
+ */
+int anchor_store_str(struct val_anchors* anchors, ldns_buffer* buffer,
+       const char* str);
+
 #endif /* VALIDATOR_VAL_ANCHOR_H */