2 * Copyright 2016 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/portability/GTest.h>
24 #include <folly/portability/Sockets.h>
25 #include <folly/portability/Stdlib.h>
26 #include <folly/test/SocketAddressTestHelper.h>
28 using namespace boost;
32 using folly::SocketAddress;
33 using folly::SocketAddressTestHelper;
35 namespace fsp = folly::portability::sockets;
37 TEST(SocketAddress, Size) {
39 EXPECT_EQ(sizeof(addr), 32);
42 TEST(SocketAddress, ConstructFromIpv4) {
43 SocketAddress addr("1.2.3.4", 4321);
44 EXPECT_EQ(addr.getFamily(), AF_INET);
45 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
46 EXPECT_EQ(addr.getPort(), 4321);
47 sockaddr_storage addrStorage;
48 addr.getAddress(&addrStorage);
49 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
50 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x01020304));
51 EXPECT_EQ(inaddr->sin_port, htons(4321));
54 TEST(SocketAddress, StringConversion) {
55 SocketAddress addr("1.2.3.4", 4321);
56 EXPECT_EQ(addr.getFamily(), AF_INET);
57 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
59 addr.getAddressStr(buf, 2);
60 EXPECT_STREQ(buf, "1");
63 TEST(SocketAddress, IPv4ToStringConversion) {
64 // testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
66 for (int pos = 0; pos < 4; ++pos) {
67 for (int i = 0; i < 256; ++i) {
68 int fragments[] = {5,5,5,5};
70 std::ostringstream ss;
71 ss << fragments[0] << "." << fragments[1] << "."
72 << fragments[2] << "." << fragments[3];
73 string ipString = ss.str();
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),
123 // Make sure the address still has the old contents
124 EXPECT_EQ(addr.getFamily(), AF_INET);
125 EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
126 EXPECT_EQ(addr.getPort(), 80);
127 sockaddr_storage addrStorage;
128 addr.getAddress(&addrStorage);
129 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
130 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
133 TEST(SocketAddress, SetFromHostname) {
134 // hopefully "localhost" is resolvable on any system that will run the tests
135 EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
136 SocketAddress addr("localhost", 80, true);
139 EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
140 addr2.setFromHostPort("localhost", 0);
143 TEST(SocketAddress, SetFromStrings) {
146 // Set from a numeric port string
147 addr.setFromLocalPort("1234");
148 EXPECT_EQ(addr.getPort(), 1234);
150 // setFromLocalPort() should not accept service names
151 EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
153 // Call setFromLocalIpPort() with just a port, no IP
154 addr.setFromLocalIpPort("80");
155 EXPECT_EQ(addr.getPort(), 80);
157 // Call setFromLocalIpPort() with an IP and port.
158 if (SocketAddressTestHelper::isIPv4Enabled()) {
159 addr.setFromLocalIpPort("127.0.0.1:4321");
160 EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
161 EXPECT_EQ(addr.getPort(), 4321);
163 if (SocketAddressTestHelper::isIPv6Enabled()) {
164 addr.setFromLocalIpPort("::1:4321");
165 EXPECT_EQ(addr.getAddressStr(), "::1");
166 EXPECT_EQ(addr.getPort(), 4321);
169 // setFromIpPort() without an address should fail
170 EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
172 // Call setFromIpPort() with an IPv6 address and port
173 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
174 EXPECT_EQ(addr.getFamily(), AF_INET6);
175 EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
176 EXPECT_EQ(addr.getPort(), 65535);
178 // Call setFromIpPort() with an IPv4 address and port
179 addr.setFromIpPort("1.2.3.4:9999");
180 EXPECT_EQ(addr.getFamily(), AF_INET);
181 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
182 EXPECT_EQ(addr.getPort(), 9999);
184 // Call setFromIpPort() with a bracketed IPv6
185 addr.setFromIpPort("[::]:1234");
186 EXPECT_EQ(addr.getFamily(), AF_INET6);
187 EXPECT_EQ(addr.getAddressStr(), "::");
188 EXPECT_EQ(addr.getPort(), 1234);
190 // Call setFromIpPort() with a bracketed IPv6
191 addr.setFromIpPort("[9:8::2]:1234");
192 EXPECT_EQ(addr.getFamily(), AF_INET6);
193 EXPECT_EQ(addr.getAddressStr(), "9:8::2");
194 EXPECT_EQ(addr.getPort(), 1234);
196 // Call setFromIpPort() with a bracketed IPv6 and no port
197 EXPECT_THROW(addr.setFromIpPort("[::]"), std::system_error);
200 TEST(SocketAddress, EqualityAndHash) {
202 SocketAddress local1("127.0.0.1", 1234);
203 EXPECT_EQ(local1, local1);
204 EXPECT_EQ(local1.hash(), local1.hash());
206 SocketAddress local2("127.0.0.1", 1234);
207 EXPECT_EQ(local1, local2);
208 EXPECT_EQ(local1.hash(), local2.hash());
210 SocketAddress local3("127.0.0.1", 4321);
211 EXPECT_NE(local1, local3);
212 EXPECT_NE(local1.hash(), local3.hash());
214 SocketAddress other1("1.2.3.4", 1234);
215 EXPECT_EQ(other1, other1);
216 EXPECT_EQ(other1.hash(), other1.hash());
217 EXPECT_NE(local1, other1);
218 EXPECT_NE(local1.hash(), other1.hash());
220 SocketAddress other2("4.3.2.1", 1234);
221 EXPECT_NE(other1.hash(), other2.hash());
222 EXPECT_NE(other1.hash(), other2.hash());
224 other2.setFromIpPort("1.2.3.4", 0);
225 EXPECT_NE(other1.hash(), other2.hash());
226 EXPECT_NE(other1.hash(), other2.hash());
227 other2.setPort(1234);
228 EXPECT_EQ(other1.hash(), other2.hash());
229 EXPECT_EQ(other1.hash(), other2.hash());
232 SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
233 SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
234 SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
235 EXPECT_EQ(v6_1, v6_2);
236 EXPECT_EQ(v6_1.hash(), v6_2.hash());
237 EXPECT_NE(v6_1, v6_3);
238 EXPECT_NE(v6_1.hash(), v6_3.hash());
240 // IPv4 versus IPv6 comparison
241 SocketAddress localIPv6("::1", 1234);
242 // Even though these both refer to localhost,
243 // IPv4 and IPv6 addresses are never treated as the same address
244 EXPECT_NE(local1, localIPv6);
245 EXPECT_NE(local1.hash(), localIPv6.hash());
247 // IPv4-mapped IPv6 addresses are not treated as equal
248 // to the equivalent IPv4 address
249 SocketAddress v4("10.0.0.3", 99);
250 SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
251 SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
252 EXPECT_NE(v4, v6_mapped1);
253 EXPECT_NE(v4, v6_mapped2);
254 EXPECT_EQ(v6_mapped1, v6_mapped2);
256 // However, after calling convertToIPv4(), the mapped address should now be
257 // equal to the v4 version.
258 EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
259 v6_mapped1.convertToIPv4();
260 EXPECT_EQ(v6_mapped1, v4);
261 EXPECT_NE(v6_mapped1, v6_mapped2);
265 unix1.setFromPath("/foo");
267 unix2.setFromPath("/foo");
269 unix3.setFromPath("/bar");
270 SocketAddress unixAnon;
271 unixAnon.setFromPath("");
273 EXPECT_EQ(unix1, unix2);
274 EXPECT_EQ(unix1.hash(), unix2.hash());
275 EXPECT_NE(unix1, unix3);
276 EXPECT_NE(unix1, unixAnon);
277 EXPECT_NE(unix2, unix3);
278 EXPECT_NE(unix2, unixAnon);
279 // anonymous addresses aren't equal to any other address,
280 // including themselves
281 EXPECT_NE(unixAnon, unixAnon);
283 // It isn't strictly required that hashes for different addresses be
284 // different, but we should have very few collisions. It generally indicates
285 // a problem if these collide
286 EXPECT_NE(unix1.hash(), unix3.hash());
287 EXPECT_NE(unix1.hash(), unixAnon.hash());
288 EXPECT_NE(unix3.hash(), unixAnon.hash());
291 TEST(SocketAddress, IsPrivate) {
293 SocketAddress addr("9.255.255.255", 0);
294 EXPECT_TRUE(!addr.isPrivateAddress());
295 addr.setFromIpPort("10.0.0.0", 0);
296 EXPECT_TRUE(addr.isPrivateAddress());
297 addr.setFromIpPort("10.255.255.255", 0);
298 EXPECT_TRUE(addr.isPrivateAddress());
299 addr.setFromIpPort("11.0.0.0", 0);
300 EXPECT_TRUE(!addr.isPrivateAddress());
302 addr.setFromIpPort("172.15.255.255", 0);
303 EXPECT_TRUE(!addr.isPrivateAddress());
304 addr.setFromIpPort("172.16.0.0", 0);
305 EXPECT_TRUE(addr.isPrivateAddress());
306 addr.setFromIpPort("172.31.255.255", 0);
307 EXPECT_TRUE(addr.isPrivateAddress());
308 addr.setFromIpPort("172.32.0.0", 0);
309 EXPECT_TRUE(!addr.isPrivateAddress());
311 addr.setFromIpPort("192.167.255.255", 0);
312 EXPECT_TRUE(!addr.isPrivateAddress());
313 addr.setFromIpPort("192.168.0.0", 0);
314 EXPECT_TRUE(addr.isPrivateAddress());
315 addr.setFromIpPort("192.168.255.255", 0);
316 EXPECT_TRUE(addr.isPrivateAddress());
317 addr.setFromIpPort("192.169.0.0", 0);
318 EXPECT_TRUE(!addr.isPrivateAddress());
320 addr.setFromIpPort("126.255.255.255", 0);
321 EXPECT_TRUE(!addr.isPrivateAddress());
322 addr.setFromIpPort("127.0.0.0", 0);
323 EXPECT_TRUE(addr.isPrivateAddress());
324 addr.setFromIpPort("127.0.0.1", 0);
325 EXPECT_TRUE(addr.isPrivateAddress());
326 addr.setFromIpPort("127.255.255.255", 0);
327 EXPECT_TRUE(addr.isPrivateAddress());
328 addr.setFromIpPort("128.0.0.0", 0);
329 EXPECT_TRUE(!addr.isPrivateAddress());
331 addr.setFromIpPort("1.2.3.4", 0);
332 EXPECT_TRUE(!addr.isPrivateAddress());
333 addr.setFromIpPort("69.171.239.10", 0);
334 EXPECT_TRUE(!addr.isPrivateAddress());
337 addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
338 EXPECT_TRUE(!addr.isPrivateAddress());
339 addr.setFromIpPort("fc00::", 0);
340 EXPECT_TRUE(addr.isPrivateAddress());
341 addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
342 EXPECT_TRUE(addr.isPrivateAddress());
343 addr.setFromIpPort("fe00::", 0);
344 EXPECT_TRUE(!addr.isPrivateAddress());
346 addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
347 EXPECT_TRUE(!addr.isPrivateAddress());
348 addr.setFromIpPort("fe80::", 0);
349 EXPECT_TRUE(addr.isPrivateAddress());
350 addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
351 EXPECT_TRUE(addr.isPrivateAddress());
352 addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
353 EXPECT_TRUE(addr.isPrivateAddress());
354 addr.setFromIpPort("fec0::", 0);
355 EXPECT_TRUE(!addr.isPrivateAddress());
357 addr.setFromIpPort("::0", 0);
358 EXPECT_TRUE(!addr.isPrivateAddress());
359 addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
360 EXPECT_TRUE(!addr.isPrivateAddress());
363 addr.setFromIpPort("::ffff:127.0.0.1", 0);
364 EXPECT_TRUE(addr.isPrivateAddress());
365 addr.setFromIpPort("::ffff:10.1.2.3", 0);
366 EXPECT_TRUE(addr.isPrivateAddress());
367 addr.setFromIpPort("::ffff:172.24.0.115", 0);
368 EXPECT_TRUE(addr.isPrivateAddress());
369 addr.setFromIpPort("::ffff:192.168.0.1", 0);
370 EXPECT_TRUE(addr.isPrivateAddress());
371 addr.setFromIpPort("::ffff:69.171.239.10", 0);
372 EXPECT_TRUE(!addr.isPrivateAddress());
374 // Unix sockets are considered private addresses
375 addr.setFromPath("/tmp/mysock");
376 EXPECT_TRUE(addr.isPrivateAddress());
379 TEST(SocketAddress, IsLoopback) {
381 SocketAddress addr("127.0.0.1", 0);
382 EXPECT_TRUE(addr.isLoopbackAddress());
383 addr.setFromIpPort("127.0.0.0", 0xffff);
384 EXPECT_TRUE(addr.isLoopbackAddress());
385 addr.setFromIpPort("127.1.1.1", 0xffff);
386 EXPECT_TRUE(addr.isLoopbackAddress());
387 addr.setFromIpPort("127.255.255.255", 80);
388 EXPECT_TRUE(addr.isLoopbackAddress());
390 addr.setFromIpPort("128.0.0.0", 0);
391 EXPECT_TRUE(!addr.isLoopbackAddress());
392 addr.setFromIpPort("126.255.255.255", 0);
393 EXPECT_TRUE(!addr.isLoopbackAddress());
394 addr.setFromIpPort("10.1.2.3", 0);
395 EXPECT_TRUE(!addr.isLoopbackAddress());
398 addr.setFromIpPort("::1", 0);
399 EXPECT_TRUE(addr.isLoopbackAddress());
400 addr.setFromIpPort("::0", 0);
401 EXPECT_TRUE(!addr.isLoopbackAddress());
402 addr.setFromIpPort("::2", 0);
403 EXPECT_TRUE(!addr.isLoopbackAddress());
406 addr.setFromIpPort("::ffff:127.0.0.1", 0);
407 EXPECT_TRUE(addr.isLoopbackAddress());
408 addr.setFromIpPort("::ffff:7f0a:141e", 0);
409 EXPECT_TRUE(addr.isLoopbackAddress());
410 addr.setFromIpPort("::ffff:169.254.0.13", 0);
411 EXPECT_TRUE(!addr.isLoopbackAddress());
413 // Unix sockets are considered loopback addresses
414 addr.setFromPath("/tmp/mysock");
415 EXPECT_TRUE(addr.isLoopbackAddress());
418 void CheckPrefixMatch(const SocketAddress& first,
419 const SocketAddress& second, unsigned matchingPrefixLen) {
421 for (i = 0; i <= matchingPrefixLen; i++) {
422 EXPECT_TRUE(first.prefixMatch(second, i));
424 unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
425 for (; i <= addrLen; i++) {
426 EXPECT_TRUE(!first.prefixMatch(second, i));
430 TEST(SocketAddress, PrefixMatch) {
432 SocketAddress addr1("127.0.0.1", 0);
433 SocketAddress addr2("127.0.0.1", 0);
434 CheckPrefixMatch(addr1, addr2, 32);
436 addr2.setFromIpPort("127.0.1.1", 0);
437 CheckPrefixMatch(addr1, addr2, 23);
439 addr2.setFromIpPort("1.1.0.127", 0);
440 CheckPrefixMatch(addr1, addr2, 1);
442 // Address family mismatch
443 addr2.setFromIpPort("::ffff:127.0.0.1", 0);
444 EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
447 addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
448 CheckPrefixMatch(addr1, addr2, 2);
450 addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
451 CheckPrefixMatch(addr1, addr2, 128);
453 addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
454 CheckPrefixMatch(addr1, addr2, 42);
457 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
458 EXPECT_TRUE(!(first < first));
459 EXPECT_TRUE(!(second < second));
460 EXPECT_TRUE(first < second);
461 EXPECT_TRUE(!(first == second));
462 EXPECT_TRUE(!(second < first));
465 TEST(SocketAddress, CheckComparatorBehavior) {
466 SocketAddress first, second;
467 // The following comparison are strict (so if first and second were
468 // inverted that is ok.
473 first.setFromIpPort("128.0.0.0", 0);
474 second.setFromIpPort("128.0.0.0", 0xFFFF);
475 CheckFirstLessThanSecond(first, second);
476 first.setFromIpPort("128.0.0.100", 0);
477 second.setFromIpPort("128.0.0.0", 0xFFFF);
478 CheckFirstLessThanSecond(first, second);
480 // Address comparisons
481 first.setFromIpPort("128.0.0.0", 10);
482 second.setFromIpPort("128.0.0.100", 10);
483 CheckFirstLessThanSecond(first, second);
485 // Comaprision between IPV4 and IPV6
486 first.setFromIpPort("128.0.0.0", 0);
487 second.setFromIpPort("::ffff:127.0.0.1", 0);
488 CheckFirstLessThanSecond(first, second);
489 first.setFromIpPort("128.0.0.0", 100);
490 second.setFromIpPort("::ffff:127.0.0.1", 0);
491 CheckFirstLessThanSecond(first, second);
496 first.setFromIpPort("::0", 0);
497 second.setFromIpPort("::0", 0xFFFF);
498 CheckFirstLessThanSecond(first, second);
499 first.setFromIpPort("::0", 0);
500 second.setFromIpPort("::1", 0xFFFF);
501 CheckFirstLessThanSecond(first, second);
503 // Address comparisons
504 first.setFromIpPort("::0", 10);
505 second.setFromIpPort("::1", 10);
506 CheckFirstLessThanSecond(first, second);
509 first.setFromPath("/foo");
510 second.setFromPath("/1234");
511 // The exact comparison order doesn't really matter, as long as
512 // (a < b), (b < a), and (a == b) are consistent.
513 // This checks our current comparison rules, which checks the path length
514 // before the path contents.
515 CheckFirstLessThanSecond(first, second);
516 first.setFromPath("/1234");
517 second.setFromPath("/5678");
518 CheckFirstLessThanSecond(first, second);
521 // We currently compare the address family values, and AF_UNIX < AF_INET
522 first.setFromPath("/foo");
523 second.setFromIpPort("127.0.0.1", 80);
524 CheckFirstLessThanSecond(first, second);
527 TEST(SocketAddress, Unix) {
531 addr.setFromPath("foo");
532 EXPECT_EQ(addr.getFamily(), AF_UNIX);
533 EXPECT_EQ(addr.describe(), "foo");
534 EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
535 EXPECT_THROW(addr.getPort(), std::invalid_argument);
536 EXPECT_TRUE(addr.isPrivateAddress());
537 EXPECT_TRUE(addr.isLoopbackAddress());
539 // Test a path that is too large
540 const char longPath[] =
541 "abcdefghijklmnopqrstuvwxyz0123456789"
542 "abcdefghijklmnopqrstuvwxyz0123456789"
543 "abcdefghijklmnopqrstuvwxyz0123456789"
544 "abcdefghijklmnopqrstuvwxyz0123456789";
545 EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
546 // The original address should still be the same
547 EXPECT_EQ(addr.getFamily(), AF_UNIX);
548 EXPECT_EQ(addr.describe(), "foo");
550 // Test a path that exactly fits in sockaddr_un
551 // (not including the NUL terminator)
552 const char exactLengthPath[] =
553 "abcdefghijklmnopqrstuvwxyz0123456789"
554 "abcdefghijklmnopqrstuvwxyz0123456789"
555 "abcdefghijklmnopqrstuvwxyz0123456789";
556 addr.setFromPath(exactLengthPath);
557 EXPECT_EQ(addr.describe(), exactLengthPath);
559 // Test converting a unix socket address to an IPv4 one, then back
560 addr.setFromHostPort("127.0.0.1", 1234);
561 EXPECT_EQ(addr.getFamily(), AF_INET);
562 EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
563 addr.setFromPath("/i/am/a/unix/address");
564 EXPECT_EQ(addr.getFamily(), AF_UNIX);
565 EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
567 // Test copy constructor and assignment operator
569 SocketAddress copy(addr);
570 EXPECT_EQ(copy, addr);
571 copy.setFromPath("/abc");
572 EXPECT_NE(copy, addr);
574 EXPECT_EQ(copy, addr);
575 copy.setFromIpPort("127.0.0.1", 80);
576 EXPECT_NE(copy, addr);
578 EXPECT_EQ(copy, addr);
582 SocketAddress copy(addr);
583 EXPECT_EQ(copy, addr);
584 EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
585 EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
587 SocketAddress other("127.0.0.1", 80);
588 EXPECT_NE(other, addr);
590 EXPECT_EQ(other, copy);
591 EXPECT_EQ(other, addr);
592 EXPECT_EQ(copy, addr);
595 #if __GXX_EXPERIMENTAL_CXX0X__
599 // move a unix address into a non-unix address
600 SocketAddress tmpCopy(addr);
601 copy = std::move(tmpCopy);
603 EXPECT_EQ(copy, addr);
605 copy.setFromPath("/another/path");
607 // move a unix address into a unix address
608 SocketAddress tmpCopy(addr);
609 copy = std::move(tmpCopy);
611 EXPECT_EQ(copy, addr);
614 // move a non-unix address into a unix address
615 SocketAddress tmp("127.0.0.1", 80);
616 copy = std::move(tmp);
618 EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
619 EXPECT_EQ(copy.getPort(), 80);
622 // move construct a unix address
623 SocketAddress other(std::move(copy));
624 EXPECT_EQ(other, addr);
625 EXPECT_EQ(other.getPath(), addr.getPath());
630 TEST(SocketAddress, AnonymousUnix) {
631 // Create a unix socket pair, and get the addresses.
633 int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
640 addr0.setFromLocalAddress(fds[0]);
641 peer0.setFromPeerAddress(fds[0]);
642 addr1.setFromLocalAddress(fds[1]);
643 peer1.setFromPeerAddress(fds[1]);
647 EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
648 EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
649 EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
650 EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
652 // Anonymous addresses should never compare equal
653 EXPECT_NE(addr0, addr1);
654 EXPECT_NE(peer0, peer1);
656 // Note that logically addr0 and peer1 are the same,
657 // but since they are both anonymous we have no way to determine this
658 EXPECT_NE(addr0, peer1);
659 // We can't even tell if an anonymous address is equal to itself
660 EXPECT_NE(addr0, addr0);
663 #define REQUIRE_ERRNO(cond, msg) \
665 int _requireErrnoCopy_ = errno; \
666 std::ostringstream _requireMsg_; \
667 _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
671 void testSetFromSocket(const SocketAddress *serverBindAddr,
672 const SocketAddress *clientBindAddr,
673 SocketAddress *listenAddrRet,
674 SocketAddress *acceptAddrRet,
675 SocketAddress *serverAddrRet,
676 SocketAddress *serverPeerAddrRet,
677 SocketAddress *clientAddrRet,
678 SocketAddress *clientPeerAddrRet) {
679 int listenSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
680 REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
681 sockaddr_storage laddr;
682 serverBindAddr->getAddress(&laddr);
683 socklen_t laddrLen = serverBindAddr->getActualSize();
684 int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
685 REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
686 rc = listen(listenSock, 10);
687 REQUIRE_ERRNO(rc == 0, "failed to listen");
689 listenAddrRet->setFromLocalAddress(listenSock);
691 SocketAddress listenPeerAddr;
692 EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
695 // Note that we use the family from serverBindAddr here, since we allow
696 // clientBindAddr to be nullptr.
697 int clientSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
698 REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
699 if (clientBindAddr != nullptr) {
700 sockaddr_storage clientAddr;
701 clientBindAddr->getAddress(&clientAddr);
703 rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
704 clientBindAddr->getActualSize());
705 REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
708 sockaddr_storage listenAddr;
709 listenAddrRet->getAddress(&listenAddr);
710 rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
711 listenAddrRet->getActualSize());
712 REQUIRE_ERRNO(rc == 0, "failed to connect");
714 sockaddr_storage acceptAddr;
715 socklen_t acceptAddrLen = sizeof(acceptAddr);
716 int serverSock = accept(listenSock,
717 reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
718 REQUIRE_ERRNO(serverSock > 0, "failed to accept");
719 acceptAddrRet->setFromSockaddr(
720 reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
722 serverAddrRet->setFromLocalAddress(serverSock);
723 serverPeerAddrRet->setFromPeerAddress(serverSock);
724 clientAddrRet->setFromLocalAddress(clientSock);
725 clientPeerAddrRet->setFromPeerAddress(clientSock);
732 TEST(SocketAddress, SetFromSocketIPv4) {
733 SocketAddress serverBindAddr("0.0.0.0", 0);
734 SocketAddress clientBindAddr("0.0.0.0", 0);
735 SocketAddress listenAddr;
736 SocketAddress acceptAddr;
737 SocketAddress serverAddr;
738 SocketAddress serverPeerAddr;
739 SocketAddress clientAddr;
740 SocketAddress clientPeerAddr;
742 testSetFromSocket(&serverBindAddr, &clientBindAddr,
743 &listenAddr, &acceptAddr,
744 &serverAddr, &serverPeerAddr,
745 &clientAddr, &clientPeerAddr);
747 // The server socket's local address should have the same port as the listen
748 // address. The IP will be different, since the listening socket is
749 // listening on INADDR_ANY, but the server socket will have a concrete IP
750 // address assigned to it.
751 EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
753 // The client's peer address should always be the same as the server
755 EXPECT_EQ(clientPeerAddr, serverAddr);
756 // The address returned by getpeername() on the server socket should
757 // be the same as the address returned by accept()
758 EXPECT_EQ(serverPeerAddr, acceptAddr);
759 EXPECT_EQ(serverPeerAddr, clientAddr);
760 EXPECT_EQ(acceptAddr, clientAddr);
764 * Note this test exercises Linux-specific Unix socket behavior
766 TEST(SocketAddress, SetFromSocketUnixAbstract) {
767 // Explicitly binding to an empty path results in an abstract socket
768 // name being picked for us automatically.
769 SocketAddress serverBindAddr;
771 path.append("test address");
772 serverBindAddr.setFromPath(path);
773 SocketAddress clientBindAddr;
774 clientBindAddr.setFromPath("");
776 SocketAddress listenAddr;
777 SocketAddress acceptAddr;
778 SocketAddress serverAddr;
779 SocketAddress serverPeerAddr;
780 SocketAddress clientAddr;
781 SocketAddress clientPeerAddr;
783 testSetFromSocket(&serverBindAddr, &clientBindAddr,
784 &listenAddr, &acceptAddr,
785 &serverAddr, &serverPeerAddr,
786 &clientAddr, &clientPeerAddr);
788 // The server socket's local address should be the same as the listen
790 EXPECT_EQ(serverAddr, listenAddr);
792 // The client's peer address should always be the same as the server
794 EXPECT_EQ(clientPeerAddr, serverAddr);
796 EXPECT_EQ(serverPeerAddr, clientAddr);
797 // Oddly, the address returned by accept() does not seem to match the address
798 // returned by getpeername() on the server socket or getsockname() on the
800 // EXPECT_EQ(serverPeerAddr, acceptAddr);
801 // EXPECT_EQ(acceptAddr, clientAddr);
804 TEST(SocketAddress, SetFromSocketUnixExplicit) {
805 // Pick two temporary path names.
806 // We use mkstemp() just to avoid warnings about mktemp,
807 // but we need to remove the file to let the socket code bind to it.
808 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
809 int serverPathFd = mkstemp(serverPath);
810 EXPECT_GE(serverPathFd, 0);
811 char clientPath[] = "/tmp/SocketAddressTest.client.XXXXXX";
812 int clientPathFd = mkstemp(clientPath);
813 EXPECT_GE(clientPathFd, 0);
815 int rc = unlink(serverPath);
817 rc = unlink(clientPath);
820 SocketAddress serverBindAddr;
821 SocketAddress clientBindAddr;
822 SocketAddress listenAddr;
823 SocketAddress acceptAddr;
824 SocketAddress serverAddr;
825 SocketAddress serverPeerAddr;
826 SocketAddress clientAddr;
827 SocketAddress clientPeerAddr;
829 serverBindAddr.setFromPath(serverPath);
830 clientBindAddr.setFromPath(clientPath);
832 testSetFromSocket(&serverBindAddr, &clientBindAddr,
833 &listenAddr, &acceptAddr,
834 &serverAddr, &serverPeerAddr,
835 &clientAddr, &clientPeerAddr);
837 // Remove the socket files after we are done
845 // The server socket's local address should be the same as the listen
847 EXPECT_EQ(serverAddr, listenAddr);
849 // The client's peer address should always be the same as the server
851 EXPECT_EQ(clientPeerAddr, serverAddr);
853 EXPECT_EQ(serverPeerAddr, clientAddr);
854 EXPECT_EQ(serverPeerAddr, acceptAddr);
855 EXPECT_EQ(acceptAddr, clientAddr);
858 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
859 // Test an anonymous client talking to a fixed-path unix socket.
860 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
861 int serverPathFd = mkstemp(serverPath);
862 EXPECT_GE(serverPathFd, 0);
863 int rc = unlink(serverPath);
866 SocketAddress serverBindAddr;
867 SocketAddress listenAddr;
868 SocketAddress acceptAddr;
869 SocketAddress serverAddr;
870 SocketAddress serverPeerAddr;
871 SocketAddress clientAddr;
872 SocketAddress clientPeerAddr;
874 serverBindAddr.setFromPath(serverPath);
876 testSetFromSocket(&serverBindAddr, nullptr,
877 &listenAddr, &acceptAddr,
878 &serverAddr, &serverPeerAddr,
879 &clientAddr, &clientPeerAddr);
881 // Remove the socket file after we are done
887 // The server socket's local address should be the same as the listen
889 EXPECT_EQ(serverAddr, listenAddr);
891 // The client's peer address should always be the same as the server
893 EXPECT_EQ(clientPeerAddr, serverAddr);
895 // Since the client is using an anonymous address, it won't compare equal to
896 // any other anonymous addresses. Make sure the addresses are anonymous.
897 EXPECT_EQ(serverPeerAddr.getPath(), "");
898 EXPECT_EQ(clientAddr.getPath(), "");
899 EXPECT_EQ(acceptAddr.getPath(), "");
902 TEST(SocketAddress, ResetUnixAddress) {
904 addy.setFromPath("/foo");
907 EXPECT_EQ(addy.getFamily(), AF_UNSPEC);
910 TEST(SocketAddress, ResetIPAddress) {
912 addr.setFromIpPort("127.0.0.1", 80);
914 EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
915 EXPECT_FALSE(addr.isInitialized());
916 EXPECT_TRUE(addr.empty());
918 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
920 EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
921 EXPECT_FALSE(addr.isInitialized());
922 EXPECT_TRUE(addr.empty());