folly/test/SocketAddressTest.cpp

   1 /*
   2  * Copyright 2016 Facebook, Inc.
   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 <folly/SocketAddress.h>
  18
  19 #include <gtest/gtest.h>
  20 #include <iostream>
  21 #include <sstream>
  22 #include <system_error>
  23
  24 #include <folly/test/SocketAddressTestHelper.h>
  25
  26 using namespace boost;
  27 using std::string;
  28 using std::cerr;
  29 using std::endl;
  30 using folly::SocketAddress;
  31 using folly::SocketAddressTestHelper;
  32
  33 TEST(SocketAddress, Size) {
  34   SocketAddress addr;
  35   EXPECT_EQ(sizeof(addr), 32);
  36 }
  37
  38 TEST(SocketAddress, ConstructFromIpv4) {
  39   SocketAddress addr("1.2.3.4", 4321);
  40   EXPECT_EQ(addr.getFamily(), AF_INET);
  41   EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
  42   EXPECT_EQ(addr.getPort(), 4321);
  43   sockaddr_storage addrStorage;
  44   addr.getAddress(&addrStorage);
  45   const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
  46   EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x01020304));
  47   EXPECT_EQ(inaddr->sin_port, htons(4321));
  48 }
  49
  50 TEST(SocketAddress, IPv4ToStringConversion) {
  51   // testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
  52   SocketAddress addr;
  53   for (int pos = 0; pos < 4; ++pos) {
  54     for (int i = 0; i < 256; ++i) {
  55       int fragments[] = {5,5,5,5};
  56       fragments[pos] = i;
  57       std::ostringstream ss;
  58       ss << fragments[0] << "." << fragments[1] << "."
  59          << fragments[2] << "." << fragments[3];
  60       string ipString = ss.str();
  61       addr.setFromIpPort(ipString, 1234);
  62       EXPECT_EQ(addr.getAddressStr(), ipString);
  63     }
  64   }
  65 }
  66
  67 TEST(SocketAddress, SetFromIpAddressPort) {
  68   SocketAddress addr;
  69   folly::IPAddress ipAddr("123.234.0.23");
  70   addr.setFromIpAddrPort(ipAddr, 8888);
  71   EXPECT_EQ(addr.getFamily(), AF_INET);
  72   EXPECT_EQ(addr.getAddressStr(), "123.234.0.23");
  73   EXPECT_EQ(addr.getIPAddress(), ipAddr);
  74   EXPECT_EQ(addr.getPort(), 8888);
  75
  76   folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
  77   SocketAddress addr6(ip6Addr, 8888);
  78   EXPECT_EQ(addr6.getFamily(), AF_INET6);
  79   EXPECT_EQ(addr6.getAddressStr(), "2620:0:1cfe:face:b00c::3");
  80   EXPECT_EQ(addr6.getIPAddress(), ip6Addr);
  81   EXPECT_EQ(addr6.getPort(), 8888);
  82 }
  83
  84 TEST(SocketAddress, SetFromIpv4) {
  85   SocketAddress addr;
  86   addr.setFromIpPort("255.254.253.252", 8888);
  87   EXPECT_EQ(addr.getFamily(), AF_INET);
  88   EXPECT_EQ(addr.getAddressStr(), "255.254.253.252");
  89   EXPECT_EQ(addr.getPort(), 8888);
  90   sockaddr_storage addrStorage;
  91   addr.getAddress(&addrStorage);
  92   const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
  93   EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0xfffefdfc));
  94   EXPECT_EQ(inaddr->sin_port, htons(8888));
  95 }
  96
  97 TEST(SocketAddress, ConstructFromInvalidIpv4) {
  98   EXPECT_THROW(SocketAddress("1.2.3.256", 1234), std::runtime_error);
  99 }
 100
 101 TEST(SocketAddress, SetFromInvalidIpv4) {
 102   SocketAddress addr("12.34.56.78", 80);
 103
 104   // Try setting to an invalid value
 105   // Since setFromIpPort() shouldn't allow hostname lookups, setting to
 106   // "localhost" should fail, even if localhost is resolvable
 107   EXPECT_THROW(addr.setFromIpPort("localhost", 1234),
 108                std::runtime_error);
 109
 110   // Make sure the address still has the old contents
 111   EXPECT_EQ(addr.getFamily(), AF_INET);
 112   EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
 113   EXPECT_EQ(addr.getPort(), 80);
 114   sockaddr_storage addrStorage;
 115   addr.getAddress(&addrStorage);
 116   const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
 117   EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
 118 }
 119
 120 TEST(SocketAddress, SetFromHostname) {
 121   // hopefully "localhost" is resolvable on any system that will run the tests
 122   EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
 123   SocketAddress addr("localhost", 80, true);
 124
 125   SocketAddress addr2;
 126   EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
 127   addr2.setFromHostPort("localhost", 0);
 128 }
 129
 130 TEST(SocketAddress, SetFromStrings) {
 131   SocketAddress addr;
 132
 133   // Set from a numeric port string
 134   addr.setFromLocalPort("1234");
 135   EXPECT_EQ(addr.getPort(), 1234);
 136
 137   // setFromLocalPort() should not accept service names
 138   EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
 139
 140   // Call setFromLocalIpPort() with just a port, no IP
 141   addr.setFromLocalIpPort("80");
 142   EXPECT_EQ(addr.getPort(), 80);
 143
 144   // Call setFromLocalIpPort() with an IP and port.
 145   if (SocketAddressTestHelper::isIPv4Enabled()) {
 146     addr.setFromLocalIpPort("127.0.0.1:4321");
 147     EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
 148     EXPECT_EQ(addr.getPort(), 4321);
 149   }
 150   if (SocketAddressTestHelper::isIPv6Enabled()) {
 151     addr.setFromLocalIpPort("::1:4321");
 152     EXPECT_EQ(addr.getAddressStr(), "::1");
 153     EXPECT_EQ(addr.getPort(), 4321);
 154   }
 155
 156   // setFromIpPort() without an address should fail
 157   EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
 158
 159   // Call setFromIpPort() with an IPv6 address and port
 160   addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
 161   EXPECT_EQ(addr.getFamily(), AF_INET6);
 162   EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
 163   EXPECT_EQ(addr.getPort(), 65535);
 164
 165   // Call setFromIpPort() with an IPv4 address and port
 166   addr.setFromIpPort("1.2.3.4:9999");
 167   EXPECT_EQ(addr.getFamily(), AF_INET);
 168   EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
 169   EXPECT_EQ(addr.getPort(), 9999);
 170
 171   // Call setFromIpPort() with a bracketed IPv6
 172   addr.setFromIpPort("[::]:1234");
 173   EXPECT_EQ(addr.getFamily(), AF_INET6);
 174   EXPECT_EQ(addr.getAddressStr(), "::");
 175   EXPECT_EQ(addr.getPort(), 1234);
 176
 177   // Call setFromIpPort() with a bracketed IPv6
 178   addr.setFromIpPort("[9:8::2]:1234");
 179   EXPECT_EQ(addr.getFamily(), AF_INET6);
 180   EXPECT_EQ(addr.getAddressStr(), "9:8::2");
 181   EXPECT_EQ(addr.getPort(), 1234);
 182
 183   // Call setFromIpPort() with a bracketed IPv6 and no port
 184   EXPECT_THROW(addr.setFromIpPort("[::]"), std::system_error);
 185 }
 186
 187 TEST(SocketAddress, EqualityAndHash) {
 188   // IPv4
 189   SocketAddress local1("127.0.0.1", 1234);
 190   EXPECT_EQ(local1, local1);
 191   EXPECT_EQ(local1.hash(), local1.hash());
 192
 193   SocketAddress local2("127.0.0.1", 1234);
 194   EXPECT_EQ(local1, local2);
 195   EXPECT_EQ(local1.hash(), local2.hash());
 196
 197   SocketAddress local3("127.0.0.1", 4321);
 198   EXPECT_NE(local1, local3);
 199   EXPECT_NE(local1.hash(), local3.hash());
 200
 201   SocketAddress other1("1.2.3.4", 1234);
 202   EXPECT_EQ(other1, other1);
 203   EXPECT_EQ(other1.hash(), other1.hash());
 204   EXPECT_NE(local1, other1);
 205   EXPECT_NE(local1.hash(), other1.hash());
 206
 207   SocketAddress other2("4.3.2.1", 1234);
 208   EXPECT_NE(other1.hash(), other2.hash());
 209   EXPECT_NE(other1.hash(), other2.hash());
 210
 211   other2.setFromIpPort("1.2.3.4", 0);
 212   EXPECT_NE(other1.hash(), other2.hash());
 213   EXPECT_NE(other1.hash(), other2.hash());
 214   other2.setPort(1234);
 215   EXPECT_EQ(other1.hash(), other2.hash());
 216   EXPECT_EQ(other1.hash(), other2.hash());
 217
 218   // IPv6
 219   SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
 220   SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
 221   SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
 222   EXPECT_EQ(v6_1, v6_2);
 223   EXPECT_EQ(v6_1.hash(), v6_2.hash());
 224   EXPECT_NE(v6_1, v6_3);
 225   EXPECT_NE(v6_1.hash(), v6_3.hash());
 226
 227   // IPv4 versus IPv6 comparison
 228   SocketAddress localIPv6("::1", 1234);
 229   // Even though these both refer to localhost,
 230   // IPv4 and IPv6 addresses are never treated as the same address
 231   EXPECT_NE(local1, localIPv6);
 232   EXPECT_NE(local1.hash(), localIPv6.hash());
 233
 234   // IPv4-mapped IPv6 addresses are not treated as equal
 235   // to the equivalent IPv4 address
 236   SocketAddress v4("10.0.0.3", 99);
 237   SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
 238   SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
 239   EXPECT_NE(v4, v6_mapped1);
 240   EXPECT_NE(v4, v6_mapped2);
 241   EXPECT_EQ(v6_mapped1, v6_mapped2);
 242
 243   // However, after calling convertToIPv4(), the mapped address should now be
 244   // equal to the v4 version.
 245   EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
 246   v6_mapped1.convertToIPv4();
 247   EXPECT_EQ(v6_mapped1, v4);
 248   EXPECT_NE(v6_mapped1, v6_mapped2);
 249
 250   // Unix
 251   SocketAddress unix1;
 252   unix1.setFromPath("/foo");
 253   SocketAddress unix2;
 254   unix2.setFromPath("/foo");
 255   SocketAddress unix3;
 256   unix3.setFromPath("/bar");
 257   SocketAddress unixAnon;
 258   unixAnon.setFromPath("");
 259
 260   EXPECT_EQ(unix1, unix2);
 261   EXPECT_EQ(unix1.hash(), unix2.hash());
 262   EXPECT_NE(unix1, unix3);
 263   EXPECT_NE(unix1, unixAnon);
 264   EXPECT_NE(unix2, unix3);
 265   EXPECT_NE(unix2, unixAnon);
 266   // anonymous addresses aren't equal to any other address,
 267   // including themselves
 268   EXPECT_NE(unixAnon, unixAnon);
 269
 270   // It isn't strictly required that hashes for different addresses be
 271   // different, but we should have very few collisions.  It generally indicates
 272   // a problem if these collide
 273   EXPECT_NE(unix1.hash(), unix3.hash());
 274   EXPECT_NE(unix1.hash(), unixAnon.hash());
 275   EXPECT_NE(unix3.hash(), unixAnon.hash());
 276 }
 277
 278 TEST(SocketAddress, IsPrivate) {
 279   // IPv4
 280   SocketAddress addr("9.255.255.255", 0);
 281   EXPECT_TRUE(!addr.isPrivateAddress());
 282   addr.setFromIpPort("10.0.0.0", 0);
 283   EXPECT_TRUE(addr.isPrivateAddress());
 284   addr.setFromIpPort("10.255.255.255", 0);
 285   EXPECT_TRUE(addr.isPrivateAddress());
 286   addr.setFromIpPort("11.0.0.0", 0);
 287   EXPECT_TRUE(!addr.isPrivateAddress());
 288
 289   addr.setFromIpPort("172.15.255.255", 0);
 290   EXPECT_TRUE(!addr.isPrivateAddress());
 291   addr.setFromIpPort("172.16.0.0", 0);
 292   EXPECT_TRUE(addr.isPrivateAddress());
 293   addr.setFromIpPort("172.31.255.255", 0);
 294   EXPECT_TRUE(addr.isPrivateAddress());
 295   addr.setFromIpPort("172.32.0.0", 0);
 296   EXPECT_TRUE(!addr.isPrivateAddress());
 297
 298   addr.setFromIpPort("192.167.255.255", 0);
 299   EXPECT_TRUE(!addr.isPrivateAddress());
 300   addr.setFromIpPort("192.168.0.0", 0);
 301   EXPECT_TRUE(addr.isPrivateAddress());
 302   addr.setFromIpPort("192.168.255.255", 0);
 303   EXPECT_TRUE(addr.isPrivateAddress());
 304   addr.setFromIpPort("192.169.0.0", 0);
 305   EXPECT_TRUE(!addr.isPrivateAddress());
 306
 307   addr.setFromIpPort("126.255.255.255", 0);
 308   EXPECT_TRUE(!addr.isPrivateAddress());
 309   addr.setFromIpPort("127.0.0.0", 0);
 310   EXPECT_TRUE(addr.isPrivateAddress());
 311   addr.setFromIpPort("127.0.0.1", 0);
 312   EXPECT_TRUE(addr.isPrivateAddress());
 313   addr.setFromIpPort("127.255.255.255", 0);
 314   EXPECT_TRUE(addr.isPrivateAddress());
 315   addr.setFromIpPort("128.0.0.0", 0);
 316   EXPECT_TRUE(!addr.isPrivateAddress());
 317
 318   addr.setFromIpPort("1.2.3.4", 0);
 319   EXPECT_TRUE(!addr.isPrivateAddress());
 320   addr.setFromIpPort("69.171.239.10", 0);
 321   EXPECT_TRUE(!addr.isPrivateAddress());
 322
 323   // IPv6
 324   addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
 325   EXPECT_TRUE(!addr.isPrivateAddress());
 326   addr.setFromIpPort("fc00::", 0);
 327   EXPECT_TRUE(addr.isPrivateAddress());
 328   addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
 329   EXPECT_TRUE(addr.isPrivateAddress());
 330   addr.setFromIpPort("fe00::", 0);
 331   EXPECT_TRUE(!addr.isPrivateAddress());
 332
 333   addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
 334   EXPECT_TRUE(!addr.isPrivateAddress());
 335   addr.setFromIpPort("fe80::", 0);
 336   EXPECT_TRUE(addr.isPrivateAddress());
 337   addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
 338   EXPECT_TRUE(addr.isPrivateAddress());
 339   addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
 340   EXPECT_TRUE(addr.isPrivateAddress());
 341   addr.setFromIpPort("fec0::", 0);
 342   EXPECT_TRUE(!addr.isPrivateAddress());
 343
 344   addr.setFromIpPort("::0", 0);
 345   EXPECT_TRUE(!addr.isPrivateAddress());
 346   addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
 347   EXPECT_TRUE(!addr.isPrivateAddress());
 348
 349   // IPv4-mapped IPv6
 350   addr.setFromIpPort("::ffff:127.0.0.1", 0);
 351   EXPECT_TRUE(addr.isPrivateAddress());
 352   addr.setFromIpPort("::ffff:10.1.2.3", 0);
 353   EXPECT_TRUE(addr.isPrivateAddress());
 354   addr.setFromIpPort("::ffff:172.24.0.115", 0);
 355   EXPECT_TRUE(addr.isPrivateAddress());
 356   addr.setFromIpPort("::ffff:192.168.0.1", 0);
 357   EXPECT_TRUE(addr.isPrivateAddress());
 358   addr.setFromIpPort("::ffff:69.171.239.10", 0);
 359   EXPECT_TRUE(!addr.isPrivateAddress());
 360
 361   // Unix sockets are considered private addresses
 362   addr.setFromPath("/tmp/mysock");
 363   EXPECT_TRUE(addr.isPrivateAddress());
 364 }
 365
 366 TEST(SocketAddress, IsLoopback) {
 367   // IPv4
 368   SocketAddress addr("127.0.0.1", 0);
 369   EXPECT_TRUE(addr.isLoopbackAddress());
 370   addr.setFromIpPort("127.0.0.0", 0xffff);
 371   EXPECT_TRUE(addr.isLoopbackAddress());
 372   addr.setFromIpPort("127.1.1.1", 0xffff);
 373   EXPECT_TRUE(addr.isLoopbackAddress());
 374   addr.setFromIpPort("127.255.255.255", 80);
 375   EXPECT_TRUE(addr.isLoopbackAddress());
 376
 377   addr.setFromIpPort("128.0.0.0", 0);
 378   EXPECT_TRUE(!addr.isLoopbackAddress());
 379   addr.setFromIpPort("126.255.255.255", 0);
 380   EXPECT_TRUE(!addr.isLoopbackAddress());
 381   addr.setFromIpPort("10.1.2.3", 0);
 382   EXPECT_TRUE(!addr.isLoopbackAddress());
 383
 384   // IPv6
 385   addr.setFromIpPort("::1", 0);
 386   EXPECT_TRUE(addr.isLoopbackAddress());
 387   addr.setFromIpPort("::0", 0);
 388   EXPECT_TRUE(!addr.isLoopbackAddress());
 389   addr.setFromIpPort("::2", 0);
 390   EXPECT_TRUE(!addr.isLoopbackAddress());
 391
 392   // IPv4-mapped IPv6
 393   addr.setFromIpPort("::ffff:127.0.0.1", 0);
 394   EXPECT_TRUE(addr.isLoopbackAddress());
 395   addr.setFromIpPort("::ffff:7f0a:141e", 0);
 396   EXPECT_TRUE(addr.isLoopbackAddress());
 397   addr.setFromIpPort("::ffff:169.254.0.13", 0);
 398   EXPECT_TRUE(!addr.isLoopbackAddress());
 399
 400   // Unix sockets are considered loopback addresses
 401   addr.setFromPath("/tmp/mysock");
 402   EXPECT_TRUE(addr.isLoopbackAddress());
 403 }
 404
 405 void CheckPrefixMatch(const SocketAddress& first,
 406     const SocketAddress& second, unsigned matchingPrefixLen) {
 407   unsigned i;
 408   for (i = 0; i <= matchingPrefixLen; i++) {
 409     EXPECT_TRUE(first.prefixMatch(second, i));
 410   }
 411   unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
 412   for (; i <= addrLen; i++) {
 413     EXPECT_TRUE(!first.prefixMatch(second, i));
 414   }
 415 }
 416
 417 TEST(SocketAddress, PrefixMatch) {
 418   // IPv4
 419   SocketAddress addr1("127.0.0.1", 0);
 420   SocketAddress addr2("127.0.0.1", 0);
 421   CheckPrefixMatch(addr1, addr2, 32);
 422
 423   addr2.setFromIpPort("127.0.1.1", 0);
 424   CheckPrefixMatch(addr1, addr2, 23);
 425
 426   addr2.setFromIpPort("1.1.0.127", 0);
 427   CheckPrefixMatch(addr1, addr2, 1);
 428
 429   // Address family mismatch
 430   addr2.setFromIpPort("::ffff:127.0.0.1", 0);
 431   EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
 432
 433   // IPv6
 434   addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
 435   CheckPrefixMatch(addr1, addr2, 2);
 436
 437   addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
 438   CheckPrefixMatch(addr1, addr2, 128);
 439
 440   addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
 441   CheckPrefixMatch(addr1, addr2, 42);
 442 }
 443
 444 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
 445   EXPECT_TRUE(!(first < first));
 446   EXPECT_TRUE(!(second < second));
 447   EXPECT_TRUE(first < second);
 448   EXPECT_TRUE(!(first == second));
 449   EXPECT_TRUE(!(second < first));
 450 }
 451
 452 TEST(SocketAddress, CheckComparatorBehavior) {
 453   SocketAddress first, second;
 454   // The following comparison are strict (so if first and second were
 455   // inverted that is ok.
 456
 457   //IP V4
 458
 459   // port comparisions
 460   first.setFromIpPort("128.0.0.0", 0);
 461   second.setFromIpPort("128.0.0.0", 0xFFFF);
 462   CheckFirstLessThanSecond(first, second);
 463   first.setFromIpPort("128.0.0.100", 0);
 464   second.setFromIpPort("128.0.0.0", 0xFFFF);
 465   CheckFirstLessThanSecond(first, second);
 466
 467   // Address comparisons
 468   first.setFromIpPort("128.0.0.0", 10);
 469   second.setFromIpPort("128.0.0.100", 10);
 470   CheckFirstLessThanSecond(first, second);
 471
 472   // Comaprision between IPV4 and IPV6
 473   first.setFromIpPort("128.0.0.0", 0);
 474   second.setFromIpPort("::ffff:127.0.0.1", 0);
 475   CheckFirstLessThanSecond(first, second);
 476   first.setFromIpPort("128.0.0.0", 100);
 477   second.setFromIpPort("::ffff:127.0.0.1", 0);
 478   CheckFirstLessThanSecond(first, second);
 479
 480   // IPV6 comparisons
 481
 482   // port comparisions
 483   first.setFromIpPort("::0", 0);
 484   second.setFromIpPort("::0", 0xFFFF);
 485   CheckFirstLessThanSecond(first, second);
 486   first.setFromIpPort("::0", 0);
 487   second.setFromIpPort("::1", 0xFFFF);
 488   CheckFirstLessThanSecond(first, second);
 489
 490   // Address comparisons
 491   first.setFromIpPort("::0", 10);
 492   second.setFromIpPort("::1", 10);
 493   CheckFirstLessThanSecond(first, second);
 494
 495   // Unix
 496   first.setFromPath("/foo");
 497   second.setFromPath("/1234");
 498   // The exact comparison order doesn't really matter, as long as
 499   // (a < b), (b < a), and (a == b) are consistent.
 500   // This checks our current comparison rules, which checks the path length
 501   // before the path contents.
 502   CheckFirstLessThanSecond(first, second);
 503   first.setFromPath("/1234");
 504   second.setFromPath("/5678");
 505   CheckFirstLessThanSecond(first, second);
 506
 507   // IPv4 vs Unix.
 508   // We currently compare the address family values, and AF_UNIX < AF_INET
 509   first.setFromPath("/foo");
 510   second.setFromIpPort("127.0.0.1", 80);
 511   CheckFirstLessThanSecond(first, second);
 512 }
 513
 514 TEST(SocketAddress, Unix) {
 515   SocketAddress addr;
 516
 517   // Test a small path
 518   addr.setFromPath("foo");
 519   EXPECT_EQ(addr.getFamily(), AF_UNIX);
 520   EXPECT_EQ(addr.describe(), "foo");
 521   EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
 522   EXPECT_THROW(addr.getPort(), std::invalid_argument);
 523   EXPECT_TRUE(addr.isPrivateAddress());
 524   EXPECT_TRUE(addr.isLoopbackAddress());
 525
 526   // Test a path that is too large
 527   const char longPath[] =
 528     "abcdefghijklmnopqrstuvwxyz0123456789"
 529     "abcdefghijklmnopqrstuvwxyz0123456789"
 530     "abcdefghijklmnopqrstuvwxyz0123456789"
 531     "abcdefghijklmnopqrstuvwxyz0123456789";
 532   EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
 533   // The original address should still be the same
 534   EXPECT_EQ(addr.getFamily(), AF_UNIX);
 535   EXPECT_EQ(addr.describe(), "foo");
 536
 537   // Test a path that exactly fits in sockaddr_un
 538   // (not including the NUL terminator)
 539   const char exactLengthPath[] =
 540     "abcdefghijklmnopqrstuvwxyz0123456789"
 541     "abcdefghijklmnopqrstuvwxyz0123456789"
 542     "abcdefghijklmnopqrstuvwxyz0123456789";
 543   addr.setFromPath(exactLengthPath);
 544   EXPECT_EQ(addr.describe(), exactLengthPath);
 545
 546   // Test converting a unix socket address to an IPv4 one, then back
 547   addr.setFromHostPort("127.0.0.1", 1234);
 548   EXPECT_EQ(addr.getFamily(), AF_INET);
 549   EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
 550   addr.setFromPath("/i/am/a/unix/address");
 551   EXPECT_EQ(addr.getFamily(), AF_UNIX);
 552   EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
 553
 554   // Test copy constructor and assignment operator
 555   {
 556     SocketAddress copy(addr);
 557     EXPECT_EQ(copy, addr);
 558     copy.setFromPath("/abc");
 559     EXPECT_NE(copy, addr);
 560     copy = addr;
 561     EXPECT_EQ(copy, addr);
 562     copy.setFromIpPort("127.0.0.1", 80);
 563     EXPECT_NE(copy, addr);
 564     copy = addr;
 565     EXPECT_EQ(copy, addr);
 566   }
 567
 568   {
 569     SocketAddress copy(addr);
 570     EXPECT_EQ(copy, addr);
 571     EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
 572     EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
 573
 574     SocketAddress other("127.0.0.1", 80);
 575     EXPECT_NE(other, addr);
 576     other = copy;
 577     EXPECT_EQ(other, copy);
 578     EXPECT_EQ(other, addr);
 579     EXPECT_EQ(copy, addr);
 580   }
 581
 582 #if __GXX_EXPERIMENTAL_CXX0X__
 583   {
 584     SocketAddress copy;
 585     {
 586       // move a unix address into a non-unix address
 587       SocketAddress tmpCopy(addr);
 588       copy = std::move(tmpCopy);
 589     }
 590     EXPECT_EQ(copy, addr);
 591
 592     copy.setFromPath("/another/path");
 593     {
 594       // move a unix address into a unix address
 595       SocketAddress tmpCopy(addr);
 596       copy = std::move(tmpCopy);
 597     }
 598     EXPECT_EQ(copy, addr);
 599
 600     {
 601       // move a non-unix address into a unix address
 602       SocketAddress tmp("127.0.0.1", 80);
 603       copy = std::move(tmp);
 604     }
 605     EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
 606     EXPECT_EQ(copy.getPort(), 80);
 607
 608     copy = addr;
 609     // move construct a unix address
 610     SocketAddress other(std::move(copy));
 611     EXPECT_EQ(other, addr);
 612     EXPECT_EQ(other.getPath(), addr.getPath());
 613   }
 614 #endif
 615 }
 616
 617 TEST(SocketAddress, AnonymousUnix) {
 618   // Create a unix socket pair, and get the addresses.
 619   int fds[2];
 620   int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
 621   EXPECT_EQ(rc, 0);
 622
 623   SocketAddress addr0;
 624   SocketAddress peer0;
 625   SocketAddress addr1;
 626   SocketAddress peer1;
 627   addr0.setFromLocalAddress(fds[0]);
 628   peer0.setFromPeerAddress(fds[0]);
 629   addr1.setFromLocalAddress(fds[1]);
 630   peer1.setFromPeerAddress(fds[1]);
 631   close(fds[0]);
 632   close(fds[1]);
 633
 634   EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
 635   EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
 636   EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
 637   EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
 638
 639   // Anonymous addresses should never compare equal
 640   EXPECT_NE(addr0, addr1);
 641   EXPECT_NE(peer0, peer1);
 642
 643   // Note that logically addr0 and peer1 are the same,
 644   // but since they are both anonymous we have no way to determine this
 645   EXPECT_NE(addr0, peer1);
 646   // We can't even tell if an anonymous address is equal to itself
 647   EXPECT_NE(addr0, addr0);
 648 }
 649
 650 #define REQUIRE_ERRNO(cond, msg) \
 651   if (!(cond)) { \
 652     int _requireErrnoCopy_ = errno; \
 653     std::ostringstream _requireMsg_; \
 654     _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
 655     ADD_FAILURE(); \
 656   }
 657
 658 void testSetFromSocket(const SocketAddress *serverBindAddr,
 659                        const SocketAddress *clientBindAddr,
 660                        SocketAddress *listenAddrRet,
 661                        SocketAddress *acceptAddrRet,
 662                        SocketAddress *serverAddrRet,
 663                        SocketAddress *serverPeerAddrRet,
 664                        SocketAddress *clientAddrRet,
 665                        SocketAddress *clientPeerAddrRet) {
 666   int listenSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
 667   REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
 668   sockaddr_storage laddr;
 669   serverBindAddr->getAddress(&laddr);
 670   socklen_t laddrLen = serverBindAddr->getActualSize();
 671   int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
 672   REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
 673   rc = listen(listenSock, 10);
 674   REQUIRE_ERRNO(rc == 0, "failed to listen");
 675
 676   listenAddrRet->setFromLocalAddress(listenSock);
 677
 678   SocketAddress listenPeerAddr;
 679   EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
 680                std::runtime_error);
 681
 682   // Note that we use the family from serverBindAddr here, since we allow
 683   // clientBindAddr to be nullptr.
 684   int clientSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
 685   REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
 686   if (clientBindAddr != nullptr) {
 687     sockaddr_storage clientAddr;
 688     clientBindAddr->getAddress(&clientAddr);
 689
 690     rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
 691               clientBindAddr->getActualSize());
 692     REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
 693   }
 694
 695   sockaddr_storage listenAddr;
 696   listenAddrRet->getAddress(&listenAddr);
 697   rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
 698                listenAddrRet->getActualSize());
 699   REQUIRE_ERRNO(rc == 0, "failed to connect");
 700
 701   sockaddr_storage acceptAddr;
 702   socklen_t acceptAddrLen = sizeof(acceptAddr);
 703   int serverSock = accept(listenSock,
 704       reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
 705   REQUIRE_ERRNO(serverSock > 0, "failed to accept");
 706   acceptAddrRet->setFromSockaddr(
 707       reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
 708
 709   serverAddrRet->setFromLocalAddress(serverSock);
 710   serverPeerAddrRet->setFromPeerAddress(serverSock);
 711   clientAddrRet->setFromLocalAddress(clientSock);
 712   clientPeerAddrRet->setFromPeerAddress(clientSock);
 713
 714   close(clientSock);
 715   close(serverSock);
 716   close(listenSock);
 717 }
 718
 719 TEST(SocketAddress, SetFromSocketIPv4) {
 720   SocketAddress serverBindAddr("0.0.0.0", 0);
 721   SocketAddress clientBindAddr("0.0.0.0", 0);
 722   SocketAddress listenAddr;
 723   SocketAddress acceptAddr;
 724   SocketAddress serverAddr;
 725   SocketAddress serverPeerAddr;
 726   SocketAddress clientAddr;
 727   SocketAddress clientPeerAddr;
 728
 729   testSetFromSocket(&serverBindAddr, &clientBindAddr,
 730                     &listenAddr, &acceptAddr,
 731                     &serverAddr, &serverPeerAddr,
 732                     &clientAddr, &clientPeerAddr);
 733
 734   // The server socket's local address should have the same port as the listen
 735   // address.  The IP will be different, since the listening socket is
 736   // listening on INADDR_ANY, but the server socket will have a concrete IP
 737   // address assigned to it.
 738   EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
 739
 740   // The client's peer address should always be the same as the server
 741   // socket's address.
 742   EXPECT_EQ(clientPeerAddr, serverAddr);
 743   // The address returned by getpeername() on the server socket should
 744   // be the same as the address returned by accept()
 745   EXPECT_EQ(serverPeerAddr, acceptAddr);
 746   EXPECT_EQ(serverPeerAddr, clientAddr);
 747   EXPECT_EQ(acceptAddr, clientAddr);
 748 }
 749
 750 /*
 751  * Note this test exercises Linux-specific Unix socket behavior
 752  */
 753 TEST(SocketAddress, SetFromSocketUnixAbstract) {
 754   // Explicitly binding to an empty path results in an abstract socket
 755   // name being picked for us automatically.
 756   SocketAddress serverBindAddr;
 757   string path(1, 0);
 758   path.append("test address");
 759   serverBindAddr.setFromPath(path);
 760   SocketAddress clientBindAddr;
 761   clientBindAddr.setFromPath("");
 762
 763   SocketAddress listenAddr;
 764   SocketAddress acceptAddr;
 765   SocketAddress serverAddr;
 766   SocketAddress serverPeerAddr;
 767   SocketAddress clientAddr;
 768   SocketAddress clientPeerAddr;
 769
 770   testSetFromSocket(&serverBindAddr, &clientBindAddr,
 771                     &listenAddr, &acceptAddr,
 772                     &serverAddr, &serverPeerAddr,
 773                     &clientAddr, &clientPeerAddr);
 774
 775   // The server socket's local address should be the same as the listen
 776   // address.
 777   EXPECT_EQ(serverAddr, listenAddr);
 778
 779   // The client's peer address should always be the same as the server
 780   // socket's address.
 781   EXPECT_EQ(clientPeerAddr, serverAddr);
 782
 783   EXPECT_EQ(serverPeerAddr, clientAddr);
 784   // Oddly, the address returned by accept() does not seem to match the address
 785   // returned by getpeername() on the server socket or getsockname() on the
 786   // client socket.
 787   // EXPECT_EQ(serverPeerAddr, acceptAddr);
 788   // EXPECT_EQ(acceptAddr, clientAddr);
 789 }
 790
 791 TEST(SocketAddress, SetFromSocketUnixExplicit) {
 792   // Pick two temporary path names.
 793   // We use mkstemp() just to avoid warnings about mktemp,
 794   // but we need to remove the file to let the socket code bind to it.
 795   char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
 796   int serverPathFd = mkstemp(serverPath);
 797   EXPECT_GE(serverPathFd, 0);
 798   char clientPath[] = "/tmp/SocketAddressTest.client.XXXXXX";
 799   int clientPathFd = mkstemp(clientPath);
 800   EXPECT_GE(clientPathFd, 0);
 801
 802   int rc = unlink(serverPath);
 803   EXPECT_EQ(rc, 0);
 804   rc = unlink(clientPath);
 805   EXPECT_EQ(rc, 0);
 806
 807   SocketAddress serverBindAddr;
 808   SocketAddress clientBindAddr;
 809   SocketAddress listenAddr;
 810   SocketAddress acceptAddr;
 811   SocketAddress serverAddr;
 812   SocketAddress serverPeerAddr;
 813   SocketAddress clientAddr;
 814   SocketAddress clientPeerAddr;
 815   try {
 816     serverBindAddr.setFromPath(serverPath);
 817     clientBindAddr.setFromPath(clientPath);
 818
 819     testSetFromSocket(&serverBindAddr, &clientBindAddr,
 820                       &listenAddr, &acceptAddr,
 821                       &serverAddr, &serverPeerAddr,
 822                       &clientAddr, &clientPeerAddr);
 823   } catch (...) {
 824     // Remove the socket files after we are done
 825     unlink(serverPath);
 826     unlink(clientPath);
 827     throw;
 828   }
 829   unlink(serverPath);
 830   unlink(clientPath);
 831
 832   // The server socket's local address should be the same as the listen
 833   // address.
 834   EXPECT_EQ(serverAddr, listenAddr);
 835
 836   // The client's peer address should always be the same as the server
 837   // socket's address.
 838   EXPECT_EQ(clientPeerAddr, serverAddr);
 839
 840   EXPECT_EQ(serverPeerAddr, clientAddr);
 841   EXPECT_EQ(serverPeerAddr, acceptAddr);
 842   EXPECT_EQ(acceptAddr, clientAddr);
 843 }
 844
 845 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
 846   // Test an anonymous client talking to a fixed-path unix socket.
 847   char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
 848   int serverPathFd = mkstemp(serverPath);
 849   EXPECT_GE(serverPathFd, 0);
 850   int rc = unlink(serverPath);
 851   EXPECT_EQ(rc, 0);
 852
 853   SocketAddress serverBindAddr;
 854   SocketAddress listenAddr;
 855   SocketAddress acceptAddr;
 856   SocketAddress serverAddr;
 857   SocketAddress serverPeerAddr;
 858   SocketAddress clientAddr;
 859   SocketAddress clientPeerAddr;
 860   try {
 861     serverBindAddr.setFromPath(serverPath);
 862
 863     testSetFromSocket(&serverBindAddr, nullptr,
 864                       &listenAddr, &acceptAddr,
 865                       &serverAddr, &serverPeerAddr,
 866                       &clientAddr, &clientPeerAddr);
 867   } catch (...) {
 868     // Remove the socket file after we are done
 869     unlink(serverPath);
 870     throw;
 871   }
 872   unlink(serverPath);
 873
 874   // The server socket's local address should be the same as the listen
 875   // address.
 876   EXPECT_EQ(serverAddr, listenAddr);
 877
 878   // The client's peer address should always be the same as the server
 879   // socket's address.
 880   EXPECT_EQ(clientPeerAddr, serverAddr);
 881
 882   // Since the client is using an anonymous address, it won't compare equal to
 883   // any other anonymous addresses.  Make sure the addresses are anonymous.
 884   EXPECT_EQ(serverPeerAddr.getPath(), "");
 885   EXPECT_EQ(clientAddr.getPath(), "");
 886   EXPECT_EQ(acceptAddr.getPath(), "");
 887 }
 888
 889 TEST(SocketAddress, ResetUnixAddress) {
 890   SocketAddress addy;
 891   addy.setFromPath("/foo");
 892
 893   addy.reset();
 894   EXPECT_EQ(addy.getFamily(), AF_UNSPEC);
 895 }