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
setup_create_dispatch_v4(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
setup(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
teardown(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
make_resolver(dns_resolver_t ** resolverp)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
destroy_resolver(dns_resolver_t ** resolverp)103 destroy_resolver(dns_resolver_t **resolverp) {
104 dns_resolver_shutdown(*resolverp);
105 dns_resolver_detach(resolverp);
106 }
107
108 static void
test_dns_resolver_create(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
test_dns_resolver_gettimeout(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
test_dns_resolver_settimeout(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
test_dns_resolver_settimeout_to_default(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
test_dns_resolver_settimeout_over_maximum(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
main(int argc,char ** argv)238 main(int argc, char **argv) {
239 t_settests(T_testlist);
240 return (t_main(argc, argv));
241 }
242 #endif
243