testcode/unitmain.c

   1 /*
   2  * testcode/unitmain.c - unit test main program for unbound.
   3  *
   4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
   5  *
   6  * This software is open source.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * Redistributions in binary form must reproduce the above copyright notice,
  16  * this list of conditions and the following disclaimer in the documentation
  17  * and/or other materials provided with the distribution.
  18  *
  19  * Neither the name of the NLNET LABS nor the names of its contributors may
  20  * be used to endorse or promote products derived from this software without
  21  * specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  */
  36 /**
  37  * \file
  38  * Unit test main program. Calls all the other unit tests.
  39  * Exits with code 1 on a failure. 0 if all unit tests are successfull.
  40  */
  41
  42 #include "config.h"
  43 #ifdef HAVE_OPENSSL_ERR_H
  44 #include <openssl/err.h>
  45 #endif
  46
  47 #ifdef HAVE_OPENSSL_RAND_H
  48 #include <openssl/rand.h>
  49 #endif
  50
  51 #ifdef HAVE_OPENSSL_CONF_H
  52 #include <openssl/conf.h>
  53 #endif
  54
  55 #ifdef HAVE_OPENSSL_ENGINE_H
  56 #include <openssl/engine.h>
  57 #endif
  58
  59 #ifdef HAVE_NSS
  60 /* nss3 */
  61 #include "nss.h"
  62 #endif
  63
  64 #include "ldns/rrdef.h"
  65 #include "ldns/keyraw.h"
  66 #include "util/log.h"
  67 #include "testcode/unitmain.h"
  68
  69 /** number of tests done */
  70 int testcount = 0;
  71
  72 #include "util/alloc.h"
  73 /** test alloc code */
  74 static void
  75 alloc_test(void) {
  76         alloc_special_t *t1, *t2;
  77         struct alloc_cache major, minor1, minor2;
  78         int i;
  79
  80         unit_show_feature("alloc_special_obtain");
  81         alloc_init(&major, NULL, 0);
  82         alloc_init(&minor1, &major, 0);
  83         alloc_init(&minor2, &major, 1);
  84
  85         t1 = alloc_special_obtain(&minor1);
  86         alloc_clear(&minor1);
  87
  88         alloc_special_release(&minor2, t1);
  89         t2 = alloc_special_obtain(&minor2);
  90         unit_assert( t1 == t2 ); /* reused */
  91         alloc_special_release(&minor2, t1);
  92
  93         for(i=0; i<100; i++) {
  94                 t1 = alloc_special_obtain(&minor1);
  95                 alloc_special_release(&minor2, t1);
  96         }
  97         if(0) {
  98                 alloc_stats(&minor1);
  99                 alloc_stats(&minor2);
 100                 alloc_stats(&major);
 101         }
 102         /* reuse happened */
 103         unit_assert(minor1.num_quar + minor2.num_quar + major.num_quar == 11);
 104
 105         alloc_clear(&minor1);
 106         alloc_clear(&minor2);
 107         unit_assert(major.num_quar == 11);
 108         alloc_clear(&major);
 109 }
 110
 111 #include "util/net_help.h"
 112 /** test net code */
 113 static void
 114 net_test(void)
 115 {
 116         const char* t4[] = {"\000\000\000\000",
 117                 "\200\000\000\000",
 118                 "\300\000\000\000",
 119                 "\340\000\000\000",
 120                 "\360\000\000\000",
 121                 "\370\000\000\000",
 122                 "\374\000\000\000",
 123                 "\376\000\000\000",
 124                 "\377\000\000\000",
 125                 "\377\200\000\000",
 126                 "\377\300\000\000",
 127                 "\377\340\000\000",
 128                 "\377\360\000\000",
 129                 "\377\370\000\000",
 130                 "\377\374\000\000",
 131                 "\377\376\000\000",
 132                 "\377\377\000\000",
 133                 "\377\377\200\000",
 134                 "\377\377\300\000",
 135                 "\377\377\340\000",
 136                 "\377\377\360\000",
 137                 "\377\377\370\000",
 138                 "\377\377\374\000",
 139                 "\377\377\376\000",
 140                 "\377\377\377\000",
 141                 "\377\377\377\200",
 142                 "\377\377\377\300",
 143                 "\377\377\377\340",
 144                 "\377\377\377\360",
 145                 "\377\377\377\370",
 146                 "\377\377\377\374",
 147                 "\377\377\377\376",
 148                 "\377\377\377\377",
 149                 "\377\377\377\377",
 150                 "\377\377\377\377",
 151         };
 152         unit_show_func("util/net_help.c", "str_is_ip6");
 153         unit_assert( str_is_ip6("::") );
 154         unit_assert( str_is_ip6("::1") );
 155         unit_assert( str_is_ip6("2001:7b8:206:1:240:f4ff:fe37:8810") );
 156         unit_assert( str_is_ip6("fe80::240:f4ff:fe37:8810") );
 157         unit_assert( !str_is_ip6("0.0.0.0") );
 158         unit_assert( !str_is_ip6("213.154.224.12") );
 159         unit_assert( !str_is_ip6("213.154.224.255") );
 160         unit_assert( !str_is_ip6("255.255.255.0") );
 161         unit_show_func("util/net_help.c", "is_pow2");
 162         unit_assert( is_pow2(0) );
 163         unit_assert( is_pow2(1) );
 164         unit_assert( is_pow2(2) );
 165         unit_assert( is_pow2(4) );
 166         unit_assert( is_pow2(8) );
 167         unit_assert( is_pow2(16) );
 168         unit_assert( is_pow2(1024) );
 169         unit_assert( is_pow2(1024*1024) );
 170         unit_assert( is_pow2(1024*1024*1024) );
 171         unit_assert( !is_pow2(3) );
 172         unit_assert( !is_pow2(5) );
 173         unit_assert( !is_pow2(6) );
 174         unit_assert( !is_pow2(7) );
 175         unit_assert( !is_pow2(9) );
 176         unit_assert( !is_pow2(10) );
 177         unit_assert( !is_pow2(11) );
 178         unit_assert( !is_pow2(17) );
 179         unit_assert( !is_pow2(23) );
 180         unit_assert( !is_pow2(257) );
 181         unit_assert( !is_pow2(259) );
 182
 183         /* test addr_mask */
 184         unit_show_func("util/net_help.c", "addr_mask");
 185         if(1) {
 186                 struct sockaddr_in a4;
 187                 struct sockaddr_in6 a6;
 188                 socklen_t l4 = (socklen_t)sizeof(a4);
 189                 socklen_t l6 = (socklen_t)sizeof(a6);
 190                 int i;
 191                 a4.sin_family = AF_INET;
 192                 a6.sin6_family = AF_INET6;
 193                 for(i=0; i<35; i++) {
 194                         /* address 255.255.255.255 */
 195                         memcpy(&a4.sin_addr, "\377\377\377\377", 4);
 196                         addr_mask((struct sockaddr_storage*)&a4, l4, i);
 197                         unit_assert(memcmp(&a4.sin_addr, t4[i], 4) == 0);
 198                 }
 199                 memcpy(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377", 16);
 200                 addr_mask((struct sockaddr_storage*)&a6, l6, 128);
 201                 unit_assert(memcmp(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377", 16) == 0);
 202                 addr_mask((struct sockaddr_storage*)&a6, l6, 122);
 203                 unit_assert(memcmp(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\300", 16) == 0);
 204                 addr_mask((struct sockaddr_storage*)&a6, l6, 120);
 205                 unit_assert(memcmp(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\000", 16) == 0);
 206                 addr_mask((struct sockaddr_storage*)&a6, l6, 64);
 207                 unit_assert(memcmp(&a6.sin6_addr, "\377\377\377\377\377\377\377\377\000\000\000\000\000\000\000\000", 16) == 0);
 208                 addr_mask((struct sockaddr_storage*)&a6, l6, 0);
 209                 unit_assert(memcmp(&a6.sin6_addr, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000", 16) == 0);
 210         }
 211
 212         /* test addr_in_common */
 213         unit_show_func("util/net_help.c", "addr_in_common");
 214         if(1) {
 215                 struct sockaddr_in a4, b4;
 216                 struct sockaddr_in6 a6, b6;
 217                 socklen_t l4 = (socklen_t)sizeof(a4);
 218                 socklen_t l6 = (socklen_t)sizeof(a6);
 219                 int i;
 220                 a4.sin_family = AF_INET;
 221                 b4.sin_family = AF_INET;
 222                 a6.sin6_family = AF_INET6;
 223                 b6.sin6_family = AF_INET6;
 224                 memcpy(&a4.sin_addr, "abcd", 4);
 225                 memcpy(&b4.sin_addr, "abcd", 4);
 226                 unit_assert(addr_in_common((struct sockaddr_storage*)&a4, 32,
 227                         (struct sockaddr_storage*)&b4, 32, l4) == 32);
 228                 unit_assert(addr_in_common((struct sockaddr_storage*)&a4, 34,
 229                         (struct sockaddr_storage*)&b4, 32, l4) == 32);
 230                 for(i=0; i<=32; i++) {
 231                         unit_assert(addr_in_common(
 232                                 (struct sockaddr_storage*)&a4, 32,
 233                                 (struct sockaddr_storage*)&b4, i, l4) == i);
 234                         unit_assert(addr_in_common(
 235                                 (struct sockaddr_storage*)&a4, i,
 236                                 (struct sockaddr_storage*)&b4, 32, l4) == i);
 237                         unit_assert(addr_in_common(
 238                                 (struct sockaddr_storage*)&a4, i,
 239                                 (struct sockaddr_storage*)&b4, i, l4) == i);
 240                 }
 241                 for(i=0; i<=32; i++) {
 242                         memcpy(&a4.sin_addr, "\377\377\377\377", 4);
 243                         memcpy(&b4.sin_addr, t4[i], 4);
 244                         unit_assert(addr_in_common(
 245                                 (struct sockaddr_storage*)&a4, 32,
 246                                 (struct sockaddr_storage*)&b4, 32, l4) == i);
 247                         unit_assert(addr_in_common(
 248                                 (struct sockaddr_storage*)&b4, 32,
 249                                 (struct sockaddr_storage*)&a4, 32, l4) == i);
 250                 }
 251                 memcpy(&a6.sin6_addr, "abcdefghabcdefgh", 16);
 252                 memcpy(&b6.sin6_addr, "abcdefghabcdefgh", 16);
 253                 unit_assert(addr_in_common((struct sockaddr_storage*)&a6, 128,
 254                         (struct sockaddr_storage*)&b6, 128, l6) == 128);
 255                 unit_assert(addr_in_common((struct sockaddr_storage*)&a6, 129,
 256                         (struct sockaddr_storage*)&b6, 128, l6) == 128);
 257                 for(i=0; i<=128; i++) {
 258                         unit_assert(addr_in_common(
 259                                 (struct sockaddr_storage*)&a6, 128,
 260                                 (struct sockaddr_storage*)&b6, i, l6) == i);
 261                         unit_assert(addr_in_common(
 262                                 (struct sockaddr_storage*)&a6, i,
 263                                 (struct sockaddr_storage*)&b6, 128, l6) == i);
 264                         unit_assert(addr_in_common(
 265                                 (struct sockaddr_storage*)&a6, i,
 266                                 (struct sockaddr_storage*)&b6, i, l6) == i);
 267                 }
 268         }
 269         /* test sockaddr_cmp_addr */
 270         unit_show_func("util/net_help.c", "sockaddr_cmp_addr");
 271         if(1) {
 272                 struct sockaddr_storage a, b;
 273                 socklen_t alen = (socklen_t)sizeof(a);
 274                 socklen_t blen = (socklen_t)sizeof(b);
 275                 unit_assert(ipstrtoaddr("127.0.0.0", 53, &a, &alen));
 276                 unit_assert(ipstrtoaddr("127.255.255.255", 53, &b, &blen));
 277                 unit_assert(sockaddr_cmp_addr(&a, alen, &b, blen) < 0);
 278                 unit_assert(sockaddr_cmp_addr(&b, blen, &a, alen) > 0);
 279                 unit_assert(sockaddr_cmp_addr(&a, alen, &a, alen) == 0);
 280                 unit_assert(sockaddr_cmp_addr(&b, blen, &b, blen) == 0);
 281                 unit_assert(ipstrtoaddr("192.168.121.5", 53, &a, &alen));
 282                 unit_assert(sockaddr_cmp_addr(&a, alen, &b, blen) > 0);
 283                 unit_assert(sockaddr_cmp_addr(&b, blen, &a, alen) < 0);
 284                 unit_assert(sockaddr_cmp_addr(&a, alen, &a, alen) == 0);
 285                 unit_assert(ipstrtoaddr("2001:3578:ffeb::99", 53, &b, &blen));
 286                 unit_assert(sockaddr_cmp_addr(&b, blen, &b, blen) == 0);
 287                 unit_assert(sockaddr_cmp_addr(&a, alen, &b, blen) < 0);
 288                 unit_assert(sockaddr_cmp_addr(&b, blen, &a, alen) > 0);
 289         }
 290         /* test addr_is_ip4mapped */
 291         unit_show_func("util/net_help.c", "addr_is_ip4mapped");
 292         if(1) {
 293                 struct sockaddr_storage a;
 294                 socklen_t l = (socklen_t)sizeof(a);
 295                 unit_assert(ipstrtoaddr("12.13.14.15", 53, &a, &l));
 296                 unit_assert(!addr_is_ip4mapped(&a, l));
 297                 unit_assert(ipstrtoaddr("fe80::217:31ff:fe91:df", 53, &a, &l));
 298                 unit_assert(!addr_is_ip4mapped(&a, l));
 299                 unit_assert(ipstrtoaddr("ffff::217:31ff:fe91:df", 53, &a, &l));
 300                 unit_assert(!addr_is_ip4mapped(&a, l));
 301                 unit_assert(ipstrtoaddr("::ffff:31ff:fe91:df", 53, &a, &l));
 302                 unit_assert(!addr_is_ip4mapped(&a, l));
 303                 unit_assert(ipstrtoaddr("::fffe:fe91:df", 53, &a, &l));
 304                 unit_assert(!addr_is_ip4mapped(&a, l));
 305                 unit_assert(ipstrtoaddr("::ffff:127.0.0.1", 53, &a, &l));
 306                 unit_assert(addr_is_ip4mapped(&a, l));
 307                 unit_assert(ipstrtoaddr("::ffff:127.0.0.2", 53, &a, &l));
 308                 unit_assert(addr_is_ip4mapped(&a, l));
 309                 unit_assert(ipstrtoaddr("::ffff:192.168.0.2", 53, &a, &l));
 310                 unit_assert(addr_is_ip4mapped(&a, l));
 311                 unit_assert(ipstrtoaddr("2::ffff:192.168.0.2", 53, &a, &l));
 312                 unit_assert(!addr_is_ip4mapped(&a, l));
 313         }
 314         /* test addr_is_any */
 315         unit_show_func("util/net_help.c", "addr_is_any");
 316         if(1) {
 317                 struct sockaddr_storage a;
 318                 socklen_t l = (socklen_t)sizeof(a);
 319                 unit_assert(ipstrtoaddr("0.0.0.0", 53, &a, &l));
 320                 unit_assert(addr_is_any(&a, l));
 321                 unit_assert(ipstrtoaddr("0.0.0.0", 10053, &a, &l));
 322                 unit_assert(addr_is_any(&a, l));
 323                 unit_assert(ipstrtoaddr("0.0.0.0", 0, &a, &l));
 324                 unit_assert(addr_is_any(&a, l));
 325                 unit_assert(ipstrtoaddr("::0", 0, &a, &l));
 326                 unit_assert(addr_is_any(&a, l));
 327                 unit_assert(ipstrtoaddr("::0", 53, &a, &l));
 328                 unit_assert(addr_is_any(&a, l));
 329                 unit_assert(ipstrtoaddr("::1", 53, &a, &l));
 330                 unit_assert(!addr_is_any(&a, l));
 331                 unit_assert(ipstrtoaddr("2001:1667::1", 0, &a, &l));
 332                 unit_assert(!addr_is_any(&a, l));
 333                 unit_assert(ipstrtoaddr("2001::0", 0, &a, &l));
 334                 unit_assert(!addr_is_any(&a, l));
 335                 unit_assert(ipstrtoaddr("10.0.0.0", 0, &a, &l));
 336                 unit_assert(!addr_is_any(&a, l));
 337                 unit_assert(ipstrtoaddr("0.0.0.10", 0, &a, &l));
 338                 unit_assert(!addr_is_any(&a, l));
 339                 unit_assert(ipstrtoaddr("192.0.2.1", 0, &a, &l));
 340                 unit_assert(!addr_is_any(&a, l));
 341         }
 342 }
 343
 344 #include "util/config_file.h"
 345 /** test config_file: cfg_parse_memsize */
 346 static void
 347 config_memsize_test(void)
 348 {
 349         size_t v = 0;
 350         unit_show_func("util/config_file.c", "cfg_parse_memsize");
 351         if(0) {
 352                 /* these emit errors */
 353                 unit_assert( cfg_parse_memsize("", &v) == 0);
 354                 unit_assert( cfg_parse_memsize("bla", &v) == 0);
 355                 unit_assert( cfg_parse_memsize("nop", &v) == 0);
 356                 unit_assert( cfg_parse_memsize("n0b", &v) == 0);
 357                 unit_assert( cfg_parse_memsize("gb", &v) == 0);
 358                 unit_assert( cfg_parse_memsize("b", &v) == 0);
 359                 unit_assert( cfg_parse_memsize("kb", &v) == 0);
 360                 unit_assert( cfg_parse_memsize("kk kb", &v) == 0);
 361         }
 362         unit_assert( cfg_parse_memsize("0", &v) && v==0);
 363         unit_assert( cfg_parse_memsize("1", &v) && v==1);
 364         unit_assert( cfg_parse_memsize("10", &v) && v==10);
 365         unit_assert( cfg_parse_memsize("10b", &v) && v==10);
 366         unit_assert( cfg_parse_memsize("5b", &v) && v==5);
 367         unit_assert( cfg_parse_memsize("1024", &v) && v==1024);
 368         unit_assert( cfg_parse_memsize("1k", &v) && v==1024);
 369         unit_assert( cfg_parse_memsize("1K", &v) && v==1024);
 370         unit_assert( cfg_parse_memsize("1Kb", &v) && v==1024);
 371         unit_assert( cfg_parse_memsize("1kb", &v) && v==1024);
 372         unit_assert( cfg_parse_memsize("1 kb", &v) && v==1024);
 373         unit_assert( cfg_parse_memsize("10 kb", &v) && v==10240);
 374         unit_assert( cfg_parse_memsize("2k", &v) && v==2048);
 375         unit_assert( cfg_parse_memsize("2m", &v) && v==2048*1024);
 376         unit_assert( cfg_parse_memsize("3M", &v) && v==3072*1024);
 377         unit_assert( cfg_parse_memsize("40m", &v) && v==40960*1024);
 378         unit_assert( cfg_parse_memsize("1G", &v) && v==1024*1024*1024);
 379         unit_assert( cfg_parse_memsize("1 Gb", &v) && v==1024*1024*1024);
 380         unit_assert( cfg_parse_memsize("0 Gb", &v) && v==0*1024*1024);
 381 }
 382
 383 #include "util/rtt.h"
 384 /** test RTT code */
 385 static void
 386 rtt_test(void)
 387 {
 388         int init = 376;
 389         int i;
 390         struct rtt_info r;
 391         unit_show_func("util/rtt.c", "rtt_timeout");
 392         rtt_init(&r);
 393         /* initial value sensible */
 394         unit_assert( rtt_timeout(&r) == init );
 395         rtt_lost(&r, init);
 396         unit_assert( rtt_timeout(&r) == init*2 );
 397         rtt_lost(&r, init*2);
 398         unit_assert( rtt_timeout(&r) == init*4 );
 399         rtt_update(&r, 4000);
 400         unit_assert( rtt_timeout(&r) >= 2000 );
 401         rtt_lost(&r, rtt_timeout(&r) );
 402         for(i=0; i<100; i++) {
 403                 rtt_lost(&r, rtt_timeout(&r) );
 404                 unit_assert( rtt_timeout(&r) > RTT_MIN_TIMEOUT-1);
 405                 unit_assert( rtt_timeout(&r) < RTT_MAX_TIMEOUT+1);
 406         }
 407 }
 408
 409 #include "services/cache/infra.h"
 410 #include "util/config_file.h"
 411
 412 /* lookup and get key and data structs easily */
 413 static struct infra_data* infra_lookup_host(struct infra_cache* infra,
 414         struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
 415         size_t zonelen, int wr, time_t now, struct infra_key** k)
 416 {
 417         struct infra_data* d;
 418         struct lruhash_entry* e = infra_lookup_nottl(infra, addr, addrlen,
 419                 zone, zonelen, wr);
 420         if(!e) return NULL;
 421         d = (struct infra_data*)e->data;
 422         if(d->ttl < now) {
 423                 lock_rw_unlock(&e->lock);
 424                 return NULL;
 425         }
 426         *k = (struct infra_key*)e->key;
 427         return d;
 428 }
 429
 430 /** test host cache */
 431 static void
 432 infra_test(void)
 433 {
 434         struct sockaddr_storage one;
 435         socklen_t onelen;
 436         uint8_t* zone = (uint8_t*)"\007example\003com\000";
 437         size_t zonelen = 13;
 438         struct infra_cache* slab;
 439         struct config_file* cfg = config_create();
 440         time_t now = 0;
 441         uint8_t edns_lame;
 442         int vs, to;
 443         struct infra_key* k;
 444         struct infra_data* d;
 445         int init = 376;
 446
 447         unit_show_feature("infra cache");
 448         unit_assert(ipstrtoaddr("127.0.0.1", 53, &one, &onelen));
 449
 450         slab = infra_create(cfg);
 451         unit_assert( infra_host(slab, &one, onelen, zone, zonelen, now,
 452                 &vs, &edns_lame, &to) );
 453         unit_assert( vs == 0 && to == init && edns_lame == 0 );
 454
 455         unit_assert( infra_rtt_update(slab, &one, onelen, zone, zonelen, LDNS_RR_TYPE_A, -1, init, now) );
 456         unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
 457                         now, &vs, &edns_lame, &to) );
 458         unit_assert( vs == 0 && to == init*2 && edns_lame == 0 );
 459
 460         unit_assert( infra_edns_update(slab, &one, onelen, zone, zonelen, -1, now) );
 461         unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
 462                         now, &vs, &edns_lame, &to) );
 463         unit_assert( vs == -1 && to == init*2  && edns_lame == 1);
 464
 465         now += cfg->host_ttl + 10;
 466         unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
 467                         now, &vs, &edns_lame, &to) );
 468         unit_assert( vs == 0 && to == init && edns_lame == 0 );
 469
 470         unit_assert( infra_set_lame(slab, &one, onelen,
 471                 zone, zonelen,  now, 0, 0, LDNS_RR_TYPE_A) );
 472         unit_assert( (d=infra_lookup_host(slab, &one, onelen, zone, zonelen, 0, now, &k)) );
 473         unit_assert( d->ttl == now+cfg->host_ttl );
 474         unit_assert( d->edns_version == 0 );
 475         unit_assert(!d->isdnsseclame && !d->rec_lame && d->lame_type_A &&
 476                 !d->lame_other);
 477         lock_rw_unlock(&k->entry.lock);
 478
 479         /* test merge of data */
 480         unit_assert( infra_set_lame(slab, &one, onelen,
 481                 zone, zonelen,  now, 0, 0, LDNS_RR_TYPE_AAAA) );
 482         unit_assert( (d=infra_lookup_host(slab, &one, onelen, zone, zonelen, 0, now, &k)) );
 483         unit_assert(!d->isdnsseclame && !d->rec_lame && d->lame_type_A &&
 484                 d->lame_other);
 485         lock_rw_unlock(&k->entry.lock);
 486
 487         /* test that noEDNS cannot overwrite known-yesEDNS */
 488         now += cfg->host_ttl + 10;
 489         unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
 490                         now, &vs, &edns_lame, &to) );
 491         unit_assert( vs == 0 && to == init && edns_lame == 0 );
 492
 493         unit_assert( infra_edns_update(slab, &one, onelen, zone, zonelen, 0, now) );
 494         unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
 495                         now, &vs, &edns_lame, &to) );
 496         unit_assert( vs == 0 && to == init && edns_lame == 1 );
 497
 498         unit_assert( infra_edns_update(slab, &one, onelen, zone, zonelen, -1, now) );
 499         unit_assert( infra_host(slab, &one, onelen, zone, zonelen,
 500                         now, &vs, &edns_lame, &to) );
 501         unit_assert( vs == 0 && to == init && edns_lame == 1 );
 502
 503         infra_delete(slab);
 504         config_delete(cfg);
 505 }
 506
 507 #include "util/random.h"
 508 /** test randomness */
 509 static void
 510 rnd_test(void)
 511 {
 512         struct ub_randstate* r;
 513         int num = 1000, i;
 514         long int a[1000];
 515         unsigned int seed = (unsigned)time(NULL);
 516         unit_show_feature("ub_random");
 517         printf("ub_random seed is %u\n", seed);
 518         unit_assert( (r = ub_initstate(seed, NULL)) );
 519         for(i=0; i<num; i++) {
 520                 a[i] = ub_random(r);
 521                 unit_assert(a[i] >= 0);
 522                 unit_assert((size_t)a[i] <= (size_t)0x7fffffff);
 523                 if(i > 5)
 524                         unit_assert(a[i] != a[i-1] || a[i] != a[i-2] ||
 525                                 a[i] != a[i-3] || a[i] != a[i-4] ||
 526                                 a[i] != a[i-5] || a[i] != a[i-6]);
 527         }
 528         a[0] = ub_random_max(r, 1);
 529         unit_assert(a[0] >= 0 && a[0] < 1);
 530         a[0] = ub_random_max(r, 10000);
 531         unit_assert(a[0] >= 0 && a[0] < 10000);
 532         for(i=0; i<num; i++) {
 533                 a[i] = ub_random_max(r, 10);
 534                 unit_assert(a[i] >= 0 && a[i] < 10);
 535         }
 536         ub_randfree(r);
 537 }
 538
 539 void unit_show_func(const char* file, const char* func)
 540 {
 541         printf("test %s:%s\n", file, func);
 542 }
 543
 544 void unit_show_feature(const char* feature)
 545 {
 546         printf("test %s functions\n", feature);
 547 }
 548
 549 /**
 550  * Main unit test program. Setup, teardown and report errors.
 551  * @param argc: arg count.
 552  * @param argv: array of commandline arguments.
 553  * @return program failure if test fails.
 554  */
 555 int
 556 main(int argc, char* argv[])
 557 {
 558         log_init(NULL, 0, NULL);
 559         if(argc != 1) {
 560                 printf("usage: %s\n", argv[0]);
 561                 printf("\tperforms unit tests.\n");
 562                 return 1;
 563         }
 564         printf("Start of %s unit test.\n", PACKAGE_STRING);
 565 #ifdef HAVE_SSL
 566         ERR_load_crypto_strings();
 567 #  ifdef HAVE_OPENSSL_CONFIG
 568         OPENSSL_config("unbound");
 569 #  endif
 570 #  ifdef USE_GOST
 571         (void)sldns_key_EVP_load_gost_id();
 572 #  endif
 573 #elif defined(HAVE_NSS)
 574         if(NSS_NoDB_Init(".") != SECSuccess)
 575                 fatal_exit("could not init NSS");
 576 #endif /* HAVE_SSL or HAVE_NSS*/
 577         checklock_start();
 578         neg_test();
 579         rnd_test();
 580         verify_test();
 581         net_test();
 582         config_memsize_test();
 583         dname_test();
 584         rtt_test();
 585         anchors_test();
 586         alloc_test();
 587         regional_test();
 588         lruhash_test();
 589         slabhash_test();
 590         infra_test();
 591         ldns_test();
 592         msgparse_test();
 593         checklock_stop();
 594         printf("%d checks ok.\n", testcount);
 595 #ifdef HAVE_SSL
 596 #  if defined(USE_GOST) && defined(HAVE_LDNS_KEY_EVP_UNLOAD_GOST)
 597         sldns_key_EVP_unload_gost();
 598 #  endif
 599 #  ifdef HAVE_OPENSSL_CONFIG
 600         EVP_cleanup();
 601         ENGINE_cleanup();
 602         CONF_modules_free();
 603 #  endif
 604         CRYPTO_cleanup_all_ex_data();
 605         ERR_remove_state(0);
 606         ERR_free_strings();
 607         RAND_cleanup();
 608 #elif defined(HAVE_NSS)
 609         if(NSS_Shutdown() != SECSuccess)
 610                 fatal_exit("could not shutdown NSS");
 611 #endif /* HAVE_SSL or HAVE_NSS */
 612 #ifdef HAVE_PTHREAD
 613         /* dlopen frees its thread specific state */
 614         pthread_exit(NULL);
 615 #endif
 616         return 0;
 617 }