folly/test/SocketAddressTest.cpp

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