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