1 // 2 // Copyright (C) 2012 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #include "shill/net/ip_address.h" 18 19 #include <gtest/gtest.h> 20 21 #include <arpa/inet.h> 22 23 #include "shill/net/byte_string.h" 24 25 using std::string; 26 using testing::Test; 27 28 namespace shill { 29 30 namespace { 31 const char kV4String1[] = "192.168.10.1"; 32 const unsigned char kV4Address1[] = { 192, 168, 10, 1 }; 33 const char kV4String2[] = "192.168.10"; 34 const unsigned char kV4Address2[] = { 192, 168, 10 }; 35 const char kV6String1[] = "fe80::1aa9:5ff:7ebf:14c5"; 36 const unsigned char kV6Address1[] = { 0xfe, 0x80, 0x00, 0x00, 37 0x00, 0x00, 0x00, 0x00, 38 0x1a, 0xa9, 0x05, 0xff, 39 0x7e, 0xbf, 0x14, 0xc5 }; 40 const char kV6String2[] = "1980:0:1000:1b02:1aa9:5ff:7ebf"; 41 const unsigned char kV6Address2[] = { 0x19, 0x80, 0x00, 0x00, 42 0x10, 0x00, 0x1b, 0x02, 43 0x1a, 0xa9, 0x05, 0xff, 44 0x7e, 0xbf }; 45 } // namespace 46 47 class IPAddressTest : public Test { 48 protected: 49 void TestAddress(IPAddress::Family family, 50 const string& good_string, 51 const ByteString& good_bytes, 52 const string& bad_string, 53 const ByteString& bad_bytes) { 54 IPAddress good_addr(family); 55 56 EXPECT_TRUE(good_addr.SetAddressFromString(good_string)); 57 EXPECT_EQ(IPAddress::GetAddressLength(family), good_addr.GetLength()); 58 EXPECT_EQ(family, good_addr.family()); 59 EXPECT_FALSE(good_addr.IsDefault()); 60 EXPECT_EQ(0, memcmp(good_addr.GetConstData(), good_bytes.GetConstData(), 61 good_bytes.GetLength())); 62 EXPECT_TRUE(good_addr.address().Equals(good_bytes)); 63 string address_string; 64 EXPECT_TRUE(good_addr.IntoString(&address_string)); 65 EXPECT_EQ(good_string, address_string); 66 67 IPAddress good_addr_from_bytes(family, good_bytes); 68 EXPECT_TRUE(good_addr.Equals(good_addr_from_bytes)); 69 70 IPAddress good_addr_from_string(good_string); 71 EXPECT_EQ(family, good_addr_from_string.family()); 72 73 IPAddress bad_addr(family); 74 EXPECT_FALSE(bad_addr.SetAddressFromString(bad_string)); 75 EXPECT_FALSE(good_addr.Equals(bad_addr)); 76 77 EXPECT_FALSE(bad_addr.IsValid()); 78 79 IPAddress bad_addr_from_bytes(family, bad_bytes); 80 EXPECT_EQ(family, bad_addr_from_bytes.family()); 81 EXPECT_FALSE(bad_addr_from_bytes.IsValid()); 82 83 IPAddress bad_addr_from_string(bad_string); 84 EXPECT_EQ(IPAddress::kFamilyUnknown, bad_addr_from_string.family()); 85 86 EXPECT_FALSE(bad_addr.Equals(bad_addr_from_bytes)); 87 EXPECT_FALSE(bad_addr.IntoString(&address_string)); 88 89 sockaddr_storage storage = {}; 90 auto addr = reinterpret_cast<sockaddr*>(&storage); 91 addr->sa_family = family; 92 ssize_t addr_size; 93 if (family == IPAddress::kFamilyIPv6) { 94 auto sin6 = reinterpret_cast<sockaddr_in6*>(addr); 95 inet_pton(AF_INET6, good_string.c_str(), &sin6->sin6_addr.s6_addr); 96 addr_size = sizeof(sockaddr_in6); 97 } else { 98 auto sin = reinterpret_cast<sockaddr_in*>(addr); 99 inet_pton(AF_INET, good_string.c_str(), &sin->sin_addr.s_addr); 100 addr_size = sizeof(sockaddr_in); 101 } 102 IPAddress from_short_sockaddr(addr, addr_size - 1); 103 EXPECT_FALSE(from_short_sockaddr.IsValid()); 104 IPAddress from_sockaddr(addr, addr_size); 105 EXPECT_TRUE(from_sockaddr.IsValid()); 106 EXPECT_EQ(family, from_sockaddr.family()); 107 EXPECT_TRUE(from_sockaddr.IntoString(&address_string)); 108 EXPECT_EQ(good_string, address_string); 109 110 sockaddr_storage storage_empty = {}; 111 sockaddr_storage storage2 = {}; 112 auto addr2 = reinterpret_cast<sockaddr*>(&storage2); 113 EXPECT_FALSE(from_short_sockaddr.IntoSockAddr(addr2, addr_size)); 114 EXPECT_EQ(0, memcmp(&storage2, &storage_empty, sizeof(storage2))); 115 EXPECT_FALSE(from_sockaddr.IntoSockAddr(addr2, addr_size - 1)); 116 EXPECT_EQ(0, memcmp(&storage2, &storage_empty, sizeof(storage2))); 117 EXPECT_TRUE(from_sockaddr.IntoSockAddr(addr2, addr_size)); 118 EXPECT_EQ(0, memcmp(&storage2, &storage, sizeof(storage2))); 119 } 120 }; 121 122 TEST_F(IPAddressTest, Statics) { 123 EXPECT_EQ(4, IPAddress::GetAddressLength(IPAddress::kFamilyIPv4)); 124 EXPECT_EQ(16, IPAddress::GetAddressLength(IPAddress::kFamilyIPv6)); 125 126 EXPECT_EQ(0, IPAddress::GetPrefixLengthFromMask(IPAddress::kFamilyIPv4, 127 "0.0.0.0")); 128 EXPECT_EQ(20, IPAddress::GetPrefixLengthFromMask(IPAddress::kFamilyIPv4, 129 "255.255.240.0")); 130 EXPECT_EQ(32, IPAddress::GetPrefixLengthFromMask(IPAddress::kFamilyIPv4, 131 "255.255.255.255")); 132 EXPECT_EQ(32, IPAddress::GetPrefixLengthFromMask(IPAddress::kFamilyIPv4, 133 "")); 134 EXPECT_EQ(32, IPAddress::GetPrefixLengthFromMask(IPAddress::kFamilyIPv4, 135 "foo")); 136 137 IPAddress addr4(IPAddress::kFamilyIPv4); 138 addr4.SetAddressToDefault(); 139 140 EXPECT_EQ(4, addr4.GetLength()); 141 EXPECT_EQ(IPAddress::kFamilyIPv4, addr4.family()); 142 EXPECT_TRUE(addr4.IsDefault()); 143 EXPECT_TRUE(addr4.address().IsZero()); 144 EXPECT_TRUE(addr4.address().Equals(ByteString(4))); 145 146 147 IPAddress addr6(IPAddress::kFamilyIPv6); 148 addr6.SetAddressToDefault(); 149 150 EXPECT_EQ(16, addr6.GetLength()); 151 EXPECT_EQ(addr6.family(), IPAddress::kFamilyIPv6); 152 EXPECT_TRUE(addr6.IsDefault()); 153 EXPECT_TRUE(addr6.address().IsZero()); 154 EXPECT_TRUE(addr6.address().Equals(ByteString(16))); 155 156 EXPECT_FALSE(addr4.Equals(addr6)); 157 } 158 159 TEST_F(IPAddressTest, IPv4) { 160 TestAddress(IPAddress::kFamilyIPv4, 161 kV4String1, ByteString(kV4Address1, sizeof(kV4Address1)), 162 kV4String2, ByteString(kV4Address2, sizeof(kV4Address2))); 163 } 164 165 166 TEST_F(IPAddressTest, IPv6) { 167 TestAddress(IPAddress::kFamilyIPv6, 168 kV6String1, ByteString(kV6Address1, sizeof(kV6Address1)), 169 kV6String2, ByteString(kV6Address2, sizeof(kV6Address2))); 170 } 171 172 TEST_F(IPAddressTest, SetAddressAndPrefixFromString) { 173 IPAddress address(IPAddress::kFamilyIPv4); 174 const string kString1(kV4String1); 175 const string kString2(kV4String2); 176 EXPECT_FALSE(address.SetAddressAndPrefixFromString("")); 177 EXPECT_FALSE(address.SetAddressAndPrefixFromString(kString1)); 178 EXPECT_FALSE(address.SetAddressAndPrefixFromString(kString1 + "/")); 179 EXPECT_FALSE(address.SetAddressAndPrefixFromString(kString1 + "/10x")); 180 EXPECT_FALSE(address.SetAddressAndPrefixFromString(kString2 + "/10")); 181 EXPECT_TRUE(address.SetAddressAndPrefixFromString(kString1 + "/0")); 182 EXPECT_EQ(0, address.prefix()); 183 EXPECT_TRUE(address.SetAddressAndPrefixFromString(kString1 + "/32")); 184 EXPECT_EQ(32, address.prefix()); 185 EXPECT_FALSE(address.SetAddressAndPrefixFromString(kString1 + "/33")); 186 EXPECT_FALSE(address.SetAddressAndPrefixFromString(kString1 + "/-1")); 187 EXPECT_TRUE(address.SetAddressAndPrefixFromString(kString1 + "/10")); 188 EXPECT_EQ(10, address.prefix()); 189 ByteString kAddress1(kV4Address1, sizeof(kV4Address1)); 190 EXPECT_TRUE(kAddress1.Equals(address.address())); 191 } 192 193 TEST_F(IPAddressTest, HasSameAddressAs) { 194 const string kString1(kV4String1); 195 IPAddress address0(IPAddress::kFamilyIPv4); 196 EXPECT_TRUE(address0.SetAddressAndPrefixFromString(kString1 + "/0")); 197 IPAddress address1(IPAddress::kFamilyIPv4); 198 EXPECT_TRUE(address1.SetAddressAndPrefixFromString(kString1 + "/10")); 199 IPAddress address2(IPAddress::kFamilyIPv4); 200 EXPECT_TRUE(address2.SetAddressAndPrefixFromString(kString1 + "/0")); 201 202 EXPECT_FALSE(address0.Equals(address1)); 203 EXPECT_TRUE(address0.Equals(address2)); 204 EXPECT_TRUE(address0.HasSameAddressAs(address1)); 205 EXPECT_TRUE(address0.HasSameAddressAs(address2)); 206 } 207 208 struct PrefixMapping { 209 PrefixMapping() : family(IPAddress::kFamilyUnknown), prefix(0) {} 210 PrefixMapping(IPAddress::Family family_in, 211 size_t prefix_in, 212 const string& expected_address_in) 213 : family(family_in), 214 prefix(prefix_in), 215 expected_address(expected_address_in) {} 216 IPAddress::Family family; 217 size_t prefix; 218 string expected_address; 219 }; 220 221 class IPAddressPrefixMappingTest 222 : public testing::TestWithParam<PrefixMapping> {}; 223 224 TEST_P(IPAddressPrefixMappingTest, TestPrefixMapping) { 225 IPAddress address = IPAddress::GetAddressMaskFromPrefix(GetParam().family, 226 GetParam().prefix); 227 IPAddress expected_address(GetParam().family); 228 EXPECT_TRUE(expected_address.SetAddressFromString( 229 GetParam().expected_address)); 230 EXPECT_TRUE(expected_address.Equals(address)); 231 } 232 233 INSTANTIATE_TEST_CASE_P( 234 IPAddressPrefixMappingTestRun, 235 IPAddressPrefixMappingTest, 236 ::testing::Values( 237 PrefixMapping(IPAddress::kFamilyIPv4, 0, "0.0.0.0"), 238 PrefixMapping(IPAddress::kFamilyIPv4, 1, "128.0.0.0"), 239 PrefixMapping(IPAddress::kFamilyIPv4, 4, "240.0.0.0"), 240 PrefixMapping(IPAddress::kFamilyIPv4, 7, "254.0.0.0"), 241 PrefixMapping(IPAddress::kFamilyIPv4, 10, "255.192.0.0"), 242 PrefixMapping(IPAddress::kFamilyIPv4, 13, "255.248.0.0"), 243 PrefixMapping(IPAddress::kFamilyIPv4, 16, "255.255.0.0"), 244 PrefixMapping(IPAddress::kFamilyIPv4, 19, "255.255.224.0"), 245 PrefixMapping(IPAddress::kFamilyIPv4, 22, "255.255.252.0"), 246 PrefixMapping(IPAddress::kFamilyIPv4, 25, "255.255.255.128"), 247 PrefixMapping(IPAddress::kFamilyIPv4, 28, "255.255.255.240"), 248 PrefixMapping(IPAddress::kFamilyIPv4, 31, "255.255.255.254"), 249 PrefixMapping(IPAddress::kFamilyIPv4, 32, "255.255.255.255"), 250 PrefixMapping(IPAddress::kFamilyIPv4, 33, "255.255.255.255"), 251 PrefixMapping(IPAddress::kFamilyIPv4, 34, "255.255.255.255"), 252 PrefixMapping(IPAddress::kFamilyIPv6, 0, "0::"), 253 PrefixMapping(IPAddress::kFamilyIPv6, 1, "8000::"), 254 PrefixMapping(IPAddress::kFamilyIPv6, 17, "ffff:8000::"), 255 PrefixMapping(IPAddress::kFamilyIPv6, 34, "ffff:ffff:c000::"), 256 PrefixMapping(IPAddress::kFamilyIPv6, 51, "ffff:ffff:ffff:e000::"), 257 PrefixMapping(IPAddress::kFamilyIPv6, 68, 258 "ffff:ffff:ffff:ffff:f000::"), 259 PrefixMapping(IPAddress::kFamilyIPv6, 85, 260 "ffff:ffff:ffff:ffff:ffff:f800::"), 261 PrefixMapping(IPAddress::kFamilyIPv6, 102, 262 "ffff:ffff:ffff:ffff:ffff:ffff:fc00::"), 263 PrefixMapping(IPAddress::kFamilyIPv6, 119, 264 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fe00"), 265 PrefixMapping(IPAddress::kFamilyIPv6, 128, 266 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), 267 PrefixMapping(IPAddress::kFamilyIPv6, 136, 268 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); 269 270 struct BitOperationMapping { 271 BitOperationMapping() : family(IPAddress::kFamilyUnknown) {} 272 BitOperationMapping(IPAddress::Family family_in, 273 const string& address_a_in, 274 const string& address_b_in, 275 const string& expected_anded_in, 276 const string& expected_orred_in) 277 : family(family_in), 278 address_a(address_a_in), 279 address_b(address_b_in), 280 expected_anded(expected_anded_in), 281 expected_orred(expected_orred_in) {} 282 IPAddress::Family family; 283 string address_a; 284 string address_b; 285 string expected_anded; 286 string expected_orred; 287 }; 288 289 class IPAddressBitOperationMappingTest 290 : public testing::TestWithParam<BitOperationMapping> {}; 291 292 TEST_P(IPAddressBitOperationMappingTest, TestBitOperationMapping) { 293 IPAddress address_a(GetParam().family); 294 EXPECT_TRUE(address_a.SetAddressFromString(GetParam().address_a)); 295 IPAddress address_b(GetParam().family); 296 EXPECT_TRUE(address_b.SetAddressFromString(GetParam().address_b)); 297 IPAddress expected_anded(GetParam().family); 298 EXPECT_TRUE(expected_anded.SetAddressFromString( 299 GetParam().expected_anded)); 300 EXPECT_TRUE(expected_anded.Equals(address_a.MaskWith(address_b))); 301 IPAddress expected_orred(GetParam().family); 302 EXPECT_TRUE(expected_orred.SetAddressFromString( 303 GetParam().expected_orred)); 304 EXPECT_TRUE(expected_orred.Equals(address_a.MergeWith(address_b))); 305 } 306 307 INSTANTIATE_TEST_CASE_P( 308 IPAddressBitOperationMappingTestRun, 309 IPAddressBitOperationMappingTest, 310 ::testing::Values( 311 BitOperationMapping(IPAddress::kFamilyIPv4, 312 "255.255.255.255", "0.0.0.0", 313 "0.0.0.0", "255.255.255.255"), 314 BitOperationMapping(IPAddress::kFamilyIPv4, 315 "0.0.0.0", "255.255.255.255", 316 "0.0.0.0", "255.255.255.255"), 317 BitOperationMapping(IPAddress::kFamilyIPv4, 318 "170.170.170.170", "85.85.85.85", 319 "0.0.0.0", "255.255.255.255"), 320 BitOperationMapping(IPAddress::kFamilyIPv4, 321 "238.187.119.221", "119.221.238.187", 322 "102.153.102.153", "255.255.255.255"), 323 BitOperationMapping(IPAddress::kFamilyIPv4, 324 "17.68.136.34", "119.221.238.187", 325 "17.68.136.34", "119.221.238.187"), 326 BitOperationMapping(IPAddress::kFamilyIPv4, 327 "192.168.1.10", "255.255.255.0", 328 "192.168.1.0", "255.255.255.10"))); 329 330 struct NetworkPartMapping { 331 NetworkPartMapping() : family(IPAddress::kFamilyUnknown) {} 332 NetworkPartMapping(IPAddress::Family family_in, 333 const string& address_in, 334 size_t prefix_in, 335 const string& expected_network_in, 336 const string& expected_broadcast_in) 337 : family(family_in), 338 address(address_in), 339 prefix(prefix_in), 340 expected_network(expected_network_in), 341 expected_broadcast(expected_broadcast_in) {} 342 IPAddress::Family family; 343 string address; 344 size_t prefix; 345 string expected_network; 346 string expected_broadcast; 347 }; 348 349 class IPAddressNetworkPartMappingTest 350 : public testing::TestWithParam<NetworkPartMapping> {}; 351 352 TEST_P(IPAddressNetworkPartMappingTest, TestNetworkPartMapping) { 353 IPAddress address(GetParam().family); 354 EXPECT_TRUE(address.SetAddressFromString(GetParam().address)); 355 IPAddress expected_network(GetParam().family); 356 EXPECT_TRUE(expected_network.SetAddressFromString( 357 GetParam().expected_network)); 358 address.set_prefix(GetParam().prefix); 359 EXPECT_TRUE(expected_network.Equals(address.GetNetworkPart())); 360 IPAddress expected_broadcast(GetParam().family); 361 EXPECT_TRUE(expected_broadcast.SetAddressFromString( 362 GetParam().expected_broadcast)); 363 EXPECT_TRUE(expected_broadcast.Equals(address.GetDefaultBroadcast())); 364 } 365 366 INSTANTIATE_TEST_CASE_P( 367 IPAddressNetworkPartMappingTestRun, 368 IPAddressNetworkPartMappingTest, 369 ::testing::Values( 370 NetworkPartMapping(IPAddress::kFamilyIPv4, 371 "255.255.255.255", 0, "0.0.0.0", "255.255.255.255"), 372 NetworkPartMapping(IPAddress::kFamilyIPv4, 373 "255.255.255.255", 32, 374 "255.255.255.255", "255.255.255.255"), 375 NetworkPartMapping(IPAddress::kFamilyIPv4, 376 "255.255.255.255", 24, 377 "255.255.255.0", "255.255.255.255"), 378 NetworkPartMapping(IPAddress::kFamilyIPv4, 379 "255.255.255.255", 16, 380 "255.255.0.0", "255.255.255.255"), 381 NetworkPartMapping(IPAddress::kFamilyIPv4, 382 "0.0.0.0", 0, "0.0.0.0", "255.255.255.255"), 383 NetworkPartMapping(IPAddress::kFamilyIPv4, 384 "0.0.0.0", 32, "0.0.0.0", "0.0.0.0"), 385 NetworkPartMapping(IPAddress::kFamilyIPv4, 386 "0.0.0.0", 24, "0.0.0.0", "0.0.0.255"), 387 NetworkPartMapping(IPAddress::kFamilyIPv4, 388 "0.0.0.0", 16, "0.0.0.0", "0.0.255.255"), 389 NetworkPartMapping(IPAddress::kFamilyIPv4, 390 "192.168.1.1", 24, "192.168.1.0", "192.168.1.255"), 391 NetworkPartMapping(IPAddress::kFamilyIPv4, 392 "10.1.0.1", 8, "10.0.0.0", "10.255.255.255"))); 393 394 struct MinPrefixLengthMapping { 395 MinPrefixLengthMapping() : family(IPAddress::kFamilyUnknown) {} 396 MinPrefixLengthMapping(IPAddress::Family family_in, 397 const string& address_in, 398 size_t expected_min_prefix_in) 399 : family(family_in), 400 address(address_in), 401 expected_min_prefix(expected_min_prefix_in) {} 402 IPAddress::Family family; 403 string address; 404 size_t expected_min_prefix; 405 }; 406 407 class IPAddressMinPrefixLengthMappingTest 408 : public testing::TestWithParam<MinPrefixLengthMapping> {}; 409 410 TEST_P(IPAddressMinPrefixLengthMappingTest, TestMinPrefixLengthMapping) { 411 IPAddress address(GetParam().family); 412 EXPECT_TRUE(address.SetAddressFromString(GetParam().address)); 413 EXPECT_EQ(GetParam().expected_min_prefix, address.GetMinPrefixLength()); 414 } 415 416 INSTANTIATE_TEST_CASE_P( 417 IPAddressMinPrefixLengthMappingTestRun, 418 IPAddressMinPrefixLengthMappingTest, 419 ::testing::Values( 420 MinPrefixLengthMapping(IPAddress::kFamilyIPv6, "fe80::", 128), 421 MinPrefixLengthMapping(IPAddress::kFamilyIPv4, "255.255.255.255", 32), 422 MinPrefixLengthMapping(IPAddress::kFamilyIPv4, "224.0.0.0", 32), 423 MinPrefixLengthMapping(IPAddress::kFamilyIPv4, "192.168.0.0", 24), 424 MinPrefixLengthMapping(IPAddress::kFamilyIPv4, "172.16.0.0", 16), 425 MinPrefixLengthMapping(IPAddress::kFamilyIPv4, "10.10.10.10", 8))); 426 427 struct CanReachAddressMapping { 428 CanReachAddressMapping() : family(IPAddress::kFamilyUnknown) {} 429 CanReachAddressMapping(IPAddress::Family family_in, 430 const string& address_a_in, 431 const string& address_b_in, 432 bool expected_result_in) 433 : family(family_in), 434 address_a(address_a_in), 435 address_b(address_b_in), 436 expected_result(expected_result_in) {} 437 IPAddress::Family family; 438 string address_a; 439 string address_b; 440 size_t expected_result; 441 }; 442 443 class IPAddressCanReachAddressMappingTest 444 : public testing::TestWithParam<CanReachAddressMapping> {}; 445 446 TEST_P(IPAddressCanReachAddressMappingTest, TestCanReachAddressMapping) { 447 IPAddress address_a(GetParam().family); 448 EXPECT_TRUE(address_a.SetAddressAndPrefixFromString(GetParam().address_a)); 449 IPAddress address_b(GetParam().family); 450 EXPECT_TRUE(address_b.SetAddressAndPrefixFromString(GetParam().address_b)); 451 EXPECT_EQ(GetParam().expected_result, address_a.CanReachAddress(address_b)); 452 } 453 454 INSTANTIATE_TEST_CASE_P( 455 IPAddressCanReachAddressMappingTestRun, 456 IPAddressCanReachAddressMappingTest, 457 ::testing::Values( 458 CanReachAddressMapping(IPAddress::kFamilyIPv6, 459 "fe80:1000::/16", "fe80:2000::/16", true), 460 CanReachAddressMapping(IPAddress::kFamilyIPv6, 461 "fe80:1000::/16", "fe80:2000::/32", true), 462 CanReachAddressMapping(IPAddress::kFamilyIPv6, 463 "fe80:1000::/32", "fe80:2000::/16", false), 464 CanReachAddressMapping(IPAddress::kFamilyIPv4, 465 "192.168.1.1/24", "192.168.1.2/24", true), 466 CanReachAddressMapping(IPAddress::kFamilyIPv4, 467 "192.168.1.1/24", "192.168.2.2/24", false), 468 CanReachAddressMapping(IPAddress::kFamilyIPv4, 469 "192.168.1.1/16", "192.168.2.2/24", true), 470 CanReachAddressMapping(IPAddress::kFamilyIPv4, 471 "192.168.1.1/24", "192.168.2.2/16", false))); 472 473 } // namespace shill 474
