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