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/Array.h>
  24 #include <folly/String.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
 272   EXPECT_EQ(unix1, unix2);
 273   EXPECT_EQ(unix1.hash(), unix2.hash());
 274   EXPECT_NE(unix1, unix3);
 275   EXPECT_NE(unix1, unixAnon);
 276   EXPECT_NE(unix2, unix3);
 277   EXPECT_NE(unix2, unixAnon);
 278   // anonymous addresses aren't equal to any other address,
 279   // including themselves
 280   EXPECT_NE(unixAnon, unixAnon);
 281
 282   // It isn't strictly required that hashes for different addresses be
 283   // different, but we should have very few collisions.  It generally indicates
 284   // a problem if these collide
 285   EXPECT_NE(unix1.hash(), unix3.hash());
 286   EXPECT_NE(unix1.hash(), unixAnon.hash());
 287   EXPECT_NE(unix3.hash(), unixAnon.hash());
 288 }
 289
 290 TEST(SocketAddress, IsPrivate) {
 291   // IPv4
 292   SocketAddress addr("9.255.255.255", 0);
 293   EXPECT_TRUE(!addr.isPrivateAddress());
 294   addr.setFromIpPort("10.0.0.0", 0);
 295   EXPECT_TRUE(addr.isPrivateAddress());
 296   addr.setFromIpPort("10.255.255.255", 0);
 297   EXPECT_TRUE(addr.isPrivateAddress());
 298   addr.setFromIpPort("11.0.0.0", 0);
 299   EXPECT_TRUE(!addr.isPrivateAddress());
 300
 301   addr.setFromIpPort("172.15.255.255", 0);
 302   EXPECT_TRUE(!addr.isPrivateAddress());
 303   addr.setFromIpPort("172.16.0.0", 0);
 304   EXPECT_TRUE(addr.isPrivateAddress());
 305   addr.setFromIpPort("172.31.255.255", 0);
 306   EXPECT_TRUE(addr.isPrivateAddress());
 307   addr.setFromIpPort("172.32.0.0", 0);
 308   EXPECT_TRUE(!addr.isPrivateAddress());
 309
 310   addr.setFromIpPort("192.167.255.255", 0);
 311   EXPECT_TRUE(!addr.isPrivateAddress());
 312   addr.setFromIpPort("192.168.0.0", 0);
 313   EXPECT_TRUE(addr.isPrivateAddress());
 314   addr.setFromIpPort("192.168.255.255", 0);
 315   EXPECT_TRUE(addr.isPrivateAddress());
 316   addr.setFromIpPort("192.169.0.0", 0);
 317   EXPECT_TRUE(!addr.isPrivateAddress());
 318
 319   addr.setFromIpPort("126.255.255.255", 0);
 320   EXPECT_TRUE(!addr.isPrivateAddress());
 321   addr.setFromIpPort("127.0.0.0", 0);
 322   EXPECT_TRUE(addr.isPrivateAddress());
 323   addr.setFromIpPort("127.0.0.1", 0);
 324   EXPECT_TRUE(addr.isPrivateAddress());
 325   addr.setFromIpPort("127.255.255.255", 0);
 326   EXPECT_TRUE(addr.isPrivateAddress());
 327   addr.setFromIpPort("128.0.0.0", 0);
 328   EXPECT_TRUE(!addr.isPrivateAddress());
 329
 330   addr.setFromIpPort("1.2.3.4", 0);
 331   EXPECT_TRUE(!addr.isPrivateAddress());
 332   addr.setFromIpPort("69.171.239.10", 0);
 333   EXPECT_TRUE(!addr.isPrivateAddress());
 334
 335   // IPv6
 336   addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
 337   EXPECT_TRUE(!addr.isPrivateAddress());
 338   addr.setFromIpPort("fc00::", 0);
 339   EXPECT_TRUE(addr.isPrivateAddress());
 340   addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
 341   EXPECT_TRUE(addr.isPrivateAddress());
 342   addr.setFromIpPort("fe00::", 0);
 343   EXPECT_TRUE(!addr.isPrivateAddress());
 344
 345   addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
 346   EXPECT_TRUE(!addr.isPrivateAddress());
 347   addr.setFromIpPort("fe80::", 0);
 348   EXPECT_TRUE(addr.isPrivateAddress());
 349   addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
 350   EXPECT_TRUE(addr.isPrivateAddress());
 351   addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
 352   EXPECT_TRUE(addr.isPrivateAddress());
 353   addr.setFromIpPort("fec0::", 0);
 354   EXPECT_TRUE(!addr.isPrivateAddress());
 355
 356   addr.setFromIpPort("::0", 0);
 357   EXPECT_TRUE(!addr.isPrivateAddress());
 358   addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
 359   EXPECT_TRUE(!addr.isPrivateAddress());
 360
 361   // IPv4-mapped IPv6
 362   addr.setFromIpPort("::ffff:127.0.0.1", 0);
 363   EXPECT_TRUE(addr.isPrivateAddress());
 364   addr.setFromIpPort("::ffff:10.1.2.3", 0);
 365   EXPECT_TRUE(addr.isPrivateAddress());
 366   addr.setFromIpPort("::ffff:172.24.0.115", 0);
 367   EXPECT_TRUE(addr.isPrivateAddress());
 368   addr.setFromIpPort("::ffff:192.168.0.1", 0);
 369   EXPECT_TRUE(addr.isPrivateAddress());
 370   addr.setFromIpPort("::ffff:69.171.239.10", 0);
 371   EXPECT_TRUE(!addr.isPrivateAddress());
 372
 373   // Unix sockets are considered private addresses
 374   addr.setFromPath("/tmp/mysock");
 375   EXPECT_TRUE(addr.isPrivateAddress());
 376 }
 377
 378 TEST(SocketAddress, IsLoopback) {
 379   // IPv4
 380   SocketAddress addr("127.0.0.1", 0);
 381   EXPECT_TRUE(addr.isLoopbackAddress());
 382   addr.setFromIpPort("127.0.0.0", 0xffff);
 383   EXPECT_TRUE(addr.isLoopbackAddress());
 384   addr.setFromIpPort("127.1.1.1", 0xffff);
 385   EXPECT_TRUE(addr.isLoopbackAddress());
 386   addr.setFromIpPort("127.255.255.255", 80);
 387   EXPECT_TRUE(addr.isLoopbackAddress());
 388
 389   addr.setFromIpPort("128.0.0.0", 0);
 390   EXPECT_TRUE(!addr.isLoopbackAddress());
 391   addr.setFromIpPort("126.255.255.255", 0);
 392   EXPECT_TRUE(!addr.isLoopbackAddress());
 393   addr.setFromIpPort("10.1.2.3", 0);
 394   EXPECT_TRUE(!addr.isLoopbackAddress());
 395
 396   // IPv6
 397   addr.setFromIpPort("::1", 0);
 398   EXPECT_TRUE(addr.isLoopbackAddress());
 399   addr.setFromIpPort("::0", 0);
 400   EXPECT_TRUE(!addr.isLoopbackAddress());
 401   addr.setFromIpPort("::2", 0);
 402   EXPECT_TRUE(!addr.isLoopbackAddress());
 403
 404   // IPv4-mapped IPv6
 405   addr.setFromIpPort("::ffff:127.0.0.1", 0);
 406   EXPECT_TRUE(addr.isLoopbackAddress());
 407   addr.setFromIpPort("::ffff:7f0a:141e", 0);
 408   EXPECT_TRUE(addr.isLoopbackAddress());
 409   addr.setFromIpPort("::ffff:169.254.0.13", 0);
 410   EXPECT_TRUE(!addr.isLoopbackAddress());
 411
 412   // Unix sockets are considered loopback addresses
 413   addr.setFromPath("/tmp/mysock");
 414   EXPECT_TRUE(addr.isLoopbackAddress());
 415 }
 416
 417 void CheckPrefixMatch(
 418     const SocketAddress& first,
 419     const SocketAddress& second,
 420     unsigned matchingPrefixLen) {
 421   unsigned i;
 422   for (i = 0; i <= matchingPrefixLen; i++) {
 423     EXPECT_TRUE(first.prefixMatch(second, i));
 424   }
 425   unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
 426   for (; i <= addrLen; i++) {
 427     EXPECT_TRUE(!first.prefixMatch(second, i));
 428   }
 429 }
 430
 431 TEST(SocketAddress, PrefixMatch) {
 432   // IPv4
 433   SocketAddress addr1("127.0.0.1", 0);
 434   SocketAddress addr2("127.0.0.1", 0);
 435   CheckPrefixMatch(addr1, addr2, 32);
 436
 437   addr2.setFromIpPort("127.0.1.1", 0);
 438   CheckPrefixMatch(addr1, addr2, 23);
 439
 440   addr2.setFromIpPort("1.1.0.127", 0);
 441   CheckPrefixMatch(addr1, addr2, 1);
 442
 443   // Address family mismatch
 444   addr2.setFromIpPort("::ffff:127.0.0.1", 0);
 445   EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
 446
 447   // IPv6
 448   addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
 449   CheckPrefixMatch(addr1, addr2, 2);
 450
 451   addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
 452   CheckPrefixMatch(addr1, addr2, 128);
 453
 454   addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
 455   CheckPrefixMatch(addr1, addr2, 42);
 456 }
 457
 458 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
 459   EXPECT_TRUE(!(first < first));
 460   EXPECT_TRUE(!(second < second));
 461   EXPECT_TRUE(first < second);
 462   EXPECT_TRUE(!(first == second));
 463   EXPECT_TRUE(!(second < first));
 464 }
 465
 466 TEST(SocketAddress, CheckComparatorBehavior) {
 467   SocketAddress first, second;
 468   // The following comparison are strict (so if first and second were
 469   // inverted that is ok.
 470
 471   // IP V4
 472
 473   // port comparisions
 474   first.setFromIpPort("128.0.0.0", 0);
 475   second.setFromIpPort("128.0.0.0", 0xFFFF);
 476   CheckFirstLessThanSecond(first, second);
 477   first.setFromIpPort("128.0.0.100", 0);
 478   second.setFromIpPort("128.0.0.0", 0xFFFF);
 479   CheckFirstLessThanSecond(first, second);
 480
 481   // Address comparisons
 482   first.setFromIpPort("128.0.0.0", 10);
 483   second.setFromIpPort("128.0.0.100", 10);
 484   CheckFirstLessThanSecond(first, second);
 485
 486   // Comaprision between IPV4 and IPV6
 487   first.setFromIpPort("128.0.0.0", 0);
 488   second.setFromIpPort("::ffff:127.0.0.1", 0);
 489   CheckFirstLessThanSecond(first, second);
 490   first.setFromIpPort("128.0.0.0", 100);
 491   second.setFromIpPort("::ffff:127.0.0.1", 0);
 492   CheckFirstLessThanSecond(first, second);
 493
 494   // IPV6 comparisons
 495
 496   // port comparisions
 497   first.setFromIpPort("::0", 0);
 498   second.setFromIpPort("::0", 0xFFFF);
 499   CheckFirstLessThanSecond(first, second);
 500   first.setFromIpPort("::0", 0);
 501   second.setFromIpPort("::1", 0xFFFF);
 502   CheckFirstLessThanSecond(first, second);
 503
 504   // Address comparisons
 505   first.setFromIpPort("::0", 10);
 506   second.setFromIpPort("::1", 10);
 507   CheckFirstLessThanSecond(first, second);
 508
 509   // Unix
 510   first.setFromPath("/foo");
 511   second.setFromPath("/1234");
 512   // The exact comparison order doesn't really matter, as long as
 513   // (a < b), (b < a), and (a == b) are consistent.
 514   // This checks our current comparison rules, which checks the path length
 515   // before the path contents.
 516   CheckFirstLessThanSecond(first, second);
 517   first.setFromPath("/1234");
 518   second.setFromPath("/5678");
 519   CheckFirstLessThanSecond(first, second);
 520
 521   // IPv4 vs Unix.
 522   // We currently compare the address family values, and AF_UNIX < AF_INET
 523   first.setFromPath("/foo");
 524   second.setFromIpPort("127.0.0.1", 80);
 525   CheckFirstLessThanSecond(first, second);
 526 }
 527
 528 TEST(SocketAddress, Unix) {
 529   SocketAddress addr;
 530
 531   // Test a small path
 532   addr.setFromPath("foo");
 533   EXPECT_EQ(addr.getFamily(), AF_UNIX);
 534   EXPECT_EQ(addr.describe(), "foo");
 535   EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
 536   EXPECT_THROW(addr.getPort(), std::invalid_argument);
 537   EXPECT_TRUE(addr.isPrivateAddress());
 538   EXPECT_TRUE(addr.isLoopbackAddress());
 539
 540   // Test a path that is too large
 541   const char longPath[] =
 542       "abcdefghijklmnopqrstuvwxyz0123456789"
 543       "abcdefghijklmnopqrstuvwxyz0123456789"
 544       "abcdefghijklmnopqrstuvwxyz0123456789"
 545       "abcdefghijklmnopqrstuvwxyz0123456789";
 546   EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
 547   // The original address should still be the same
 548   EXPECT_EQ(addr.getFamily(), AF_UNIX);
 549   EXPECT_EQ(addr.describe(), "foo");
 550
 551   // Test a path that exactly fits in sockaddr_un
 552   // (not including the NUL terminator)
 553   const char exactLengthPath[] =
 554       "abcdefghijklmnopqrstuvwxyz0123456789"
 555       "abcdefghijklmnopqrstuvwxyz0123456789"
 556       "abcdefghijklmnopqrstuvwxyz0123456789";
 557   addr.setFromPath(exactLengthPath);
 558   EXPECT_EQ(addr.describe(), exactLengthPath);
 559
 560   // Test converting a unix socket address to an IPv4 one, then back
 561   addr.setFromHostPort("127.0.0.1", 1234);
 562   EXPECT_EQ(addr.getFamily(), AF_INET);
 563   EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
 564   addr.setFromPath("/i/am/a/unix/address");
 565   EXPECT_EQ(addr.getFamily(), AF_UNIX);
 566   EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
 567
 568   // Test copy constructor and assignment operator
 569   {
 570     SocketAddress copy(addr);
 571     EXPECT_EQ(copy, addr);
 572     copy.setFromPath("/abc");
 573     EXPECT_NE(copy, addr);
 574     copy = addr;
 575     EXPECT_EQ(copy, addr);
 576     copy.setFromIpPort("127.0.0.1", 80);
 577     EXPECT_NE(copy, addr);
 578     copy = addr;
 579     EXPECT_EQ(copy, addr);
 580   }
 581
 582   {
 583     SocketAddress copy(addr);
 584     EXPECT_EQ(copy, addr);
 585     EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
 586     EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
 587
 588     SocketAddress other("127.0.0.1", 80);
 589     EXPECT_NE(other, addr);
 590     other = copy;
 591     EXPECT_EQ(other, copy);
 592     EXPECT_EQ(other, addr);
 593     EXPECT_EQ(copy, addr);
 594   }
 595
 596 #if __GXX_EXPERIMENTAL_CXX0X__
 597   {
 598     SocketAddress copy;
 599     {
 600       // move a unix address into a non-unix address
 601       SocketAddress tmpCopy(addr);
 602       copy = std::move(tmpCopy);
 603     }
 604     EXPECT_EQ(copy, addr);
 605
 606     copy.setFromPath("/another/path");
 607     {
 608       // move a unix address into a unix address
 609       SocketAddress tmpCopy(addr);
 610       copy = std::move(tmpCopy);
 611     }
 612     EXPECT_EQ(copy, addr);
 613
 614     {
 615       // move a non-unix address into a unix address
 616       SocketAddress tmp("127.0.0.1", 80);
 617       copy = std::move(tmp);
 618     }
 619     EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
 620     EXPECT_EQ(copy.getPort(), 80);
 621
 622     copy = addr;
 623     // move construct a unix address
 624     SocketAddress other(std::move(copy));
 625     EXPECT_EQ(other, addr);
 626     EXPECT_EQ(other.getPath(), addr.getPath());
 627   }
 628 #endif
 629 }
 630
 631 TEST(SocketAddress, AnonymousUnix) {
 632   // Create a unix socket pair, and get the addresses.
 633   int fds[2];
 634   int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
 635   EXPECT_EQ(rc, 0);
 636
 637   SocketAddress addr0;
 638   SocketAddress peer0;
 639   SocketAddress addr1;
 640   SocketAddress peer1;
 641   addr0.setFromLocalAddress(fds[0]);
 642   peer0.setFromPeerAddress(fds[0]);
 643   addr1.setFromLocalAddress(fds[1]);
 644   peer1.setFromPeerAddress(fds[1]);
 645   close(fds[0]);
 646   close(fds[1]);
 647
 648   EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
 649   EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
 650   EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
 651   EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
 652
 653   // Anonymous addresses should never compare equal
 654   EXPECT_NE(addr0, addr1);
 655   EXPECT_NE(peer0, peer1);
 656
 657   // Note that logically addr0 and peer1 are the same,
 658   // but since they are both anonymous we have no way to determine this
 659   EXPECT_NE(addr0, peer1);
 660   // We can't even tell if an anonymous address is equal to itself
 661   EXPECT_NE(addr0, addr0);
 662 }
 663
 664 #define REQUIRE_ERRNO(cond, msg)                                   \
 665   if (!(cond)) {                                                   \
 666     int _requireErrnoCopy_ = errno;                                \
 667     std::ostringstream _requireMsg_;                               \
 668     _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
 669     ADD_FAILURE();                                                 \
 670   }
 671
 672 void testSetFromSocket(
 673     const SocketAddress* serverBindAddr,
 674     const SocketAddress* clientBindAddr,
 675     SocketAddress* listenAddrRet,
 676     SocketAddress* acceptAddrRet,
 677     SocketAddress* serverAddrRet,
 678     SocketAddress* serverPeerAddrRet,
 679     SocketAddress* clientAddrRet,
 680     SocketAddress* clientPeerAddrRet) {
 681   int listenSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
 682   REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
 683   sockaddr_storage laddr;
 684   serverBindAddr->getAddress(&laddr);
 685   socklen_t laddrLen = serverBindAddr->getActualSize();
 686   int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
 687   REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
 688   rc = listen(listenSock, 10);
 689   REQUIRE_ERRNO(rc == 0, "failed to listen");
 690
 691   listenAddrRet->setFromLocalAddress(listenSock);
 692
 693   SocketAddress listenPeerAddr;
 694   EXPECT_THROW(
 695       listenPeerAddr.setFromPeerAddress(listenSock), std::runtime_error);
 696
 697   // Note that we use the family from serverBindAddr here, since we allow
 698   // clientBindAddr to be nullptr.
 699   int clientSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
 700   REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
 701   if (clientBindAddr != nullptr) {
 702     sockaddr_storage clientAddr;
 703     clientBindAddr->getAddress(&clientAddr);
 704
 705     rc = bind(
 706         clientSock,
 707         reinterpret_cast<sockaddr*>(&clientAddr),
 708         clientBindAddr->getActualSize());
 709     REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
 710   }
 711
 712   sockaddr_storage listenAddr;
 713   listenAddrRet->getAddress(&listenAddr);
 714   rc = connect(
 715       clientSock,
 716       reinterpret_cast<sockaddr*>(&listenAddr),
 717       listenAddrRet->getActualSize());
 718   REQUIRE_ERRNO(rc == 0, "failed to connect");
 719
 720   sockaddr_storage acceptAddr;
 721   socklen_t acceptAddrLen = sizeof(acceptAddr);
 722   int serverSock = accept(
 723       listenSock, reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
 724   REQUIRE_ERRNO(serverSock > 0, "failed to accept");
 725   acceptAddrRet->setFromSockaddr(
 726       reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
 727
 728   serverAddrRet->setFromLocalAddress(serverSock);
 729   serverPeerAddrRet->setFromPeerAddress(serverSock);
 730   clientAddrRet->setFromLocalAddress(clientSock);
 731   clientPeerAddrRet->setFromPeerAddress(clientSock);
 732
 733   close(clientSock);
 734   close(serverSock);
 735   close(listenSock);
 736 }
 737
 738 TEST(SocketAddress, SetFromSocketIPv4) {
 739   SocketAddress serverBindAddr("0.0.0.0", 0);
 740   SocketAddress clientBindAddr("0.0.0.0", 0);
 741   SocketAddress listenAddr;
 742   SocketAddress acceptAddr;
 743   SocketAddress serverAddr;
 744   SocketAddress serverPeerAddr;
 745   SocketAddress clientAddr;
 746   SocketAddress clientPeerAddr;
 747
 748   testSetFromSocket(
 749       &serverBindAddr,
 750       &clientBindAddr,
 751       &listenAddr,
 752       &acceptAddr,
 753       &serverAddr,
 754       &serverPeerAddr,
 755       &clientAddr,
 756       &clientPeerAddr);
 757
 758   // The server socket's local address should have the same port as the listen
 759   // address.  The IP will be different, since the listening socket is
 760   // listening on INADDR_ANY, but the server socket will have a concrete IP
 761   // address assigned to it.
 762   EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
 763
 764   // The client's peer address should always be the same as the server
 765   // socket's address.
 766   EXPECT_EQ(clientPeerAddr, serverAddr);
 767   // The address returned by getpeername() on the server socket should
 768   // be the same as the address returned by accept()
 769   EXPECT_EQ(serverPeerAddr, acceptAddr);
 770   EXPECT_EQ(serverPeerAddr, clientAddr);
 771   EXPECT_EQ(acceptAddr, clientAddr);
 772 }
 773
 774 /*
 775  * Note this test exercises Linux-specific Unix socket behavior
 776  */
 777 TEST(SocketAddress, SetFromSocketUnixAbstract) {
 778   // Explicitly binding to an empty path results in an abstract socket
 779   // name being picked for us automatically.
 780   SocketAddress serverBindAddr;
 781   string path(1, 0);
 782   path.append("test address");
 783   serverBindAddr.setFromPath(path);
 784   SocketAddress clientBindAddr;
 785   clientBindAddr.setFromPath("");
 786
 787   SocketAddress listenAddr;
 788   SocketAddress acceptAddr;
 789   SocketAddress serverAddr;
 790   SocketAddress serverPeerAddr;
 791   SocketAddress clientAddr;
 792   SocketAddress clientPeerAddr;
 793
 794   testSetFromSocket(
 795       &serverBindAddr,
 796       &clientBindAddr,
 797       &listenAddr,
 798       &acceptAddr,
 799       &serverAddr,
 800       &serverPeerAddr,
 801       &clientAddr,
 802       &clientPeerAddr);
 803
 804   // The server socket's local address should be the same as the listen
 805   // address.
 806   EXPECT_EQ(serverAddr, listenAddr);
 807
 808   // The client's peer address should always be the same as the server
 809   // socket's address.
 810   EXPECT_EQ(clientPeerAddr, serverAddr);
 811
 812   EXPECT_EQ(serverPeerAddr, clientAddr);
 813   // Oddly, the address returned by accept() does not seem to match the address
 814   // returned by getpeername() on the server socket or getsockname() on the
 815   // client socket.
 816   // EXPECT_EQ(serverPeerAddr, acceptAddr);
 817   // EXPECT_EQ(acceptAddr, clientAddr);
 818 }
 819
 820 TEST(SocketAddress, SetFromSocketUnixExplicit) {
 821   // Pick two temporary path names.
 822   TemporaryDirectory tempDirectory("SocketAddressTest");
 823   std::string serverPath = (tempDirectory.path() / "server").string();
 824   std::string clientPath = (tempDirectory.path() / "client").string();
 825
 826   SocketAddress serverBindAddr;
 827   SocketAddress clientBindAddr;
 828   SocketAddress listenAddr;
 829   SocketAddress acceptAddr;
 830   SocketAddress serverAddr;
 831   SocketAddress serverPeerAddr;
 832   SocketAddress clientAddr;
 833   SocketAddress clientPeerAddr;
 834   try {
 835     serverBindAddr.setFromPath(serverPath.c_str());
 836     clientBindAddr.setFromPath(clientPath.c_str());
 837
 838     testSetFromSocket(
 839         &serverBindAddr,
 840         &clientBindAddr,
 841         &listenAddr,
 842         &acceptAddr,
 843         &serverAddr,
 844         &serverPeerAddr,
 845         &clientAddr,
 846         &clientPeerAddr);
 847   } catch (...) {
 848     // Remove the socket files after we are done
 849     unlink(serverPath.c_str());
 850     unlink(clientPath.c_str());
 851     throw;
 852   }
 853   unlink(serverPath.c_str());
 854   unlink(clientPath.c_str());
 855
 856   // The server socket's local address should be the same as the listen
 857   // address.
 858   EXPECT_EQ(serverAddr, listenAddr);
 859
 860   // The client's peer address should always be the same as the server
 861   // socket's address.
 862   EXPECT_EQ(clientPeerAddr, serverAddr);
 863
 864   EXPECT_EQ(serverPeerAddr, clientAddr);
 865   EXPECT_EQ(serverPeerAddr, acceptAddr);
 866   EXPECT_EQ(acceptAddr, clientAddr);
 867 }
 868
 869 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
 870   // Test an anonymous client talking to a fixed-path unix socket.
 871   TemporaryDirectory tempDirectory("SocketAddressTest");
 872   std::string serverPath = (tempDirectory.path() / "server").string();
 873
 874   SocketAddress serverBindAddr;
 875   SocketAddress listenAddr;
 876   SocketAddress acceptAddr;
 877   SocketAddress serverAddr;
 878   SocketAddress serverPeerAddr;
 879   SocketAddress clientAddr;
 880   SocketAddress clientPeerAddr;
 881   try {
 882     serverBindAddr.setFromPath(serverPath.c_str());
 883
 884     testSetFromSocket(
 885         &serverBindAddr,
 886         nullptr,
 887         &listenAddr,
 888         &acceptAddr,
 889         &serverAddr,
 890         &serverPeerAddr,
 891         &clientAddr,
 892         &clientPeerAddr);
 893   } catch (...) {
 894     // Remove the socket file after we are done
 895     unlink(serverPath.c_str());
 896     throw;
 897   }
 898   unlink(serverPath.c_str());
 899
 900   // The server socket's local address should be the same as the listen
 901   // address.
 902   EXPECT_EQ(serverAddr, listenAddr);
 903
 904   // The client's peer address should always be the same as the server
 905   // socket's address.
 906   EXPECT_EQ(clientPeerAddr, serverAddr);
 907
 908   // Since the client is using an anonymous address, it won't compare equal to
 909   // any other anonymous addresses.  Make sure the addresses are anonymous.
 910   EXPECT_EQ(serverPeerAddr.getPath(), "");
 911   EXPECT_EQ(clientAddr.getPath(), "");
 912   EXPECT_EQ(acceptAddr.getPath(), "");
 913 }
 914
 915 TEST(SocketAddress, ResetUnixAddress) {
 916   SocketAddress addy;
 917   addy.setFromPath("/foo");
 918
 919   addy.reset();
 920   EXPECT_EQ(addy.getFamily(), AF_UNSPEC);
 921 }
 922
 923 TEST(SocketAddress, ResetIPAddress) {
 924   SocketAddress addr;
 925   addr.setFromIpPort("127.0.0.1", 80);
 926   addr.reset();
 927   EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
 928   EXPECT_FALSE(addr.isInitialized());
 929   EXPECT_TRUE(addr.empty());
 930
 931   addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
 932   addr.reset();
 933   EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
 934   EXPECT_FALSE(addr.isInitialized());
 935   EXPECT_TRUE(addr.empty());
 936 }
 937
 938 TEST(SocketAddress, ValidFamilyInet) {
 939   SocketAddress addr;
 940   EXPECT_FALSE(addr.isFamilyInet());
 941   folly::IPAddress ipAddr("123.234.0.23");
 942   addr.setFromIpAddrPort(ipAddr, 8888);
 943   EXPECT_TRUE(addr.isFamilyInet());
 944
 945   folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
 946   SocketAddress addr6(ip6Addr, 8888);
 947   EXPECT_TRUE(addr6.isFamilyInet());
 948 }