henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 11 | #include "rtc_base/ip_address.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 12 | |
| 13 | #include "test/gtest.h" |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 14 | |
| 15 | namespace rtc { |
| 16 | |
| 17 | static const unsigned int kIPv4AddrSize = 4; |
| 18 | static const unsigned int kIPv6AddrSize = 16; |
| 19 | static const unsigned int kIPv4RFC1918Addr = 0xC0A80701; |
| 20 | static const unsigned int kIPv4PublicAddr = 0x01020304; |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 21 | static const unsigned int kIPv4RFC6598Addr = 0x64410801; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 22 | static const unsigned int kIPv4LinkLocalAddr = 0xA9FE10C1; // 169.254.16.193 |
| 23 | static const in6_addr kIPv6LinkLocalAddr = { |
| 24 | {{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe, 0x30, 0x5b, 0xff, |
| 25 | 0xfe, 0xe5, 0x00, 0xc3}}}; |
| 26 | static const in6_addr kIPv6PublicAddr = { |
| 27 | {{0x24, 0x01, 0xfa, 0x00, 0x00, 0x04, 0x10, 0x00, 0xbe, 0x30, 0x5b, 0xff, |
| 28 | 0xfe, 0xe5, 0x00, 0xc3}}}; |
| 29 | static const in6_addr kIPv6PublicAddr2 = { |
| 30 | {{0x24, 0x01, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0xbe, 0x30, 0x5b, 0xff, |
| 31 | 0xfe, 0xe5, 0x00, 0xc3}}}; |
| 32 | static const in6_addr kIPv4MappedAnyAddr = { |
| 33 | {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, |
| 34 | 0x00, 0x00, 0x00, 0x00}}}; |
| 35 | static const in6_addr kIPv4MappedRFC1918Addr = { |
| 36 | {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, |
| 37 | 0xc0, 0xa8, 0x07, 0x01}}}; |
| 38 | static const in6_addr kIPv4MappedPublicAddr = { |
| 39 | {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, |
| 40 | 0x01, 0x02, 0x03, 0x04}}}; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 41 | |
| 42 | static const std::string kIPv4AnyAddrString = "0.0.0.0"; |
| 43 | static const std::string kIPv4LoopbackAddrString = "127.0.0.1"; |
| 44 | static const std::string kIPv4RFC1918AddrString = "192.168.7.1"; |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 45 | static const std::string kIPv4RFC6598AddrString = "100.65.8.1"; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 46 | static const std::string kIPv4PublicAddrString = "1.2.3.4"; |
| 47 | static const std::string kIPv4PublicAddrAnonymizedString = "1.2.3.x"; |
| 48 | static const std::string kIPv6AnyAddrString = "::"; |
| 49 | static const std::string kIPv6LoopbackAddrString = "::1"; |
| 50 | static const std::string kIPv6LinkLocalAddrString = "fe80::be30:5bff:fee5:c3"; |
guoweis@webrtc.org | b91d0f5 | 2015-03-17 14:43:20 +0000 | [diff] [blame] | 51 | static const std::string kIPv6EuiAddrString = |
| 52 | "2620:0:1008:1201:a248:1cff:fe98:360"; |
| 53 | static const std::string kIPv6TemporaryAddrString = |
| 54 | "2620:0:1008:1201:2089:6dda:385e:80c0"; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 55 | static const std::string kIPv6PublicAddrString = |
| 56 | "2401:fa00:4:1000:be30:5bff:fee5:c3"; |
henrikg | ac921d7 | 2015-12-14 02:07:03 -0800 | [diff] [blame] | 57 | static const std::string kIPv6PublicAddr2String = |
| 58 | "2401::1000:be30:5bff:fee5:c3"; |
| 59 | static const std::string kIPv6PublicAddrAnonymizedString = |
| 60 | "2401:fa00:4:x:x:x:x:x"; |
| 61 | static const std::string kIPv6PublicAddr2AnonymizedString = |
Sergey Ulanov | beed828 | 2016-01-13 18:14:49 -0800 | [diff] [blame] | 62 | "2401:0:0:x:x:x:x:x"; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 63 | static const std::string kIPv4MappedAnyAddrString = "::ffff:0:0"; |
| 64 | static const std::string kIPv4MappedRFC1918AddrString = "::ffff:c0a8:701"; |
| 65 | static const std::string kIPv4MappedLoopbackAddrString = "::ffff:7f00:1"; |
| 66 | static const std::string kIPv4MappedPublicAddrString = "::ffff:102:0304"; |
| 67 | static const std::string kIPv4MappedV4StyleAddrString = "::ffff:192.168.7.1"; |
| 68 | |
| 69 | static const std::string kIPv4BrokenString1 = "192.168.7."; |
| 70 | static const std::string kIPv4BrokenString2 = "192.168.7.1.1"; |
| 71 | static const std::string kIPv4BrokenString3 = "192.168.7.1:80"; |
| 72 | static const std::string kIPv4BrokenString4 = "192.168.7.ONE"; |
| 73 | static const std::string kIPv4BrokenString5 = "-192.168.7.1"; |
| 74 | static const std::string kIPv4BrokenString6 = "256.168.7.1"; |
| 75 | static const std::string kIPv6BrokenString1 = "2401:fa00:4:1000:be30"; |
| 76 | static const std::string kIPv6BrokenString2 = |
| 77 | "2401:fa00:4:1000:be30:5bff:fee5:c3:1"; |
| 78 | static const std::string kIPv6BrokenString3 = |
| 79 | "[2401:fa00:4:1000:be30:5bff:fee5:c3]:1"; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 80 | static const std::string kIPv6BrokenString4 = "2401::4::be30"; |
| 81 | static const std::string kIPv6BrokenString5 = "2401:::4:fee5:be30"; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 82 | static const std::string kIPv6BrokenString6 = |
| 83 | "2401f:fa00:4:1000:be30:5bff:fee5:c3"; |
| 84 | static const std::string kIPv6BrokenString7 = |
| 85 | "2401:ga00:4:1000:be30:5bff:fee5:c3"; |
| 86 | static const std::string kIPv6BrokenString8 = |
| 87 | "2401:fa000:4:1000:be30:5bff:fee5:c3"; |
| 88 | static const std::string kIPv6BrokenString9 = |
| 89 | "2401:fal0:4:1000:be30:5bff:fee5:c3"; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 90 | static const std::string kIPv6BrokenString10 = "::ffff:192.168.7."; |
| 91 | static const std::string kIPv6BrokenString11 = "::ffff:192.168.7.1.1.1"; |
| 92 | static const std::string kIPv6BrokenString12 = "::fffe:192.168.7.1"; |
| 93 | static const std::string kIPv6BrokenString13 = "::ffff:192.168.7.ff"; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 94 | static const std::string kIPv6BrokenString14 = |
| 95 | "0x2401:fa00:4:1000:be30:5bff:fee5:c3"; |
| 96 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 97 | bool AreEqual(const IPAddress& addr, const IPAddress& addr2) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 98 | if ((IPIsAny(addr) != IPIsAny(addr2)) || |
| 99 | (IPIsLoopback(addr) != IPIsLoopback(addr2)) || |
| 100 | (IPIsPrivate(addr) != IPIsPrivate(addr2)) || |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 101 | (HashIP(addr) != HashIP(addr2)) || (addr.Size() != addr2.Size()) || |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 102 | (addr.family() != addr2.family()) || |
| 103 | (addr.ToString() != addr2.ToString())) { |
| 104 | return false; |
| 105 | } |
| 106 | in_addr v4addr, v4addr2; |
| 107 | v4addr = addr.ipv4_address(); |
| 108 | v4addr2 = addr2.ipv4_address(); |
| 109 | if (0 != memcmp(&v4addr, &v4addr2, sizeof(v4addr))) { |
| 110 | return false; |
| 111 | } |
| 112 | in6_addr v6addr, v6addr2; |
| 113 | v6addr = addr.ipv6_address(); |
| 114 | v6addr2 = addr2.ipv6_address(); |
| 115 | if (0 != memcmp(&v6addr, &v6addr2, sizeof(v6addr))) { |
| 116 | return false; |
| 117 | } |
| 118 | return true; |
| 119 | } |
| 120 | |
| 121 | bool BrokenIPStringFails(const std::string& broken) { |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 122 | IPAddress addr(0); // Intentionally make it v4. |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 123 | if (IPFromString(kIPv4BrokenString1, &addr)) { |
| 124 | return false; |
| 125 | } |
| 126 | return addr.family() == AF_UNSPEC; |
| 127 | } |
| 128 | |
| 129 | bool CheckMaskCount(const std::string& mask, int expected_length) { |
| 130 | IPAddress addr; |
| 131 | return IPFromString(mask, &addr) && |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 132 | (expected_length == CountIPMaskBits(addr)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | bool TryInvalidMaskCount(const std::string& mask) { |
| 136 | // We don't care about the result at all, but we do want to know if |
| 137 | // CountIPMaskBits is going to crash or infinite loop or something. |
| 138 | IPAddress addr; |
| 139 | if (!IPFromString(mask, &addr)) { |
| 140 | return false; |
| 141 | } |
| 142 | CountIPMaskBits(addr); |
| 143 | return true; |
| 144 | } |
| 145 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 146 | bool CheckTruncateIP(const std::string& initial, |
| 147 | int truncate_length, |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 148 | const std::string& expected_result) { |
| 149 | IPAddress addr, expected; |
| 150 | IPFromString(initial, &addr); |
| 151 | IPFromString(expected_result, &expected); |
| 152 | IPAddress truncated = TruncateIP(addr, truncate_length); |
| 153 | return truncated == expected; |
| 154 | } |
| 155 | |
| 156 | TEST(IPAddressTest, TestDefaultCtor) { |
| 157 | IPAddress addr; |
| 158 | EXPECT_FALSE(IPIsAny(addr)); |
| 159 | EXPECT_FALSE(IPIsLoopback(addr)); |
| 160 | EXPECT_FALSE(IPIsPrivate(addr)); |
| 161 | |
| 162 | EXPECT_EQ(0U, addr.Size()); |
| 163 | EXPECT_EQ(AF_UNSPEC, addr.family()); |
| 164 | EXPECT_EQ("", addr.ToString()); |
| 165 | } |
| 166 | |
| 167 | TEST(IPAddressTest, TestInAddrCtor) { |
| 168 | in_addr v4addr; |
| 169 | |
| 170 | // Test V4 Any address. |
| 171 | v4addr.s_addr = INADDR_ANY; |
| 172 | IPAddress addr(v4addr); |
| 173 | EXPECT_TRUE(IPIsAny(addr)); |
| 174 | EXPECT_FALSE(IPIsLoopback(addr)); |
| 175 | EXPECT_FALSE(IPIsPrivate(addr)); |
| 176 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 177 | EXPECT_EQ(kIPv4AnyAddrString, addr.ToString()); |
| 178 | |
| 179 | // Test a V4 loopback address. |
| 180 | v4addr.s_addr = htonl(INADDR_LOOPBACK); |
| 181 | addr = IPAddress(v4addr); |
| 182 | EXPECT_FALSE(IPIsAny(addr)); |
| 183 | EXPECT_TRUE(IPIsLoopback(addr)); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 184 | EXPECT_FALSE(IPIsSharedNetwork(addr)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 185 | EXPECT_TRUE(IPIsPrivate(addr)); |
| 186 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 187 | EXPECT_EQ(kIPv4LoopbackAddrString, addr.ToString()); |
| 188 | |
| 189 | // Test an RFC1918 address. |
| 190 | v4addr.s_addr = htonl(kIPv4RFC1918Addr); |
| 191 | addr = IPAddress(v4addr); |
| 192 | EXPECT_FALSE(IPIsAny(addr)); |
| 193 | EXPECT_FALSE(IPIsLoopback(addr)); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 194 | EXPECT_FALSE(IPIsSharedNetwork(addr)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 195 | EXPECT_TRUE(IPIsPrivate(addr)); |
| 196 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 197 | EXPECT_EQ(kIPv4RFC1918AddrString, addr.ToString()); |
| 198 | |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 199 | // Test an shared (RFC6598) address. |
| 200 | v4addr.s_addr = htonl(kIPv4RFC6598Addr); |
| 201 | addr = IPAddress(v4addr); |
| 202 | EXPECT_FALSE(IPIsAny(addr)); |
| 203 | EXPECT_FALSE(IPIsLoopback(addr)); |
| 204 | EXPECT_TRUE(IPIsPrivate(addr)); |
| 205 | EXPECT_TRUE(IPIsSharedNetwork(addr)); |
| 206 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 207 | EXPECT_EQ(kIPv4RFC6598AddrString, addr.ToString()); |
| 208 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 209 | // Test a 'normal' v4 address. |
| 210 | v4addr.s_addr = htonl(kIPv4PublicAddr); |
| 211 | addr = IPAddress(v4addr); |
| 212 | EXPECT_FALSE(IPIsAny(addr)); |
| 213 | EXPECT_FALSE(IPIsLoopback(addr)); |
| 214 | EXPECT_FALSE(IPIsPrivate(addr)); |
| 215 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 216 | EXPECT_EQ(kIPv4PublicAddrString, addr.ToString()); |
| 217 | } |
| 218 | |
| 219 | TEST(IPAddressTest, TestInAddr6Ctor) { |
| 220 | // Test v6 empty. |
| 221 | IPAddress addr(in6addr_any); |
| 222 | EXPECT_TRUE(IPIsAny(addr)); |
| 223 | EXPECT_FALSE(IPIsLoopback(addr)); |
| 224 | EXPECT_FALSE(IPIsPrivate(addr)); |
| 225 | EXPECT_EQ(kIPv6AddrSize, addr.Size()); |
| 226 | EXPECT_EQ(kIPv6AnyAddrString, addr.ToString()); |
| 227 | |
| 228 | // Test v6 loopback. |
| 229 | addr = IPAddress(in6addr_loopback); |
| 230 | EXPECT_FALSE(IPIsAny(addr)); |
| 231 | EXPECT_TRUE(IPIsLoopback(addr)); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 232 | EXPECT_FALSE(IPIsSharedNetwork(addr)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 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)); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 241 | EXPECT_FALSE(IPIsSharedNetwork(addr)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 242 | EXPECT_TRUE(IPIsPrivate(addr)); |
| 243 | EXPECT_EQ(kIPv6AddrSize, addr.Size()); |
| 244 | EXPECT_EQ(kIPv6LinkLocalAddrString, addr.ToString()); |
| 245 | |
| 246 | // Test v6 global address. |
| 247 | addr = IPAddress(kIPv6PublicAddr); |
| 248 | EXPECT_FALSE(IPIsAny(addr)); |
| 249 | EXPECT_FALSE(IPIsLoopback(addr)); |
| 250 | EXPECT_FALSE(IPIsPrivate(addr)); |
| 251 | EXPECT_EQ(kIPv6AddrSize, addr.Size()); |
| 252 | EXPECT_EQ(kIPv6PublicAddrString, addr.ToString()); |
| 253 | } |
| 254 | |
| 255 | TEST(IPAddressTest, TestUint32Ctor) { |
| 256 | // Test V4 Any address. |
| 257 | IPAddress addr(0); |
| 258 | EXPECT_TRUE(IPIsAny(addr)); |
| 259 | EXPECT_FALSE(IPIsLoopback(addr)); |
| 260 | EXPECT_FALSE(IPIsPrivate(addr)); |
| 261 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 262 | EXPECT_EQ(kIPv4AnyAddrString, addr.ToString()); |
| 263 | |
| 264 | // Test a V4 loopback address. |
| 265 | addr = IPAddress(INADDR_LOOPBACK); |
| 266 | EXPECT_FALSE(IPIsAny(addr)); |
| 267 | EXPECT_TRUE(IPIsLoopback(addr)); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 268 | EXPECT_FALSE(IPIsSharedNetwork(addr)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 269 | EXPECT_TRUE(IPIsPrivate(addr)); |
| 270 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 271 | EXPECT_EQ(kIPv4LoopbackAddrString, addr.ToString()); |
| 272 | |
| 273 | // Test an RFC1918 address. |
| 274 | addr = IPAddress(kIPv4RFC1918Addr); |
| 275 | EXPECT_FALSE(IPIsAny(addr)); |
| 276 | EXPECT_FALSE(IPIsLoopback(addr)); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 277 | EXPECT_FALSE(IPIsSharedNetwork(addr)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 278 | EXPECT_TRUE(IPIsPrivate(addr)); |
| 279 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 280 | EXPECT_EQ(kIPv4RFC1918AddrString, addr.ToString()); |
| 281 | |
| 282 | // Test a 'normal' v4 address. |
| 283 | addr = IPAddress(kIPv4PublicAddr); |
| 284 | EXPECT_FALSE(IPIsAny(addr)); |
| 285 | EXPECT_FALSE(IPIsLoopback(addr)); |
| 286 | EXPECT_FALSE(IPIsPrivate(addr)); |
| 287 | EXPECT_EQ(kIPv4AddrSize, addr.Size()); |
| 288 | EXPECT_EQ(kIPv4PublicAddrString, addr.ToString()); |
| 289 | } |
| 290 | |
| 291 | TEST(IPAddressTest, TestCopyCtor) { |
| 292 | in_addr v4addr; |
| 293 | v4addr.s_addr = htonl(kIPv4PublicAddr); |
| 294 | IPAddress addr(v4addr); |
| 295 | IPAddress addr2(addr); |
| 296 | |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 297 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 298 | |
| 299 | addr = IPAddress(INADDR_ANY); |
| 300 | addr2 = IPAddress(addr); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 301 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 302 | |
| 303 | addr = IPAddress(INADDR_LOOPBACK); |
| 304 | addr2 = IPAddress(addr); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 305 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 306 | |
| 307 | addr = IPAddress(kIPv4PublicAddr); |
| 308 | addr2 = IPAddress(addr); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 309 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 310 | |
| 311 | addr = IPAddress(kIPv4RFC1918Addr); |
| 312 | addr2 = IPAddress(addr); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 313 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 314 | |
| 315 | addr = IPAddress(in6addr_any); |
| 316 | addr2 = IPAddress(addr); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 317 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 318 | |
| 319 | addr = IPAddress(in6addr_loopback); |
| 320 | addr2 = IPAddress(addr); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 321 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 322 | |
| 323 | addr = IPAddress(kIPv6LinkLocalAddr); |
| 324 | addr2 = IPAddress(addr); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 325 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 326 | |
| 327 | addr = IPAddress(kIPv6PublicAddr); |
| 328 | addr2 = IPAddress(addr); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 329 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 330 | } |
| 331 | |
| 332 | TEST(IPAddressTest, TestEquality) { |
| 333 | // Check v4 equality |
| 334 | in_addr v4addr, v4addr2; |
| 335 | v4addr.s_addr = htonl(kIPv4PublicAddr); |
| 336 | v4addr2.s_addr = htonl(kIPv4PublicAddr + 1); |
| 337 | IPAddress addr(v4addr); |
| 338 | IPAddress addr2(v4addr2); |
| 339 | IPAddress addr3(v4addr); |
| 340 | |
| 341 | EXPECT_TRUE(addr == addr); |
| 342 | EXPECT_TRUE(addr2 == addr2); |
| 343 | EXPECT_TRUE(addr3 == addr3); |
| 344 | EXPECT_TRUE(addr == addr3); |
| 345 | EXPECT_TRUE(addr3 == addr); |
| 346 | EXPECT_FALSE(addr2 == addr); |
| 347 | EXPECT_FALSE(addr2 == addr3); |
| 348 | EXPECT_FALSE(addr == addr2); |
| 349 | EXPECT_FALSE(addr3 == addr2); |
| 350 | |
| 351 | // Check v6 equality |
| 352 | IPAddress addr4(kIPv6PublicAddr); |
| 353 | IPAddress addr5(kIPv6LinkLocalAddr); |
| 354 | IPAddress addr6(kIPv6PublicAddr); |
| 355 | |
| 356 | EXPECT_TRUE(addr4 == addr4); |
| 357 | EXPECT_TRUE(addr5 == addr5); |
| 358 | EXPECT_TRUE(addr4 == addr6); |
| 359 | EXPECT_TRUE(addr6 == addr4); |
| 360 | EXPECT_FALSE(addr4 == addr5); |
| 361 | EXPECT_FALSE(addr5 == addr4); |
| 362 | EXPECT_FALSE(addr6 == addr5); |
| 363 | EXPECT_FALSE(addr5 == addr6); |
| 364 | |
| 365 | // Check v4/v6 cross-equality |
| 366 | EXPECT_FALSE(addr == addr4); |
| 367 | EXPECT_FALSE(addr == addr5); |
| 368 | EXPECT_FALSE(addr == addr6); |
| 369 | EXPECT_FALSE(addr4 == addr); |
| 370 | EXPECT_FALSE(addr5 == addr); |
| 371 | EXPECT_FALSE(addr6 == addr); |
| 372 | EXPECT_FALSE(addr2 == addr4); |
| 373 | EXPECT_FALSE(addr2 == addr5); |
| 374 | EXPECT_FALSE(addr2 == addr6); |
| 375 | EXPECT_FALSE(addr4 == addr2); |
| 376 | EXPECT_FALSE(addr5 == addr2); |
| 377 | EXPECT_FALSE(addr6 == addr2); |
| 378 | EXPECT_FALSE(addr3 == addr4); |
| 379 | EXPECT_FALSE(addr3 == addr5); |
| 380 | EXPECT_FALSE(addr3 == addr6); |
| 381 | EXPECT_FALSE(addr4 == addr3); |
| 382 | EXPECT_FALSE(addr5 == addr3); |
| 383 | EXPECT_FALSE(addr6 == addr3); |
| 384 | |
| 385 | // Special cases: loopback and any. |
| 386 | // They're special but they're still not equal. |
| 387 | IPAddress v4loopback(htonl(INADDR_LOOPBACK)); |
| 388 | IPAddress v6loopback(in6addr_loopback); |
| 389 | EXPECT_FALSE(v4loopback == v6loopback); |
| 390 | |
| 391 | IPAddress v4any(0); |
| 392 | IPAddress v6any(in6addr_any); |
| 393 | EXPECT_FALSE(v4any == v6any); |
| 394 | } |
| 395 | |
| 396 | TEST(IPAddressTest, TestComparison) { |
| 397 | // Defined in 'ascending' order. |
| 398 | // v6 > v4, and intra-family sorting is purely numerical |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 399 | IPAddress addr0; // AF_UNSPEC |
| 400 | IPAddress addr1(INADDR_ANY); // 0.0.0.0 |
| 401 | IPAddress addr2(kIPv4PublicAddr); // 1.2.3.4 |
| 402 | IPAddress addr3(INADDR_LOOPBACK); // 127.0.0.1 |
| 403 | IPAddress addr4(kIPv4RFC1918Addr); // 192.168.7.1. |
| 404 | IPAddress addr5(in6addr_any); // :: |
| 405 | IPAddress addr6(in6addr_loopback); // ::1 |
| 406 | IPAddress addr7(kIPv6PublicAddr); // 2401.... |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 407 | IPAddress addr8(kIPv6LinkLocalAddr); // fe80.... |
| 408 | |
| 409 | EXPECT_TRUE(addr0 < addr1); |
| 410 | EXPECT_TRUE(addr1 < addr2); |
| 411 | EXPECT_TRUE(addr2 < addr3); |
| 412 | EXPECT_TRUE(addr3 < addr4); |
| 413 | EXPECT_TRUE(addr4 < addr5); |
| 414 | EXPECT_TRUE(addr5 < addr6); |
| 415 | EXPECT_TRUE(addr6 < addr7); |
| 416 | EXPECT_TRUE(addr7 < addr8); |
| 417 | |
| 418 | EXPECT_FALSE(addr0 > addr1); |
| 419 | EXPECT_FALSE(addr1 > addr2); |
| 420 | EXPECT_FALSE(addr2 > addr3); |
| 421 | EXPECT_FALSE(addr3 > addr4); |
| 422 | EXPECT_FALSE(addr4 > addr5); |
| 423 | EXPECT_FALSE(addr5 > addr6); |
| 424 | EXPECT_FALSE(addr6 > addr7); |
| 425 | EXPECT_FALSE(addr7 > addr8); |
| 426 | |
| 427 | EXPECT_FALSE(addr0 > addr0); |
| 428 | EXPECT_FALSE(addr1 > addr1); |
| 429 | EXPECT_FALSE(addr2 > addr2); |
| 430 | EXPECT_FALSE(addr3 > addr3); |
| 431 | EXPECT_FALSE(addr4 > addr4); |
| 432 | EXPECT_FALSE(addr5 > addr5); |
| 433 | EXPECT_FALSE(addr6 > addr6); |
| 434 | EXPECT_FALSE(addr7 > addr7); |
| 435 | EXPECT_FALSE(addr8 > addr8); |
| 436 | |
| 437 | EXPECT_FALSE(addr0 < addr0); |
| 438 | EXPECT_FALSE(addr1 < addr1); |
| 439 | EXPECT_FALSE(addr2 < addr2); |
| 440 | EXPECT_FALSE(addr3 < addr3); |
| 441 | EXPECT_FALSE(addr4 < addr4); |
| 442 | EXPECT_FALSE(addr5 < addr5); |
| 443 | EXPECT_FALSE(addr6 < addr6); |
| 444 | EXPECT_FALSE(addr7 < addr7); |
| 445 | EXPECT_FALSE(addr8 < addr8); |
| 446 | } |
| 447 | |
| 448 | TEST(IPAddressTest, TestFromString) { |
| 449 | IPAddress addr; |
| 450 | IPAddress addr2; |
| 451 | addr2 = IPAddress(INADDR_ANY); |
| 452 | |
| 453 | EXPECT_TRUE(IPFromString(kIPv4AnyAddrString, &addr)); |
| 454 | EXPECT_EQ(addr.ToString(), kIPv4AnyAddrString); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 455 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 456 | |
| 457 | addr2 = IPAddress(INADDR_LOOPBACK); |
| 458 | EXPECT_TRUE(IPFromString(kIPv4LoopbackAddrString, &addr)); |
| 459 | EXPECT_EQ(addr.ToString(), kIPv4LoopbackAddrString); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 460 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 461 | |
| 462 | addr2 = IPAddress(kIPv4RFC1918Addr); |
| 463 | EXPECT_TRUE(IPFromString(kIPv4RFC1918AddrString, &addr)); |
| 464 | EXPECT_EQ(addr.ToString(), kIPv4RFC1918AddrString); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 465 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 466 | |
| 467 | addr2 = IPAddress(kIPv4PublicAddr); |
| 468 | EXPECT_TRUE(IPFromString(kIPv4PublicAddrString, &addr)); |
| 469 | EXPECT_EQ(addr.ToString(), kIPv4PublicAddrString); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 470 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 471 | |
| 472 | addr2 = IPAddress(in6addr_any); |
| 473 | EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr)); |
| 474 | EXPECT_EQ(addr.ToString(), kIPv6AnyAddrString); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 475 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 476 | |
| 477 | addr2 = IPAddress(in6addr_loopback); |
| 478 | EXPECT_TRUE(IPFromString(kIPv6LoopbackAddrString, &addr)); |
| 479 | EXPECT_EQ(addr.ToString(), kIPv6LoopbackAddrString); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 480 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 481 | |
| 482 | addr2 = IPAddress(kIPv6LinkLocalAddr); |
| 483 | EXPECT_TRUE(IPFromString(kIPv6LinkLocalAddrString, &addr)); |
| 484 | EXPECT_EQ(addr.ToString(), kIPv6LinkLocalAddrString); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 485 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 486 | |
| 487 | addr2 = IPAddress(kIPv6PublicAddr); |
| 488 | EXPECT_TRUE(IPFromString(kIPv6PublicAddrString, &addr)); |
| 489 | EXPECT_EQ(addr.ToString(), kIPv6PublicAddrString); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 490 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 491 | |
| 492 | addr2 = IPAddress(kIPv4MappedRFC1918Addr); |
| 493 | EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr)); |
Jonas Olsson | abbe841 | 2018-04-03 13:40:05 +0200 | [diff] [blame] | 494 | EXPECT_TRUE(AreEqual(addr, addr2)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 495 | |
| 496 | // Broken cases, should set addr to AF_UNSPEC. |
| 497 | EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString1); |
| 498 | EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString2); |
| 499 | EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString3); |
| 500 | EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString4); |
| 501 | EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString5); |
| 502 | EXPECT_PRED1(BrokenIPStringFails, kIPv4BrokenString6); |
| 503 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString1); |
| 504 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString2); |
| 505 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString3); |
| 506 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString4); |
| 507 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString5); |
| 508 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString6); |
| 509 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString7); |
| 510 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString8); |
| 511 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString9); |
| 512 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString10); |
| 513 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString11); |
| 514 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString12); |
| 515 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString13); |
| 516 | EXPECT_PRED1(BrokenIPStringFails, kIPv6BrokenString14); |
| 517 | } |
| 518 | |
| 519 | TEST(IPAddressTest, TestIPFromAddrInfo) { |
| 520 | struct sockaddr_in expected4; |
| 521 | struct sockaddr_in6 expected6; |
| 522 | struct addrinfo test_info; |
| 523 | struct addrinfo next_info; |
| 524 | memset(&next_info, 'A', sizeof(next_info)); |
| 525 | test_info.ai_next = &next_info; |
| 526 | // Check that we can get an IPv4 address out. |
| 527 | test_info.ai_addr = reinterpret_cast<struct sockaddr*>(&expected4); |
| 528 | expected4.sin_addr.s_addr = HostToNetwork32(kIPv4PublicAddr); |
| 529 | expected4.sin_family = AF_INET; |
| 530 | IPAddress expected(kIPv4PublicAddr); |
| 531 | IPAddress addr; |
| 532 | EXPECT_TRUE(IPFromAddrInfo(&test_info, &addr)); |
| 533 | EXPECT_EQ(expected, addr); |
| 534 | // Check that we can get an IPv6 address out. |
| 535 | expected6.sin6_addr = kIPv6PublicAddr; |
| 536 | expected6.sin6_family = AF_INET6; |
| 537 | expected = IPAddress(kIPv6PublicAddr); |
| 538 | test_info.ai_addr = reinterpret_cast<struct sockaddr*>(&expected6); |
| 539 | EXPECT_TRUE(IPFromAddrInfo(&test_info, &addr)); |
| 540 | EXPECT_EQ(expected, addr); |
| 541 | // Check that unspec fails. |
| 542 | expected6.sin6_family = AF_UNSPEC; |
| 543 | EXPECT_FALSE(IPFromAddrInfo(&test_info, &addr)); |
| 544 | // Check a zeroed out addrinfo doesn't crash us. |
| 545 | memset(&next_info, 0, sizeof(next_info)); |
| 546 | EXPECT_FALSE(IPFromAddrInfo(&next_info, &addr)); |
| 547 | } |
| 548 | |
| 549 | TEST(IPAddressTest, TestIsPrivate) { |
| 550 | EXPECT_FALSE(IPIsPrivate(IPAddress(INADDR_ANY))); |
| 551 | EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4PublicAddr))); |
| 552 | EXPECT_FALSE(IPIsPrivate(IPAddress(in6addr_any))); |
| 553 | EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv6PublicAddr))); |
| 554 | EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedAnyAddr))); |
| 555 | EXPECT_FALSE(IPIsPrivate(IPAddress(kIPv4MappedPublicAddr))); |
| 556 | |
| 557 | EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv4RFC1918Addr))); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 558 | EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv4RFC6598Addr))); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 559 | EXPECT_TRUE(IPIsPrivate(IPAddress(INADDR_LOOPBACK))); |
| 560 | EXPECT_TRUE(IPIsPrivate(IPAddress(in6addr_loopback))); |
| 561 | EXPECT_TRUE(IPIsPrivate(IPAddress(kIPv6LinkLocalAddr))); |
| 562 | } |
| 563 | |
Guo-wei Shieh | 1147702 | 2015-08-15 09:28:41 -0700 | [diff] [blame] | 564 | TEST(IPAddressTest, TestIsNil) { |
| 565 | IPAddress addr; |
| 566 | EXPECT_TRUE(IPAddress().IsNil()); |
| 567 | |
| 568 | EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr)); |
| 569 | EXPECT_FALSE(addr.IsNil()); |
| 570 | |
| 571 | EXPECT_TRUE(IPFromString(kIPv4AnyAddrString, &addr)); |
| 572 | EXPECT_FALSE(addr.IsNil()); |
| 573 | |
| 574 | EXPECT_FALSE(IPAddress(kIPv4PublicAddr).IsNil()); |
| 575 | } |
| 576 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 577 | TEST(IPAddressTest, TestIsLoopback) { |
| 578 | EXPECT_FALSE(IPIsLoopback(IPAddress(INADDR_ANY))); |
| 579 | EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4PublicAddr))); |
| 580 | EXPECT_FALSE(IPIsLoopback(IPAddress(in6addr_any))); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 581 | EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4RFC6598Addr))); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 582 | EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv6PublicAddr))); |
| 583 | EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedAnyAddr))); |
| 584 | EXPECT_FALSE(IPIsLoopback(IPAddress(kIPv4MappedPublicAddr))); |
| 585 | |
| 586 | EXPECT_TRUE(IPIsLoopback(IPAddress(INADDR_LOOPBACK))); |
deadbeef | 9922016 | 2016-10-27 18:30:23 -0700 | [diff] [blame] | 587 | // Try an address in the loopback range (127.0.0.0/8) other than the typical |
| 588 | // 127.0.0.1. |
| 589 | EXPECT_TRUE(IPIsLoopback(IPAddress(0x7f010203))); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 590 | EXPECT_TRUE(IPIsLoopback(IPAddress(in6addr_loopback))); |
| 591 | } |
| 592 | |
Daniel Lazarenko | 2870b0a | 2018-01-25 10:30:22 +0100 | [diff] [blame] | 593 | TEST(IPAddressTest, TestIsLinkLocal) { |
| 594 | // "any" addresses |
| 595 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(INADDR_ANY))); |
| 596 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(in6addr_any))); |
| 597 | // loopback addresses |
| 598 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(INADDR_LOOPBACK))); |
| 599 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(in6addr_loopback))); |
Jeroen de Borst | af242c8 | 2019-04-24 13:13:48 -0700 | [diff] [blame] | 600 | // shared addresses |
| 601 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(kIPv4RFC6598Addr))); |
Daniel Lazarenko | 2870b0a | 2018-01-25 10:30:22 +0100 | [diff] [blame] | 602 | // public addresses |
| 603 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(kIPv4PublicAddr))); |
| 604 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(kIPv6PublicAddr))); |
| 605 | // private network addresses |
| 606 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(kIPv4RFC1918Addr))); |
| 607 | // mapped addresses |
| 608 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(kIPv4MappedAnyAddr))); |
| 609 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(kIPv4MappedPublicAddr))); |
| 610 | EXPECT_FALSE(IPIsLinkLocal(IPAddress(kIPv4MappedRFC1918Addr))); |
| 611 | |
| 612 | // link-local network addresses |
| 613 | EXPECT_TRUE(IPIsLinkLocal(IPAddress(kIPv4LinkLocalAddr))); |
| 614 | EXPECT_TRUE(IPIsLinkLocal(IPAddress(kIPv6LinkLocalAddr))); |
| 615 | } |
| 616 | |
guoweis@webrtc.org | 59ae5ff | 2015-03-01 23:45:16 +0000 | [diff] [blame] | 617 | // Verify that IPIsAny catches all cases of "any" address. |
| 618 | TEST(IPAddressTest, TestIsAny) { |
| 619 | IPAddress addr; |
| 620 | |
| 621 | EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr)); |
| 622 | EXPECT_TRUE(IPIsAny(addr)); |
| 623 | |
| 624 | EXPECT_TRUE(IPFromString(kIPv4AnyAddrString, &addr)); |
| 625 | EXPECT_TRUE(IPIsAny(addr)); |
| 626 | |
| 627 | EXPECT_TRUE(IPIsAny(IPAddress(kIPv4MappedAnyAddr))); |
| 628 | } |
| 629 | |
guoweis@webrtc.org | b91d0f5 | 2015-03-17 14:43:20 +0000 | [diff] [blame] | 630 | TEST(IPAddressTest, TestIsEui64) { |
| 631 | IPAddress addr; |
| 632 | EXPECT_TRUE(IPFromString(kIPv6EuiAddrString, &addr)); |
| 633 | EXPECT_TRUE(IPIsMacBased(addr)); |
| 634 | |
| 635 | EXPECT_TRUE(IPFromString(kIPv6TemporaryAddrString, &addr)); |
| 636 | EXPECT_FALSE(IPIsMacBased(addr)); |
| 637 | |
| 638 | EXPECT_TRUE(IPFromString(kIPv6LinkLocalAddrString, &addr)); |
| 639 | EXPECT_TRUE(IPIsMacBased(addr)); |
| 640 | |
| 641 | EXPECT_TRUE(IPFromString(kIPv6AnyAddrString, &addr)); |
| 642 | EXPECT_FALSE(IPIsMacBased(addr)); |
| 643 | |
| 644 | EXPECT_TRUE(IPFromString(kIPv6LoopbackAddrString, &addr)); |
| 645 | EXPECT_FALSE(IPIsMacBased(addr)); |
| 646 | } |
| 647 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 648 | TEST(IPAddressTest, TestNormalized) { |
| 649 | // Check normalizing a ::ffff:a.b.c.d address. |
| 650 | IPAddress addr; |
| 651 | EXPECT_TRUE(IPFromString(kIPv4MappedV4StyleAddrString, &addr)); |
| 652 | IPAddress addr2(kIPv4RFC1918Addr); |
| 653 | addr = addr.Normalized(); |
| 654 | EXPECT_EQ(addr2, addr); |
| 655 | |
| 656 | // Check normalizing a ::ffff:aabb:ccdd address. |
| 657 | addr = IPAddress(kIPv4MappedPublicAddr); |
| 658 | addr2 = IPAddress(kIPv4PublicAddr); |
| 659 | addr = addr.Normalized(); |
| 660 | EXPECT_EQ(addr, addr2); |
| 661 | |
| 662 | // Check that a non-mapped v6 addresses isn't altered. |
| 663 | addr = IPAddress(kIPv6PublicAddr); |
| 664 | addr2 = IPAddress(kIPv6PublicAddr); |
| 665 | addr = addr.Normalized(); |
| 666 | EXPECT_EQ(addr, addr2); |
| 667 | |
| 668 | // Check that addresses that look a bit like mapped addresses aren't altered |
| 669 | EXPECT_TRUE(IPFromString("fe80::ffff:0102:0304", &addr)); |
| 670 | addr2 = addr; |
| 671 | addr = addr.Normalized(); |
| 672 | EXPECT_EQ(addr, addr2); |
| 673 | EXPECT_TRUE(IPFromString("::0102:0304", &addr)); |
| 674 | addr2 = addr; |
| 675 | addr = addr.Normalized(); |
| 676 | EXPECT_EQ(addr, addr2); |
| 677 | // This string should 'work' as an IP address but is not a mapped address, |
| 678 | // so it shouldn't change on normalization. |
| 679 | EXPECT_TRUE(IPFromString("::192.168.7.1", &addr)); |
| 680 | addr2 = addr; |
| 681 | addr = addr.Normalized(); |
| 682 | EXPECT_EQ(addr, addr2); |
| 683 | |
| 684 | // Check that v4 addresses aren't altered. |
| 685 | addr = IPAddress(htonl(kIPv4PublicAddr)); |
| 686 | addr2 = IPAddress(htonl(kIPv4PublicAddr)); |
| 687 | addr = addr.Normalized(); |
| 688 | EXPECT_EQ(addr, addr2); |
| 689 | } |
| 690 | |
| 691 | TEST(IPAddressTest, TestAsIPv6Address) { |
| 692 | IPAddress addr(kIPv4PublicAddr); |
| 693 | IPAddress addr2(kIPv4MappedPublicAddr); |
| 694 | addr = addr.AsIPv6Address(); |
| 695 | EXPECT_EQ(addr, addr2); |
| 696 | |
| 697 | addr = IPAddress(kIPv4MappedPublicAddr); |
| 698 | addr2 = IPAddress(kIPv4MappedPublicAddr); |
| 699 | addr = addr.AsIPv6Address(); |
| 700 | EXPECT_EQ(addr, addr2); |
| 701 | |
| 702 | addr = IPAddress(kIPv6PublicAddr); |
| 703 | addr2 = IPAddress(kIPv6PublicAddr); |
| 704 | addr = addr.AsIPv6Address(); |
| 705 | EXPECT_EQ(addr, addr2); |
| 706 | } |
| 707 | |
oprypin | 8ad0e58 | 2017-09-05 03:00:37 -0700 | [diff] [blame] | 708 | TEST(IPAddressTest, TestCountIPMaskBits) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 709 | IPAddress mask; |
| 710 | // IPv4 on byte boundaries |
| 711 | EXPECT_PRED2(CheckMaskCount, "255.255.255.255", 32); |
| 712 | EXPECT_PRED2(CheckMaskCount, "255.255.255.0", 24); |
| 713 | EXPECT_PRED2(CheckMaskCount, "255.255.0.0", 16); |
| 714 | EXPECT_PRED2(CheckMaskCount, "255.0.0.0", 8); |
| 715 | EXPECT_PRED2(CheckMaskCount, "0.0.0.0", 0); |
| 716 | |
| 717 | // IPv4 not on byte boundaries |
| 718 | EXPECT_PRED2(CheckMaskCount, "128.0.0.0", 1); |
| 719 | EXPECT_PRED2(CheckMaskCount, "224.0.0.0", 3); |
| 720 | EXPECT_PRED2(CheckMaskCount, "255.248.0.0", 13); |
| 721 | EXPECT_PRED2(CheckMaskCount, "255.255.224.0", 19); |
| 722 | EXPECT_PRED2(CheckMaskCount, "255.255.255.252", 30); |
| 723 | |
| 724 | // V6 on byte boundaries |
| 725 | EXPECT_PRED2(CheckMaskCount, "::", 0); |
| 726 | EXPECT_PRED2(CheckMaskCount, "ff00::", 8); |
| 727 | EXPECT_PRED2(CheckMaskCount, "ffff::", 16); |
| 728 | EXPECT_PRED2(CheckMaskCount, "ffff:ff00::", 24); |
| 729 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff::", 32); |
| 730 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ff00::", 40); |
| 731 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff::", 48); |
| 732 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ff00::", 56); |
| 733 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff::", 64); |
| 734 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ff00::", 72); |
| 735 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff::", 80); |
| 736 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff00::", 88); |
| 737 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff::", 96); |
| 738 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff00:0000", 104); |
| 739 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0000", 112); |
| 740 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00", 120); |
| 741 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 128); |
| 742 | |
| 743 | // V6 not on byte boundaries. |
| 744 | EXPECT_PRED2(CheckMaskCount, "8000::", 1); |
| 745 | EXPECT_PRED2(CheckMaskCount, "ff80::", 9); |
| 746 | EXPECT_PRED2(CheckMaskCount, "ffff:fe00::", 23); |
| 747 | EXPECT_PRED2(CheckMaskCount, "ffff:fffe::", 31); |
| 748 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:e000::", 35); |
| 749 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffe0::", 43); |
| 750 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:f800::", 53); |
| 751 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:fff8::", 61); |
| 752 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fc00::", 70); |
| 753 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:fffc::", 78); |
| 754 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:8000::", 81); |
| 755 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ff80::", 89); |
| 756 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fe00::", 103); |
| 757 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:fffe:0000", 111); |
| 758 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fc00", 118); |
| 759 | EXPECT_PRED2(CheckMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffc", 126); |
| 760 | |
| 761 | // Non-contiguous ranges. These are invalid but lets test them |
| 762 | // to make sure they don't crash anything or infinite loop or something. |
| 763 | EXPECT_PRED1(TryInvalidMaskCount, "217.0.0.0"); |
| 764 | EXPECT_PRED1(TryInvalidMaskCount, "255.185.0.0"); |
| 765 | EXPECT_PRED1(TryInvalidMaskCount, "255.255.251.0"); |
| 766 | EXPECT_PRED1(TryInvalidMaskCount, "255.255.251.255"); |
| 767 | EXPECT_PRED1(TryInvalidMaskCount, "255.255.254.201"); |
| 768 | EXPECT_PRED1(TryInvalidMaskCount, "::1"); |
| 769 | EXPECT_PRED1(TryInvalidMaskCount, "fe80::1"); |
| 770 | EXPECT_PRED1(TryInvalidMaskCount, "ff80::1"); |
| 771 | EXPECT_PRED1(TryInvalidMaskCount, "ffff::1"); |
| 772 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ff00:1::1"); |
| 773 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff::ffff:1"); |
| 774 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ff00:1::"); |
| 775 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff::ff00"); |
| 776 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ff00:1234::"); |
| 777 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:0012::ffff"); |
| 778 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ff01::"); |
| 779 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:7f00::"); |
| 780 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ff7a::"); |
| 781 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:7f00:0000"); |
| 782 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ff70:0000"); |
| 783 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:0211"); |
| 784 | EXPECT_PRED1(TryInvalidMaskCount, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff7f"); |
| 785 | } |
| 786 | |
| 787 | TEST(IPAddressTest, TestTruncateIP) { |
| 788 | EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 24, "255.255.255.0"); |
| 789 | EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 16, "255.255.0.0"); |
| 790 | EXPECT_PRED3(CheckTruncateIP, "255.255.255.255", 8, "255.0.0.0"); |
| 791 | EXPECT_PRED3(CheckTruncateIP, "202.67.7.255", 24, "202.67.7.0"); |
| 792 | EXPECT_PRED3(CheckTruncateIP, "202.129.65.205", 16, "202.129.0.0"); |
| 793 | EXPECT_PRED3(CheckTruncateIP, "55.25.2.77", 8, "55.0.0.0"); |
| 794 | EXPECT_PRED3(CheckTruncateIP, "74.128.99.254", 1, "0.0.0.0"); |
| 795 | EXPECT_PRED3(CheckTruncateIP, "106.55.99.254", 3, "96.0.0.0"); |
| 796 | EXPECT_PRED3(CheckTruncateIP, "172.167.53.222", 13, "172.160.0.0"); |
| 797 | EXPECT_PRED3(CheckTruncateIP, "255.255.224.0", 18, "255.255.192.0"); |
| 798 | EXPECT_PRED3(CheckTruncateIP, "255.255.255.252", 28, "255.255.255.240"); |
| 799 | |
| 800 | EXPECT_PRED3(CheckTruncateIP, "fe80:1111:2222:3333:4444:5555:6666:7777", 1, |
| 801 | "8000::"); |
| 802 | EXPECT_PRED3(CheckTruncateIP, "fff0:1111:2222:3333:4444:5555:6666:7777", 9, |
| 803 | "ff80::"); |
| 804 | EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 23, |
| 805 | "ffff:fe00::"); |
| 806 | EXPECT_PRED3(CheckTruncateIP, "ffff:ff80:1111:2222:3333:4444:5555:6666", 32, |
| 807 | "ffff:ff80::"); |
| 808 | EXPECT_PRED3(CheckTruncateIP, "2400:f9af:e456:1111:2222:3333:4444:5555", 35, |
| 809 | "2400:f9af:e000::"); |
| 810 | EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4444:5555:6666:7777:8888", 53, |
| 811 | "9999:1111:2233:4000::"); |
| 812 | EXPECT_PRED3(CheckTruncateIP, "9999:1111:2233:4567:5555:6666:7777:8888", 64, |
| 813 | "9999:1111:2233:4567::"); |
| 814 | EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 68, |
| 815 | "1111:2222:3333:4444:5000::"); |
| 816 | EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 92, |
| 817 | "1111:2222:3333:4444:5555:6660::"); |
| 818 | EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 96, |
| 819 | "1111:2222:3333:4444:5555:6666::"); |
| 820 | EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 105, |
| 821 | "1111:2222:3333:4444:5555:6666:7700::"); |
| 822 | EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 124, |
| 823 | "1111:2222:3333:4444:5555:6666:7777:8880"); |
| 824 | |
| 825 | // Slightly degenerate cases |
| 826 | EXPECT_PRED3(CheckTruncateIP, "202.165.33.127", 32, "202.165.33.127"); |
| 827 | EXPECT_PRED3(CheckTruncateIP, "235.105.77.12", 0, "0.0.0.0"); |
| 828 | EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 128, |
| 829 | "1111:2222:3333:4444:5555:6666:7777:8888"); |
| 830 | EXPECT_PRED3(CheckTruncateIP, "1111:2222:3333:4444:5555:6666:7777:8888", 0, |
| 831 | "::"); |
| 832 | } |
| 833 | |
| 834 | TEST(IPAddressTest, TestCategorizeIPv6) { |
| 835 | // Test determining if an IPAddress is 6Bone/6To4/Teredo/etc. |
| 836 | // IPv4 address, should be none of these (not even v4compat/v4mapped). |
| 837 | IPAddress v4_addr(kIPv4PublicAddr); |
| 838 | EXPECT_FALSE(IPIs6Bone(v4_addr)); |
| 839 | EXPECT_FALSE(IPIs6To4(v4_addr)); |
| 840 | EXPECT_FALSE(IPIsSiteLocal(v4_addr)); |
| 841 | EXPECT_FALSE(IPIsTeredo(v4_addr)); |
| 842 | EXPECT_FALSE(IPIsULA(v4_addr)); |
| 843 | EXPECT_FALSE(IPIsV4Compatibility(v4_addr)); |
| 844 | EXPECT_FALSE(IPIsV4Mapped(v4_addr)); |
| 845 | // Linklocal (fe80::/16) adddress; should be none of these. |
| 846 | IPAddress linklocal_addr(kIPv6LinkLocalAddr); |
| 847 | EXPECT_FALSE(IPIs6Bone(linklocal_addr)); |
| 848 | EXPECT_FALSE(IPIs6To4(linklocal_addr)); |
| 849 | EXPECT_FALSE(IPIsSiteLocal(linklocal_addr)); |
| 850 | EXPECT_FALSE(IPIsTeredo(linklocal_addr)); |
| 851 | EXPECT_FALSE(IPIsULA(linklocal_addr)); |
| 852 | EXPECT_FALSE(IPIsV4Compatibility(linklocal_addr)); |
| 853 | EXPECT_FALSE(IPIsV4Mapped(linklocal_addr)); |
| 854 | // 'Normal' IPv6 address, should also be none of these. |
| 855 | IPAddress normal_addr(kIPv6PublicAddr); |
| 856 | EXPECT_FALSE(IPIs6Bone(normal_addr)); |
| 857 | EXPECT_FALSE(IPIs6To4(normal_addr)); |
| 858 | EXPECT_FALSE(IPIsSiteLocal(normal_addr)); |
| 859 | EXPECT_FALSE(IPIsTeredo(normal_addr)); |
| 860 | EXPECT_FALSE(IPIsULA(normal_addr)); |
| 861 | EXPECT_FALSE(IPIsV4Compatibility(normal_addr)); |
| 862 | EXPECT_FALSE(IPIsV4Mapped(normal_addr)); |
| 863 | // IPv4 mapped address (::ffff:123.123.123.123) |
| 864 | IPAddress v4mapped_addr(kIPv4MappedPublicAddr); |
| 865 | EXPECT_TRUE(IPIsV4Mapped(v4mapped_addr)); |
| 866 | EXPECT_FALSE(IPIsV4Compatibility(v4mapped_addr)); |
| 867 | EXPECT_FALSE(IPIs6Bone(v4mapped_addr)); |
| 868 | EXPECT_FALSE(IPIs6To4(v4mapped_addr)); |
| 869 | EXPECT_FALSE(IPIsSiteLocal(v4mapped_addr)); |
| 870 | EXPECT_FALSE(IPIsTeredo(v4mapped_addr)); |
| 871 | EXPECT_FALSE(IPIsULA(v4mapped_addr)); |
| 872 | // IPv4 compatibility address (::123.123.123.123) |
| 873 | IPAddress v4compat_addr; |
| 874 | IPFromString("::192.168.7.1", &v4compat_addr); |
| 875 | EXPECT_TRUE(IPIsV4Compatibility(v4compat_addr)); |
| 876 | EXPECT_FALSE(IPIs6Bone(v4compat_addr)); |
| 877 | EXPECT_FALSE(IPIs6To4(v4compat_addr)); |
| 878 | EXPECT_FALSE(IPIsSiteLocal(v4compat_addr)); |
| 879 | EXPECT_FALSE(IPIsTeredo(v4compat_addr)); |
| 880 | EXPECT_FALSE(IPIsULA(v4compat_addr)); |
| 881 | EXPECT_FALSE(IPIsV4Mapped(v4compat_addr)); |
| 882 | // 6Bone address (3FFE::/16) |
| 883 | IPAddress sixbone_addr; |
| 884 | IPFromString("3FFE:123:456::789:123", &sixbone_addr); |
| 885 | EXPECT_TRUE(IPIs6Bone(sixbone_addr)); |
| 886 | EXPECT_FALSE(IPIs6To4(sixbone_addr)); |
| 887 | EXPECT_FALSE(IPIsSiteLocal(sixbone_addr)); |
| 888 | EXPECT_FALSE(IPIsTeredo(sixbone_addr)); |
| 889 | EXPECT_FALSE(IPIsULA(sixbone_addr)); |
| 890 | EXPECT_FALSE(IPIsV4Mapped(sixbone_addr)); |
| 891 | EXPECT_FALSE(IPIsV4Compatibility(sixbone_addr)); |
| 892 | // Unique Local Address (FC::/7) |
| 893 | IPAddress ula_addr; |
| 894 | IPFromString("FC00:123:456::789:123", &ula_addr); |
| 895 | EXPECT_TRUE(IPIsULA(ula_addr)); |
| 896 | EXPECT_FALSE(IPIs6Bone(ula_addr)); |
| 897 | EXPECT_FALSE(IPIs6To4(ula_addr)); |
| 898 | EXPECT_FALSE(IPIsSiteLocal(ula_addr)); |
| 899 | EXPECT_FALSE(IPIsTeredo(ula_addr)); |
| 900 | EXPECT_FALSE(IPIsV4Mapped(ula_addr)); |
| 901 | EXPECT_FALSE(IPIsV4Compatibility(ula_addr)); |
| 902 | // 6To4 Address (2002::/16) |
| 903 | IPAddress sixtofour_addr; |
| 904 | IPFromString("2002:123:456::789:123", &sixtofour_addr); |
| 905 | EXPECT_TRUE(IPIs6To4(sixtofour_addr)); |
| 906 | EXPECT_FALSE(IPIs6Bone(sixtofour_addr)); |
| 907 | EXPECT_FALSE(IPIsSiteLocal(sixtofour_addr)); |
| 908 | EXPECT_FALSE(IPIsTeredo(sixtofour_addr)); |
| 909 | EXPECT_FALSE(IPIsULA(sixtofour_addr)); |
| 910 | EXPECT_FALSE(IPIsV4Compatibility(sixtofour_addr)); |
| 911 | EXPECT_FALSE(IPIsV4Mapped(sixtofour_addr)); |
| 912 | // Site Local address (FEC0::/10) |
| 913 | IPAddress sitelocal_addr; |
| 914 | IPFromString("FEC0:123:456::789:123", &sitelocal_addr); |
| 915 | EXPECT_TRUE(IPIsSiteLocal(sitelocal_addr)); |
| 916 | EXPECT_FALSE(IPIs6Bone(sitelocal_addr)); |
| 917 | EXPECT_FALSE(IPIs6To4(sitelocal_addr)); |
| 918 | EXPECT_FALSE(IPIsTeredo(sitelocal_addr)); |
| 919 | EXPECT_FALSE(IPIsULA(sitelocal_addr)); |
| 920 | EXPECT_FALSE(IPIsV4Compatibility(sitelocal_addr)); |
| 921 | EXPECT_FALSE(IPIsV4Mapped(sitelocal_addr)); |
| 922 | // Teredo Address (2001:0000::/32) |
| 923 | IPAddress teredo_addr; |
| 924 | IPFromString("2001:0000:123:456::789:123", &teredo_addr); |
| 925 | EXPECT_TRUE(IPIsTeredo(teredo_addr)); |
| 926 | EXPECT_FALSE(IPIsSiteLocal(teredo_addr)); |
| 927 | EXPECT_FALSE(IPIs6Bone(teredo_addr)); |
| 928 | EXPECT_FALSE(IPIs6To4(teredo_addr)); |
| 929 | EXPECT_FALSE(IPIsULA(teredo_addr)); |
| 930 | EXPECT_FALSE(IPIsV4Compatibility(teredo_addr)); |
| 931 | EXPECT_FALSE(IPIsV4Mapped(teredo_addr)); |
| 932 | } |
| 933 | |
| 934 | TEST(IPAddressTest, TestToSensitiveString) { |
| 935 | IPAddress addr_v4 = IPAddress(kIPv4PublicAddr); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 936 | IPAddress addr_v6 = IPAddress(kIPv6PublicAddr); |
henrikg | ac921d7 | 2015-12-14 02:07:03 -0800 | [diff] [blame] | 937 | IPAddress addr_v6_2 = IPAddress(kIPv6PublicAddr2); |
Peter Boström | cdb38e5 | 2015-11-26 00:35:49 +0100 | [diff] [blame] | 938 | EXPECT_EQ(kIPv4PublicAddrString, addr_v4.ToString()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 939 | EXPECT_EQ(kIPv6PublicAddrString, addr_v6.ToString()); |
henrikg | ac921d7 | 2015-12-14 02:07:03 -0800 | [diff] [blame] | 940 | EXPECT_EQ(kIPv6PublicAddr2String, addr_v6_2.ToString()); |
Peter Boström | cdb38e5 | 2015-11-26 00:35:49 +0100 | [diff] [blame] | 941 | #if defined(NDEBUG) |
| 942 | EXPECT_EQ(kIPv4PublicAddrAnonymizedString, addr_v4.ToSensitiveString()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 943 | EXPECT_EQ(kIPv6PublicAddrAnonymizedString, addr_v6.ToSensitiveString()); |
henrikg | ac921d7 | 2015-12-14 02:07:03 -0800 | [diff] [blame] | 944 | EXPECT_EQ(kIPv6PublicAddr2AnonymizedString, addr_v6_2.ToSensitiveString()); |
Peter Boström | cdb38e5 | 2015-11-26 00:35:49 +0100 | [diff] [blame] | 945 | #else |
| 946 | EXPECT_EQ(kIPv4PublicAddrString, addr_v4.ToSensitiveString()); |
| 947 | EXPECT_EQ(kIPv6PublicAddrString, addr_v6.ToSensitiveString()); |
henrikg | ac921d7 | 2015-12-14 02:07:03 -0800 | [diff] [blame] | 948 | EXPECT_EQ(kIPv6PublicAddr2String, addr_v6_2.ToSensitiveString()); |
Peter Boström | cdb38e5 | 2015-11-26 00:35:49 +0100 | [diff] [blame] | 949 | #endif // defined(NDEBUG) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 950 | } |
| 951 | |
guoweis@webrtc.org | fa60398 | 2014-09-09 23:42:40 +0000 | [diff] [blame] | 952 | TEST(IPAddressTest, TestInterfaceAddress) { |
| 953 | in6_addr addr; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 954 | InterfaceAddress addr1(kIPv6PublicAddr, IPV6_ADDRESS_FLAG_TEMPORARY); |
guoweis@webrtc.org | fa60398 | 2014-09-09 23:42:40 +0000 | [diff] [blame] | 955 | EXPECT_EQ(addr1.ipv6_flags(), IPV6_ADDRESS_FLAG_TEMPORARY); |
| 956 | EXPECT_EQ(addr1.family(), AF_INET6); |
| 957 | |
| 958 | addr = addr1.ipv6_address(); |
| 959 | EXPECT_TRUE(IN6_ARE_ADDR_EQUAL(&addr, &kIPv6PublicAddr)); |
| 960 | |
| 961 | InterfaceAddress addr2 = addr1; |
| 962 | EXPECT_EQ(addr1, addr2); |
| 963 | EXPECT_EQ(addr2.ipv6_flags(), IPV6_ADDRESS_FLAG_TEMPORARY); |
| 964 | addr = addr2.ipv6_address(); |
| 965 | EXPECT_TRUE(IN6_ARE_ADDR_EQUAL(&addr, &kIPv6PublicAddr)); |
| 966 | |
| 967 | InterfaceAddress addr3(addr1); |
| 968 | EXPECT_EQ(addr1, addr3); |
| 969 | EXPECT_EQ(addr3.ipv6_flags(), IPV6_ADDRESS_FLAG_TEMPORARY); |
| 970 | addr = addr3.ipv6_address(); |
| 971 | EXPECT_TRUE(IN6_ARE_ADDR_EQUAL(&addr, &kIPv6PublicAddr)); |
| 972 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 973 | InterfaceAddress addr4(kIPv6PublicAddr, IPV6_ADDRESS_FLAG_DEPRECATED); |
guoweis@webrtc.org | fa60398 | 2014-09-09 23:42:40 +0000 | [diff] [blame] | 974 | EXPECT_NE(addr1, addr4); |
| 975 | |
| 976 | // When you compare them as IPAddress, since operator== |
| 977 | // is not virtual, it'll be equal. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 978 | IPAddress* paddr1 = &addr1; |
| 979 | IPAddress* paddr4 = &addr4; |
guoweis@webrtc.org | fa60398 | 2014-09-09 23:42:40 +0000 | [diff] [blame] | 980 | EXPECT_EQ(*paddr1, *paddr4); |
| 981 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 982 | InterfaceAddress addr5(kIPv6LinkLocalAddr, IPV6_ADDRESS_FLAG_TEMPORARY); |
guoweis@webrtc.org | fa60398 | 2014-09-09 23:42:40 +0000 | [diff] [blame] | 983 | EXPECT_NE(addr1, addr5); |
| 984 | } |
| 985 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 986 | } // namespace rtc |