tests/test_res_query_search.c

   1 /*
   2  * Copyright (C) Jakub Hrozek 2014 <jakub.hrozek@posteo.se>
   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 int 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         return 0;
  60 }
  61
  62 static int teardown(void **state)
  63 {
  64         torture_teardown_dns_srv(state);
  65
  66         return 0;
  67 }
  68
  69 static void test_res_query(void **state)
  70 {
  71         int rv;
  72         struct __res_state dnsstate;
  73         unsigned char answer[ANSIZE];
  74         char addr[INET_ADDRSTRLEN];
  75         ns_msg handle;
  76         ns_rr rr;   /* expanded resource record */
  77
  78         (void) state; /* unused */
  79
  80         memset(&dnsstate, 0, sizeof(struct __res_state));
  81         rv = res_ninit(&dnsstate);
  82         assert_int_equal(rv, 0);
  83
  84         rv = res_nquery(&dnsstate, "www.cwrap.org", ns_c_in, ns_t_a,
  85                         answer, sizeof(answer));
  86         assert_int_not_equal(rv, -1);
  87
  88         ns_initparse(answer, sizeof(answer), &handle);
  89         /*
  90          * The query must finish w/o an error, have one answer and the answer
  91          * must be a parseable RR of type A and have the address that our
  92          * test server sends.
  93          */
  94         assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror);
  95         assert_int_equal(ns_msg_count(handle, ns_s_an), 1);
  96         assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0);
  97         assert_int_equal(ns_rr_type(rr), ns_t_a);
  98         assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr),
  99                         addr, sizeof(addr)));
 100         assert_string_equal(addr, "127.0.10.10");
 101
 102         res_nclose(&dnsstate);
 103 }
 104
 105 static void test_res_search(void **state)
 106 {
 107         int rv;
 108         struct __res_state dnsstate;
 109         unsigned char answer[ANSIZE];
 110         char addr[INET_ADDRSTRLEN];
 111         ns_msg handle;
 112         ns_rr rr;   /* expanded resource record */
 113
 114         (void) state; /* unused */
 115
 116         memset(&dnsstate, 0, sizeof(struct __res_state));
 117         rv = res_ninit(&dnsstate);
 118         assert_int_equal(rv, 0);
 119
 120         rv = res_nsearch(&dnsstate, "www.cwrap.org", ns_c_in, ns_t_a,
 121                          answer, sizeof(answer));
 122         assert_int_not_equal(rv, -1);
 123
 124         ns_initparse(answer, sizeof(answer), &handle);
 125         /* The query must finish w/o an error, have one answer and the answer
 126          * must be a parseable RR of type A and have the address that our
 127          * test server sends
 128          */
 129         assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror);
 130         assert_int_equal(ns_msg_count(handle, ns_s_an), 1);
 131         assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0);
 132         assert_int_equal(ns_rr_type(rr), ns_t_a);
 133         assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr),
 134                         addr, sizeof(addr)));
 135         assert_string_equal(addr, "127.0.10.10");
 136
 137         res_nclose(&dnsstate);
 138 }
 139
 140 int main(void)
 141 {
 142         int rc;
 143
 144         const struct CMUnitTest res_tests[] = {
 145                 cmocka_unit_test_setup_teardown(test_res_query,
 146                                                 setup_dns_srv_ipv4,
 147                                                 teardown),
 148                 cmocka_unit_test_setup_teardown(test_res_search,
 149                                                 setup_dns_srv_ipv4,
 150                                                 teardown),
 151         };
 152
 153         rc = cmocka_run_group_tests(res_tests, NULL, NULL);
 154
 155         return rc;
 156 }