1 /* 2 * libjingle 3 * Copyright 2004--2011, Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "talk/base/gunit.h" 29 #include "talk/base/ipaddress.h" 30 31 namespace talk_base { 32 33 static const unsigned int kIPv4AddrSize = 4; 34 static const unsigned int kIPv6AddrSize = 16; 35 static const unsigned int kIPv4RFC1918Addr = 0xC0A80701; 36 static const unsigned int kIPv4PublicAddr = 0x01020304; 37 static const in6_addr kIPv6LinkLocalAddr = {{{0xfe, 0x80, 0x00, 0x00, 38 0x00, 0x00, 0x00, 0x00, 39 0xbe, 0x30, 0x5b, 0xff, 40 0xfe, 0xe5, 0x00, 0xc3}}}; 41 static const in6_addr kIPv6PublicAddr = {{{0x24, 0x01, 0xfa, 0x00, 42 0x00, 0x04, 0x10, 0x00, 43 0xbe, 0x30, 0x5b, 0xff, 44 0xfe, 0xe5, 0x00, 0xc3}}}; 45 static const in6_addr kIPv4MappedAnyAddr = {{{0x00, 0x00, 0x00, 0x00, 46 0x00, 0x00, 0x00, 0x00, 47 0x00, 0x00, 0xff, 0xff, 48 0x00, 0x00, 0x00, 0x00}}}; 49 static const in6_addr kIPv4MappedRFC1918Addr = {{{0x00, 0x00, 0x00, 0x00, 50 0x00, 0x00, 0x00, 0x00, 51 0x00, 0x00, 0xff, 0xff, 52 0xc0, 0xa8, 0x07, 0x01}}}; 53 static const in6_addr kIPv4MappedPublicAddr = {{{0x00, 0x00, 0x00, 0x00, 54 0x00, 0x00, 0x00, 0x00, 55 0x00, 0x00, 0xff, 0xff, 56 0x01, 0x02, 0x03, 0x04}}}; 57 58 static const std::string kIPv4AnyAddrString = "0.0.0.0"; 59 static const std::string kIPv4LoopbackAddrString = "127.0.0.1"; 60 static const std::string kIPv4RFC1918AddrString = "192.168.7.1"; 61 static const std::string kIPv4PublicAddrString = "1.2.3.4"; 62 static const std::string kIPv4PublicAddrAnonymizedString = "1.2.3.x"; 63 static const std::string kIPv6AnyAddrString = "::"; 64 static const std::string kIPv6LoopbackAddrString = "::1"; 65 static const std::string kIPv6LinkLocalAddrString = "fe80::be30:5bff:fee5:c3"; 66 static const std::string kIPv6PublicAddrString = 67 "2401:fa00:4:1000:be30:5bff:fee5:c3"; 68 static const std::string kIPv6PublicAddrAnonymizedString = "2401:fa00:4::"; 69 static const std::string kIPv4MappedAnyAddrString = "::ffff:0:0"; 70 static const std::string kIPv4MappedRFC1918AddrString = "::ffff:c0a8:701"; 71 static const std::string kIPv4MappedLoopbackAddrString = "::ffff:7f00:1"; 72 static const std::string kIPv4MappedPublicAddrString = "::ffff:102:0304"; 73 static const std::string kIPv4MappedV4StyleAddrString = "::ffff:192.168.7.1"; 74 75 static const std::string kIPv4BrokenString1 = "192.168.7."; 76 static const std::string kIPv4BrokenString2 = "192.168.7.1.1"; 77 static const std::string kIPv4BrokenString3 = "192.168.7.1:80"; 78 static const std::string kIPv4BrokenString4 = "192.168.7.ONE"; 79 static const std::string kIPv4BrokenString5 = "-192.168.7.1"; 80 static const std::string kIPv4BrokenString6 = "256.168.7.1"; 81 static const std::string kIPv6BrokenString1 = "2401:fa00:4:1000:be30"; 82 static const std::string kIPv6BrokenString2 = 83 "2401:fa00:4:1000:be30:5bff:fee5:c3:1"; 84 static const std::string kIPv6BrokenString3 = 85 "[2401:fa00:4:1000:be30:5bff:fee5:c3]:1"; 86 static const std::string kIPv6BrokenString4 = 87 "2401::4::be30"; 88 static const std::string kIPv6BrokenString5 = 89 "2401:::4:fee5:be30"; 90 static const std::string kIPv6BrokenString6 = 91 "2401f:fa00:4:1000:be30:5bff:fee5:c3"; 92 static const std::string kIPv6BrokenString7 = 93 "2401:ga00:4:1000:be30:5bff:fee5:c3"; 94 static const std::string kIPv6BrokenString8 = 95 "2401:fa000:4:1000:be30:5bff:fee5:c3"; 96 static const std::string kIPv6BrokenString9 = 97 "2401:fal0:4:1000:be30:5bff:fee5:c3"; 98 static const std::string kIPv6BrokenString10 = 99 "::ffff:192.168.7."; 100 static const std::string kIPv6BrokenString11 = 101 "::ffff:192.168.7.1.1.1"; 102 static const std::string kIPv6BrokenString12 = 103 "::fffe:192.168.7.1"; 104 static const std::string kIPv6BrokenString13 = 105 "::ffff:192.168.7.ff"; 106 static const std::string kIPv6BrokenString14 = 107 "0x2401:fa00:4:1000:be30:5bff:fee5:c3"; 108 109 bool AreEqual(const IPAddress& addr, 110 const IPAddress& addr2) { 111 if ((IPIsAny(addr) != IPIsAny(addr2)) || 112 (IPIsLoopback(addr) != IPIsLoopback(addr2)) || 113 (IPIsPrivate(addr) != IPIsPrivate(addr2)) || 114 (HashIP(addr) != HashIP(addr2)) || 115 (addr.Size() != addr2.Size()) || 116 (addr.family() != addr2.family()) || 117 (addr.ToString() != addr2.ToString())) { 118 return false; 119 } 120 in_addr v4addr, v4addr2; 121 v4addr = addr.ipv4_address(); 122 v4addr2 = addr2.ipv4_address(); 123 if (0 != memcmp(&v4addr, &v4addr2, sizeof(v4addr))) { 124 return false; 125 } 126 in6_addr v6addr, v6addr2; 127 v6addr = addr.ipv6_address(); 128 v6addr2 = addr2.ipv6_address(); 129 if (0 != memcmp(&v6addr, &v6addr2, sizeof(v6addr))) { 130 return false; 131 } 132 return true; 133 } 134 135 bool BrokenIPStringFails(const std::string& broken) { 136 IPAddress addr(0); // Intentionally make it v4. 137 if (IPFromString(kIPv4BrokenString1, &addr)) { 138 return false; 139 } 140 return addr.family() == AF_UNSPEC; 141 } 142 143 bool CheckMaskCount(const std::string& mask, int expected_length) { 144 IPAddress addr; 145 return IPFromString(mask, &addr) && 146 (expected_length == CountIPMaskBits(addr)); 147 } 148 149 bool TryInvalidMaskCount(const std::string& mask) { 150 // We don't care about the result at all, but we do want to know if 151 // CountIPMaskBits is going to crash or infinite loop or something. 152 IPAddress addr; 153 if (!IPFromString(mask, &addr)) { 154 return false; 155 } 156 CountIPMaskBits(addr); 157 return true; 158 } 159 160 bool CheckTruncateIP(const std::string& initial, int truncate_length, 161 const std::string& expected_result) { 162 IPAddress addr, expected; 163 IPFromString(initial, &addr); 164 IPFromString(expected_result, &expected); 165 IPAddress truncated = TruncateIP(addr, truncate_length); 166 return truncated == expected; 167 } 168 169 TEST(IPAddressTest, TestDefaultCtor) { 170 IPAddress addr; 171 EXPECT_FALSE(IPIsAny(addr)); 172 EXPECT_FALSE(IPIsLoopback(addr)); 173 EXPECT_FALSE(IPIsPrivate(addr)); 174 175 EXPECT_EQ(0U, addr.Size()); 176 EXPECT_EQ(AF_UNSPEC, addr.family()); 177 EXPECT_EQ("", addr.ToString()); 178 } 179 180 TEST(IPAddressTest, TestInAddrCtor) { 181 in_addr v4addr; 182 183 // Test V4 Any address. 184 v4addr.s_addr = INADDR_ANY; 185 IPAddress addr(v4addr); 186 EXPECT_TRUE(IPIsAny(addr)); 187 EXPECT_FALSE(IPIsLoopback(addr)); 188 EXPECT_FALSE(IPIsPrivate(addr)); 189 EXPECT_EQ(kIPv4AddrSize, addr.Size()); 190 EXPECT_EQ(kIPv4AnyAddrString, addr.ToString()); 191 192 // Test a V4 loopback address. 193 v4addr.s_addr = htonl(INADDR_LOOPBACK); 194 addr = IPAddress(v4addr); 195 EXPECT_FALSE(IPIsAny(addr)); 196 EXPECT_TRUE(IPIsLoopback(addr)); 197 EXPECT_TRUE(IPIsPrivate(addr)); 198 EXPECT_EQ(kIPv4AddrSize, addr.Size()); 199 EXPECT_EQ(kIPv4LoopbackAddrString, addr.ToString()); 200 201 // Test an RFC1918 address. 202 v4addr.s_addr = htonl(kIPv4RFC1918Addr); 203 addr = IPAddress(v4addr); 204 EXPECT_FALSE(IPIsAny(addr)); 205 EXPECT_FALSE(IPIsLoopback(addr)); 206 EXPECT_TRUE(IPIsPrivate(addr)); 207 EXPECT_EQ(kIPv4AddrSize, addr.Size()); 208 EXPECT_EQ(kIPv4RFC1918AddrString, addr.ToString()); 209 210 // Test a 'normal' v4 address. 211 v4addr.s_addr = htonl(kIPv4PublicAddr); 212 addr = IPAddress(v4addr); 213 EXPECT_FALSE(IPIsAny(addr)); 214 EXPECT_FALSE(IPIsLoopback(addr)); 215 EXPECT_FALSE(IPIsPrivate(addr)); 216 EXPECT_EQ(kIPv4AddrSize, addr.Size()); 217 EXPECT_EQ(kIPv4PublicAddrString, addr.ToString()); 218 } 219 220 TEST(IPAddressTest, TestInAddr6Ctor) { 221 // Test v6 empty. 222 IPAddress addr(in6addr_any); 223 EXPECT_TRUE(IPIsAny(addr)); 224 EXPECT_FALSE(IPIsLoopback(addr)); 225 EXPECT_FALSE(IPIsPrivate(addr)); 226 EXPECT_EQ(kIPv6AddrSize, addr.Size()); 227 EXPECT_EQ(kIPv6AnyAddrString, addr.ToString()); 228 229 // Test v6 loopback. 230 addr = IPAddress(in6addr_loopback); 231 EXPECT_FALSE(IPIsAny(addr)); 232 EXPECT_TRUE(IPIsLoopback(addr)); 233 EXPECT_TRUE(IPIsPrivate(addr)); 234 EXPECT_EQ(kIPv6AddrSize, addr.Size()); 235 EXPECT_EQ(kIPv6LoopbackAddrString, addr.ToString()); 236 237 // Test v6 link-local. 238 addr = IPAddress(kIPv6LinkLocalAddr); 239 EXPECT_FALSE(IPIsAny(addr)); 240 EXPECT_FALSE(IPIsLoopback(addr)); 241 EXPECT_TRUE(IPIsPrivate(addr)); 242 EXPECT_EQ(kIPv6AddrSize, addr.Size()); 243 EXPECT_EQ(kIPv6LinkLocalAddrString, addr.ToString()); 244 245 // Test v6 global address. 246 addr = IPAddress(kIPv6PublicAddr); 247 EXPECT_FALSE(IPIsAny(addr)); 248 EXPECT_FALSE(IPIsLoopback(addr)); 249 EXPECT_FALSE(IPIsPrivate(addr)); 250 EXPECT_EQ(kIPv6AddrSize, addr.Size()); 251 EXPECT_EQ(kIPv6PublicAddrString, addr.ToString()); 252 } 253 254 TEST(IPAddressTest, TestUint32Ctor) { 255 // Test V4 Any address. 256 IPAddress addr(0); 257 EXPECT_TRUE(IPIsAny(addr)); 258 EXPECT_FALSE(IPIsLoopback(addr)); 259 EXPECT_FALSE(IPIsPrivate(addr)); 260 EXPECT_EQ(kIPv4AddrSize, addr.Size()); 261 EXPECT_EQ(kIPv4AnyAddrString, addr.ToString()); 262 263 // Test a V4 loopback address. 264 addr = IPAddress(INADDR_LOOPBACK); 265 EXPECT_FALSE(IPIsAny(addr)); 266 EXPECT_TRUE(IPIsLoopback(addr)); 267 EXPECT_TRUE(IPIsPrivate(addr)); 268 EXPECT_EQ(kIPv4AddrSize, addr.Size()); 269 EXPECT_EQ(kIPv4LoopbackAddrString, addr.ToString()); 270 271 // Test an RFC1918 address. 272 addr = IPAddress(kIPv4RFC1918Addr); 273 EXPECT_FALSE(IPIsAny(addr)); 274 EXPECT_FALSE(IPIsLoopback(addr)); 275 EXPECT_TRUE(IPIsPrivate(addr)); 276 EXPECT_EQ(kIPv4AddrSize, addr.Size()); 277 EXPECT_EQ(kIPv4RFC1918AddrString, addr.ToString()); 278 279 // Test a 'normal' v4 address. 280 addr = IPAddress(kIPv4PublicAddr); 281 EXPECT_FALSE(IPIsAny(addr)); 282 EXPECT_FALSE(IPIsLoopback(addr)); 283 EXPECT_FALSE(IPIsPrivate(addr)); 284 EXPECT_EQ(kIPv4AddrSize, addr.Size()); 285 EXPECT_EQ(kIPv4PublicAddrString, addr.ToString()); 286 } 287 288 TEST(IPAddressTest, TestCopyCtor) { 289 in_addr v4addr; 290 v4addr.s_addr = htonl(kIPv4PublicAddr); 291 IPAddress addr(v4addr); 292 IPAddress addr2(addr); 293 294 EXPECT_PRED2(AreEqual, addr, addr2); 295 296 addr = IPAddress(INADDR_ANY); 297 addr2 = IPAddress(addr); 298 EXPECT_PRED2(AreEqual, addr, addr2); 299 300 addr = IPAddress(INADDR_LOOPBACK); 301 addr2 = IPAddress(addr); 302 EXPECT_PRED2(AreEqual, addr, addr2); 303 304 addr = IPAddress(kIPv4PublicAddr); 305 addr2 = IPAddress(addr); 306 EXPECT_PRED2(AreEqual, addr, addr2); 307 308 addr = IPAddress(kIPv4RFC1918Addr); 309 addr2 = IPAddress(addr); 310 EXPECT_PRED2(AreEqual, addr, addr2); 311 312 addr = IPAddress(in6addr_any); 313 addr2 = IPAddress(addr); 314 EXPECT_PRED2(AreEqual, addr, addr2); 315 316 addr = IPAddress(in6addr_loopback); 317 addr2 = IPAddress(addr); 318 EXPECT_PRED2(AreEqual, addr, addr2); 319 320 addr = IPAddress(kIPv6LinkLocalAddr); 321 addr2 = IPAddress(addr); 322 EXPECT_PRED2(AreEqual, addr, addr2); 323 324 addr = IPAddress(kIPv6PublicAddr); 325 addr2 = IPAddress(addr); 326 EXPECT_PRED2(AreEqual, addr, addr2); 327 } 328 329 TEST(IPAddressTest, TestEquality) { 330 // Check v4 equality 331 in_addr v4addr, v4addr2; 332 v4addr.s_addr = htonl(kIPv4PublicAddr); 333 v4addr2.s_addr = htonl(kIPv4PublicAddr + 1); 334 IPAddress addr(v4addr); 335 IPAddress addr2(v4addr2); 336 IPAddress addr3(v4addr); 337 338 EXPECT_TRUE(addr == addr); 339 EXPECT_TRUE(addr2 == addr2); 340 EXPECT_TRUE(addr3 == addr3); 341 EXPECT_TRUE(addr == addr3); 342 EXPECT_TRUE(addr3 == addr); 343 EXPECT_FALSE(addr2 == addr); 344 EXPECT_FALSE(addr2 == addr3); 345 EXPECT_FALSE(addr == addr2); 346 EXPECT_FALSE(addr3 == addr2); 347 348 // Check v6 equality 349 IPAddress addr4(kIPv6PublicAddr); 350 IPAddress addr5(kIPv6LinkLocalAddr); 351 IPAddress addr6(kIPv6PublicAddr); 352 353 EXPECT_TRUE(addr4 == addr4); 354 EXPECT_TRUE(addr5 == addr5); 355 EXPECT_TRUE(addr4 == addr6); 356 EXPECT_TRUE(addr6 == addr4); 357 EXPECT_FALSE(addr4 == addr5); 358 EXPECT_FALSE(addr5 == addr4); 359 EXPECT_FALSE(addr6 == addr5); 360 EXPECT_FALSE(addr5 == addr6); 361 362 // Check v4/v6 cross-equality 363 EXPECT_FALSE(addr == addr4); 364 EXPECT_FALSE(addr == addr5); 365 EXPECT_FALSE(addr == addr6); 366 EXPECT_FALSE(addr4 == addr); 367 EXPECT_FALSE(addr5 == addr); 368 EXPECT_FALSE(addr6 == addr); 369 EXPECT_FALSE(addr2 == addr4); 370 EXPECT_FALSE(addr2 == addr5); 371 EXPECT_FALSE(addr2 == addr6); 372 EXPECT_FALSE(addr4 == addr2); 373 EXPECT_FALSE(addr5 == addr2); 374 EXPECT_FALSE(addr6 == addr2); 375 EXPECT_FALSE(addr3 == addr4); 376 EXPECT_FALSE(addr3 == addr5); 377 EXPECT_FALSE(addr3 == addr6); 378 EXPECT_FALSE(addr4 == addr3); 379 EXPECT_FALSE(addr5 == addr3); 380 EXPECT_FALSE(addr6 == addr3); 381 382 // Special cases: loopback and any. 383 // They're special but they're still not equal. 384 IPAddress v4loopback(htonl(INADDR_LOOPBACK)); 385 IPAddress v6loopback(in6addr_loopback); 386 EXPECT_FALSE(v4loopback == v6loopback); 387 388 IPAddress v4any(0); 389 IPAddress v6any(in6addr_any); 390 EXPECT_FALSE(v4any == v6any); 391 } 392 393 TEST(IPAddressTest, TestComparison) { 394 // Defined in 'ascending' order. 395 // v6 > v4, and intra-family sorting is purely numerical 396 IPAddress addr0; // AF_UNSPEC 397 IPAddress addr1(INADDR_ANY); // 0.0.0.0 398 IPAddress addr2(kIPv4PublicAddr); // 1.2.3.4 399 IPAddress addr3(INADDR_LOOPBACK); // 127.0.0.1 400 IPAddress addr4(kIPv4RFC1918Addr); // 192.168.7.1. 401 IPAddress addr5(in6addr_any); // :: 402 IPAddress addr6(in6addr_loopback); // ::1 403 IPAddress addr7(kIPv6PublicAddr); // 2401.... 404 IPAddress addr8(kIPv6LinkLocalAddr); // fe80.... 405 406 EXPECT_TRUE(addr0 < addr1); 407 EXPECT_TRUE(addr1 < addr2); 408 EXPECT_TRUE(addr2 < addr3); 409 EXPECT_TRUE(addr3 < addr4); 410 EXPECT_TRUE(addr4 < addr5); 411 EXPECT_TRUE(addr5 < addr6); 412 EXPECT_TRUE(addr6 < addr7); 413 EXPECT_TRUE(addr7 < addr8); 414 415 EXPECT_FALSE(addr0 > addr1); 416 EXPECT_FALSE(addr1 > addr2); 417 EXPECT_FALSE(addr2 > addr3); 418 EXPECT_FALSE(addr3 > addr4); 419 EXPECT_FALSE(addr4 > addr5); 420 EXPECT_FALSE(addr5 > addr6); 421 EXPECT_FALSE(addr6 > addr7); 422 EXPECT_FALSE(addr7 > addr8); 423 424 EXPECT_FALSE(addr0 > addr0); 425 EXPECT_FALSE(addr1 > addr1); 426 EXPECT_FALSE(addr2 > addr2); 427 EXPECT_FALSE(addr3 > addr3); 428 EXPECT_FALSE(addr4 > addr4); 429 EXPECT_FALSE(addr5 > addr5); 430 EXPECT_FALSE(addr6 > addr6); 431 EXPECT_FALSE(addr7 > addr7); 432 EXPECT_FALSE(addr8 > addr8); 433 434 EXPECT_FALSE(addr0 < addr0); 435 EXPECT_FALSE(addr1 < addr1); 436 EXPECT_FALSE(addr2 < addr2); 437 EXPECT_FALSE(addr3 < addr3); 438 EXPECT_FALSE(addr4 < addr4); 439 EXPECT_FALSE(addr5 < addr5); 440 EXPECT_FALSE(addr6 < addr6); 441 EXPECT_FALSE(addr7 < addr7); 442 EXPECT_FALSE(addr8 < addr8); 443 } 444 445 TEST(IPAddressTest, TestFromString) { 446 IPAddress addr; 447 IPAddress addr2; 448 addr2 = IPAddress(INADDR_ANY); 449 450 EXPECT_TRUE(IPFromString(kIPv4AnyAddrString, &addr)); 451 EXPECT_EQ(addr.ToString(), kIPv4AnyAddrString); 452 EXPECT_PRED2(AreEqual, addr, addr2); 453 454 addr2 = IPAddress(INADDR_LOOPBACK); 455 EXPECT_TRUE(IPFromString(kIPv4LoopbackAddrString, &addr)); 456 EXPECT_EQ(addr.ToString(), kIPv4LoopbackAddrString); 457 EXPECT_PRED2(AreEqual, addr, addr2); 458 459 addr2 = IPAddress(kIPv4RFC1918Addr); 460 EXPECT_TRUE(IPFromString(kIPv4RFC1918AddrString, &addr)); 461 EXPECT_EQ(addr.ToString(), kIPv4RFC1918AddrString); 462 EXPECT_PRED2(AreEqual, addr, addr2); 463 464 addr2 = IPAddress(kIPv4PublicAddr); 465 EXPECT_TRUE(IPFromString(kIPv4PublicAddrString, &addr)); 466 EXPECT_EQ(addr.ToString(), kIPv4PublicAddrString); 467 EXPECT_PRED2(AreEqual, addr, addr2); 468 469 addr2 = IPAddress(in6addr_any); 470 EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr)); 471 EXPECT_EQ(addr.ToString(), kIPv6AnyAddrString); 472 EXPECT_PRED2(AreEqual, addr, addr2); 473 474 addr2 = IPAddress(in6addr_loopback); 475 EXPECT_TRUE(IPFromString(kIPv6LoopbackAddrString, &addr)); 476 EXPECT_EQ(addr.ToString(), kIPv6LoopbackAddrString); 477 EXPECT_PRED2(AreEqual, addr, addr2); 478 479 addr2 = IPAddress(kIPv6LinkLocalAddr); 480 EXPECT_TRUE(IPFromString(kIPv6LinkLocalAddrString, &addr)); 481 EXPECT_EQ(addr.ToString(), kIPv6LinkLocalAddrString); 482 EXPECT_PRED2(AreEqual, addr, addr2); 483 484 addr2 = IPAddress(kIPv6PublicAddr); 485 EXPECT_TRUE(IPFromString(kIPv6PublicAddrString, &addr)); 486 EXPECT_EQ(addr.ToString(), kIPv6PublicAddrString); 487 EXPECT_PRED2(AreEqual, addr, addr2); 488 489 addr2 = IPAddress(kIPv4MappedRFC1918Addr); 490 EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr)); 491 EXPECT_PRED2(AreEqual, addr, addr2); 492 493 // Broken cases, should set addr to AF_UNSPEC. 494 EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString1); 495 EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString2); 496 EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString3); 497 EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString4); 498 EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString5); 499 EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString6); 500 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString1); 501 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString2); 502 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString3); 503 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString4); 504 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString5); 505 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString6); 506 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString7); 507 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString8); 508 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString9); 509 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString10); 510 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString11); 511 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString12); 512 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString13); 513 EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString14); 514 } 515 516 TEST(IPAddressTest, TestIPFromAddrInfo) { 517 struct sockaddr_in expected4; 518 struct sockaddr_in6 expected6; 519 struct addrinfo test_info; 520 struct addrinfo next_info; 521 memset(&next_info, 'A', sizeof(next_info)); 522 test_info.ai_next = &next_info; 523 // Check that we can get an IPv4 address out. 524 test_info.ai_addr = reinterpret_cast<struct sockaddr*>(&expected4); 525 expected4.sin_addr.s_addr = HostToNetwork32(kIPv4PublicAddr); 526 expected4.sin_family = AF_INET; 527 IPAddress expected(kIPv4PublicAddr); 528 IPAddress addr; 529 EXPECT_TRUE(IPFromAddrInfo(&test_info, &addr)); 530 EXPECT_EQ(expected, addr); 531 // Check that we can get an IPv6 address out. 532 expected6.sin6_addr = kIPv6PublicAddr; 533 expected6.sin6_family = AF_INET6; 534 expected = IPAddress(kIPv6PublicAddr); 535 test_info.ai_addr = reinterpret_cast<struct sockaddr*>(&expected6); 536 EXPECT_TRUE(IPFromAddrInfo(&test_info, &addr)); 537 EXPECT_EQ(expected, addr); 538 // Check that unspec fails. 539 expected6.sin6_family = AF_UNSPEC; 540 EXPECT_FALSE(IPFromAddrInfo(&test_info, &addr)); 541 // Check a zeroed out addrinfo doesn't crash us. 542 memset(&next_info, 0, sizeof(next_info)); 543 EXPECT_FALSE(IPFromAddrInfo(&next_info, &addr)); 544 } 545 546 TEST(IPAddressTest, TestIsPrivate) { 547 EXPECT_FALSE(IPIsPrivate(IPAddress(INADDR_ANY))); 548 EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4PublicAddr))); 549 EXPECT_FALSE(IPIsPrivate(IPAddress(in6addr_any))); 550 EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv6PublicAddr))); 551 EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedAnyAddr))); 552 EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedPublicAddr))); 553 554 EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv4RFC1918Addr))); 555 EXPECT_TRUE(IPIsPrivate(IPAddress(INADDR_LOOPBACK))); 556 EXPECT_TRUE(IPIsPrivate(IPAddress(in6addr_loopback))); 557 EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv6LinkLocalAddr))); 558 } 559 560 TEST(IPAddressTest, TestIsLoopback) { 561 EXPECT_FALSE(IPIsLoopback(IPAddress(INADDR_ANY))); 562 EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4PublicAddr))); 563 EXPECT_FALSE(IPIsLoopback(IPAddress(in6addr_any))); 564 EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv6PublicAddr))); 565 EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedAnyAddr))); 566 EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedPublicAddr))); 567 568 EXPECT_TRUE(IPIsLoopback(IPAddress(INADDR_LOOPBACK))); 569 EXPECT_TRUE(IPIsLoopback(IPAddress(in6addr_loopback))); 570 } 571 572 TEST(IPAddressTest, TestNormalized) { 573 // Check normalizing a ::ffff:a.b.c.d address. 574 IPAddress addr; 575 EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr)); 576 IPAddress addr2(kIPv4RFC1918Addr); 577 addr = addr.Normalized(); 578 EXPECT_EQ(addr2, addr); 579 580 // Check normalizing a ::ffff:aabb:ccdd address. 581 addr = IPAddress(kIPv4MappedPublicAddr); 582 addr2 = IPAddress(kIPv4PublicAddr); 583 addr = addr.Normalized(); 584 EXPECT_EQ(addr, addr2); 585 586 // Check that a non-mapped v6 addresses isn't altered. 587 addr = IPAddress(kIPv6PublicAddr); 588 addr2 = IPAddress(kIPv6PublicAddr); 589 addr = addr.Normalized(); 590 EXPECT_EQ(addr, addr2); 591 592 // Check that addresses that look a bit like mapped addresses aren't altered 593 EXPECT_TRUE(IPFromString("fe80::ffff:0102:0304", &addr)); 594 addr2 = addr; 595 addr = addr.Normalized(); 596 EXPECT_EQ(addr, addr2); 597 EXPECT_TRUE(IPFromString("::0102:0304", &addr)); 598 addr2 = addr; 599 addr = addr.Normalized(); 600 EXPECT_EQ(addr, addr2); 601 // This string should 'work' as an IP address but is not a mapped address, 602 // so it shouldn't change on normalization. 603 EXPECT_TRUE(IPFromString("::192.168.7.1", &addr)); 604 addr2 = addr; 605 addr = addr.Normalized(); 606 EXPECT_EQ(addr, addr2); 607 608 // Check that v4 addresses aren't altered. 609 addr = IPAddress(htonl(kIPv4PublicAddr)); 610 addr2 = IPAddress(htonl(kIPv4PublicAddr)); 611 addr = addr.Normalized(); 612 EXPECT_EQ(addr, addr2); 613 } 614 615 TEST(IPAddressTest, TestAsIPv6Address) { 616 IPAddress addr(kIPv4PublicAddr); 617 IPAddress addr2(kIPv4MappedPublicAddr); 618 addr = addr.AsIPv6Address(); 619 EXPECT_EQ(addr, addr2); 620 621 addr = IPAddress(kIPv4MappedPublicAddr); 622 addr2 = IPAddress(kIPv4MappedPublicAddr); 623 addr = addr.AsIPv6Address(); 624 EXPECT_EQ(addr, addr2); 625 626 addr = IPAddress(kIPv6PublicAddr); 627 addr2 = IPAddress(kIPv6PublicAddr); 628 addr = addr.AsIPv6Address(); 629 EXPECT_EQ(addr, addr2); 630 } 631 632 TEST(IPAddressTest, TestCountIPMaskBits) { 633 IPAddress mask; 634 // IPv4 on byte boundaries 635 EXPECT_PRED2(CheckMaskCount, "255.255.255.255", 32); 636 EXPECT_PRED2(CheckMaskCount, "255.255.255.0", 24); 637 EXPECT_PRED2(CheckMaskCount, "255.255.0.0", 16); 638 EXPECT_PRED2(CheckMaskCount, "255.0.0.0", 8); 639 EXPECT_PRED2(CheckMaskCount, "0.0.0.0", 0); 640 641 // IPv4 not on byte boundaries 642 EXPECT_PRED2(CheckMaskCount, "128.0.0.0", 1); 643 EXPECT_PRED2(CheckMaskCount, "224.0.0.0", 3); 644 EXPECT_PRED2(CheckMaskCount, "255.248.0.0", 13); 645 EXPECT_PRED2(CheckMaskCount, "255.255.224.0", 19); 646 EXPECT_PRED2(CheckMaskCount, "255.255.255.252", 30); 647 648 // V6 on byte boundaries 649 EXPECT_PRED2(CheckMaskCount, "::", 0); 650 EXPECT_PRED2(CheckMaskCount, "ff00::", 8); 651 EXPECT_PRED2(CheckMaskCount, "ffff::", 16); 652 EXPECT_PRED2(CheckMaskCount, "ffff:ff00::", 24); 653 EXPECT_PRED2(CheckMaskCount, "ffff:ffff::", 32); 654 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ff00::", 40); 655 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff::", 48); 656 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ff00::", 56); 657 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff::", 64); 658 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ff00::", 72); 659 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff::", 80); 660 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff00::", 88); 661 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff::", 96); 662 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff00:0000", 104); 663 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0000", 112); 664 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00", 120); 665 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 128); 666 667 // V6 not on byte boundaries. 668 EXPECT_PRED2(CheckMaskCount, "8000::", 1); 669 EXPECT_PRED2(CheckMaskCount, "ff80::", 9); 670 EXPECT_PRED2(CheckMaskCount, "ffff:fe00::", 23); 671 EXPECT_PRED2(CheckMaskCount, "ffff:fffe::", 31); 672 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:e000::", 35); 673 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffe0::", 43); 674 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:f800::", 53); 675 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:fff8::", 61); 676 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fc00::", 70); 677 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fffc::", 78); 678 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:8000::", 81); 679 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff80::", 89); 680 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fe00::", 103); 681 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fffe:0000", 111); 682 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fc00", 118); 683 EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffc", 126); 684 685 // Non-contiguous ranges. These are invalid but lets test them 686 // to make sure they don't crash anything or infinite loop or something. 687 EXPECT_PRED1(TryInvalidMaskCount, "217.0.0.0"); 688 EXPECT_PRED1(TryInvalidMaskCount, "255.185.0.0"); 689 EXPECT_PRED1(TryInvalidMaskCount, "255.255.251.0"); 690 EXPECT_PRED1(TryInvalidMaskCount, "255.255.251.255"); 691 EXPECT_PRED1(TryInvalidMaskCount, "255.255.254.201"); 692 EXPECT_PRED1(TryInvalidMaskCount, "::1"); 693 EXPECT_PRED1(TryInvalidMaskCount, "fe80::1"); 694 EXPECT_PRED1(TryInvalidMaskCount, "ff80::1"); 695 EXPECT_PRED1(TryInvalidMaskCount, "ffff::1"); 696 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ff00:1::1"); 697 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff::ffff:1"); 698 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ff00:1::"); 699 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff::ff00"); 700 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ff00:1234::"); 701 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:0012::ffff"); 702 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ff01::"); 703 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:7f00::"); 704 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ff7a::"); 705 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:7f00:0000"); 706 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff70:0000"); 707 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0211"); 708 EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff7f"); 709 } 710 711 TEST(IPAddressTest, TestTruncateIP) { 712 EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 24, "255.255.255.0"); 713 EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 16, "255.255.0.0"); 714 EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 8, "255.0.0.0"); 715 EXPECT_PRED3(CheckTruncateIP, "202.67.7.255", 24, "202.67.7.0"); 716 EXPECT_PRED3(CheckTruncateIP, "202.129.65.205", 16, "202.129.0.0"); 717 EXPECT_PRED3(CheckTruncateIP, "55.25.2.77", 8, "55.0.0.0"); 718 EXPECT_PRED3(CheckTruncateIP, "74.128.99.254", 1, "0.0.0.0"); 719 EXPECT_PRED3(CheckTruncateIP, "106.55.99.254", 3, "96.0.0.0"); 720 EXPECT_PRED3(CheckTruncateIP, "172.167.53.222", 13, "172.160.0.0"); 721 EXPECT_PRED3(CheckTruncateIP, "255.255.224.0", 18, "255.255.192.0"); 722 EXPECT_PRED3(CheckTruncateIP, "255.255.255.252", 28, "255.255.255.240"); 723 724 EXPECT_PRED3(CheckTruncateIP, "fe80:1111:2222:3333:4444:5555:6666:7777", 1, 725 "8000::"); 726 EXPECT_PRED3(CheckTruncateIP, "fff0:1111:2222:3333:4444:5555:6666:7777", 9, 727 "ff80::"); 728 EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 23, 729 "ffff:fe00::"); 730 EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 32, 731 "ffff:ff80::"); 732 EXPECT_PRED3(CheckTruncateIP, "2400:f9af:e456:1111:2222:3333:4444:5555", 35, 733 "2400:f9af:e000::"); 734 EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4444:5555:6666:7777:8888", 53, 735 "9999:1111:2233:4000::"); 736 EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4567:5555:6666:7777:8888", 64, 737 "9999:1111:2233:4567::"); 738 EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 68, 739 "1111:2222:3333:4444:5000::"); 740 EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 92, 741 "1111:2222:3333:4444:5555:6660::"); 742 EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 96, 743 "1111:2222:3333:4444:5555:6666::"); 744 EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 105, 745 "1111:2222:3333:4444:5555:6666:7700::"); 746 EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 124, 747 "1111:2222:3333:4444:5555:6666:7777:8880"); 748 749 // Slightly degenerate cases 750 EXPECT_PRED3(CheckTruncateIP, "202.165.33.127", 32, "202.165.33.127"); 751 EXPECT_PRED3(CheckTruncateIP, "235.105.77.12", 0, "0.0.0.0"); 752 EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 128, 753 "1111:2222:3333:4444:5555:6666:7777:8888"); 754 EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 0, 755 "::"); 756 } 757 758 TEST(IPAddressTest, TestCategorizeIPv6) { 759 // Test determining if an IPAddress is 6Bone/6To4/Teredo/etc. 760 // IPv4 address, should be none of these (not even v4compat/v4mapped). 761 IPAddress v4_addr(kIPv4PublicAddr); 762 EXPECT_FALSE(IPIs6Bone(v4_addr)); 763 EXPECT_FALSE(IPIs6To4(v4_addr)); 764 EXPECT_FALSE(IPIsSiteLocal(v4_addr)); 765 EXPECT_FALSE(IPIsTeredo(v4_addr)); 766 EXPECT_FALSE(IPIsULA(v4_addr)); 767 EXPECT_FALSE(IPIsV4Compatibility(v4_addr)); 768 EXPECT_FALSE(IPIsV4Mapped(v4_addr)); 769 // Linklocal (fe80::/16) adddress; should be none of these. 770 IPAddress linklocal_addr(kIPv6LinkLocalAddr); 771 EXPECT_FALSE(IPIs6Bone(linklocal_addr)); 772 EXPECT_FALSE(IPIs6To4(linklocal_addr)); 773 EXPECT_FALSE(IPIsSiteLocal(linklocal_addr)); 774 EXPECT_FALSE(IPIsTeredo(linklocal_addr)); 775 EXPECT_FALSE(IPIsULA(linklocal_addr)); 776 EXPECT_FALSE(IPIsV4Compatibility(linklocal_addr)); 777 EXPECT_FALSE(IPIsV4Mapped(linklocal_addr)); 778 // 'Normal' IPv6 address, should also be none of these. 779 IPAddress normal_addr(kIPv6PublicAddr); 780 EXPECT_FALSE(IPIs6Bone(normal_addr)); 781 EXPECT_FALSE(IPIs6To4(normal_addr)); 782 EXPECT_FALSE(IPIsSiteLocal(normal_addr)); 783 EXPECT_FALSE(IPIsTeredo(normal_addr)); 784 EXPECT_FALSE(IPIsULA(normal_addr)); 785 EXPECT_FALSE(IPIsV4Compatibility(normal_addr)); 786 EXPECT_FALSE(IPIsV4Mapped(normal_addr)); 787 // IPv4 mapped address (::ffff:123.123.123.123) 788 IPAddress v4mapped_addr(kIPv4MappedPublicAddr); 789 EXPECT_TRUE(IPIsV4Mapped(v4mapped_addr)); 790 EXPECT_FALSE(IPIsV4Compatibility(v4mapped_addr)); 791 EXPECT_FALSE(IPIs6Bone(v4mapped_addr)); 792 EXPECT_FALSE(IPIs6To4(v4mapped_addr)); 793 EXPECT_FALSE(IPIsSiteLocal(v4mapped_addr)); 794 EXPECT_FALSE(IPIsTeredo(v4mapped_addr)); 795 EXPECT_FALSE(IPIsULA(v4mapped_addr)); 796 // IPv4 compatibility address (::123.123.123.123) 797 IPAddress v4compat_addr; 798 IPFromString("::192.168.7.1", &v4compat_addr); 799 EXPECT_TRUE(IPIsV4Compatibility(v4compat_addr)); 800 EXPECT_FALSE(IPIs6Bone(v4compat_addr)); 801 EXPECT_FALSE(IPIs6To4(v4compat_addr)); 802 EXPECT_FALSE(IPIsSiteLocal(v4compat_addr)); 803 EXPECT_FALSE(IPIsTeredo(v4compat_addr)); 804 EXPECT_FALSE(IPIsULA(v4compat_addr)); 805 EXPECT_FALSE(IPIsV4Mapped(v4compat_addr)); 806 // 6Bone address (3FFE::/16) 807 IPAddress sixbone_addr; 808 IPFromString("3FFE:123:456::789:123", &sixbone_addr); 809 EXPECT_TRUE(IPIs6Bone(sixbone_addr)); 810 EXPECT_FALSE(IPIs6To4(sixbone_addr)); 811 EXPECT_FALSE(IPIsSiteLocal(sixbone_addr)); 812 EXPECT_FALSE(IPIsTeredo(sixbone_addr)); 813 EXPECT_FALSE(IPIsULA(sixbone_addr)); 814 EXPECT_FALSE(IPIsV4Mapped(sixbone_addr)); 815 EXPECT_FALSE(IPIsV4Compatibility(sixbone_addr)); 816 // Unique Local Address (FC::/7) 817 IPAddress ula_addr; 818 IPFromString("FC00:123:456::789:123", &ula_addr); 819 EXPECT_TRUE(IPIsULA(ula_addr)); 820 EXPECT_FALSE(IPIs6Bone(ula_addr)); 821 EXPECT_FALSE(IPIs6To4(ula_addr)); 822 EXPECT_FALSE(IPIsSiteLocal(ula_addr)); 823 EXPECT_FALSE(IPIsTeredo(ula_addr)); 824 EXPECT_FALSE(IPIsV4Mapped(ula_addr)); 825 EXPECT_FALSE(IPIsV4Compatibility(ula_addr)); 826 // 6To4 Address (2002::/16) 827 IPAddress sixtofour_addr; 828 IPFromString("2002:123:456::789:123", &sixtofour_addr); 829 EXPECT_TRUE(IPIs6To4(sixtofour_addr)); 830 EXPECT_FALSE(IPIs6Bone(sixtofour_addr)); 831 EXPECT_FALSE(IPIsSiteLocal(sixtofour_addr)); 832 EXPECT_FALSE(IPIsTeredo(sixtofour_addr)); 833 EXPECT_FALSE(IPIsULA(sixtofour_addr)); 834 EXPECT_FALSE(IPIsV4Compatibility(sixtofour_addr)); 835 EXPECT_FALSE(IPIsV4Mapped(sixtofour_addr)); 836 // Site Local address (FEC0::/10) 837 IPAddress sitelocal_addr; 838 IPFromString("FEC0:123:456::789:123", &sitelocal_addr); 839 EXPECT_TRUE(IPIsSiteLocal(sitelocal_addr)); 840 EXPECT_FALSE(IPIs6Bone(sitelocal_addr)); 841 EXPECT_FALSE(IPIs6To4(sitelocal_addr)); 842 EXPECT_FALSE(IPIsTeredo(sitelocal_addr)); 843 EXPECT_FALSE(IPIsULA(sitelocal_addr)); 844 EXPECT_FALSE(IPIsV4Compatibility(sitelocal_addr)); 845 EXPECT_FALSE(IPIsV4Mapped(sitelocal_addr)); 846 // Teredo Address (2001:0000::/32) 847 IPAddress teredo_addr; 848 IPFromString("2001:0000:123:456::789:123", &teredo_addr); 849 EXPECT_TRUE(IPIsTeredo(teredo_addr)); 850 EXPECT_FALSE(IPIsSiteLocal(teredo_addr)); 851 EXPECT_FALSE(IPIs6Bone(teredo_addr)); 852 EXPECT_FALSE(IPIs6To4(teredo_addr)); 853 EXPECT_FALSE(IPIsULA(teredo_addr)); 854 EXPECT_FALSE(IPIsV4Compatibility(teredo_addr)); 855 EXPECT_FALSE(IPIsV4Mapped(teredo_addr)); 856 } 857 858 TEST(IPAddressTest, TestToSensitiveString) { 859 IPAddress addr_v4 = IPAddress(kIPv4PublicAddr); 860 EXPECT_EQ(kIPv4PublicAddrString, addr_v4.ToString()); 861 EXPECT_EQ(kIPv4PublicAddrString, addr_v4.ToSensitiveString()); 862 IPAddress::set_strip_sensitive(true); 863 EXPECT_EQ(kIPv4PublicAddrString, addr_v4.ToString()); 864 EXPECT_EQ(kIPv4PublicAddrAnonymizedString, addr_v4.ToSensitiveString()); 865 IPAddress::set_strip_sensitive(false); 866 867 IPAddress addr_v6 = IPAddress(kIPv6PublicAddr); 868 EXPECT_EQ(kIPv6PublicAddrString, addr_v6.ToString()); 869 EXPECT_EQ(kIPv6PublicAddrString, addr_v6.ToSensitiveString()); 870 IPAddress::set_strip_sensitive(true); 871 EXPECT_EQ(kIPv6PublicAddrString, addr_v6.ToString()); 872 EXPECT_EQ(kIPv6PublicAddrAnonymizedString, addr_v6.ToSensitiveString()); 873 IPAddress::set_strip_sensitive(false); 874 } 875 876 } // namespace talk_base 877
