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