1 /* $NetBSD: t_resolver.c,v 1.11 2014/12/10 04:37:53 christos Exp $ */ 2 3 /* 4 * Copyright (C) 2011-2014 Internet Systems Consortium, Inc. ("ISC") 5 * 6 * Permission to use, copy, modify, and/or distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH 11 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 12 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, 13 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 14 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 15 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 /* Id: t_resolver.c,v 1.3 2011/02/03 12:18:11 tbox Exp */ 20 21 #include <config.h> 22 23 #include <ctype.h> 24 #include <stdlib.h> 25 26 #include <isc/mem.h> 27 #include <isc/util.h> 28 #include <isc/string.h> 29 #include <isc/timer.h> 30 #include <isc/task.h> 31 32 #include <dns/dispatch.h> 33 #include <dns/resolver.h> 34 #include <dns/result.h> 35 #include <dns/view.h> 36 37 #include <tests/t_api.h> 38 39 char *progname; 40 41 #define CHECK(x) RUNTIME_CHECK(ISC_R_SUCCESS == (x)) 42 43 44 isc_mem_t *mctx = NULL; 45 isc_timermgr_t *timer_manager = NULL; 46 isc_socketmgr_t *socket_manager = NULL; 47 isc_taskmgr_t *task_manager = NULL; 48 dns_dispatchmgr_t *dispatch_manager = NULL; 49 dns_view_t *view = NULL; 50 dns_dispatch_t *dispatch_v4 = NULL; 51 52 static void 53 setup_create_dispatch_v4(void) 54 { 55 isc_sockaddr_t local_address; 56 isc_sockaddr_any(&local_address); 57 58 CHECK(dns_dispatch_getudp(dispatch_manager, socket_manager, 59 task_manager, &local_address, 60 4096, 100, 100, 100, 500, 0, 0, 61 &dispatch_v4)); 62 } 63 static void 64 setup(void) { 65 /* 1 */ CHECK(isc_mem_create(0, 0, &mctx)); 66 /* 2 */ CHECK(isc_timermgr_create(mctx, &timer_manager)); 67 /* 3 */ CHECK(isc_taskmgr_create(mctx, 1, 0, &task_manager)); 68 /* 4 */ CHECK(isc_socketmgr_create(mctx, &socket_manager)); 69 /* 5 */ CHECK(dns_dispatchmgr_create(mctx, NULL, &dispatch_manager)); 70 /* 6 */ CHECK(dns_view_create(mctx, dns_rdataclass_in, "testview", &view)); 71 /* 7 */ setup_create_dispatch_v4(); 72 } 73 74 static void 75 teardown(void) { 76 /* 7 */ dns_dispatch_detach(&dispatch_v4); 77 /* 6 */ dns_view_detach(&view); 78 /* 5 */ dns_dispatchmgr_destroy(&dispatch_manager); 79 /* 4 */ isc_socketmgr_destroy(&socket_manager); 80 /* 3 */ isc_taskmgr_destroy(&task_manager); 81 /* 2 */ isc_timermgr_destroy(&timer_manager); 82 /* 1 */ isc_mem_destroy(&mctx); 83 } 84 85 static isc_result_t 86 make_resolver(dns_resolver_t **resolverp) { 87 isc_result_t result; 88 89 result = dns_resolver_create(view, 90 task_manager, 1, 1, 91 socket_manager, 92 timer_manager, 93 0, /* unsigned int options, */ 94 dispatch_manager, 95 dispatch_v4, 96 NULL, /* dns_dispatch_t *dispatchv6, */ 97 resolverp); 98 99 return (result); 100 } 101 102 static void 103 destroy_resolver(dns_resolver_t **resolverp) { 104 dns_resolver_shutdown(*resolverp); 105 dns_resolver_detach(resolverp); 106 } 107 108 static void 109 test_dns_resolver_create(void) { 110 dns_resolver_t *resolver = NULL; 111 112 t_assert("test_dns_resolver_create", 1, T_REQUIRED, "%s", 113 "a resolver can be created successfully"); 114 setup(); 115 CHECK(make_resolver(&resolver)); 116 117 destroy_resolver(&resolver); 118 teardown(); 119 120 t_result(T_PASS); 121 } 122 123 static void 124 test_dns_resolver_gettimeout(void) { 125 dns_resolver_t *resolver = NULL; 126 int test_result; 127 unsigned int timeout; 128 129 t_assert("test_dns_resolver_gettimeout", 1, T_REQUIRED, "%s", 130 "The default timeout is returned from _gettimeout()"); 131 setup(); 132 CHECK(make_resolver(&resolver)); 133 134 timeout = dns_resolver_gettimeout(resolver); 135 t_info("The default timeout is %d second%s\n", timeout, (timeout == 1 ? "" : "s")); 136 test_result = (timeout > 0) ? T_PASS : T_FAIL; 137 138 destroy_resolver(&resolver); 139 teardown(); 140 141 t_result(test_result); 142 } 143 144 static void 145 test_dns_resolver_settimeout(void) { 146 dns_resolver_t *resolver = NULL; 147 int test_result; 148 unsigned int default_timeout, timeout; 149 150 t_assert("test_dns_resolver_settimeout", 1, T_REQUIRED, "%s", 151 "_settimeout() can change the timeout to a non-default"); 152 setup(); 153 CHECK(make_resolver(&resolver)); 154 155 default_timeout = dns_resolver_gettimeout(resolver); 156 t_info("The default timeout is %d second%s\n", default_timeout, 157 (default_timeout == 1 ? "" : "s")); 158 159 dns_resolver_settimeout(resolver, default_timeout + 1); 160 timeout = dns_resolver_gettimeout(resolver); 161 t_info("The new timeout is %d second%s\n", timeout, 162 (timeout == 1 ? "" : "s")); 163 test_result = (timeout == default_timeout + 1) ? T_PASS : T_FAIL; 164 165 destroy_resolver(&resolver); 166 teardown(); 167 168 t_result(test_result); 169 } 170 171 static void 172 test_dns_resolver_settimeout_to_default(void) { 173 dns_resolver_t *resolver = NULL; 174 int test_result; 175 unsigned int default_timeout, timeout; 176 177 t_assert("test_dns_resolver_settimeout_to_default", 1, T_REQUIRED, "%s", 178 "_settimeout() can change the timeout back to a default value" 179 " by specifying 0 as the timeout."); 180 setup(); 181 CHECK(make_resolver(&resolver)); 182 183 default_timeout = dns_resolver_gettimeout(resolver); 184 t_info("The default timeout is %d second%s\n", default_timeout, 185 (default_timeout == 1 ? "" : "s")); 186 187 dns_resolver_settimeout(resolver, default_timeout - 1); 188 timeout = dns_resolver_gettimeout(resolver); 189 t_info("The new timeout is %d second%s\n", timeout, 190 (timeout == 1 ? "" : "s")); 191 192 dns_resolver_settimeout(resolver, 0); 193 timeout = dns_resolver_gettimeout(resolver); 194 test_result = (timeout == default_timeout) ? T_PASS : T_FAIL; 195 196 destroy_resolver(&resolver); 197 teardown(); 198 199 t_result(test_result); 200 } 201 202 static void 203 test_dns_resolver_settimeout_over_maximum(void) { 204 dns_resolver_t *resolver = NULL; 205 int test_result; 206 unsigned int timeout; 207 208 t_assert("test_dns_resolver_settimeout_over_maximum", 1, T_REQUIRED, "%s", 209 "_settimeout() cannot set the value larger than the maximum."); 210 setup(); 211 CHECK(make_resolver(&resolver)); 212 213 dns_resolver_settimeout(resolver, 4000000); 214 timeout = dns_resolver_gettimeout(resolver); 215 t_info("The new timeout is %d second%s\n", timeout, 216 (timeout == 1 ? "" : "s")); 217 218 test_result = (timeout < 4000000 && timeout > 0) ? T_PASS : T_FAIL; 219 220 destroy_resolver(&resolver); 221 teardown(); 222 223 t_result(test_result); 224 } 225 226 227 testspec_t T_testlist[] = { 228 { (PFV) test_dns_resolver_create, "dns_resolver_create" }, 229 { (PFV) test_dns_resolver_settimeout, "dns_resolver_settimeout" }, 230 { (PFV) test_dns_resolver_gettimeout, "dns_resolver_gettimeout" }, 231 { (PFV) test_dns_resolver_settimeout_to_default, "test_dns_resolver_settimeout_to_default" }, 232 { (PFV) test_dns_resolver_settimeout_over_maximum, "test_dns_resolver_settimeout_over_maximum" }, 233 { (PFV) 0, NULL } 234 }; 235 236 #ifdef WIN32 237 int 238 main(int argc, char **argv) { 239 t_settests(T_testlist); 240 return (t_main(argc, argv)); 241 } 242 #endif 243