2 * Copyright 2017 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include <folly/SocketAddress.h>
21 #include <system_error>
23 #include <folly/Array.h>
24 #include <folly/String.h>
25 #include <folly/experimental/TestUtil.h>
26 #include <folly/portability/GTest.h>
27 #include <folly/portability/Sockets.h>
28 #include <folly/test/SocketAddressTestHelper.h>
30 using namespace boost;
34 using folly::SocketAddress;
35 using folly::SocketAddressTestHelper;
36 using folly::test::TemporaryDirectory;
38 namespace fsp = folly::portability::sockets;
40 TEST(SocketAddress, Size) {
42 EXPECT_EQ(sizeof(addr), 32);
45 TEST(SocketAddress, ConstructFromIpv4) {
46 SocketAddress addr("1.2.3.4", 4321);
47 EXPECT_EQ(addr.getFamily(), AF_INET);
48 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
49 EXPECT_EQ(addr.getPort(), 4321);
50 sockaddr_storage addrStorage;
51 addr.getAddress(&addrStorage);
52 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
53 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x01020304));
54 EXPECT_EQ(inaddr->sin_port, htons(4321));
57 TEST(SocketAddress, StringConversion) {
58 SocketAddress addr("1.2.3.4", 4321);
59 EXPECT_EQ(addr.getFamily(), AF_INET);
60 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
62 addr.getAddressStr(buf, 2);
63 EXPECT_STREQ(buf, "1");
66 TEST(SocketAddress, IPv4ToStringConversion) {
67 // testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
69 for (int pos = 0; pos < 4; ++pos) {
70 for (int i = 0; i < 256; ++i) {
71 auto fragments = folly::make_array(5, 5, 5, 5);
73 auto ipString = folly::join(".", fragments);
74 addr.setFromIpPort(ipString, 1234);
75 EXPECT_EQ(addr.getAddressStr(), ipString);
80 TEST(SocketAddress, SetFromIpAddressPort) {
82 folly::IPAddress ipAddr("123.234.0.23");
83 addr.setFromIpAddrPort(ipAddr, 8888);
84 EXPECT_EQ(addr.getFamily(), AF_INET);
85 EXPECT_EQ(addr.getAddressStr(), "123.234.0.23");
86 EXPECT_EQ(addr.getIPAddress(), ipAddr);
87 EXPECT_EQ(addr.getPort(), 8888);
89 folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
90 SocketAddress addr6(ip6Addr, 8888);
91 EXPECT_EQ(addr6.getFamily(), AF_INET6);
92 EXPECT_EQ(addr6.getAddressStr(), "2620:0:1cfe:face:b00c::3");
93 EXPECT_EQ(addr6.getIPAddress(), ip6Addr);
94 EXPECT_EQ(addr6.getPort(), 8888);
97 TEST(SocketAddress, SetFromIpv4) {
99 addr.setFromIpPort("255.254.253.252", 8888);
100 EXPECT_EQ(addr.getFamily(), AF_INET);
101 EXPECT_EQ(addr.getAddressStr(), "255.254.253.252");
102 EXPECT_EQ(addr.getPort(), 8888);
103 sockaddr_storage addrStorage;
104 addr.getAddress(&addrStorage);
105 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
106 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0xfffefdfc));
107 EXPECT_EQ(inaddr->sin_port, htons(8888));
110 TEST(SocketAddress, ConstructFromInvalidIpv4) {
111 EXPECT_THROW(SocketAddress("1.2.3.256", 1234), std::runtime_error);
114 TEST(SocketAddress, SetFromInvalidIpv4) {
115 SocketAddress addr("12.34.56.78", 80);
117 // Try setting to an invalid value
118 // Since setFromIpPort() shouldn't allow hostname lookups, setting to
119 // "localhost" should fail, even if localhost is resolvable
120 EXPECT_THROW(addr.setFromIpPort("localhost", 1234), std::runtime_error);
122 // Make sure the address still has the old contents
123 EXPECT_EQ(addr.getFamily(), AF_INET);
124 EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
125 EXPECT_EQ(addr.getPort(), 80);
126 sockaddr_storage addrStorage;
127 addr.getAddress(&addrStorage);
128 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
129 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
132 TEST(SocketAddress, SetFromHostname) {
133 // hopefully "localhost" is resolvable on any system that will run the tests
134 EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
135 SocketAddress addr("localhost", 80, true);
138 EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
139 addr2.setFromHostPort("localhost", 0);
142 TEST(SocketAddress, SetFromStrings) {
145 // Set from a numeric port string
146 addr.setFromLocalPort("1234");
147 EXPECT_EQ(addr.getPort(), 1234);
149 // setFromLocalPort() should not accept service names
150 EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
152 // Call setFromLocalIpPort() with just a port, no IP
153 addr.setFromLocalIpPort("80");
154 EXPECT_EQ(addr.getPort(), 80);
156 // Call setFromLocalIpPort() with an IP and port.
157 if (SocketAddressTestHelper::isIPv4Enabled()) {
158 addr.setFromLocalIpPort("127.0.0.1:4321");
159 EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
160 EXPECT_EQ(addr.getPort(), 4321);
162 if (SocketAddressTestHelper::isIPv6Enabled()) {
163 addr.setFromLocalIpPort("::1:4321");
164 EXPECT_EQ(addr.getAddressStr(), "::1");
165 EXPECT_EQ(addr.getPort(), 4321);
168 // setFromIpPort() without an address should fail
169 EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
171 // Call setFromIpPort() with an IPv6 address and port
172 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
173 EXPECT_EQ(addr.getFamily(), AF_INET6);
174 EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
175 EXPECT_EQ(addr.getPort(), 65535);
177 // Call setFromIpPort() with an IPv4 address and port
178 addr.setFromIpPort("1.2.3.4:9999");
179 EXPECT_EQ(addr.getFamily(), AF_INET);
180 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
181 EXPECT_EQ(addr.getPort(), 9999);
183 // Call setFromIpPort() with a bracketed IPv6
184 addr.setFromIpPort("[::]:1234");
185 EXPECT_EQ(addr.getFamily(), AF_INET6);
186 EXPECT_EQ(addr.getAddressStr(), "::");
187 EXPECT_EQ(addr.getPort(), 1234);
189 // Call setFromIpPort() with a bracketed IPv6
190 addr.setFromIpPort("[9:8::2]:1234");
191 EXPECT_EQ(addr.getFamily(), AF_INET6);
192 EXPECT_EQ(addr.getAddressStr(), "9:8::2");
193 EXPECT_EQ(addr.getPort(), 1234);
195 // Call setFromIpPort() with a bracketed IPv6 and no port
196 EXPECT_THROW(addr.setFromIpPort("[::]"), std::system_error);
199 TEST(SocketAddress, EqualityAndHash) {
201 SocketAddress local1("127.0.0.1", 1234);
202 EXPECT_EQ(local1, local1);
203 EXPECT_EQ(local1.hash(), local1.hash());
205 SocketAddress local2("127.0.0.1", 1234);
206 EXPECT_EQ(local1, local2);
207 EXPECT_EQ(local1.hash(), local2.hash());
209 SocketAddress local3("127.0.0.1", 4321);
210 EXPECT_NE(local1, local3);
211 EXPECT_NE(local1.hash(), local3.hash());
213 SocketAddress other1("1.2.3.4", 1234);
214 EXPECT_EQ(other1, other1);
215 EXPECT_EQ(other1.hash(), other1.hash());
216 EXPECT_NE(local1, other1);
217 EXPECT_NE(local1.hash(), other1.hash());
219 SocketAddress other2("4.3.2.1", 1234);
220 EXPECT_NE(other1.hash(), other2.hash());
221 EXPECT_NE(other1.hash(), other2.hash());
223 other2.setFromIpPort("1.2.3.4", 0);
224 EXPECT_NE(other1.hash(), other2.hash());
225 EXPECT_NE(other1.hash(), other2.hash());
226 other2.setPort(1234);
227 EXPECT_EQ(other1.hash(), other2.hash());
228 EXPECT_EQ(other1.hash(), other2.hash());
231 SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
232 SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
233 SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
234 EXPECT_EQ(v6_1, v6_2);
235 EXPECT_EQ(v6_1.hash(), v6_2.hash());
236 EXPECT_NE(v6_1, v6_3);
237 EXPECT_NE(v6_1.hash(), v6_3.hash());
239 // IPv4 versus IPv6 comparison
240 SocketAddress localIPv6("::1", 1234);
241 // Even though these both refer to localhost,
242 // IPv4 and IPv6 addresses are never treated as the same address
243 EXPECT_NE(local1, localIPv6);
244 EXPECT_NE(local1.hash(), localIPv6.hash());
246 // IPv4-mapped IPv6 addresses are not treated as equal
247 // to the equivalent IPv4 address
248 SocketAddress v4("10.0.0.3", 99);
249 SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
250 SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
251 EXPECT_NE(v4, v6_mapped1);
252 EXPECT_NE(v4, v6_mapped2);
253 EXPECT_EQ(v6_mapped1, v6_mapped2);
255 // However, after calling convertToIPv4(), the mapped address should now be
256 // equal to the v4 version.
257 EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
258 v6_mapped1.convertToIPv4();
259 EXPECT_EQ(v6_mapped1, v4);
260 EXPECT_NE(v6_mapped1, v6_mapped2);
264 unix1.setFromPath("/foo");
266 unix2.setFromPath("/foo");
268 unix3.setFromPath("/bar");
269 SocketAddress unixAnon;
270 unixAnon.setFromPath("");
271 auto unix5 = SocketAddress::makeFromPath("/foo");
272 auto unixAnon2 = SocketAddress::makeFromPath("");
274 EXPECT_EQ(unix1, unix2);
275 EXPECT_EQ(unix1, unix5);
276 EXPECT_EQ(unix1.hash(), unix2.hash());
277 EXPECT_EQ(unix1.hash(), unix5.hash());
278 EXPECT_NE(unix1, unix3);
279 EXPECT_NE(unix1, unixAnon);
280 EXPECT_NE(unix1, unixAnon2);
281 EXPECT_NE(unix2, unix3);
282 EXPECT_NE(unix5, unix3);
283 EXPECT_NE(unix2, unixAnon);
284 EXPECT_NE(unix2, unixAnon2);
285 EXPECT_NE(unix5, unixAnon);
286 EXPECT_NE(unix5, unixAnon2);
287 // anonymous addresses aren't equal to any other address,
288 // including themselves
289 EXPECT_NE(unixAnon, unixAnon);
290 EXPECT_NE(unixAnon2, unixAnon2);
292 // It isn't strictly required that hashes for different addresses be
293 // different, but we should have very few collisions. It generally indicates
294 // a problem if these collide
295 EXPECT_NE(unix1.hash(), unix3.hash());
296 EXPECT_NE(unix1.hash(), unixAnon.hash());
297 EXPECT_NE(unix3.hash(), unixAnon.hash());
298 EXPECT_NE(unix1.hash(), unixAnon2.hash());
299 EXPECT_NE(unix3.hash(), unixAnon2.hash());
302 TEST(SocketAddress, IsPrivate) {
304 SocketAddress addr("9.255.255.255", 0);
305 EXPECT_TRUE(!addr.isPrivateAddress());
306 addr.setFromIpPort("10.0.0.0", 0);
307 EXPECT_TRUE(addr.isPrivateAddress());
308 addr.setFromIpPort("10.255.255.255", 0);
309 EXPECT_TRUE(addr.isPrivateAddress());
310 addr.setFromIpPort("11.0.0.0", 0);
311 EXPECT_TRUE(!addr.isPrivateAddress());
313 addr.setFromIpPort("172.15.255.255", 0);
314 EXPECT_TRUE(!addr.isPrivateAddress());
315 addr.setFromIpPort("172.16.0.0", 0);
316 EXPECT_TRUE(addr.isPrivateAddress());
317 addr.setFromIpPort("172.31.255.255", 0);
318 EXPECT_TRUE(addr.isPrivateAddress());
319 addr.setFromIpPort("172.32.0.0", 0);
320 EXPECT_TRUE(!addr.isPrivateAddress());
322 addr.setFromIpPort("192.167.255.255", 0);
323 EXPECT_TRUE(!addr.isPrivateAddress());
324 addr.setFromIpPort("192.168.0.0", 0);
325 EXPECT_TRUE(addr.isPrivateAddress());
326 addr.setFromIpPort("192.168.255.255", 0);
327 EXPECT_TRUE(addr.isPrivateAddress());
328 addr.setFromIpPort("192.169.0.0", 0);
329 EXPECT_TRUE(!addr.isPrivateAddress());
331 addr.setFromIpPort("126.255.255.255", 0);
332 EXPECT_TRUE(!addr.isPrivateAddress());
333 addr.setFromIpPort("127.0.0.0", 0);
334 EXPECT_TRUE(addr.isPrivateAddress());
335 addr.setFromIpPort("127.0.0.1", 0);
336 EXPECT_TRUE(addr.isPrivateAddress());
337 addr.setFromIpPort("127.255.255.255", 0);
338 EXPECT_TRUE(addr.isPrivateAddress());
339 addr.setFromIpPort("128.0.0.0", 0);
340 EXPECT_TRUE(!addr.isPrivateAddress());
342 addr.setFromIpPort("1.2.3.4", 0);
343 EXPECT_TRUE(!addr.isPrivateAddress());
344 addr.setFromIpPort("69.171.239.10", 0);
345 EXPECT_TRUE(!addr.isPrivateAddress());
348 addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
349 EXPECT_TRUE(!addr.isPrivateAddress());
350 addr.setFromIpPort("fc00::", 0);
351 EXPECT_TRUE(addr.isPrivateAddress());
352 addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
353 EXPECT_TRUE(addr.isPrivateAddress());
354 addr.setFromIpPort("fe00::", 0);
355 EXPECT_TRUE(!addr.isPrivateAddress());
357 addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
358 EXPECT_TRUE(!addr.isPrivateAddress());
359 addr.setFromIpPort("fe80::", 0);
360 EXPECT_TRUE(addr.isPrivateAddress());
361 addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
362 EXPECT_TRUE(addr.isPrivateAddress());
363 addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
364 EXPECT_TRUE(addr.isPrivateAddress());
365 addr.setFromIpPort("fec0::", 0);
366 EXPECT_TRUE(!addr.isPrivateAddress());
368 addr.setFromIpPort("::0", 0);
369 EXPECT_TRUE(!addr.isPrivateAddress());
370 addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
371 EXPECT_TRUE(!addr.isPrivateAddress());
374 addr.setFromIpPort("::ffff:127.0.0.1", 0);
375 EXPECT_TRUE(addr.isPrivateAddress());
376 addr.setFromIpPort("::ffff:10.1.2.3", 0);
377 EXPECT_TRUE(addr.isPrivateAddress());
378 addr.setFromIpPort("::ffff:172.24.0.115", 0);
379 EXPECT_TRUE(addr.isPrivateAddress());
380 addr.setFromIpPort("::ffff:192.168.0.1", 0);
381 EXPECT_TRUE(addr.isPrivateAddress());
382 addr.setFromIpPort("::ffff:69.171.239.10", 0);
383 EXPECT_TRUE(!addr.isPrivateAddress());
385 // Unix sockets are considered private addresses
386 addr.setFromPath("/tmp/mysock");
387 EXPECT_TRUE(addr.isPrivateAddress());
390 TEST(SocketAddress, IsLoopback) {
392 SocketAddress addr("127.0.0.1", 0);
393 EXPECT_TRUE(addr.isLoopbackAddress());
394 addr.setFromIpPort("127.0.0.0", 0xffff);
395 EXPECT_TRUE(addr.isLoopbackAddress());
396 addr.setFromIpPort("127.1.1.1", 0xffff);
397 EXPECT_TRUE(addr.isLoopbackAddress());
398 addr.setFromIpPort("127.255.255.255", 80);
399 EXPECT_TRUE(addr.isLoopbackAddress());
401 addr.setFromIpPort("128.0.0.0", 0);
402 EXPECT_TRUE(!addr.isLoopbackAddress());
403 addr.setFromIpPort("126.255.255.255", 0);
404 EXPECT_TRUE(!addr.isLoopbackAddress());
405 addr.setFromIpPort("10.1.2.3", 0);
406 EXPECT_TRUE(!addr.isLoopbackAddress());
409 addr.setFromIpPort("::1", 0);
410 EXPECT_TRUE(addr.isLoopbackAddress());
411 addr.setFromIpPort("::0", 0);
412 EXPECT_TRUE(!addr.isLoopbackAddress());
413 addr.setFromIpPort("::2", 0);
414 EXPECT_TRUE(!addr.isLoopbackAddress());
417 addr.setFromIpPort("::ffff:127.0.0.1", 0);
418 EXPECT_TRUE(addr.isLoopbackAddress());
419 addr.setFromIpPort("::ffff:7f0a:141e", 0);
420 EXPECT_TRUE(addr.isLoopbackAddress());
421 addr.setFromIpPort("::ffff:169.254.0.13", 0);
422 EXPECT_TRUE(!addr.isLoopbackAddress());
424 // Unix sockets are considered loopback addresses
425 addr.setFromPath("/tmp/mysock");
426 EXPECT_TRUE(addr.isLoopbackAddress());
429 void CheckPrefixMatch(
430 const SocketAddress& first,
431 const SocketAddress& second,
432 unsigned matchingPrefixLen) {
434 for (i = 0; i <= matchingPrefixLen; i++) {
435 EXPECT_TRUE(first.prefixMatch(second, i));
437 unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
438 for (; i <= addrLen; i++) {
439 EXPECT_TRUE(!first.prefixMatch(second, i));
443 TEST(SocketAddress, PrefixMatch) {
445 SocketAddress addr1("127.0.0.1", 0);
446 SocketAddress addr2("127.0.0.1", 0);
447 CheckPrefixMatch(addr1, addr2, 32);
449 addr2.setFromIpPort("127.0.1.1", 0);
450 CheckPrefixMatch(addr1, addr2, 23);
452 addr2.setFromIpPort("1.1.0.127", 0);
453 CheckPrefixMatch(addr1, addr2, 1);
455 // Address family mismatch
456 addr2.setFromIpPort("::ffff:127.0.0.1", 0);
457 EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
460 addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
461 CheckPrefixMatch(addr1, addr2, 2);
463 addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
464 CheckPrefixMatch(addr1, addr2, 128);
466 addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
467 CheckPrefixMatch(addr1, addr2, 42);
470 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
471 EXPECT_TRUE(!(first < first));
472 EXPECT_TRUE(!(second < second));
473 EXPECT_TRUE(first < second);
474 EXPECT_TRUE(!(first == second));
475 EXPECT_TRUE(!(second < first));
478 TEST(SocketAddress, CheckComparatorBehavior) {
479 SocketAddress first, second;
480 // The following comparison are strict (so if first and second were
481 // inverted that is ok.
486 first.setFromIpPort("128.0.0.0", 0);
487 second.setFromIpPort("128.0.0.0", 0xFFFF);
488 CheckFirstLessThanSecond(first, second);
489 first.setFromIpPort("128.0.0.100", 0);
490 second.setFromIpPort("128.0.0.0", 0xFFFF);
491 CheckFirstLessThanSecond(first, second);
493 // Address comparisons
494 first.setFromIpPort("128.0.0.0", 10);
495 second.setFromIpPort("128.0.0.100", 10);
496 CheckFirstLessThanSecond(first, second);
498 // Comaprision between IPV4 and IPV6
499 first.setFromIpPort("128.0.0.0", 0);
500 second.setFromIpPort("::ffff:127.0.0.1", 0);
501 CheckFirstLessThanSecond(first, second);
502 first.setFromIpPort("128.0.0.0", 100);
503 second.setFromIpPort("::ffff:127.0.0.1", 0);
504 CheckFirstLessThanSecond(first, second);
509 first.setFromIpPort("::0", 0);
510 second.setFromIpPort("::0", 0xFFFF);
511 CheckFirstLessThanSecond(first, second);
512 first.setFromIpPort("::0", 0);
513 second.setFromIpPort("::1", 0xFFFF);
514 CheckFirstLessThanSecond(first, second);
516 // Address comparisons
517 first.setFromIpPort("::0", 10);
518 second.setFromIpPort("::1", 10);
519 CheckFirstLessThanSecond(first, second);
522 first.setFromPath("/foo");
523 second.setFromPath("/1234");
524 // The exact comparison order doesn't really matter, as long as
525 // (a < b), (b < a), and (a == b) are consistent.
526 // This checks our current comparison rules, which checks the path length
527 // before the path contents.
528 CheckFirstLessThanSecond(first, second);
529 first.setFromPath("/1234");
530 second.setFromPath("/5678");
531 CheckFirstLessThanSecond(first, second);
534 // We currently compare the address family values, and AF_UNIX < AF_INET
535 first.setFromPath("/foo");
536 second.setFromIpPort("127.0.0.1", 80);
537 CheckFirstLessThanSecond(first, second);
540 TEST(SocketAddress, Unix) {
544 addr.setFromPath("foo");
545 EXPECT_EQ(addr.getFamily(), AF_UNIX);
546 EXPECT_EQ(addr.describe(), "foo");
547 EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
548 EXPECT_THROW(addr.getPort(), std::invalid_argument);
549 EXPECT_TRUE(addr.isPrivateAddress());
550 EXPECT_TRUE(addr.isLoopbackAddress());
552 // Test a path that is too large
553 const char longPath[] =
554 "abcdefghijklmnopqrstuvwxyz0123456789"
555 "abcdefghijklmnopqrstuvwxyz0123456789"
556 "abcdefghijklmnopqrstuvwxyz0123456789"
557 "abcdefghijklmnopqrstuvwxyz0123456789";
558 EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
559 // The original address should still be the same
560 EXPECT_EQ(addr.getFamily(), AF_UNIX);
561 EXPECT_EQ(addr.describe(), "foo");
563 // Test a path that exactly fits in sockaddr_un
564 // (not including the NUL terminator)
565 const char exactLengthPath[] =
566 "abcdefghijklmnopqrstuvwxyz0123456789"
567 "abcdefghijklmnopqrstuvwxyz0123456789"
568 "abcdefghijklmnopqrstuvwxyz0123456789";
569 addr.setFromPath(exactLengthPath);
570 EXPECT_EQ(addr.describe(), exactLengthPath);
572 // Test converting a unix socket address to an IPv4 one, then back
573 addr.setFromHostPort("127.0.0.1", 1234);
574 EXPECT_EQ(addr.getFamily(), AF_INET);
575 EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
576 addr.setFromPath("/i/am/a/unix/address");
577 EXPECT_EQ(addr.getFamily(), AF_UNIX);
578 EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
580 // Test copy constructor and assignment operator
582 SocketAddress copy(addr);
583 EXPECT_EQ(copy, addr);
584 copy.setFromPath("/abc");
585 EXPECT_NE(copy, addr);
587 EXPECT_EQ(copy, addr);
588 copy.setFromIpPort("127.0.0.1", 80);
589 EXPECT_NE(copy, addr);
591 EXPECT_EQ(copy, addr);
595 SocketAddress copy(addr);
596 EXPECT_EQ(copy, addr);
597 EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
598 EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
600 SocketAddress other("127.0.0.1", 80);
601 EXPECT_NE(other, addr);
603 EXPECT_EQ(other, copy);
604 EXPECT_EQ(other, addr);
605 EXPECT_EQ(copy, addr);
608 #if __GXX_EXPERIMENTAL_CXX0X__
612 // move a unix address into a non-unix address
613 SocketAddress tmpCopy(addr);
614 copy = std::move(tmpCopy);
616 EXPECT_EQ(copy, addr);
618 copy.setFromPath("/another/path");
620 // move a unix address into a unix address
621 SocketAddress tmpCopy(addr);
622 copy = std::move(tmpCopy);
624 EXPECT_EQ(copy, addr);
627 // move a non-unix address into a unix address
628 SocketAddress tmp("127.0.0.1", 80);
629 copy = std::move(tmp);
631 EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
632 EXPECT_EQ(copy.getPort(), 80);
635 // move construct a unix address
636 SocketAddress other(std::move(copy));
637 EXPECT_EQ(other, addr);
638 EXPECT_EQ(other.getPath(), addr.getPath());
643 TEST(SocketAddress, AnonymousUnix) {
644 // Create a unix socket pair, and get the addresses.
646 int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
653 addr0.setFromLocalAddress(fds[0]);
654 peer0.setFromPeerAddress(fds[0]);
655 addr1.setFromLocalAddress(fds[1]);
656 peer1.setFromPeerAddress(fds[1]);
660 EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
661 EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
662 EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
663 EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
665 // Anonymous addresses should never compare equal
666 EXPECT_NE(addr0, addr1);
667 EXPECT_NE(peer0, peer1);
669 // Note that logically addr0 and peer1 are the same,
670 // but since they are both anonymous we have no way to determine this
671 EXPECT_NE(addr0, peer1);
672 // We can't even tell if an anonymous address is equal to itself
673 EXPECT_NE(addr0, addr0);
676 #define REQUIRE_ERRNO(cond, msg) \
678 int _requireErrnoCopy_ = errno; \
679 std::ostringstream _requireMsg_; \
680 _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
684 void testSetFromSocket(
685 const SocketAddress* serverBindAddr,
686 const SocketAddress* clientBindAddr,
687 SocketAddress* listenAddrRet,
688 SocketAddress* acceptAddrRet,
689 SocketAddress* serverAddrRet,
690 SocketAddress* serverPeerAddrRet,
691 SocketAddress* clientAddrRet,
692 SocketAddress* clientPeerAddrRet) {
693 int listenSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
694 REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
695 sockaddr_storage laddr;
696 serverBindAddr->getAddress(&laddr);
697 socklen_t laddrLen = serverBindAddr->getActualSize();
698 int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
699 REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
700 rc = listen(listenSock, 10);
701 REQUIRE_ERRNO(rc == 0, "failed to listen");
703 listenAddrRet->setFromLocalAddress(listenSock);
705 SocketAddress listenPeerAddr;
707 listenPeerAddr.setFromPeerAddress(listenSock), std::runtime_error);
709 // Note that we use the family from serverBindAddr here, since we allow
710 // clientBindAddr to be nullptr.
711 int clientSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
712 REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
713 if (clientBindAddr != nullptr) {
714 sockaddr_storage clientAddr;
715 clientBindAddr->getAddress(&clientAddr);
719 reinterpret_cast<sockaddr*>(&clientAddr),
720 clientBindAddr->getActualSize());
721 REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
724 sockaddr_storage listenAddr;
725 listenAddrRet->getAddress(&listenAddr);
728 reinterpret_cast<sockaddr*>(&listenAddr),
729 listenAddrRet->getActualSize());
730 REQUIRE_ERRNO(rc == 0, "failed to connect");
732 sockaddr_storage acceptAddr;
733 socklen_t acceptAddrLen = sizeof(acceptAddr);
734 int serverSock = accept(
735 listenSock, reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
736 REQUIRE_ERRNO(serverSock > 0, "failed to accept");
737 acceptAddrRet->setFromSockaddr(
738 reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
740 serverAddrRet->setFromLocalAddress(serverSock);
741 serverPeerAddrRet->setFromPeerAddress(serverSock);
742 clientAddrRet->setFromLocalAddress(clientSock);
743 clientPeerAddrRet->setFromPeerAddress(clientSock);
750 TEST(SocketAddress, SetFromSocketIPv4) {
751 SocketAddress serverBindAddr("0.0.0.0", 0);
752 SocketAddress clientBindAddr("0.0.0.0", 0);
753 SocketAddress listenAddr;
754 SocketAddress acceptAddr;
755 SocketAddress serverAddr;
756 SocketAddress serverPeerAddr;
757 SocketAddress clientAddr;
758 SocketAddress clientPeerAddr;
770 // The server socket's local address should have the same port as the listen
771 // address. The IP will be different, since the listening socket is
772 // listening on INADDR_ANY, but the server socket will have a concrete IP
773 // address assigned to it.
774 EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
776 // The client's peer address should always be the same as the server
778 EXPECT_EQ(clientPeerAddr, serverAddr);
779 // The address returned by getpeername() on the server socket should
780 // be the same as the address returned by accept()
781 EXPECT_EQ(serverPeerAddr, acceptAddr);
782 EXPECT_EQ(serverPeerAddr, clientAddr);
783 EXPECT_EQ(acceptAddr, clientAddr);
787 * Note this test exercises Linux-specific Unix socket behavior
789 TEST(SocketAddress, SetFromSocketUnixAbstract) {
790 // Explicitly binding to an empty path results in an abstract socket
791 // name being picked for us automatically.
792 SocketAddress serverBindAddr;
794 path.append("test address");
795 serverBindAddr.setFromPath(path);
796 SocketAddress clientBindAddr;
797 clientBindAddr.setFromPath("");
799 SocketAddress listenAddr;
800 SocketAddress acceptAddr;
801 SocketAddress serverAddr;
802 SocketAddress serverPeerAddr;
803 SocketAddress clientAddr;
804 SocketAddress clientPeerAddr;
816 // The server socket's local address should be the same as the listen
818 EXPECT_EQ(serverAddr, listenAddr);
820 // The client's peer address should always be the same as the server
822 EXPECT_EQ(clientPeerAddr, serverAddr);
824 EXPECT_EQ(serverPeerAddr, clientAddr);
825 // Oddly, the address returned by accept() does not seem to match the address
826 // returned by getpeername() on the server socket or getsockname() on the
828 // EXPECT_EQ(serverPeerAddr, acceptAddr);
829 // EXPECT_EQ(acceptAddr, clientAddr);
832 TEST(SocketAddress, SetFromSocketUnixExplicit) {
833 // Pick two temporary path names.
834 TemporaryDirectory tempDirectory("SocketAddressTest");
835 std::string serverPath = (tempDirectory.path() / "server").string();
836 std::string clientPath = (tempDirectory.path() / "client").string();
838 SocketAddress serverBindAddr;
839 SocketAddress clientBindAddr;
840 SocketAddress listenAddr;
841 SocketAddress acceptAddr;
842 SocketAddress serverAddr;
843 SocketAddress serverPeerAddr;
844 SocketAddress clientAddr;
845 SocketAddress clientPeerAddr;
847 serverBindAddr.setFromPath(serverPath.c_str());
848 clientBindAddr.setFromPath(clientPath.c_str());
860 // Remove the socket files after we are done
861 unlink(serverPath.c_str());
862 unlink(clientPath.c_str());
865 unlink(serverPath.c_str());
866 unlink(clientPath.c_str());
868 // The server socket's local address should be the same as the listen
870 EXPECT_EQ(serverAddr, listenAddr);
872 // The client's peer address should always be the same as the server
874 EXPECT_EQ(clientPeerAddr, serverAddr);
876 EXPECT_EQ(serverPeerAddr, clientAddr);
877 EXPECT_EQ(serverPeerAddr, acceptAddr);
878 EXPECT_EQ(acceptAddr, clientAddr);
881 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
882 // Test an anonymous client talking to a fixed-path unix socket.
883 TemporaryDirectory tempDirectory("SocketAddressTest");
884 std::string serverPath = (tempDirectory.path() / "server").string();
886 SocketAddress serverBindAddr;
887 SocketAddress listenAddr;
888 SocketAddress acceptAddr;
889 SocketAddress serverAddr;
890 SocketAddress serverPeerAddr;
891 SocketAddress clientAddr;
892 SocketAddress clientPeerAddr;
894 serverBindAddr.setFromPath(serverPath.c_str());
906 // Remove the socket file after we are done
907 unlink(serverPath.c_str());
910 unlink(serverPath.c_str());
912 // The server socket's local address should be the same as the listen
914 EXPECT_EQ(serverAddr, listenAddr);
916 // The client's peer address should always be the same as the server
918 EXPECT_EQ(clientPeerAddr, serverAddr);
920 // Since the client is using an anonymous address, it won't compare equal to
921 // any other anonymous addresses. Make sure the addresses are anonymous.
922 EXPECT_EQ(serverPeerAddr.getPath(), "");
923 EXPECT_EQ(clientAddr.getPath(), "");
924 EXPECT_EQ(acceptAddr.getPath(), "");
927 TEST(SocketAddress, ResetUnixAddress) {
929 addy.setFromPath("/foo");
932 EXPECT_EQ(addy.getFamily(), AF_UNSPEC);
935 TEST(SocketAddress, ResetIPAddress) {
937 addr.setFromIpPort("127.0.0.1", 80);
939 EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
940 EXPECT_FALSE(addr.isInitialized());
941 EXPECT_TRUE(addr.empty());
943 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
945 EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
946 EXPECT_FALSE(addr.isInitialized());
947 EXPECT_TRUE(addr.empty());
950 TEST(SocketAddress, ValidFamilyInet) {
952 EXPECT_FALSE(addr.isFamilyInet());
953 folly::IPAddress ipAddr("123.234.0.23");
954 addr.setFromIpAddrPort(ipAddr, 8888);
955 EXPECT_TRUE(addr.isFamilyInet());
957 folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
958 SocketAddress addr6(ip6Addr, 8888);
959 EXPECT_TRUE(addr6.isFamilyInet());