ip_address_unittest.cc 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682
  1. // Copyright (c) 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/base/ip_address.h"
  5. #include <vector>
  6. #include "base/format_macros.h"
  7. #include "base/strings/string_number_conversions.h"
  8. #include "base/strings/stringprintf.h"
  9. #include "testing/gtest/include/gtest/gtest.h"
  10. namespace net {
  11. namespace {
  12. // Helper to stringize an IP address (used to define expectations).
  13. std::string DumpIPAddress(const IPAddress& v) {
  14. std::string out;
  15. for (size_t i = 0; i < v.bytes().size(); ++i) {
  16. if (i != 0)
  17. out.append(",");
  18. out.append(base::NumberToString(v.bytes()[i]));
  19. }
  20. return out;
  21. }
  22. TEST(IPAddressBytesTest, ConstructEmpty) {
  23. IPAddressBytes bytes;
  24. ASSERT_EQ(0u, bytes.size());
  25. }
  26. TEST(IPAddressBytesTest, ConstructIPv4) {
  27. uint8_t data[] = {192, 168, 1, 1};
  28. IPAddressBytes bytes(data, std::size(data));
  29. ASSERT_EQ(std::size(data), bytes.size());
  30. size_t i = 0;
  31. for (uint8_t byte : bytes)
  32. EXPECT_EQ(data[i++], byte);
  33. ASSERT_EQ(std::size(data), i);
  34. }
  35. TEST(IPAddressBytesTest, ConstructIPv6) {
  36. uint8_t data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
  37. IPAddressBytes bytes(data, std::size(data));
  38. ASSERT_EQ(std::size(data), bytes.size());
  39. size_t i = 0;
  40. for (uint8_t byte : bytes)
  41. EXPECT_EQ(data[i++], byte);
  42. ASSERT_EQ(std::size(data), i);
  43. }
  44. TEST(IPAddressBytesTest, Assign) {
  45. uint8_t data[] = {192, 168, 1, 1};
  46. IPAddressBytes copy;
  47. copy.Assign(data, std::size(data));
  48. EXPECT_EQ(IPAddressBytes(data, std::size(data)), copy);
  49. }
  50. TEST(IPAddressTest, ConstructIPv4) {
  51. EXPECT_EQ("127.0.0.1", IPAddress::IPv4Localhost().ToString());
  52. IPAddress ipv4_ctor(192, 168, 1, 1);
  53. EXPECT_EQ("192.168.1.1", ipv4_ctor.ToString());
  54. }
  55. TEST(IPAddressTest, IsIPVersion) {
  56. uint8_t addr1[4] = {192, 168, 0, 1};
  57. IPAddress ip_address1(addr1);
  58. EXPECT_TRUE(ip_address1.IsIPv4());
  59. EXPECT_FALSE(ip_address1.IsIPv6());
  60. uint8_t addr2[16] = {0xFE, 0xDC, 0xBA, 0x98};
  61. IPAddress ip_address2(addr2);
  62. EXPECT_TRUE(ip_address2.IsIPv6());
  63. EXPECT_FALSE(ip_address2.IsIPv4());
  64. IPAddress ip_address3;
  65. EXPECT_FALSE(ip_address3.IsIPv6());
  66. EXPECT_FALSE(ip_address3.IsIPv4());
  67. }
  68. TEST(IPAddressTest, IsValid) {
  69. uint8_t addr1[4] = {192, 168, 0, 1};
  70. IPAddress ip_address1(addr1);
  71. EXPECT_TRUE(ip_address1.IsValid());
  72. EXPECT_FALSE(ip_address1.empty());
  73. uint8_t addr2[16] = {0xFE, 0xDC, 0xBA, 0x98};
  74. IPAddress ip_address2(addr2);
  75. EXPECT_TRUE(ip_address2.IsValid());
  76. EXPECT_FALSE(ip_address2.empty());
  77. uint8_t addr3[5] = {0xFE, 0xDC, 0xBA, 0x98};
  78. IPAddress ip_address3(addr3);
  79. EXPECT_FALSE(ip_address3.IsValid());
  80. EXPECT_FALSE(ip_address3.empty());
  81. IPAddress ip_address4;
  82. EXPECT_FALSE(ip_address4.IsValid());
  83. EXPECT_TRUE(ip_address4.empty());
  84. }
  85. enum IPAddressReservedResult : bool { NOT_RESERVED = false, RESERVED = true };
  86. // Tests for the reserved IPv4 ranges and the (unreserved) blocks in between.
  87. // The reserved ranges are tested by checking the first and last address of each
  88. // range. The unreserved blocks are tested similarly. These tests cover the
  89. // entire IPv4 address range, as well as this range mapped to IPv6.
  90. TEST(IPAddressTest, IsPubliclyRoutableIPv4) {
  91. struct {
  92. const char* const address;
  93. IPAddressReservedResult is_reserved;
  94. } tests[] = {// 0.0.0.0/8
  95. {"0.0.0.0", RESERVED},
  96. {"0.255.255.255", RESERVED},
  97. // Unreserved block(s)
  98. {"1.0.0.0", NOT_RESERVED},
  99. {"9.255.255.255", NOT_RESERVED},
  100. // 10.0.0.0/8
  101. {"10.0.0.0", RESERVED},
  102. {"10.255.255.255", RESERVED},
  103. // Unreserved block(s)
  104. {"11.0.0.0", NOT_RESERVED},
  105. {"100.63.255.255", NOT_RESERVED},
  106. // 100.64.0.0/10
  107. {"100.64.0.0", RESERVED},
  108. {"100.127.255.255", RESERVED},
  109. // Unreserved block(s)
  110. {"100.128.0.0", NOT_RESERVED},
  111. {"126.255.255.255", NOT_RESERVED},
  112. // 127.0.0.0/8
  113. {"127.0.0.0", RESERVED},
  114. {"127.255.255.255", RESERVED},
  115. // Unreserved block(s)
  116. {"128.0.0.0", NOT_RESERVED},
  117. {"169.253.255.255", NOT_RESERVED},
  118. // 169.254.0.0/16
  119. {"169.254.0.0", RESERVED},
  120. {"169.254.255.255", RESERVED},
  121. // Unreserved block(s)
  122. {"169.255.0.0", NOT_RESERVED},
  123. {"172.15.255.255", NOT_RESERVED},
  124. // 172.16.0.0/12
  125. {"172.16.0.0", RESERVED},
  126. {"172.31.255.255", RESERVED},
  127. // Unreserved block(s)
  128. {"172.32.0.0", NOT_RESERVED},
  129. {"191.255.255.255", NOT_RESERVED},
  130. // 192.0.0.0/24 (including sub ranges)
  131. {"192.0.0.0", RESERVED},
  132. {"192.0.0.255", RESERVED},
  133. // Unreserved block(s)
  134. {"192.0.1.0", NOT_RESERVED},
  135. {"192.0.1.255", NOT_RESERVED},
  136. // 192.0.2.0/24
  137. {"192.0.2.0", RESERVED},
  138. {"192.0.2.255", RESERVED},
  139. // Unreserved block(s)
  140. {"192.0.3.0", NOT_RESERVED},
  141. {"192.31.195.255", NOT_RESERVED},
  142. // 192.31.196.0/24
  143. {"192.31.196.0", NOT_RESERVED},
  144. {"192.31.196.255", NOT_RESERVED},
  145. // Unreserved block(s)
  146. {"192.32.197.0", NOT_RESERVED},
  147. {"192.52.192.255", NOT_RESERVED},
  148. // 192.52.193.0/24
  149. {"192.52.193.0", NOT_RESERVED},
  150. {"192.52.193.255", NOT_RESERVED},
  151. // Unreserved block(s)
  152. {"192.52.194.0", NOT_RESERVED},
  153. {"192.88.98.255", NOT_RESERVED},
  154. // 192.88.99.0/24
  155. {"192.88.99.0", RESERVED},
  156. {"192.88.99.255", RESERVED},
  157. // Unreserved block(s)
  158. {"192.88.100.0", NOT_RESERVED},
  159. {"192.167.255.255", NOT_RESERVED},
  160. // 192.168.0.0/16
  161. {"192.168.0.0", RESERVED},
  162. {"192.168.255.255", RESERVED},
  163. // Unreserved block(s)
  164. {"192.169.0.0", NOT_RESERVED},
  165. {"192.175.47.255", NOT_RESERVED},
  166. // 192.175.48.0/24
  167. {"192.175.48.0", NOT_RESERVED},
  168. {"192.175.48.255", NOT_RESERVED},
  169. // Unreserved block(s)
  170. {"192.175.49.0", NOT_RESERVED},
  171. {"198.17.255.255", NOT_RESERVED},
  172. // 198.18.0.0/15
  173. {"198.18.0.0", RESERVED},
  174. {"198.19.255.255", RESERVED},
  175. // Unreserved block(s)
  176. {"198.20.0.0", NOT_RESERVED},
  177. {"198.51.99.255", NOT_RESERVED},
  178. // 198.51.100.0/24
  179. {"198.51.100.0", RESERVED},
  180. {"198.51.100.255", RESERVED},
  181. // Unreserved block(s)
  182. {"198.51.101.0", NOT_RESERVED},
  183. {"203.0.112.255", NOT_RESERVED},
  184. // 203.0.113.0/24
  185. {"203.0.113.0", RESERVED},
  186. {"203.0.113.255", RESERVED},
  187. // Unreserved block(s)
  188. {"203.0.114.0", NOT_RESERVED},
  189. {"223.255.255.255", NOT_RESERVED},
  190. // 224.0.0.0/8 - 255.0.0.0/8
  191. {"224.0.0.0", RESERVED},
  192. {"255.255.255.255", RESERVED}};
  193. for (const auto& test : tests) {
  194. IPAddress address;
  195. EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
  196. ASSERT_TRUE(address.IsValid());
  197. EXPECT_EQ(!test.is_reserved, address.IsPubliclyRoutable());
  198. // Check these IPv4 addresses when mapped to IPv6. This verifies we're
  199. // properly unpacking mapped addresses.
  200. IPAddress mapped_address = ConvertIPv4ToIPv4MappedIPv6(address);
  201. EXPECT_EQ(!test.is_reserved, mapped_address.IsPubliclyRoutable());
  202. }
  203. }
  204. // Tests for the reserved IPv6 ranges and the (unreserved) blocks in between.
  205. // The reserved ranges are tested by checking the first and last address of each
  206. // range. The unreserved blocks are tested similarly. These tests cover the
  207. // entire IPv6 address range.
  208. TEST(IPAddressTest, IsPubliclyRoutableIPv6) {
  209. struct {
  210. const char* const address;
  211. IPAddressReservedResult is_reserved;
  212. } tests[] = {// 0000::/8.
  213. // Skip testing ::ffff:/96 explicitly since it was tested
  214. // in IsPubliclyRoutableIPv4
  215. {"0:0:0:0:0:0:0:0", RESERVED},
  216. {"ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  217. // 0100::/8
  218. {"100:0:0:0:0:0:0:0", RESERVED},
  219. {"1ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  220. // 0200::/7
  221. {"200:0:0:0:0:0:0:0", RESERVED},
  222. {"3ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  223. // 0400::/6
  224. {"400:0:0:0:0:0:0:0", RESERVED},
  225. {"7ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  226. // 0800::/5
  227. {"800:0:0:0:0:0:0:0", RESERVED},
  228. {"fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  229. // 1000::/4
  230. {"1000:0:0:0:0:0:0:0", RESERVED},
  231. {"1fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  232. // 2000::/3 (Global Unicast)
  233. {"2000:0:0:0:0:0:0:0", NOT_RESERVED},
  234. {"3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", NOT_RESERVED},
  235. // 4000::/3
  236. {"4000:0:0:0:0:0:0:0", RESERVED},
  237. {"5fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  238. // 6000::/3
  239. {"6000:0:0:0:0:0:0:0", RESERVED},
  240. {"7fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  241. // 8000::/3
  242. {"8000:0:0:0:0:0:0:0", RESERVED},
  243. {"9fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  244. // c000::/3
  245. {"c000:0:0:0:0:0:0:0", RESERVED},
  246. {"dfff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  247. // e000::/4
  248. {"e000:0:0:0:0:0:0:0", RESERVED},
  249. {"efff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  250. // f000::/5
  251. {"f000:0:0:0:0:0:0:0", RESERVED},
  252. {"f7ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  253. // f800::/6
  254. {"f800:0:0:0:0:0:0:0", RESERVED},
  255. {"fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  256. // fc00::/7
  257. {"fc00:0:0:0:0:0:0:0", RESERVED},
  258. {"fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  259. // fe00::/9
  260. {"fe00:0:0:0:0:0:0:0", RESERVED},
  261. {"fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  262. // fe80::/10
  263. {"fe80:0:0:0:0:0:0:0", RESERVED},
  264. {"febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  265. // fec0::/10
  266. {"fec0:0:0:0:0:0:0:0", RESERVED},
  267. {"feff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", RESERVED},
  268. // ff00::/8 (Multicast)
  269. {"ff00:0:0:0:0:0:0:0", NOT_RESERVED},
  270. {"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", NOT_RESERVED}};
  271. IPAddress address;
  272. for (const auto& test : tests) {
  273. EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
  274. EXPECT_EQ(!test.is_reserved, address.IsPubliclyRoutable());
  275. }
  276. }
  277. TEST(IPAddressTest, IsZero) {
  278. uint8_t address1[4] = {};
  279. IPAddress zero_ipv4_address(address1);
  280. EXPECT_TRUE(zero_ipv4_address.IsZero());
  281. uint8_t address2[4] = {10};
  282. IPAddress non_zero_ipv4_address(address2);
  283. EXPECT_FALSE(non_zero_ipv4_address.IsZero());
  284. uint8_t address3[16] = {};
  285. IPAddress zero_ipv6_address(address3);
  286. EXPECT_TRUE(zero_ipv6_address.IsZero());
  287. uint8_t address4[16] = {10};
  288. IPAddress non_zero_ipv6_address(address4);
  289. EXPECT_FALSE(non_zero_ipv6_address.IsZero());
  290. IPAddress empty_address;
  291. EXPECT_FALSE(empty_address.IsZero());
  292. }
  293. TEST(IPAddressTest, IsIPv4Mapped) {
  294. IPAddress ipv4_address(192, 168, 0, 1);
  295. EXPECT_FALSE(ipv4_address.IsIPv4MappedIPv6());
  296. IPAddress ipv6_address(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
  297. EXPECT_FALSE(ipv6_address.IsIPv4MappedIPv6());
  298. IPAddress mapped_address(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 1, 1, 0, 1);
  299. EXPECT_TRUE(mapped_address.IsIPv4MappedIPv6());
  300. }
  301. TEST(IPAddressTest, AllZeros) {
  302. EXPECT_TRUE(IPAddress::AllZeros(0).empty());
  303. EXPECT_EQ(3u, IPAddress::AllZeros(3).size());
  304. EXPECT_TRUE(IPAddress::AllZeros(3).IsZero());
  305. EXPECT_EQ("0.0.0.0", IPAddress::IPv4AllZeros().ToString());
  306. EXPECT_EQ("::", IPAddress::IPv6AllZeros().ToString());
  307. }
  308. TEST(IPAddressTest, ToString) {
  309. EXPECT_EQ("0.0.0.0", IPAddress::IPv4AllZeros().ToString());
  310. IPAddress address(192, 168, 0, 1);
  311. EXPECT_EQ("192.168.0.1", address.ToString());
  312. IPAddress address2(0xFE, 0xDC, 0xBA, 0x98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  313. 0);
  314. EXPECT_EQ("fedc:ba98::", address2.ToString());
  315. // ToString() shouldn't crash on invalid addresses.
  316. uint8_t addr4[2];
  317. IPAddress address4(addr4);
  318. EXPECT_EQ("", address4.ToString());
  319. IPAddress address5;
  320. EXPECT_EQ("", address5.ToString());
  321. }
  322. TEST(IPAddressTest, IPAddressToStringWithPort) {
  323. EXPECT_EQ("0.0.0.0:3",
  324. IPAddressToStringWithPort(IPAddress::IPv4AllZeros(), 3));
  325. IPAddress address1(192, 168, 0, 1);
  326. EXPECT_EQ("192.168.0.1:99", IPAddressToStringWithPort(address1, 99));
  327. IPAddress address2(0xFE, 0xDC, 0xBA, 0x98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  328. 0);
  329. EXPECT_EQ("[fedc:ba98::]:8080", IPAddressToStringWithPort(address2, 8080));
  330. // IPAddressToStringWithPort() shouldn't crash on invalid addresses.
  331. uint8_t addr3[2];
  332. EXPECT_EQ("", IPAddressToStringWithPort(IPAddress(addr3), 8080));
  333. }
  334. TEST(IPAddressTest, IPAddressToPackedString) {
  335. IPAddress ipv4_address;
  336. EXPECT_TRUE(ipv4_address.AssignFromIPLiteral("4.31.198.44"));
  337. std::string expected_ipv4_address("\x04\x1f\xc6\x2c", 4);
  338. EXPECT_EQ(expected_ipv4_address, IPAddressToPackedString(ipv4_address));
  339. IPAddress ipv6_address;
  340. EXPECT_TRUE(ipv6_address.AssignFromIPLiteral("2001:0700:0300:1800::000f"));
  341. std::string expected_ipv6_address(
  342. "\x20\x01\x07\x00\x03\x00\x18\x00"
  343. "\x00\x00\x00\x00\x00\x00\x00\x0f",
  344. 16);
  345. EXPECT_EQ(expected_ipv6_address, IPAddressToPackedString(ipv6_address));
  346. }
  347. // Test that invalid IP literals fail to parse.
  348. TEST(IPAddressTest, AssignFromIPLiteral_FailParse) {
  349. IPAddress address;
  350. EXPECT_FALSE(address.AssignFromIPLiteral("bad value"));
  351. EXPECT_FALSE(address.AssignFromIPLiteral("bad:value"));
  352. EXPECT_FALSE(address.AssignFromIPLiteral(std::string()));
  353. EXPECT_FALSE(address.AssignFromIPLiteral("192.168.0.1:30"));
  354. EXPECT_FALSE(address.AssignFromIPLiteral(" 192.168.0.1 "));
  355. EXPECT_FALSE(address.AssignFromIPLiteral("[::1]"));
  356. }
  357. // Test that a failure calling AssignFromIPLiteral() has the sideffect of
  358. // clearing the current value.
  359. TEST(IPAddressTest, AssignFromIPLiteral_ResetOnFailure) {
  360. IPAddress address = IPAddress::IPv6Localhost();
  361. EXPECT_TRUE(address.IsValid());
  362. EXPECT_FALSE(address.empty());
  363. EXPECT_FALSE(address.AssignFromIPLiteral("bad value"));
  364. EXPECT_FALSE(address.IsValid());
  365. EXPECT_TRUE(address.empty());
  366. }
  367. // Test parsing an IPv4 literal.
  368. TEST(IPAddressTest, AssignFromIPLiteral_IPv4) {
  369. IPAddress address;
  370. EXPECT_TRUE(address.AssignFromIPLiteral("192.168.0.1"));
  371. EXPECT_EQ("192,168,0,1", DumpIPAddress(address));
  372. EXPECT_EQ("192.168.0.1", address.ToString());
  373. }
  374. // Test parsing an IPv6 literal.
  375. TEST(IPAddressTest, AssignFromIPLiteral_IPv6) {
  376. IPAddress address;
  377. EXPECT_TRUE(address.AssignFromIPLiteral("1:abcd::3:4:ff"));
  378. EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPAddress(address));
  379. EXPECT_EQ("1:abcd::3:4:ff", address.ToString());
  380. }
  381. TEST(IPAddressTest, IsIPv4MappedIPv6) {
  382. IPAddress ipv4_address(192, 168, 0, 1);
  383. EXPECT_FALSE(ipv4_address.IsIPv4MappedIPv6());
  384. IPAddress ipv6_address = IPAddress::IPv6Localhost();
  385. EXPECT_FALSE(ipv6_address.IsIPv4MappedIPv6());
  386. IPAddress mapped_address(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 1, 1, 0, 1);
  387. EXPECT_TRUE(mapped_address.IsIPv4MappedIPv6());
  388. }
  389. TEST(IPAddressTest, IsEqual) {
  390. IPAddress ip_address1;
  391. EXPECT_TRUE(ip_address1.AssignFromIPLiteral("127.0.0.1"));
  392. IPAddress ip_address2;
  393. EXPECT_TRUE(ip_address2.AssignFromIPLiteral("2001:db8:0::42"));
  394. IPAddress ip_address3;
  395. EXPECT_TRUE(ip_address3.AssignFromIPLiteral("127.0.0.1"));
  396. EXPECT_FALSE(ip_address1 == ip_address2);
  397. EXPECT_TRUE(ip_address1 == ip_address3);
  398. }
  399. TEST(IPAddressTest, LessThan) {
  400. // IPv4 vs IPv6
  401. IPAddress ip_address1;
  402. EXPECT_TRUE(ip_address1.AssignFromIPLiteral("127.0.0.1"));
  403. IPAddress ip_address2;
  404. EXPECT_TRUE(ip_address2.AssignFromIPLiteral("2001:db8:0::42"));
  405. EXPECT_TRUE(ip_address1 < ip_address2);
  406. EXPECT_FALSE(ip_address2 < ip_address1);
  407. // Compare equivalent addresses.
  408. IPAddress ip_address3;
  409. EXPECT_TRUE(ip_address3.AssignFromIPLiteral("127.0.0.1"));
  410. EXPECT_FALSE(ip_address1 < ip_address3);
  411. EXPECT_FALSE(ip_address3 < ip_address1);
  412. IPAddress ip_address4;
  413. EXPECT_TRUE(ip_address4.AssignFromIPLiteral("128.0.0.0"));
  414. EXPECT_TRUE(ip_address1 < ip_address4);
  415. EXPECT_FALSE(ip_address4 < ip_address1);
  416. }
  417. // Test mapping an IPv4 address to an IPv6 address.
  418. TEST(IPAddressTest, ConvertIPv4ToIPv4MappedIPv6) {
  419. IPAddress ipv4_address(192, 168, 0, 1);
  420. IPAddress ipv6_address = ConvertIPv4ToIPv4MappedIPv6(ipv4_address);
  421. // ::ffff:192.168.0.1
  422. EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
  423. DumpIPAddress(ipv6_address));
  424. EXPECT_EQ("::ffff:c0a8:1", ipv6_address.ToString());
  425. }
  426. // Test reversal of a IPv6 address mapping.
  427. TEST(IPAddressTest, ConvertIPv4MappedIPv6ToIPv4) {
  428. IPAddress ipv4mapped_address;
  429. EXPECT_TRUE(ipv4mapped_address.AssignFromIPLiteral("::ffff:c0a8:1"));
  430. IPAddress expected(192, 168, 0, 1);
  431. IPAddress result = ConvertIPv4MappedIPv6ToIPv4(ipv4mapped_address);
  432. EXPECT_EQ(expected, result);
  433. }
  434. TEST(IPAddressTest, IPAddressMatchesPrefix) {
  435. struct {
  436. const char* const cidr_literal;
  437. size_t prefix_length_in_bits;
  438. const char* const ip_literal;
  439. bool expected_to_match;
  440. } tests[] = {
  441. // IPv4 prefix with IPv4 inputs.
  442. {"10.10.1.32", 27, "10.10.1.44", true},
  443. {"10.10.1.32", 27, "10.10.1.90", false},
  444. {"10.10.1.32", 27, "10.10.1.90", false},
  445. // IPv6 prefix with IPv6 inputs.
  446. {"2001:db8::", 32, "2001:DB8:3:4::5", true},
  447. {"2001:db8::", 32, "2001:c8::", false},
  448. // IPv6 prefix with IPv4 inputs.
  449. {"2001:db8::", 33, "192.168.0.1", false},
  450. {"::ffff:192.168.0.1", 112, "192.168.33.77", true},
  451. // IPv4 prefix with IPv6 inputs.
  452. {"10.11.33.44", 16, "::ffff:0a0b:89", true},
  453. {"10.11.33.44", 16, "::ffff:10.12.33.44", false},
  454. };
  455. for (const auto& test : tests) {
  456. SCOPED_TRACE(
  457. base::StringPrintf("%s, %s", test.cidr_literal, test.ip_literal));
  458. IPAddress ip_address;
  459. EXPECT_TRUE(ip_address.AssignFromIPLiteral(test.ip_literal));
  460. IPAddress ip_prefix;
  461. EXPECT_TRUE(ip_prefix.AssignFromIPLiteral(test.cidr_literal));
  462. EXPECT_EQ(test.expected_to_match,
  463. IPAddressMatchesPrefix(ip_address, ip_prefix,
  464. test.prefix_length_in_bits));
  465. }
  466. }
  467. // Test parsing invalid CIDR notation literals.
  468. TEST(IPAddressTest, ParseCIDRBlock_Invalid) {
  469. const char* const bad_literals[] = {"foobar",
  470. "",
  471. "192.168.0.1",
  472. "::1",
  473. "/",
  474. "/1",
  475. "1",
  476. "192.168.1.1/-1",
  477. "192.168.1.1/33",
  478. "::1/-3",
  479. "a::3/129",
  480. "::1/x",
  481. "192.168.0.1//11",
  482. "192.168.1.1/+1",
  483. "192.168.1.1/ +1",
  484. "192.168.1.1/"};
  485. for (auto* bad_literal : bad_literals) {
  486. IPAddress ip_address;
  487. size_t prefix_length_in_bits;
  488. EXPECT_FALSE(
  489. ParseCIDRBlock(bad_literal, &ip_address, &prefix_length_in_bits));
  490. }
  491. }
  492. // Test parsing a valid CIDR notation literal.
  493. TEST(IPAddressTest, ParseCIDRBlock_Valid) {
  494. IPAddress ip_address;
  495. size_t prefix_length_in_bits;
  496. EXPECT_TRUE(
  497. ParseCIDRBlock("192.168.0.1/11", &ip_address, &prefix_length_in_bits));
  498. EXPECT_EQ("192,168,0,1", DumpIPAddress(ip_address));
  499. EXPECT_EQ(11u, prefix_length_in_bits);
  500. EXPECT_TRUE(ParseCIDRBlock("::ffff:192.168.0.1/112", &ip_address,
  501. &prefix_length_in_bits));
  502. EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
  503. DumpIPAddress(ip_address));
  504. EXPECT_EQ(112u, prefix_length_in_bits);
  505. }
  506. TEST(IPAddressTest, ParseURLHostnameToAddress_FailParse) {
  507. IPAddress address;
  508. EXPECT_FALSE(ParseURLHostnameToAddress("bad value", &address));
  509. EXPECT_FALSE(ParseURLHostnameToAddress("bad:value", &address));
  510. EXPECT_FALSE(ParseURLHostnameToAddress(std::string(), &address));
  511. EXPECT_FALSE(ParseURLHostnameToAddress("192.168.0.1:30", &address));
  512. EXPECT_FALSE(ParseURLHostnameToAddress(" 192.168.0.1 ", &address));
  513. EXPECT_FALSE(ParseURLHostnameToAddress("::1", &address));
  514. EXPECT_FALSE(ParseURLHostnameToAddress("[192.169.0.1]", &address));
  515. }
  516. TEST(IPAddressTest, ParseURLHostnameToAddress_IPv4) {
  517. IPAddress address;
  518. EXPECT_TRUE(ParseURLHostnameToAddress("192.168.0.1", &address));
  519. EXPECT_EQ("192,168,0,1", DumpIPAddress(address));
  520. EXPECT_EQ("192.168.0.1", address.ToString());
  521. }
  522. TEST(IPAddressTest, ParseURLHostnameToAddress_IPv6) {
  523. IPAddress address;
  524. EXPECT_TRUE(ParseURLHostnameToAddress("[1:abcd::3:4:ff]", &address));
  525. EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPAddress(address));
  526. EXPECT_EQ("1:abcd::3:4:ff", address.ToString());
  527. }
  528. TEST(IPAddressTest, IPAddressStartsWith) {
  529. IPAddress ipv4_address(192, 168, 10, 5);
  530. uint8_t ipv4_prefix1[] = {192, 168, 10};
  531. EXPECT_TRUE(IPAddressStartsWith(ipv4_address, ipv4_prefix1));
  532. uint8_t ipv4_prefix3[] = {192, 168, 10, 5};
  533. EXPECT_TRUE(IPAddressStartsWith(ipv4_address, ipv4_prefix3));
  534. uint8_t ipv4_prefix2[] = {192, 168, 10, 10};
  535. EXPECT_FALSE(IPAddressStartsWith(ipv4_address, ipv4_prefix2));
  536. // Prefix is longer than the address.
  537. uint8_t ipv4_prefix4[] = {192, 168, 10, 10, 0};
  538. EXPECT_FALSE(IPAddressStartsWith(ipv4_address, ipv4_prefix4));
  539. IPAddress ipv6_address;
  540. EXPECT_TRUE(ipv6_address.AssignFromIPLiteral("2a00:1450:400c:c09::64"));
  541. uint8_t ipv6_prefix1[] = {42, 0, 20, 80, 64, 12, 12, 9};
  542. EXPECT_TRUE(IPAddressStartsWith(ipv6_address, ipv6_prefix1));
  543. uint8_t ipv6_prefix2[] = {41, 0, 20, 80, 64, 12, 12, 9,
  544. 0, 0, 0, 0, 0, 0, 100};
  545. EXPECT_FALSE(IPAddressStartsWith(ipv6_address, ipv6_prefix2));
  546. uint8_t ipv6_prefix3[] = {42, 0, 20, 80, 64, 12, 12, 9,
  547. 0, 0, 0, 0, 0, 0, 0, 100};
  548. EXPECT_TRUE(IPAddressStartsWith(ipv6_address, ipv6_prefix3));
  549. uint8_t ipv6_prefix4[] = {42, 0, 20, 80, 64, 12, 12, 9,
  550. 0, 0, 0, 0, 0, 0, 0, 0};
  551. EXPECT_FALSE(IPAddressStartsWith(ipv6_address, ipv6_prefix4));
  552. // Prefix is longer than the address.
  553. uint8_t ipv6_prefix5[] = {42, 0, 20, 80, 64, 12, 12, 9, 0,
  554. 0, 0, 0, 0, 0, 0, 0, 10};
  555. EXPECT_FALSE(IPAddressStartsWith(ipv6_address, ipv6_prefix5));
  556. }
  557. TEST(IPAddressTest, IsLinkLocal) {
  558. const char* kPositive[] = {
  559. "169.254.0.0",
  560. "169.254.100.1",
  561. "169.254.100.1",
  562. "::ffff:169.254.0.0",
  563. "::ffff:169.254.100.1",
  564. "fe80::1",
  565. "fe81::1",
  566. };
  567. for (const char* literal : kPositive) {
  568. IPAddress ip_address;
  569. ASSERT_TRUE(ip_address.AssignFromIPLiteral(literal));
  570. EXPECT_TRUE(ip_address.IsLinkLocal()) << literal;
  571. }
  572. const char* kNegative[] = {
  573. "170.254.0.0", "169.255.0.0", "::169.254.0.0",
  574. "::fffe:169.254.0.0", "::ffff:169.255.0.0", "fec0::1",
  575. };
  576. for (const char* literal : kNegative) {
  577. IPAddress ip_address;
  578. ASSERT_TRUE(ip_address.AssignFromIPLiteral(literal));
  579. EXPECT_FALSE(ip_address.IsLinkLocal()) << literal;
  580. }
  581. }
  582. } // anonymous namespace
  583. } // namespace net