portconfig_unittest.cc 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298
  1. // Copyright (C) 2011 Internet Systems Consortium, Inc. ("ISC")
  2. //
  3. // Permission to use, copy, modify, and/or distribute this software for any
  4. // purpose with or without fee is hereby granted, provided that the above
  5. // copyright notice and this permission notice appear in all copies.
  6. //
  7. // THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  8. // REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  9. // AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  10. // INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  11. // LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  12. // OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  13. // PERFORMANCE OF THIS SOFTWARE.
  14. #include <server_common/portconfig.h>
  15. #include <testutils/socket_request.h>
  16. #include <cc/data.h>
  17. #include <exceptions/exceptions.h>
  18. #include <asiolink/asiolink.h>
  19. #include <asiodns/asiodns.h>
  20. #include <gtest/gtest.h>
  21. #include <string>
  22. using namespace isc::server_common::portconfig;
  23. using namespace isc::server_common;
  24. using namespace isc::data;
  25. using namespace isc;
  26. using namespace std;
  27. using namespace isc::asiolink;
  28. using namespace isc::asiodns;
  29. using boost::lexical_cast;
  30. namespace {
  31. /// Testcase for parseAddresses call (struct, nobody cares about private here)
  32. struct ParseAddresses : public ::testing::Test {
  33. AddressList result_;
  34. void empty(ElementPtr config, const string& name) {
  35. SCOPED_TRACE(name);
  36. EXPECT_NO_THROW(result_ = parseAddresses(config, "test"));
  37. EXPECT_TRUE(result_.empty());
  38. }
  39. template<class Exception>
  40. void invalidTest(const string& json, const string& name) {
  41. SCOPED_TRACE(name);
  42. ElementPtr config(Element::fromJSON(json));
  43. EXPECT_THROW(parseAddresses(config, "test"), Exception) <<
  44. "Should throw " << typeid(Exception).name();
  45. }
  46. };
  47. // Parse valid IPv4 address
  48. TEST_F(ParseAddresses, ipv4) {
  49. ElementPtr config(Element::fromJSON("["
  50. " {"
  51. " \"address\": \"192.0.2.1\","
  52. " \"port\": 53"
  53. " }"
  54. "]"));
  55. EXPECT_NO_THROW(result_ = parseAddresses(config, "test"));
  56. ASSERT_EQ(1, result_.size());
  57. EXPECT_EQ("192.0.2.1", result_[0].first);
  58. EXPECT_EQ(53, result_[0].second);
  59. }
  60. // Parse valid IPv6 address
  61. TEST_F(ParseAddresses, ipv6) {
  62. ElementPtr config(Element::fromJSON("["
  63. " {"
  64. " \"address\": \"2001:db8::1\","
  65. " \"port\": 53"
  66. " }"
  67. "]"));
  68. EXPECT_NO_THROW(result_ = parseAddresses(config, "test"));
  69. ASSERT_EQ(1, result_.size());
  70. EXPECT_EQ("2001:db8::1", result_[0].first);
  71. EXPECT_EQ(53, result_[0].second);
  72. }
  73. // Parse multiple addresses at once
  74. // (even the ports are different to see they are not mistaken)
  75. TEST_F(ParseAddresses, multi) {
  76. ElementPtr config(Element::fromJSON("["
  77. " {"
  78. " \"address\": \"2001:db8::1\","
  79. " \"port\": 53"
  80. " },"
  81. " {"
  82. " \"address\": \"192.0.2.1\","
  83. " \"port\": 54"
  84. " }"
  85. "]"));
  86. EXPECT_NO_THROW(result_ = parseAddresses(config, "test"));
  87. ASSERT_EQ(2, result_.size());
  88. EXPECT_EQ("2001:db8::1", result_[0].first);
  89. EXPECT_EQ(53, result_[0].second);
  90. EXPECT_EQ("192.0.2.1", result_[1].first);
  91. EXPECT_EQ(54, result_[1].second);
  92. }
  93. // Parse various versions of empty list
  94. TEST_F(ParseAddresses, empty) {
  95. empty(Element::fromJSON("[]"), "Empty list");
  96. empty(ElementPtr(new NullElement), "Null element");
  97. empty(ElementPtr(), "Null pointer");
  98. }
  99. // Reject invalid configs
  100. TEST_F(ParseAddresses, invalid) {
  101. invalidTest<TypeError>("{}", "Not a list");
  102. invalidTest<BadValue>("[{}]", "Empty element");
  103. invalidTest<TypeError>("[{"
  104. " \"port\": 1.5,"
  105. " \"address\": \"192.0.2.1\""
  106. "}]", "Float port");
  107. invalidTest<BadValue>("[{"
  108. " \"port\": -5,"
  109. " \"address\": \"192.0.2.1\""
  110. "}]", "Negative port");
  111. invalidTest<BadValue>("[{"
  112. " \"port\": 1000000,"
  113. " \"address\": \"192.0.2.1\""
  114. "}]", "Port too big");
  115. invalidTest<IOError>("[{"
  116. " \"port\": 53,"
  117. " \"address\": \"bad_address\""
  118. "}]", "Bad address");
  119. }
  120. // Test fixture for installListenAddresses
  121. struct InstallListenAddresses : public ::testing::Test {
  122. InstallListenAddresses() :
  123. dnss_(ios_, NULL, NULL, NULL),
  124. sock_requestor_(dnss_, store_, 5288)
  125. {
  126. valid_.push_back(AddressPair("127.0.0.1", 5288));
  127. valid_.push_back(AddressPair("::1", 5288));
  128. invalid_.push_back(AddressPair("127.0.0.1", 5288));
  129. invalid_.push_back(AddressPair("192.0.2.2", 1));
  130. }
  131. IOService ios_;
  132. DNSService dnss_;
  133. AddressList store_;
  134. isc::testutils::TestSocketRequestor sock_requestor_;
  135. // We should be able to bind to these addresses
  136. AddressList valid_;
  137. // But this shouldn't work
  138. AddressList invalid_;
  139. // Check that the store_ addresses are the same as expected
  140. void checkAddresses(const AddressList& expected, const string& name) const
  141. {
  142. SCOPED_TRACE(name);
  143. ASSERT_EQ(expected.size(), store_.size()) <<
  144. "Different amount of elements, not checking content";
  145. // Run in parallel through the vectors
  146. for (AddressList::const_iterator ei(expected.begin()),
  147. si(store_.begin()); ei != expected.end(); ++ei, ++si) {
  148. EXPECT_EQ(ei->first, si->first);
  149. EXPECT_EQ(ei->second, si->second);
  150. }
  151. }
  152. };
  153. // Try switching valid addresses
  154. // Check the sockets are correctly requested and returned
  155. TEST_F(InstallListenAddresses, valid) {
  156. // First, bind to the valid addresses
  157. EXPECT_NO_THROW(installListenAddresses(valid_, store_, dnss_));
  158. checkAddresses(valid_, "Valid addresses");
  159. const char* tokens1[] = {
  160. "TCP:127.0.0.1:5288:1",
  161. "UDP:127.0.0.1:5288:2",
  162. "TCP:::1:5288:3",
  163. "UDP:::1:5288:4",
  164. NULL
  165. };
  166. const char* no_tokens[] = { NULL };
  167. sock_requestor_.checkTokens(tokens1, sock_requestor_.given_tokens_,
  168. "Valid given tokens 1");
  169. sock_requestor_.checkTokens(no_tokens, sock_requestor_.released_tokens_,
  170. "Valid no released tokens 1");
  171. // TODO Maybe some test to actually connect to them
  172. // Try setting it back to nothing
  173. sock_requestor_.given_tokens_.clear();
  174. EXPECT_NO_THROW(installListenAddresses(AddressList(), store_, dnss_));
  175. checkAddresses(AddressList(), "No addresses");
  176. sock_requestor_.checkTokens(no_tokens, sock_requestor_.given_tokens_,
  177. "Valid no given tokens");
  178. sock_requestor_.checkTokens(tokens1, sock_requestor_.released_tokens_,
  179. "Valid released tokens");
  180. // Try switching back again
  181. EXPECT_NO_THROW(installListenAddresses(valid_, store_, dnss_));
  182. checkAddresses(valid_, "Valid addresses");
  183. const char* tokens2[] = {
  184. "TCP:127.0.0.1:5288:5",
  185. "UDP:127.0.0.1:5288:6",
  186. "TCP:::1:5288:7",
  187. "UDP:::1:5288:8",
  188. NULL
  189. };
  190. sock_requestor_.checkTokens(tokens2, sock_requestor_.given_tokens_,
  191. "Valid given tokens 2");
  192. sock_requestor_.checkTokens(tokens1, sock_requestor_.released_tokens_,
  193. "Valid released tokens");
  194. }
  195. // Try if rollback works
  196. TEST_F(InstallListenAddresses, rollback) {
  197. // Set some addresses
  198. EXPECT_NO_THROW(installListenAddresses(valid_, store_, dnss_));
  199. checkAddresses(valid_, "Before rollback");
  200. const char* tokens1[] = {
  201. "TCP:127.0.0.1:5288:1",
  202. "UDP:127.0.0.1:5288:2",
  203. "TCP:::1:5288:3",
  204. "UDP:::1:5288:4",
  205. NULL
  206. };
  207. const char* no_tokens[] = { NULL };
  208. sock_requestor_.checkTokens(tokens1, sock_requestor_.given_tokens_,
  209. "Given before rollback");
  210. sock_requestor_.checkTokens(no_tokens, sock_requestor_.released_tokens_,
  211. "Released before rollback");
  212. sock_requestor_.given_tokens_.clear();
  213. // This should not bind them, but should leave the original addresses
  214. EXPECT_THROW(installListenAddresses(invalid_, store_, dnss_),
  215. SocketRequestor::SocketError);
  216. checkAddresses(valid_, "After rollback");
  217. // Now, it should have requested first pair of sockets from the invalids
  218. // and, as the second failed, it should have returned them right away.
  219. const char* released1[] = {
  220. "TCP:127.0.0.1:5288:1",
  221. "UDP:127.0.0.1:5288:2",
  222. "TCP:::1:5288:3",
  223. "UDP:::1:5288:4",
  224. "TCP:127.0.0.1:5288:5",
  225. "UDP:127.0.0.1:5288:6",
  226. NULL
  227. };
  228. // It should request the first pair of sockets, and then request the
  229. // complete set of valid addresses to rollback
  230. const char* tokens2[] = {
  231. "TCP:127.0.0.1:5288:5",
  232. "UDP:127.0.0.1:5288:6",
  233. "TCP:127.0.0.1:5288:7",
  234. "UDP:127.0.0.1:5288:8",
  235. "TCP:::1:5288:9",
  236. "UDP:::1:5288:10",
  237. NULL
  238. };
  239. sock_requestor_.checkTokens(tokens2, sock_requestor_.given_tokens_,
  240. "Given after rollback");
  241. sock_requestor_.checkTokens(released1, sock_requestor_.released_tokens_,
  242. "Released after rollback");
  243. }
  244. // Try it at least releases everything when even the rollback fails.
  245. TEST_F(InstallListenAddresses, brokenRollback) {
  246. EXPECT_NO_THROW(installListenAddresses(valid_, store_, dnss_));
  247. checkAddresses(valid_, "Before rollback");
  248. // Don't check the tokens now, we already do it in rollback and valid tests
  249. sock_requestor_.given_tokens_.clear();
  250. sock_requestor_.break_rollback_ = true;
  251. EXPECT_THROW(installListenAddresses(invalid_, store_, dnss_),
  252. SocketRequestor::SocketError);
  253. // No addresses here
  254. EXPECT_TRUE(store_.empty());
  255. // The first pair should be requested in the first part of the failure to
  256. // bind and the second pair in the first part of rollback
  257. const char* tokens[] = {
  258. "TCP:127.0.0.1:5288:5",
  259. "UDP:127.0.0.1:5288:6",
  260. "TCP:127.0.0.1:5288:7",
  261. "UDP:127.0.0.1:5288:8",
  262. NULL
  263. };
  264. // The first set should be released, as well as all the ones we request now
  265. const char* released[] = {
  266. "TCP:127.0.0.1:5288:1",
  267. "UDP:127.0.0.1:5288:2",
  268. "TCP:::1:5288:3",
  269. "UDP:::1:5288:4",
  270. "TCP:127.0.0.1:5288:5",
  271. "UDP:127.0.0.1:5288:6",
  272. "TCP:127.0.0.1:5288:7",
  273. "UDP:127.0.0.1:5288:8",
  274. NULL
  275. };
  276. sock_requestor_.checkTokens(tokens, sock_requestor_.given_tokens_,
  277. "given");
  278. sock_requestor_.checkTokens(released, sock_requestor_.released_tokens_,
  279. "released");
  280. }
  281. }