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/experimental/TestUtil.h>
24 #include <folly/portability/GTest.h>
25 #include <folly/portability/Sockets.h>
26 #include <folly/test/SocketAddressTestHelper.h>
28 using namespace boost;
32 using folly::SocketAddress;
33 using folly::SocketAddressTestHelper;
34 using folly::test::TemporaryDirectory;
36 namespace fsp = folly::portability::sockets;
38 TEST(SocketAddress, Size) {
40 EXPECT_EQ(sizeof(addr), 32);
43 TEST(SocketAddress, ConstructFromIpv4) {
44 SocketAddress addr("1.2.3.4", 4321);
45 EXPECT_EQ(addr.getFamily(), AF_INET);
46 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
47 EXPECT_EQ(addr.getPort(), 4321);
48 sockaddr_storage addrStorage;
49 addr.getAddress(&addrStorage);
50 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
51 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x01020304));
52 EXPECT_EQ(inaddr->sin_port, htons(4321));
55 TEST(SocketAddress, StringConversion) {
56 SocketAddress addr("1.2.3.4", 4321);
57 EXPECT_EQ(addr.getFamily(), AF_INET);
58 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
60 addr.getAddressStr(buf, 2);
61 EXPECT_STREQ(buf, "1");
64 TEST(SocketAddress, IPv4ToStringConversion) {
65 // testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
67 for (int pos = 0; pos < 4; ++pos) {
68 for (int i = 0; i < 256; ++i) {
69 int fragments[] = {5,5,5,5};
71 std::ostringstream ss;
72 ss << fragments[0] << "." << fragments[1] << "."
73 << fragments[2] << "." << fragments[3];
74 string ipString = ss.str();
75 addr.setFromIpPort(ipString, 1234);
76 EXPECT_EQ(addr.getAddressStr(), ipString);
81 TEST(SocketAddress, SetFromIpAddressPort) {
83 folly::IPAddress ipAddr("123.234.0.23");
84 addr.setFromIpAddrPort(ipAddr, 8888);
85 EXPECT_EQ(addr.getFamily(), AF_INET);
86 EXPECT_EQ(addr.getAddressStr(), "123.234.0.23");
87 EXPECT_EQ(addr.getIPAddress(), ipAddr);
88 EXPECT_EQ(addr.getPort(), 8888);
90 folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
91 SocketAddress addr6(ip6Addr, 8888);
92 EXPECT_EQ(addr6.getFamily(), AF_INET6);
93 EXPECT_EQ(addr6.getAddressStr(), "2620:0:1cfe:face:b00c::3");
94 EXPECT_EQ(addr6.getIPAddress(), ip6Addr);
95 EXPECT_EQ(addr6.getPort(), 8888);
98 TEST(SocketAddress, SetFromIpv4) {
100 addr.setFromIpPort("255.254.253.252", 8888);
101 EXPECT_EQ(addr.getFamily(), AF_INET);
102 EXPECT_EQ(addr.getAddressStr(), "255.254.253.252");
103 EXPECT_EQ(addr.getPort(), 8888);
104 sockaddr_storage addrStorage;
105 addr.getAddress(&addrStorage);
106 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
107 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0xfffefdfc));
108 EXPECT_EQ(inaddr->sin_port, htons(8888));
111 TEST(SocketAddress, ConstructFromInvalidIpv4) {
112 EXPECT_THROW(SocketAddress("1.2.3.256", 1234), std::runtime_error);
115 TEST(SocketAddress, SetFromInvalidIpv4) {
116 SocketAddress addr("12.34.56.78", 80);
118 // Try setting to an invalid value
119 // Since setFromIpPort() shouldn't allow hostname lookups, setting to
120 // "localhost" should fail, even if localhost is resolvable
121 EXPECT_THROW(addr.setFromIpPort("localhost", 1234),
124 // Make sure the address still has the old contents
125 EXPECT_EQ(addr.getFamily(), AF_INET);
126 EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
127 EXPECT_EQ(addr.getPort(), 80);
128 sockaddr_storage addrStorage;
129 addr.getAddress(&addrStorage);
130 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
131 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
134 TEST(SocketAddress, SetFromHostname) {
135 // hopefully "localhost" is resolvable on any system that will run the tests
136 EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
137 SocketAddress addr("localhost", 80, true);
140 EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
141 addr2.setFromHostPort("localhost", 0);
144 TEST(SocketAddress, SetFromStrings) {
147 // Set from a numeric port string
148 addr.setFromLocalPort("1234");
149 EXPECT_EQ(addr.getPort(), 1234);
151 // setFromLocalPort() should not accept service names
152 EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
154 // Call setFromLocalIpPort() with just a port, no IP
155 addr.setFromLocalIpPort("80");
156 EXPECT_EQ(addr.getPort(), 80);
158 // Call setFromLocalIpPort() with an IP and port.
159 if (SocketAddressTestHelper::isIPv4Enabled()) {
160 addr.setFromLocalIpPort("127.0.0.1:4321");
161 EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
162 EXPECT_EQ(addr.getPort(), 4321);
164 if (SocketAddressTestHelper::isIPv6Enabled()) {
165 addr.setFromLocalIpPort("::1:4321");
166 EXPECT_EQ(addr.getAddressStr(), "::1");
167 EXPECT_EQ(addr.getPort(), 4321);
170 // setFromIpPort() without an address should fail
171 EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
173 // Call setFromIpPort() with an IPv6 address and port
174 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
175 EXPECT_EQ(addr.getFamily(), AF_INET6);
176 EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
177 EXPECT_EQ(addr.getPort(), 65535);
179 // Call setFromIpPort() with an IPv4 address and port
180 addr.setFromIpPort("1.2.3.4:9999");
181 EXPECT_EQ(addr.getFamily(), AF_INET);
182 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
183 EXPECT_EQ(addr.getPort(), 9999);
185 // Call setFromIpPort() with a bracketed IPv6
186 addr.setFromIpPort("[::]:1234");
187 EXPECT_EQ(addr.getFamily(), AF_INET6);
188 EXPECT_EQ(addr.getAddressStr(), "::");
189 EXPECT_EQ(addr.getPort(), 1234);
191 // Call setFromIpPort() with a bracketed IPv6
192 addr.setFromIpPort("[9:8::2]:1234");
193 EXPECT_EQ(addr.getFamily(), AF_INET6);
194 EXPECT_EQ(addr.getAddressStr(), "9:8::2");
195 EXPECT_EQ(addr.getPort(), 1234);
197 // Call setFromIpPort() with a bracketed IPv6 and no port
198 EXPECT_THROW(addr.setFromIpPort("[::]"), std::system_error);
201 TEST(SocketAddress, EqualityAndHash) {
203 SocketAddress local1("127.0.0.1", 1234);
204 EXPECT_EQ(local1, local1);
205 EXPECT_EQ(local1.hash(), local1.hash());
207 SocketAddress local2("127.0.0.1", 1234);
208 EXPECT_EQ(local1, local2);
209 EXPECT_EQ(local1.hash(), local2.hash());
211 SocketAddress local3("127.0.0.1", 4321);
212 EXPECT_NE(local1, local3);
213 EXPECT_NE(local1.hash(), local3.hash());
215 SocketAddress other1("1.2.3.4", 1234);
216 EXPECT_EQ(other1, other1);
217 EXPECT_EQ(other1.hash(), other1.hash());
218 EXPECT_NE(local1, other1);
219 EXPECT_NE(local1.hash(), other1.hash());
221 SocketAddress other2("4.3.2.1", 1234);
222 EXPECT_NE(other1.hash(), other2.hash());
223 EXPECT_NE(other1.hash(), other2.hash());
225 other2.setFromIpPort("1.2.3.4", 0);
226 EXPECT_NE(other1.hash(), other2.hash());
227 EXPECT_NE(other1.hash(), other2.hash());
228 other2.setPort(1234);
229 EXPECT_EQ(other1.hash(), other2.hash());
230 EXPECT_EQ(other1.hash(), other2.hash());
233 SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
234 SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
235 SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
236 EXPECT_EQ(v6_1, v6_2);
237 EXPECT_EQ(v6_1.hash(), v6_2.hash());
238 EXPECT_NE(v6_1, v6_3);
239 EXPECT_NE(v6_1.hash(), v6_3.hash());
241 // IPv4 versus IPv6 comparison
242 SocketAddress localIPv6("::1", 1234);
243 // Even though these both refer to localhost,
244 // IPv4 and IPv6 addresses are never treated as the same address
245 EXPECT_NE(local1, localIPv6);
246 EXPECT_NE(local1.hash(), localIPv6.hash());
248 // IPv4-mapped IPv6 addresses are not treated as equal
249 // to the equivalent IPv4 address
250 SocketAddress v4("10.0.0.3", 99);
251 SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
252 SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
253 EXPECT_NE(v4, v6_mapped1);
254 EXPECT_NE(v4, v6_mapped2);
255 EXPECT_EQ(v6_mapped1, v6_mapped2);
257 // However, after calling convertToIPv4(), the mapped address should now be
258 // equal to the v4 version.
259 EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
260 v6_mapped1.convertToIPv4();
261 EXPECT_EQ(v6_mapped1, v4);
262 EXPECT_NE(v6_mapped1, v6_mapped2);
266 unix1.setFromPath("/foo");
268 unix2.setFromPath("/foo");
270 unix3.setFromPath("/bar");
271 SocketAddress unixAnon;
272 unixAnon.setFromPath("");
274 EXPECT_EQ(unix1, unix2);
275 EXPECT_EQ(unix1.hash(), unix2.hash());
276 EXPECT_NE(unix1, unix3);
277 EXPECT_NE(unix1, unixAnon);
278 EXPECT_NE(unix2, unix3);
279 EXPECT_NE(unix2, unixAnon);
280 // anonymous addresses aren't equal to any other address,
281 // including themselves
282 EXPECT_NE(unixAnon, unixAnon);
284 // It isn't strictly required that hashes for different addresses be
285 // different, but we should have very few collisions. It generally indicates
286 // a problem if these collide
287 EXPECT_NE(unix1.hash(), unix3.hash());
288 EXPECT_NE(unix1.hash(), unixAnon.hash());
289 EXPECT_NE(unix3.hash(), unixAnon.hash());
292 TEST(SocketAddress, IsPrivate) {
294 SocketAddress addr("9.255.255.255", 0);
295 EXPECT_TRUE(!addr.isPrivateAddress());
296 addr.setFromIpPort("10.0.0.0", 0);
297 EXPECT_TRUE(addr.isPrivateAddress());
298 addr.setFromIpPort("10.255.255.255", 0);
299 EXPECT_TRUE(addr.isPrivateAddress());
300 addr.setFromIpPort("11.0.0.0", 0);
301 EXPECT_TRUE(!addr.isPrivateAddress());
303 addr.setFromIpPort("172.15.255.255", 0);
304 EXPECT_TRUE(!addr.isPrivateAddress());
305 addr.setFromIpPort("172.16.0.0", 0);
306 EXPECT_TRUE(addr.isPrivateAddress());
307 addr.setFromIpPort("172.31.255.255", 0);
308 EXPECT_TRUE(addr.isPrivateAddress());
309 addr.setFromIpPort("172.32.0.0", 0);
310 EXPECT_TRUE(!addr.isPrivateAddress());
312 addr.setFromIpPort("192.167.255.255", 0);
313 EXPECT_TRUE(!addr.isPrivateAddress());
314 addr.setFromIpPort("192.168.0.0", 0);
315 EXPECT_TRUE(addr.isPrivateAddress());
316 addr.setFromIpPort("192.168.255.255", 0);
317 EXPECT_TRUE(addr.isPrivateAddress());
318 addr.setFromIpPort("192.169.0.0", 0);
319 EXPECT_TRUE(!addr.isPrivateAddress());
321 addr.setFromIpPort("126.255.255.255", 0);
322 EXPECT_TRUE(!addr.isPrivateAddress());
323 addr.setFromIpPort("127.0.0.0", 0);
324 EXPECT_TRUE(addr.isPrivateAddress());
325 addr.setFromIpPort("127.0.0.1", 0);
326 EXPECT_TRUE(addr.isPrivateAddress());
327 addr.setFromIpPort("127.255.255.255", 0);
328 EXPECT_TRUE(addr.isPrivateAddress());
329 addr.setFromIpPort("128.0.0.0", 0);
330 EXPECT_TRUE(!addr.isPrivateAddress());
332 addr.setFromIpPort("1.2.3.4", 0);
333 EXPECT_TRUE(!addr.isPrivateAddress());
334 addr.setFromIpPort("69.171.239.10", 0);
335 EXPECT_TRUE(!addr.isPrivateAddress());
338 addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
339 EXPECT_TRUE(!addr.isPrivateAddress());
340 addr.setFromIpPort("fc00::", 0);
341 EXPECT_TRUE(addr.isPrivateAddress());
342 addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
343 EXPECT_TRUE(addr.isPrivateAddress());
344 addr.setFromIpPort("fe00::", 0);
345 EXPECT_TRUE(!addr.isPrivateAddress());
347 addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
348 EXPECT_TRUE(!addr.isPrivateAddress());
349 addr.setFromIpPort("fe80::", 0);
350 EXPECT_TRUE(addr.isPrivateAddress());
351 addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
352 EXPECT_TRUE(addr.isPrivateAddress());
353 addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
354 EXPECT_TRUE(addr.isPrivateAddress());
355 addr.setFromIpPort("fec0::", 0);
356 EXPECT_TRUE(!addr.isPrivateAddress());
358 addr.setFromIpPort("::0", 0);
359 EXPECT_TRUE(!addr.isPrivateAddress());
360 addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
361 EXPECT_TRUE(!addr.isPrivateAddress());
364 addr.setFromIpPort("::ffff:127.0.0.1", 0);
365 EXPECT_TRUE(addr.isPrivateAddress());
366 addr.setFromIpPort("::ffff:10.1.2.3", 0);
367 EXPECT_TRUE(addr.isPrivateAddress());
368 addr.setFromIpPort("::ffff:172.24.0.115", 0);
369 EXPECT_TRUE(addr.isPrivateAddress());
370 addr.setFromIpPort("::ffff:192.168.0.1", 0);
371 EXPECT_TRUE(addr.isPrivateAddress());
372 addr.setFromIpPort("::ffff:69.171.239.10", 0);
373 EXPECT_TRUE(!addr.isPrivateAddress());
375 // Unix sockets are considered private addresses
376 addr.setFromPath("/tmp/mysock");
377 EXPECT_TRUE(addr.isPrivateAddress());
380 TEST(SocketAddress, IsLoopback) {
382 SocketAddress addr("127.0.0.1", 0);
383 EXPECT_TRUE(addr.isLoopbackAddress());
384 addr.setFromIpPort("127.0.0.0", 0xffff);
385 EXPECT_TRUE(addr.isLoopbackAddress());
386 addr.setFromIpPort("127.1.1.1", 0xffff);
387 EXPECT_TRUE(addr.isLoopbackAddress());
388 addr.setFromIpPort("127.255.255.255", 80);
389 EXPECT_TRUE(addr.isLoopbackAddress());
391 addr.setFromIpPort("128.0.0.0", 0);
392 EXPECT_TRUE(!addr.isLoopbackAddress());
393 addr.setFromIpPort("126.255.255.255", 0);
394 EXPECT_TRUE(!addr.isLoopbackAddress());
395 addr.setFromIpPort("10.1.2.3", 0);
396 EXPECT_TRUE(!addr.isLoopbackAddress());
399 addr.setFromIpPort("::1", 0);
400 EXPECT_TRUE(addr.isLoopbackAddress());
401 addr.setFromIpPort("::0", 0);
402 EXPECT_TRUE(!addr.isLoopbackAddress());
403 addr.setFromIpPort("::2", 0);
404 EXPECT_TRUE(!addr.isLoopbackAddress());
407 addr.setFromIpPort("::ffff:127.0.0.1", 0);
408 EXPECT_TRUE(addr.isLoopbackAddress());
409 addr.setFromIpPort("::ffff:7f0a:141e", 0);
410 EXPECT_TRUE(addr.isLoopbackAddress());
411 addr.setFromIpPort("::ffff:169.254.0.13", 0);
412 EXPECT_TRUE(!addr.isLoopbackAddress());
414 // Unix sockets are considered loopback addresses
415 addr.setFromPath("/tmp/mysock");
416 EXPECT_TRUE(addr.isLoopbackAddress());
419 void CheckPrefixMatch(const SocketAddress& first,
420 const SocketAddress& second, unsigned matchingPrefixLen) {
422 for (i = 0; i <= matchingPrefixLen; i++) {
423 EXPECT_TRUE(first.prefixMatch(second, i));
425 unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
426 for (; i <= addrLen; i++) {
427 EXPECT_TRUE(!first.prefixMatch(second, i));
431 TEST(SocketAddress, PrefixMatch) {
433 SocketAddress addr1("127.0.0.1", 0);
434 SocketAddress addr2("127.0.0.1", 0);
435 CheckPrefixMatch(addr1, addr2, 32);
437 addr2.setFromIpPort("127.0.1.1", 0);
438 CheckPrefixMatch(addr1, addr2, 23);
440 addr2.setFromIpPort("1.1.0.127", 0);
441 CheckPrefixMatch(addr1, addr2, 1);
443 // Address family mismatch
444 addr2.setFromIpPort("::ffff:127.0.0.1", 0);
445 EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
448 addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
449 CheckPrefixMatch(addr1, addr2, 2);
451 addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
452 CheckPrefixMatch(addr1, addr2, 128);
454 addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
455 CheckPrefixMatch(addr1, addr2, 42);
458 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
459 EXPECT_TRUE(!(first < first));
460 EXPECT_TRUE(!(second < second));
461 EXPECT_TRUE(first < second);
462 EXPECT_TRUE(!(first == second));
463 EXPECT_TRUE(!(second < first));
466 TEST(SocketAddress, CheckComparatorBehavior) {
467 SocketAddress first, second;
468 // The following comparison are strict (so if first and second were
469 // inverted that is ok.
474 first.setFromIpPort("128.0.0.0", 0);
475 second.setFromIpPort("128.0.0.0", 0xFFFF);
476 CheckFirstLessThanSecond(first, second);
477 first.setFromIpPort("128.0.0.100", 0);
478 second.setFromIpPort("128.0.0.0", 0xFFFF);
479 CheckFirstLessThanSecond(first, second);
481 // Address comparisons
482 first.setFromIpPort("128.0.0.0", 10);
483 second.setFromIpPort("128.0.0.100", 10);
484 CheckFirstLessThanSecond(first, second);
486 // Comaprision between IPV4 and IPV6
487 first.setFromIpPort("128.0.0.0", 0);
488 second.setFromIpPort("::ffff:127.0.0.1", 0);
489 CheckFirstLessThanSecond(first, second);
490 first.setFromIpPort("128.0.0.0", 100);
491 second.setFromIpPort("::ffff:127.0.0.1", 0);
492 CheckFirstLessThanSecond(first, second);
497 first.setFromIpPort("::0", 0);
498 second.setFromIpPort("::0", 0xFFFF);
499 CheckFirstLessThanSecond(first, second);
500 first.setFromIpPort("::0", 0);
501 second.setFromIpPort("::1", 0xFFFF);
502 CheckFirstLessThanSecond(first, second);
504 // Address comparisons
505 first.setFromIpPort("::0", 10);
506 second.setFromIpPort("::1", 10);
507 CheckFirstLessThanSecond(first, second);
510 first.setFromPath("/foo");
511 second.setFromPath("/1234");
512 // The exact comparison order doesn't really matter, as long as
513 // (a < b), (b < a), and (a == b) are consistent.
514 // This checks our current comparison rules, which checks the path length
515 // before the path contents.
516 CheckFirstLessThanSecond(first, second);
517 first.setFromPath("/1234");
518 second.setFromPath("/5678");
519 CheckFirstLessThanSecond(first, second);
522 // We currently compare the address family values, and AF_UNIX < AF_INET
523 first.setFromPath("/foo");
524 second.setFromIpPort("127.0.0.1", 80);
525 CheckFirstLessThanSecond(first, second);
528 TEST(SocketAddress, Unix) {
532 addr.setFromPath("foo");
533 EXPECT_EQ(addr.getFamily(), AF_UNIX);
534 EXPECT_EQ(addr.describe(), "foo");
535 EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
536 EXPECT_THROW(addr.getPort(), std::invalid_argument);
537 EXPECT_TRUE(addr.isPrivateAddress());
538 EXPECT_TRUE(addr.isLoopbackAddress());
540 // Test a path that is too large
541 const char longPath[] =
542 "abcdefghijklmnopqrstuvwxyz0123456789"
543 "abcdefghijklmnopqrstuvwxyz0123456789"
544 "abcdefghijklmnopqrstuvwxyz0123456789"
545 "abcdefghijklmnopqrstuvwxyz0123456789";
546 EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
547 // The original address should still be the same
548 EXPECT_EQ(addr.getFamily(), AF_UNIX);
549 EXPECT_EQ(addr.describe(), "foo");
551 // Test a path that exactly fits in sockaddr_un
552 // (not including the NUL terminator)
553 const char exactLengthPath[] =
554 "abcdefghijklmnopqrstuvwxyz0123456789"
555 "abcdefghijklmnopqrstuvwxyz0123456789"
556 "abcdefghijklmnopqrstuvwxyz0123456789";
557 addr.setFromPath(exactLengthPath);
558 EXPECT_EQ(addr.describe(), exactLengthPath);
560 // Test converting a unix socket address to an IPv4 one, then back
561 addr.setFromHostPort("127.0.0.1", 1234);
562 EXPECT_EQ(addr.getFamily(), AF_INET);
563 EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
564 addr.setFromPath("/i/am/a/unix/address");
565 EXPECT_EQ(addr.getFamily(), AF_UNIX);
566 EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
568 // Test copy constructor and assignment operator
570 SocketAddress copy(addr);
571 EXPECT_EQ(copy, addr);
572 copy.setFromPath("/abc");
573 EXPECT_NE(copy, addr);
575 EXPECT_EQ(copy, addr);
576 copy.setFromIpPort("127.0.0.1", 80);
577 EXPECT_NE(copy, addr);
579 EXPECT_EQ(copy, addr);
583 SocketAddress copy(addr);
584 EXPECT_EQ(copy, addr);
585 EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
586 EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
588 SocketAddress other("127.0.0.1", 80);
589 EXPECT_NE(other, addr);
591 EXPECT_EQ(other, copy);
592 EXPECT_EQ(other, addr);
593 EXPECT_EQ(copy, addr);
596 #if __GXX_EXPERIMENTAL_CXX0X__
600 // move a unix address into a non-unix address
601 SocketAddress tmpCopy(addr);
602 copy = std::move(tmpCopy);
604 EXPECT_EQ(copy, addr);
606 copy.setFromPath("/another/path");
608 // move a unix address into a unix address
609 SocketAddress tmpCopy(addr);
610 copy = std::move(tmpCopy);
612 EXPECT_EQ(copy, addr);
615 // move a non-unix address into a unix address
616 SocketAddress tmp("127.0.0.1", 80);
617 copy = std::move(tmp);
619 EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
620 EXPECT_EQ(copy.getPort(), 80);
623 // move construct a unix address
624 SocketAddress other(std::move(copy));
625 EXPECT_EQ(other, addr);
626 EXPECT_EQ(other.getPath(), addr.getPath());
631 TEST(SocketAddress, AnonymousUnix) {
632 // Create a unix socket pair, and get the addresses.
634 int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
641 addr0.setFromLocalAddress(fds[0]);
642 peer0.setFromPeerAddress(fds[0]);
643 addr1.setFromLocalAddress(fds[1]);
644 peer1.setFromPeerAddress(fds[1]);
648 EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
649 EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
650 EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
651 EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
653 // Anonymous addresses should never compare equal
654 EXPECT_NE(addr0, addr1);
655 EXPECT_NE(peer0, peer1);
657 // Note that logically addr0 and peer1 are the same,
658 // but since they are both anonymous we have no way to determine this
659 EXPECT_NE(addr0, peer1);
660 // We can't even tell if an anonymous address is equal to itself
661 EXPECT_NE(addr0, addr0);
664 #define REQUIRE_ERRNO(cond, msg) \
666 int _requireErrnoCopy_ = errno; \
667 std::ostringstream _requireMsg_; \
668 _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
672 void testSetFromSocket(const SocketAddress *serverBindAddr,
673 const SocketAddress *clientBindAddr,
674 SocketAddress *listenAddrRet,
675 SocketAddress *acceptAddrRet,
676 SocketAddress *serverAddrRet,
677 SocketAddress *serverPeerAddrRet,
678 SocketAddress *clientAddrRet,
679 SocketAddress *clientPeerAddrRet) {
680 int listenSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
681 REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
682 sockaddr_storage laddr;
683 serverBindAddr->getAddress(&laddr);
684 socklen_t laddrLen = serverBindAddr->getActualSize();
685 int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
686 REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
687 rc = listen(listenSock, 10);
688 REQUIRE_ERRNO(rc == 0, "failed to listen");
690 listenAddrRet->setFromLocalAddress(listenSock);
692 SocketAddress listenPeerAddr;
693 EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
696 // Note that we use the family from serverBindAddr here, since we allow
697 // clientBindAddr to be nullptr.
698 int clientSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
699 REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
700 if (clientBindAddr != nullptr) {
701 sockaddr_storage clientAddr;
702 clientBindAddr->getAddress(&clientAddr);
704 rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
705 clientBindAddr->getActualSize());
706 REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
709 sockaddr_storage listenAddr;
710 listenAddrRet->getAddress(&listenAddr);
711 rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
712 listenAddrRet->getActualSize());
713 REQUIRE_ERRNO(rc == 0, "failed to connect");
715 sockaddr_storage acceptAddr;
716 socklen_t acceptAddrLen = sizeof(acceptAddr);
717 int serverSock = accept(listenSock,
718 reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
719 REQUIRE_ERRNO(serverSock > 0, "failed to accept");
720 acceptAddrRet->setFromSockaddr(
721 reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
723 serverAddrRet->setFromLocalAddress(serverSock);
724 serverPeerAddrRet->setFromPeerAddress(serverSock);
725 clientAddrRet->setFromLocalAddress(clientSock);
726 clientPeerAddrRet->setFromPeerAddress(clientSock);
733 TEST(SocketAddress, SetFromSocketIPv4) {
734 SocketAddress serverBindAddr("0.0.0.0", 0);
735 SocketAddress clientBindAddr("0.0.0.0", 0);
736 SocketAddress listenAddr;
737 SocketAddress acceptAddr;
738 SocketAddress serverAddr;
739 SocketAddress serverPeerAddr;
740 SocketAddress clientAddr;
741 SocketAddress clientPeerAddr;
743 testSetFromSocket(&serverBindAddr, &clientBindAddr,
744 &listenAddr, &acceptAddr,
745 &serverAddr, &serverPeerAddr,
746 &clientAddr, &clientPeerAddr);
748 // The server socket's local address should have the same port as the listen
749 // address. The IP will be different, since the listening socket is
750 // listening on INADDR_ANY, but the server socket will have a concrete IP
751 // address assigned to it.
752 EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
754 // The client's peer address should always be the same as the server
756 EXPECT_EQ(clientPeerAddr, serverAddr);
757 // The address returned by getpeername() on the server socket should
758 // be the same as the address returned by accept()
759 EXPECT_EQ(serverPeerAddr, acceptAddr);
760 EXPECT_EQ(serverPeerAddr, clientAddr);
761 EXPECT_EQ(acceptAddr, clientAddr);
765 * Note this test exercises Linux-specific Unix socket behavior
767 TEST(SocketAddress, SetFromSocketUnixAbstract) {
768 // Explicitly binding to an empty path results in an abstract socket
769 // name being picked for us automatically.
770 SocketAddress serverBindAddr;
772 path.append("test address");
773 serverBindAddr.setFromPath(path);
774 SocketAddress clientBindAddr;
775 clientBindAddr.setFromPath("");
777 SocketAddress listenAddr;
778 SocketAddress acceptAddr;
779 SocketAddress serverAddr;
780 SocketAddress serverPeerAddr;
781 SocketAddress clientAddr;
782 SocketAddress clientPeerAddr;
784 testSetFromSocket(&serverBindAddr, &clientBindAddr,
785 &listenAddr, &acceptAddr,
786 &serverAddr, &serverPeerAddr,
787 &clientAddr, &clientPeerAddr);
789 // The server socket's local address should be the same as the listen
791 EXPECT_EQ(serverAddr, listenAddr);
793 // The client's peer address should always be the same as the server
795 EXPECT_EQ(clientPeerAddr, serverAddr);
797 EXPECT_EQ(serverPeerAddr, clientAddr);
798 // Oddly, the address returned by accept() does not seem to match the address
799 // returned by getpeername() on the server socket or getsockname() on the
801 // EXPECT_EQ(serverPeerAddr, acceptAddr);
802 // EXPECT_EQ(acceptAddr, clientAddr);
805 TEST(SocketAddress, SetFromSocketUnixExplicit) {
806 // Pick two temporary path names.
807 TemporaryDirectory tempDirectory("SocketAddressTest");
808 std::string serverPath = (tempDirectory.path() / "server").string();
809 std::string clientPath = (tempDirectory.path() / "client").string();
811 SocketAddress serverBindAddr;
812 SocketAddress clientBindAddr;
813 SocketAddress listenAddr;
814 SocketAddress acceptAddr;
815 SocketAddress serverAddr;
816 SocketAddress serverPeerAddr;
817 SocketAddress clientAddr;
818 SocketAddress clientPeerAddr;
820 serverBindAddr.setFromPath(serverPath.c_str());
821 clientBindAddr.setFromPath(clientPath.c_str());
823 testSetFromSocket(&serverBindAddr, &clientBindAddr,
824 &listenAddr, &acceptAddr,
825 &serverAddr, &serverPeerAddr,
826 &clientAddr, &clientPeerAddr);
828 // Remove the socket files after we are done
829 unlink(serverPath.c_str());
830 unlink(clientPath.c_str());
833 unlink(serverPath.c_str());
834 unlink(clientPath.c_str());
836 // The server socket's local address should be the same as the listen
838 EXPECT_EQ(serverAddr, listenAddr);
840 // The client's peer address should always be the same as the server
842 EXPECT_EQ(clientPeerAddr, serverAddr);
844 EXPECT_EQ(serverPeerAddr, clientAddr);
845 EXPECT_EQ(serverPeerAddr, acceptAddr);
846 EXPECT_EQ(acceptAddr, clientAddr);
849 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
850 // Test an anonymous client talking to a fixed-path unix socket.
851 TemporaryDirectory tempDirectory("SocketAddressTest");
852 std::string serverPath = (tempDirectory.path() / "server").string();
854 SocketAddress serverBindAddr;
855 SocketAddress listenAddr;
856 SocketAddress acceptAddr;
857 SocketAddress serverAddr;
858 SocketAddress serverPeerAddr;
859 SocketAddress clientAddr;
860 SocketAddress clientPeerAddr;
862 serverBindAddr.setFromPath(serverPath.c_str());
864 testSetFromSocket(&serverBindAddr, nullptr,
865 &listenAddr, &acceptAddr,
866 &serverAddr, &serverPeerAddr,
867 &clientAddr, &clientPeerAddr);
869 // Remove the socket file after we are done
870 unlink(serverPath.c_str());
873 unlink(serverPath.c_str());
875 // The server socket's local address should be the same as the listen
877 EXPECT_EQ(serverAddr, listenAddr);
879 // The client's peer address should always be the same as the server
881 EXPECT_EQ(clientPeerAddr, serverAddr);
883 // Since the client is using an anonymous address, it won't compare equal to
884 // any other anonymous addresses. Make sure the addresses are anonymous.
885 EXPECT_EQ(serverPeerAddr.getPath(), "");
886 EXPECT_EQ(clientAddr.getPath(), "");
887 EXPECT_EQ(acceptAddr.getPath(), "");
890 TEST(SocketAddress, ResetUnixAddress) {
892 addy.setFromPath("/foo");
895 EXPECT_EQ(addy.getFamily(), AF_UNSPEC);
898 TEST(SocketAddress, ResetIPAddress) {
900 addr.setFromIpPort("127.0.0.1", 80);
902 EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
903 EXPECT_FALSE(addr.isInitialized());
904 EXPECT_TRUE(addr.empty());
906 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
908 EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
909 EXPECT_FALSE(addr.isInitialized());
910 EXPECT_TRUE(addr.empty());
913 TEST(SocketAddress, ValidFamilyInet) {
915 EXPECT_FALSE(addr.isFamilyInet());
916 folly::IPAddress ipAddr("123.234.0.23");
917 addr.setFromIpAddrPort(ipAddr, 8888);
918 EXPECT_TRUE(addr.isFamilyInet());
920 folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
921 SocketAddress addr6(ip6Addr, 8888);
922 EXPECT_TRUE(addr6.isFamilyInet());