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); 43 ATF_TC_HEAD(zonemgr_create, tc) { 44 atf_tc_set_md_var(tc, "descr", "create zone manager"); 45 } 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); 68 ATF_TC_HEAD(zonemgr_managezone, tc) { 69 atf_tc_set_md_var(tc, "descr", "manage and release a zone"); 70 } 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); 116 ATF_TC_HEAD(zonemgr_createzone, tc) { 117 atf_tc_set_md_var(tc, "descr", "create and release a zone"); 118 } 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); 156 ATF_TC_HEAD(zonemgr_unreachable, tc) { 157 atf_tc_set_md_var(tc, "descr", "manage and release a zone"); 158 } 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 */ 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