tests/test_res_query_search.c

   1 /*
   2  * Copyright (C) Jakub Hrozek 2014 <jakub.hrozek@gmail.com>
   3  *
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the author nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include <stdarg.h>
  35 #include <stddef.h>
  36 #include <setjmp.h>
  37 #include <cmocka.h>
  38
  39 #include "config.h"
  40 #include "torture.h"
  41
  42 #include <stdlib.h>
  43 #include <unistd.h>
  44 #include <string.h>
  45 #include <stdio.h>
  46
  47 #include <netinet/in.h>
  48 #include <arpa/nameser.h>
  49 #include <arpa/inet.h>
  50 #include <resolv.h>
  51
  52 #define ANSIZE 256
  53
  54 static void setup_dns_srv_ipv4(void **state)
  55 {
  56         torture_setup_dns_srv_ipv4(state);
  57         setenv("RESOLV_WRAPPER_CONF", torture_server_resolv_conf(state), 1);
  58 }
  59
  60 static void teardown(void **state)
  61 {
  62         torture_teardown_dns_srv(state);
  63 }
  64
  65 static void test_res_query(void **state)
  66 {
  67         int rv;
  68         struct __res_state dnsstate;
  69         unsigned char answer[ANSIZE];
  70         char addr[INET_ADDRSTRLEN];
  71         ns_msg handle;
  72         ns_rr rr;   /* expanded resource record */
  73
  74         (void) state; /* unused */
  75
  76         memset(&dnsstate, 0, sizeof(struct __res_state));
  77         rv = res_ninit(&dnsstate);
  78         assert_int_equal(rv, 0);
  79
  80         rv = res_nquery(&dnsstate, "www.cwrap.org", ns_c_in, ns_t_a,
  81                         answer, ANSIZE);
  82         assert_int_not_equal(rv, -1);
  83
  84         ns_initparse(answer, 256, &handle);
  85         /*
  86          * The query must finish w/o an error, have one answer and the answer
  87          * must be a parseable RR of type A and have the address that our
  88          * test server sends.
  89          */
  90         assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror);
  91         assert_int_equal(ns_msg_count(handle, ns_s_an), 1);
  92         assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0);
  93         assert_int_equal(ns_rr_type(rr), ns_t_a);
  94         assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr), addr, 256));
  95         assert_string_equal(addr, "127.0.10.10");
  96
  97         res_nclose(&dnsstate);
  98 }
  99
 100 static void test_res_search(void **state)
 101 {
 102         int rv;
 103         struct __res_state dnsstate;
 104         unsigned char answer[ANSIZE];
 105         char addr[INET_ADDRSTRLEN];
 106         ns_msg handle;
 107         ns_rr rr;   /* expanded resource record */
 108
 109         (void) state; /* unused */
 110
 111         memset(&dnsstate, 0, sizeof(struct __res_state));
 112         rv = res_ninit(&dnsstate);
 113         assert_int_equal(rv, 0);
 114
 115         rv = res_nsearch(&dnsstate, "www.cwrap.org", ns_c_in, ns_t_a,
 116                          answer, ANSIZE);
 117         assert_int_not_equal(rv, -1);
 118
 119         ns_initparse(answer, 256, &handle);
 120         /* The query must finish w/o an error, have one answer and the answer
 121          * must be a parseable RR of type A and have the address that our
 122          * test server sends
 123          */
 124         assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror);
 125         assert_int_equal(ns_msg_count(handle, ns_s_an), 1);
 126         assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0);
 127         assert_int_equal(ns_rr_type(rr), ns_t_a);
 128         assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr), addr, 256));
 129         assert_string_equal(addr, "127.0.10.10");
 130
 131         res_nclose(&dnsstate);
 132 }
 133
 134 int main(void)
 135 {
 136         int rc;
 137
 138         const UnitTest tests[] = {
 139                 unit_test_setup_teardown(test_res_query,
 140                                          setup_dns_srv_ipv4,
 141                                          teardown),
 142                 unit_test_setup_teardown(test_res_search,
 143                                          setup_dns_srv_ipv4,
 144                                          teardown),
 145         };
 146
 147         rc = run_tests(tests);
 148
 149         return rc;
 150 }