folly/test/SocketAddressTest.cpp

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