option4_addrlst_unittest.cc 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255
  1. // Copyright (C) 2011-2013 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 <config.h>
  15. #include <asiolink/io_address.h>
  16. #include <dhcp/dhcp4.h>
  17. #include <dhcp/option.h>
  18. #include <dhcp/option4_addrlst.h>
  19. #include <util/buffer.h>
  20. #include <gtest/gtest.h>
  21. #include <boost/scoped_ptr.hpp>
  22. #include <iostream>
  23. #include <sstream>
  24. #include <arpa/inet.h>
  25. using namespace std;
  26. using namespace isc;
  27. using namespace isc::dhcp;
  28. using namespace isc::asiolink;
  29. using namespace isc::util;
  30. using boost::scoped_ptr;
  31. namespace {
  32. // a sample data (list of 4 addresses)
  33. const uint8_t sampledata[] = {
  34. 192, 0, 2, 3, // 192.0.2.3
  35. 255, 255, 255, 0, // 255.255.255.0 - popular netmask
  36. 0, 0, 0 , 0, // used for default routes or (any address)
  37. 127, 0, 0, 1 // loopback
  38. };
  39. // expected on-wire format for an option with 1 address
  40. const uint8_t expected1[] = { // 1 address
  41. DHO_DOMAIN_NAME_SERVERS, 4, // type, length
  42. 192, 0, 2, 3, // 192.0.2.3
  43. };
  44. // expected on-wire format for an option with 4 addresses
  45. const uint8_t expected4[] = { // 4 addresses
  46. 254, 16, // type = 254, len = 16
  47. 192, 0, 2, 3, // 192.0.2.3
  48. 255, 255, 255, 0, // 255.255.255.0 - popular netmask
  49. 0, 0, 0 ,0, // used for default routes or (any address)
  50. 127, 0, 0, 1 // loopback
  51. };
  52. class Option4AddrLstTest : public ::testing::Test {
  53. protected:
  54. Option4AddrLstTest():
  55. vec_(vector<uint8_t>(300, 0)) // 300 bytes long filled with 0s
  56. {
  57. sampleAddrs_.push_back(IOAddress("192.0.2.3"));
  58. sampleAddrs_.push_back(IOAddress("255.255.255.0"));
  59. sampleAddrs_.push_back(IOAddress("0.0.0.0"));
  60. sampleAddrs_.push_back(IOAddress("127.0.0.1"));
  61. }
  62. vector<uint8_t> vec_;
  63. Option4AddrLst::AddressContainer sampleAddrs_;
  64. };
  65. TEST_F(Option4AddrLstTest, parse1) {
  66. memcpy(&vec_[0], sampledata, sizeof(sampledata));
  67. // Just one address
  68. scoped_ptr<Option4AddrLst> opt1;
  69. EXPECT_NO_THROW(
  70. opt1.reset(new Option4AddrLst(DHO_DOMAIN_NAME_SERVERS,
  71. vec_.begin(),
  72. vec_.begin()+4));
  73. // Use just first address (4 bytes), not the whole
  74. // sampledata
  75. );
  76. EXPECT_EQ(Option::V4, opt1->getUniverse());
  77. EXPECT_EQ(DHO_DOMAIN_NAME_SERVERS, opt1->getType());
  78. EXPECT_EQ(6, opt1->len()); // 2 (header) + 4 (1x IPv4 addr)
  79. Option4AddrLst::AddressContainer addrs = opt1->getAddresses();
  80. ASSERT_EQ(1, addrs.size());
  81. EXPECT_EQ("192.0.2.3", addrs[0].toText());
  82. EXPECT_NO_THROW(opt1.reset());
  83. }
  84. TEST_F(Option4AddrLstTest, parse4) {
  85. vector<uint8_t> buffer(300, 0); // 300 bytes long filled with 0s
  86. memcpy(&buffer[0], sampledata, sizeof(sampledata));
  87. // 4 addresses
  88. scoped_ptr<Option4AddrLst> opt4;
  89. EXPECT_NO_THROW(
  90. opt4.reset(new Option4AddrLst(254,
  91. buffer.begin(),
  92. buffer.begin()+sizeof(sampledata)));
  93. );
  94. EXPECT_EQ(Option::V4, opt4->getUniverse());
  95. EXPECT_EQ(254, opt4->getType());
  96. EXPECT_EQ(18, opt4->len()); // 2 (header) + 16 (4x IPv4 addrs)
  97. Option4AddrLst::AddressContainer addrs = opt4->getAddresses();
  98. ASSERT_EQ(4, addrs.size());
  99. EXPECT_EQ("192.0.2.3", addrs[0].toText());
  100. EXPECT_EQ("255.255.255.0", addrs[1].toText());
  101. EXPECT_EQ("0.0.0.0", addrs[2].toText());
  102. EXPECT_EQ("127.0.0.1", addrs[3].toText());
  103. EXPECT_NO_THROW(opt4.reset());
  104. }
  105. TEST_F(Option4AddrLstTest, assembly1) {
  106. scoped_ptr<Option4AddrLst> opt;
  107. EXPECT_NO_THROW(
  108. opt.reset(new Option4AddrLst(DHO_DOMAIN_NAME_SERVERS,
  109. IOAddress("192.0.2.3")));
  110. );
  111. EXPECT_EQ(Option::V4, opt->getUniverse());
  112. EXPECT_EQ(DHO_DOMAIN_NAME_SERVERS, opt->getType());
  113. Option4AddrLst::AddressContainer addrs = opt->getAddresses();
  114. ASSERT_EQ(1, addrs.size() );
  115. EXPECT_EQ("192.0.2.3", addrs[0].toText());
  116. OutputBuffer buf(100);
  117. EXPECT_NO_THROW(
  118. opt->pack(buf);
  119. );
  120. ASSERT_EQ(6, opt->len());
  121. ASSERT_EQ(6, buf.getLength());
  122. EXPECT_EQ(0, memcmp(expected1, buf.getData(), 6));
  123. EXPECT_NO_THROW(opt.reset());
  124. // This is old-fashioned option. We don't serve IPv6 types here!
  125. EXPECT_THROW(
  126. opt.reset(new Option4AddrLst(DHO_DOMAIN_NAME_SERVERS,
  127. IOAddress("2001:db8::1"))),
  128. BadValue
  129. );
  130. }
  131. TEST_F(Option4AddrLstTest, assembly4) {
  132. scoped_ptr<Option4AddrLst> opt;
  133. EXPECT_NO_THROW(
  134. opt.reset(new Option4AddrLst(254, sampleAddrs_));
  135. );
  136. EXPECT_EQ(Option::V4, opt->getUniverse());
  137. EXPECT_EQ(254, opt->getType());
  138. Option4AddrLst::AddressContainer addrs = opt->getAddresses();
  139. ASSERT_EQ(4, addrs.size() );
  140. EXPECT_EQ("192.0.2.3", addrs[0].toText());
  141. EXPECT_EQ("255.255.255.0", addrs[1].toText());
  142. EXPECT_EQ("0.0.0.0", addrs[2].toText());
  143. EXPECT_EQ("127.0.0.1", addrs[3].toText());
  144. OutputBuffer buf(100);
  145. EXPECT_NO_THROW(
  146. opt->pack(buf);
  147. );
  148. ASSERT_EQ(18, opt->len()); // 2(header) + 4xsizeof(IPv4addr)
  149. ASSERT_EQ(18, buf.getLength());
  150. ASSERT_EQ(0, memcmp(expected4, buf.getData(), 18));
  151. EXPECT_NO_THROW(opt.reset());
  152. // This is old-fashioned option. We don't serve IPv6 types here!
  153. sampleAddrs_.push_back(IOAddress("2001:db8::1"));
  154. EXPECT_THROW(
  155. opt.reset(new Option4AddrLst(DHO_DOMAIN_NAME_SERVERS, sampleAddrs_)),
  156. BadValue
  157. );
  158. }
  159. TEST_F(Option4AddrLstTest, setAddress) {
  160. scoped_ptr<Option4AddrLst> opt;
  161. EXPECT_NO_THROW(
  162. opt.reset(new Option4AddrLst(123, IOAddress("1.2.3.4")));
  163. );
  164. opt->setAddress(IOAddress("192.0.255.255"));
  165. Option4AddrLst::AddressContainer addrs = opt->getAddresses();
  166. ASSERT_EQ(1, addrs.size() );
  167. EXPECT_EQ("192.0.255.255", addrs[0].toText());
  168. // We should accept IPv4-only addresses.
  169. EXPECT_THROW(
  170. opt->setAddress(IOAddress("2001:db8::1")),
  171. BadValue
  172. );
  173. EXPECT_NO_THROW(opt.reset());
  174. }
  175. TEST_F(Option4AddrLstTest, setAddresses) {
  176. scoped_ptr<Option4AddrLst> opt;
  177. EXPECT_NO_THROW(
  178. opt.reset(new Option4AddrLst(123)); // Empty list
  179. );
  180. opt->setAddresses(sampleAddrs_);
  181. Option4AddrLst::AddressContainer addrs = opt->getAddresses();
  182. ASSERT_EQ(4, addrs.size() );
  183. EXPECT_EQ("192.0.2.3", addrs[0].toText());
  184. EXPECT_EQ("255.255.255.0", addrs[1].toText());
  185. EXPECT_EQ("0.0.0.0", addrs[2].toText());
  186. EXPECT_EQ("127.0.0.1", addrs[3].toText());
  187. // We should accept IPv4-only addresses.
  188. sampleAddrs_.push_back(IOAddress("2001:db8::1"));
  189. EXPECT_THROW(
  190. opt->setAddresses(sampleAddrs_),
  191. BadValue
  192. );
  193. EXPECT_NO_THROW(opt.reset());
  194. }
  195. } // namespace