folly/test/SocketAddressTest.cpp

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