test_net_address_private.cc 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323
  1. // Copyright (c) 2012 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 "ppapi/tests/test_net_address_private.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <string.h>
  8. #include "ppapi/c/private/ppb_net_address_private.h"
  9. #include "ppapi/cpp/private/net_address_private.h"
  10. #include "ppapi/tests/test_utils.h"
  11. #include "ppapi/tests/testing_instance.h"
  12. using pp::NetAddressPrivate;
  13. namespace {
  14. PP_NetAddress_Private MakeIPv4NetAddress(const uint8_t host[4], int port) {
  15. PP_NetAddress_Private addr;
  16. NetAddressPrivate::CreateFromIPv4Address(host, port, &addr);
  17. return addr;
  18. }
  19. PP_NetAddress_Private MakeIPv6NetAddress(const uint16_t host[8], uint16_t port,
  20. uint32_t scope_id) {
  21. PP_NetAddress_Private addr = PP_NetAddress_Private();
  22. uint8_t ip[16];
  23. for(int i = 0; i < 8; ++i) {
  24. ip[i * 2] = host[i] >> 8;
  25. ip[i * 2 + 1] = host[i] & 0xff;
  26. }
  27. NetAddressPrivate::CreateFromIPv6Address(ip, scope_id, port, &addr);
  28. return addr;
  29. }
  30. } // namespace
  31. REGISTER_TEST_CASE(NetAddressPrivate);
  32. TestNetAddressPrivate::TestNetAddressPrivate(TestingInstance* instance)
  33. : TestCase(instance) {
  34. }
  35. bool TestNetAddressPrivate::Init() {
  36. return NetAddressPrivate::IsAvailable();
  37. }
  38. void TestNetAddressPrivate::RunTests(const std::string& filter) {
  39. RUN_TEST(AreEqual, filter);
  40. RUN_TEST(AreHostsEqual, filter);
  41. RUN_TEST(Describe, filter);
  42. RUN_TEST(ReplacePort, filter);
  43. RUN_TEST(GetAnyAddress, filter);
  44. RUN_TEST(DescribeIPv6, filter);
  45. RUN_TEST(GetFamily, filter);
  46. RUN_TEST(GetPort, filter);
  47. RUN_TEST(GetAddress, filter);
  48. RUN_TEST(GetScopeID, filter);
  49. }
  50. std::string TestNetAddressPrivate::TestAreEqual() {
  51. // No comparisons should ever be done with invalid addresses.
  52. PP_NetAddress_Private invalid = PP_NetAddress_Private();
  53. ASSERT_FALSE(NetAddressPrivate::AreEqual(invalid, invalid));
  54. uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
  55. PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
  56. ASSERT_TRUE(NetAddressPrivate::AreEqual(localhost_80, localhost_80));
  57. ASSERT_FALSE(NetAddressPrivate::AreEqual(localhost_80, invalid));
  58. PP_NetAddress_Private localhost_1234 = MakeIPv4NetAddress(localhost_ip, 1234);
  59. ASSERT_FALSE(NetAddressPrivate::AreEqual(localhost_80, localhost_1234));
  60. uint8_t other_ip[4] = { 192, 168, 0, 1 };
  61. PP_NetAddress_Private other_80 = MakeIPv4NetAddress(other_ip, 80);
  62. ASSERT_FALSE(NetAddressPrivate::AreEqual(localhost_80, other_80));
  63. PASS();
  64. }
  65. std::string TestNetAddressPrivate::TestAreHostsEqual() {
  66. // No comparisons should ever be done with invalid addresses.
  67. PP_NetAddress_Private invalid = PP_NetAddress_Private();
  68. ASSERT_FALSE(NetAddressPrivate::AreHostsEqual(invalid, invalid));
  69. uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
  70. PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
  71. ASSERT_TRUE(NetAddressPrivate::AreHostsEqual(localhost_80, localhost_80));
  72. ASSERT_FALSE(NetAddressPrivate::AreHostsEqual(localhost_80, invalid));
  73. PP_NetAddress_Private localhost_1234 = MakeIPv4NetAddress(localhost_ip, 1234);
  74. ASSERT_TRUE(NetAddressPrivate::AreHostsEqual(localhost_80, localhost_1234));
  75. uint8_t other_ip[4] = { 192, 168, 0, 1 };
  76. PP_NetAddress_Private other_80 = MakeIPv4NetAddress(other_ip, 80);
  77. ASSERT_FALSE(NetAddressPrivate::AreHostsEqual(localhost_80, other_80));
  78. PASS();
  79. }
  80. std::string TestNetAddressPrivate::TestDescribe() {
  81. PP_NetAddress_Private invalid = PP_NetAddress_Private();
  82. ASSERT_EQ("", NetAddressPrivate::Describe(invalid, false));
  83. ASSERT_EQ("", NetAddressPrivate::Describe(invalid, true));
  84. uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
  85. PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
  86. ASSERT_EQ("127.0.0.1", NetAddressPrivate::Describe(localhost_80, false));
  87. ASSERT_EQ("127.0.0.1:80", NetAddressPrivate::Describe(localhost_80, true));
  88. PP_NetAddress_Private localhost_1234 = MakeIPv4NetAddress(localhost_ip, 1234);
  89. ASSERT_EQ("127.0.0.1", NetAddressPrivate::Describe(localhost_1234, false));
  90. ASSERT_EQ("127.0.0.1:1234", NetAddressPrivate::Describe(localhost_1234,
  91. true));
  92. uint8_t other_ip[4] = { 192, 168, 0, 1 };
  93. PP_NetAddress_Private other_80 = MakeIPv4NetAddress(other_ip, 80);
  94. ASSERT_EQ("192.168.0.1", NetAddressPrivate::Describe(other_80, false));
  95. ASSERT_EQ("192.168.0.1:80", NetAddressPrivate::Describe(other_80, true));
  96. PASS();
  97. }
  98. std::string TestNetAddressPrivate::TestReplacePort() {
  99. // Assume that |AreEqual()| works correctly.
  100. PP_NetAddress_Private result = PP_NetAddress_Private();
  101. PP_NetAddress_Private invalid = PP_NetAddress_Private();
  102. ASSERT_FALSE(NetAddressPrivate::ReplacePort(invalid, 1234, &result));
  103. uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
  104. PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
  105. ASSERT_TRUE(NetAddressPrivate::ReplacePort(localhost_80, 1234, &result));
  106. PP_NetAddress_Private localhost_1234 = MakeIPv4NetAddress(localhost_ip, 1234);
  107. ASSERT_TRUE(NetAddressPrivate::AreEqual(result, localhost_1234));
  108. // Test that having the out param being the same as the in param works
  109. // properly.
  110. ASSERT_TRUE(NetAddressPrivate::ReplacePort(result, 80, &result));
  111. ASSERT_TRUE(NetAddressPrivate::AreEqual(result, localhost_80));
  112. PASS();
  113. }
  114. std::string TestNetAddressPrivate::TestGetAnyAddress() {
  115. // Just make sure it doesn't crash and such.
  116. PP_NetAddress_Private result = PP_NetAddress_Private();
  117. NetAddressPrivate::GetAnyAddress(false, &result);
  118. ASSERT_TRUE(NetAddressPrivate::AreEqual(result, result));
  119. NetAddressPrivate::GetAnyAddress(true, &result);
  120. ASSERT_TRUE(NetAddressPrivate::AreEqual(result, result));
  121. PASS();
  122. }
  123. // TODO(viettrungluu): More IPv6 tests needed.
  124. std::string TestNetAddressPrivate::TestDescribeIPv6() {
  125. static const struct {
  126. uint16_t address[8];
  127. uint16_t port;
  128. uint32_t scope;
  129. const char* expected_without_port;
  130. const char* expected_with_port;
  131. } test_cases[] = {
  132. { // Generic test case (unique longest run of zeros to collapse).
  133. { 0x12, 0xabcd, 0, 0x0001, 0, 0, 0, 0xcdef }, 12, 0,
  134. "12:abcd:0:1::cdef", "[12:abcd:0:1::cdef]:12"
  135. },
  136. { // Non-zero scope.
  137. { 0x1234, 0xabcd, 0, 0x0001, 0, 0, 0, 0xcdef }, 1234, 789,
  138. "1234:abcd:0:1::cdef%789", "[1234:abcd:0:1::cdef%789]:1234"
  139. },
  140. { // Ignore the first (non-longest) run of zeros.
  141. { 0, 0, 0, 0x0123, 0, 0, 0, 0 }, 123, 0,
  142. "0:0:0:123::", "[0:0:0:123::]:123"
  143. },
  144. { // Collapse the first (equally-longest) run of zeros.
  145. { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef }, 123, 0,
  146. "1234:abcd::ff:0:0:cdef", "[1234:abcd::ff:0:0:cdef]:123"
  147. },
  148. { // Don't collapse "runs" of zeros of length 1.
  149. { 0, 0xa, 1, 2, 3, 0, 5, 0 }, 123, 0,
  150. "0:a:1:2:3:0:5:0", "[0:a:1:2:3:0:5:0]:123"
  151. },
  152. { // Collapse a run of zeros at the beginning.
  153. { 0, 0, 0, 2, 3, 0, 0, 0 }, 123, 0,
  154. "::2:3:0:0:0", "[::2:3:0:0:0]:123"
  155. },
  156. { // Collapse a run of zeros at the end.
  157. { 0, 0xa, 1, 2, 3, 0, 0, 0 }, 123, 0,
  158. "0:a:1:2:3::", "[0:a:1:2:3::]:123"
  159. },
  160. { // IPv4 192.168.1.2 embedded in IPv6 in the deprecated way.
  161. { 0, 0, 0, 0, 0, 0, 0xc0a8, 0x102 }, 123, 0,
  162. "::192.168.1.2", "[::192.168.1.2]:123"
  163. },
  164. { // ... with non-zero scope.
  165. { 0, 0, 0, 0, 0, 0, 0xc0a8, 0x102 }, 123, 789,
  166. "::192.168.1.2%789", "[::192.168.1.2%789]:123"
  167. },
  168. { // IPv4 192.168.1.2 embedded in IPv6.
  169. { 0, 0, 0, 0, 0, 0xffff, 0xc0a8, 0x102 }, 123, 0,
  170. "::ffff:192.168.1.2", "[::ffff:192.168.1.2]:123"
  171. },
  172. { // ... with non-zero scope.
  173. { 0, 0, 0, 0, 0, 0xffff, 0xc0a8, 0x102 }, 123, 789,
  174. "::ffff:192.168.1.2%789", "[::ffff:192.168.1.2%789]:123"
  175. },
  176. { // *Not* IPv4 embedded in IPv6.
  177. { 0, 0, 0, 0, 0, 0x1234, 0xc0a8, 0x102 }, 123, 0,
  178. "::1234:c0a8:102", "[::1234:c0a8:102]:123"
  179. }
  180. };
  181. for (size_t i = 0; i < sizeof(test_cases)/sizeof(test_cases[0]); i++) {
  182. PP_NetAddress_Private addr = MakeIPv6NetAddress(test_cases[i].address,
  183. test_cases[i].port,
  184. test_cases[i].scope);
  185. ASSERT_EQ(test_cases[i].expected_without_port,
  186. NetAddressPrivate::Describe(addr, false));
  187. ASSERT_EQ(test_cases[i].expected_with_port,
  188. NetAddressPrivate::Describe(addr, true));
  189. }
  190. PASS();
  191. }
  192. std::string TestNetAddressPrivate::TestGetFamily() {
  193. uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
  194. PP_NetAddress_Private ipv4 = MakeIPv4NetAddress(localhost_ip, 80);
  195. ASSERT_EQ(NetAddressPrivate::GetFamily(ipv4),
  196. PP_NETADDRESSFAMILY_PRIVATE_IPV4);
  197. uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
  198. PP_NetAddress_Private ipv6 = MakeIPv6NetAddress(ipv6_address, 123, 0);
  199. ASSERT_EQ(NetAddressPrivate::GetFamily(ipv6),
  200. PP_NETADDRESSFAMILY_PRIVATE_IPV6);
  201. PASS();
  202. }
  203. std::string TestNetAddressPrivate::TestGetPort() {
  204. uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
  205. PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(localhost_ip, 80);
  206. ASSERT_EQ(NetAddressPrivate::GetPort(localhost_80), 80);
  207. uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
  208. PP_NetAddress_Private port_123 = MakeIPv6NetAddress(ipv6_address, 123, 0);
  209. ASSERT_EQ(NetAddressPrivate::GetPort(port_123), 123);
  210. PP_NetAddress_Private port_FFFF = MakeIPv6NetAddress(ipv6_address,
  211. 0xFFFF,
  212. 0);
  213. ASSERT_EQ(NetAddressPrivate::GetPort(port_FFFF), 0xFFFF);
  214. PASS();
  215. }
  216. std::string TestNetAddressPrivate::TestGetAddress() {
  217. const int addr_storage_len = 16;
  218. unsigned char addr_storage[addr_storage_len];
  219. const uint8_t ipv4_addr[4] = { 127, 0, 0, 1 };
  220. PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress(ipv4_addr, 80);
  221. memset(addr_storage, 0, addr_storage_len);
  222. ASSERT_TRUE(NetAddressPrivate::GetAddress(localhost_80,
  223. addr_storage,
  224. addr_storage_len));
  225. ASSERT_EQ(memcmp(addr_storage, &ipv4_addr, 4), 0);
  226. // Insufficient storage for address.
  227. ASSERT_FALSE(NetAddressPrivate::GetAddress(localhost_80,
  228. addr_storage,
  229. 1));
  230. uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
  231. PP_NetAddress_Private ipv6_addr = MakeIPv6NetAddress(ipv6_address,
  232. 123,
  233. 0);
  234. // Ensure the ipv6 address is transformed properly into network order.
  235. uint8_t ipv6_bytes[16];
  236. for(int i = 0; i < 8; ++i) {
  237. ipv6_bytes[i * 2] = ipv6_address[i] >> 8;
  238. ipv6_bytes[i * 2 + 1] = ipv6_address[i] & 0xFF;
  239. }
  240. memset(addr_storage, 0, addr_storage_len);
  241. ASSERT_TRUE(NetAddressPrivate::GetAddress(ipv6_addr,
  242. addr_storage,
  243. addr_storage_len));
  244. ASSERT_EQ(memcmp(addr_storage, ipv6_bytes, 16), 0);
  245. // Insufficient storage for address.
  246. ASSERT_FALSE(NetAddressPrivate::GetAddress(ipv6_addr,
  247. addr_storage,
  248. 1));
  249. PASS();
  250. }
  251. std::string TestNetAddressPrivate::TestGetScopeID() {
  252. uint8_t localhost_ip[4] = { 127, 0, 0, 1 };
  253. PP_NetAddress_Private ipv4 = MakeIPv4NetAddress(localhost_ip, 80);
  254. ASSERT_EQ(0, NetAddressPrivate::GetScopeID(ipv4));
  255. uint16_t ipv6_address[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
  256. PP_NetAddress_Private ipv6_123 = MakeIPv6NetAddress(ipv6_address, 0, 123);
  257. ASSERT_EQ(123, NetAddressPrivate::GetScopeID(ipv6_123));
  258. PP_NetAddress_Private ipv6_max =
  259. MakeIPv6NetAddress(ipv6_address, 0, 0xFFFFFFFF);
  260. ASSERT_EQ(NetAddressPrivate::GetScopeID(ipv6_max), 0xFFFFFFFF);
  261. PASS();
  262. }