1 /* $NetBSD: zonemgr_test.c,v 1.4 2015/07/08 17:28:59 christos Exp $ */
2
3 /*
4 * Copyright (C) 2011-2013, 2015 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 */
20
21 /*! \file */
22
23 #include <config.h>
24
25 #include <atf-c.h>
26
27 #include <unistd.h>
28
29 #include <isc/buffer.h>
30 #include <isc/task.h>
31 #include <isc/timer.h>
32
33 #include <dns/name.h>
34 #include <dns/view.h>
35 #include <dns/zone.h>
36
37 #include "dnstest.h"
38
39 /*
40 * Individual unit tests
41 */
42 ATF_TC(zonemgr_create);
ATF_TC_HEAD(zonemgr_create,tc)43 ATF_TC_HEAD(zonemgr_create, tc) {
44 atf_tc_set_md_var(tc, "descr", "create zone manager");
45 }
ATF_TC_BODY(zonemgr_create,tc)46 ATF_TC_BODY(zonemgr_create, tc) {
47 dns_zonemgr_t *myzonemgr = NULL;
48 isc_result_t result;
49
50 UNUSED(tc);
51
52 result = dns_test_begin(NULL, ISC_TRUE);
53 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
54
55 result = dns_zonemgr_create(mctx, taskmgr, timermgr, socketmgr,
56 &myzonemgr);
57 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
58
59 dns_zonemgr_shutdown(myzonemgr);
60 dns_zonemgr_detach(&myzonemgr);
61 ATF_REQUIRE_EQ(myzonemgr, NULL);
62
63 dns_test_end();
64 }
65
66
67 ATF_TC(zonemgr_managezone);
ATF_TC_HEAD(zonemgr_managezone,tc)68 ATF_TC_HEAD(zonemgr_managezone, tc) {
69 atf_tc_set_md_var(tc, "descr", "manage and release a zone");
70 }
ATF_TC_BODY(zonemgr_managezone,tc)71 ATF_TC_BODY(zonemgr_managezone, tc) {
72 dns_zonemgr_t *myzonemgr = NULL;
73 dns_zone_t *zone = NULL;
74 isc_result_t result;
75
76 UNUSED(tc);
77
78 result = dns_test_begin(NULL, ISC_TRUE);
79 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
80
81 result = dns_zonemgr_create(mctx, taskmgr, timermgr, socketmgr,
82 &myzonemgr);
83 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
84
85 result = dns_test_makezone("foo", &zone, NULL, ISC_FALSE);
86 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
87
88 /* This should not succeed until the dns_zonemgr_setsize() is run */
89 result = dns_zonemgr_managezone(myzonemgr, zone);
90 ATF_REQUIRE_EQ(result, ISC_R_FAILURE);
91
92 ATF_REQUIRE_EQ(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 0);
93
94 result = dns_zonemgr_setsize(myzonemgr, 1);
95 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
96
97 /* Now it should succeed */
98 result = dns_zonemgr_managezone(myzonemgr, zone);
99 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
100
101 ATF_REQUIRE_EQ(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 1);
102
103 dns_zonemgr_releasezone(myzonemgr, zone);
104 dns_zone_detach(&zone);
105
106 ATF_REQUIRE_EQ(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 0);
107
108 dns_zonemgr_shutdown(myzonemgr);
109 dns_zonemgr_detach(&myzonemgr);
110 ATF_REQUIRE_EQ(myzonemgr, NULL);
111
112 dns_test_end();
113 }
114
115 ATF_TC(zonemgr_createzone);
ATF_TC_HEAD(zonemgr_createzone,tc)116 ATF_TC_HEAD(zonemgr_createzone, tc) {
117 atf_tc_set_md_var(tc, "descr", "create and release a zone");
118 }
ATF_TC_BODY(zonemgr_createzone,tc)119 ATF_TC_BODY(zonemgr_createzone, tc) {
120 dns_zonemgr_t *myzonemgr = NULL;
121 dns_zone_t *zone = NULL;
122 isc_result_t result;
123
124 UNUSED(tc);
125
126 result = dns_test_begin(NULL, ISC_TRUE);
127 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
128
129 result = dns_zonemgr_create(mctx, taskmgr, timermgr, socketmgr,
130 &myzonemgr);
131 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
132
133 /* This should not succeed until the dns_zonemgr_setsize() is run */
134 result = dns_zonemgr_createzone(myzonemgr, &zone);
135 ATF_REQUIRE_EQ(result, ISC_R_FAILURE);
136
137 result = dns_zonemgr_setsize(myzonemgr, 1);
138 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
139
140 /* Now it should succeed */
141 result = dns_zonemgr_createzone(myzonemgr, &zone);
142 ATF_CHECK_EQ(result, ISC_R_SUCCESS);
143 ATF_CHECK(zone != NULL);
144
145 if (zone != NULL)
146 dns_zone_detach(&zone);
147
148 dns_zonemgr_shutdown(myzonemgr);
149 dns_zonemgr_detach(&myzonemgr);
150 ATF_REQUIRE_EQ(myzonemgr, NULL);
151
152 dns_test_end();
153 }
154
155 ATF_TC(zonemgr_unreachable);
ATF_TC_HEAD(zonemgr_unreachable,tc)156 ATF_TC_HEAD(zonemgr_unreachable, tc) {
157 atf_tc_set_md_var(tc, "descr", "manage and release a zone");
158 }
ATF_TC_BODY(zonemgr_unreachable,tc)159 ATF_TC_BODY(zonemgr_unreachable, tc) {
160 dns_zonemgr_t *myzonemgr = NULL;
161 dns_zone_t *zone = NULL;
162 isc_sockaddr_t addr1, addr2;
163 struct in_addr in;
164 isc_result_t result;
165 isc_time_t now;
166
167 UNUSED(tc);
168
169 TIME_NOW(&now);
170
171 result = dns_test_begin(NULL, ISC_TRUE);
172
173 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
174
175 result = dns_zonemgr_create(mctx, taskmgr, timermgr, socketmgr,
176 &myzonemgr);
177 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
178
179 result = dns_test_makezone("foo", &zone, NULL, ISC_FALSE);
180 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
181
182 result = dns_zonemgr_setsize(myzonemgr, 1);
183 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
184
185 result = dns_zonemgr_managezone(myzonemgr, zone);
186 ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
187
188 in.s_addr = inet_addr("10.53.0.1");
189 isc_sockaddr_fromin(&addr1, &in, 2112);
190 in.s_addr = inet_addr("10.53.0.2");
191 isc_sockaddr_fromin(&addr2, &in, 5150);
192 ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
193 /*
194 * We require multiple unreachableadd calls to mark a server as
195 * unreachable.
196 */
197 dns_zonemgr_unreachableadd(myzonemgr, &addr1, &addr2, &now);
198 ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
199 dns_zonemgr_unreachableadd(myzonemgr, &addr1, &addr2, &now);
200 ATF_CHECK(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
201
202 in.s_addr = inet_addr("10.53.0.3");
203 isc_sockaddr_fromin(&addr2, &in, 5150);
204 ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
205 /*
206 * We require multiple unreachableadd calls to mark a server as
207 * unreachable.
208 */
209 dns_zonemgr_unreachableadd(myzonemgr, &addr1, &addr2, &now);
210 dns_zonemgr_unreachableadd(myzonemgr, &addr1, &addr2, &now);
211 ATF_CHECK(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
212
213 dns_zonemgr_unreachabledel(myzonemgr, &addr1, &addr2);
214 ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
215
216 in.s_addr = inet_addr("10.53.0.2");
217 isc_sockaddr_fromin(&addr2, &in, 5150);
218 ATF_CHECK(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
219 dns_zonemgr_unreachabledel(myzonemgr, &addr1, &addr2);
220 ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
221
222 dns_zonemgr_releasezone(myzonemgr, zone);
223 dns_zone_detach(&zone);
224 dns_zonemgr_shutdown(myzonemgr);
225 dns_zonemgr_detach(&myzonemgr);
226 ATF_REQUIRE_EQ(myzonemgr, NULL);
227
228 dns_test_end();
229 }
230
231
232 /*
233 * Main
234 */
ATF_TP_ADD_TCS(tp)235 ATF_TP_ADD_TCS(tp) {
236 ATF_TP_ADD_TC(tp, zonemgr_create);
237 ATF_TP_ADD_TC(tp, zonemgr_managezone);
238 ATF_TP_ADD_TC(tp, zonemgr_createzone);
239 ATF_TP_ADD_TC(tp, zonemgr_unreachable);
240 return (atf_no_error());
241 }
242
243 /*
244 * XXX:
245 * dns_zonemgr API calls that are not yet part of this unit test:
246 *
247 * - dns_zonemgr_attach
248 * - dns_zonemgr_forcemaint
249 * - dns_zonemgr_resumexfrs
250 * - dns_zonemgr_shutdown
251 * - dns_zonemgr_setsize
252 * - dns_zonemgr_settransfersin
253 * - dns_zonemgr_getttransfersin
254 * - dns_zonemgr_settransfersperns
255 * - dns_zonemgr_getttransfersperns
256 * - dns_zonemgr_setiolimit
257 * - dns_zonemgr_getiolimit
258 * - dns_zonemgr_dbdestroyed
259 * - dns_zonemgr_setserialqueryrate
260 * - dns_zonemgr_getserialqueryrate
261 */
262