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>
19 #include <gtest/gtest.h>
22 #include <system_error>
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, IPv4ToStringConversion) {
55 // testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
57 for (int pos = 0; pos < 4; ++pos) {
58 for (int i = 0; i < 256; ++i) {
59 int fragments[] = {5,5,5,5};
61 std::ostringstream ss;
62 ss << fragments[0] << "." << fragments[1] << "."
63 << fragments[2] << "." << fragments[3];
64 string ipString = ss.str();
65 addr.setFromIpPort(ipString, 1234);
66 EXPECT_EQ(addr.getAddressStr(), ipString);
71 TEST(SocketAddress, SetFromIpAddressPort) {
73 folly::IPAddress ipAddr("123.234.0.23");
74 addr.setFromIpAddrPort(ipAddr, 8888);
75 EXPECT_EQ(addr.getFamily(), AF_INET);
76 EXPECT_EQ(addr.getAddressStr(), "123.234.0.23");
77 EXPECT_EQ(addr.getIPAddress(), ipAddr);
78 EXPECT_EQ(addr.getPort(), 8888);
80 folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
81 SocketAddress addr6(ip6Addr, 8888);
82 EXPECT_EQ(addr6.getFamily(), AF_INET6);
83 EXPECT_EQ(addr6.getAddressStr(), "2620:0:1cfe:face:b00c::3");
84 EXPECT_EQ(addr6.getIPAddress(), ip6Addr);
85 EXPECT_EQ(addr6.getPort(), 8888);
88 TEST(SocketAddress, SetFromIpv4) {
90 addr.setFromIpPort("255.254.253.252", 8888);
91 EXPECT_EQ(addr.getFamily(), AF_INET);
92 EXPECT_EQ(addr.getAddressStr(), "255.254.253.252");
93 EXPECT_EQ(addr.getPort(), 8888);
94 sockaddr_storage addrStorage;
95 addr.getAddress(&addrStorage);
96 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
97 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0xfffefdfc));
98 EXPECT_EQ(inaddr->sin_port, htons(8888));
101 TEST(SocketAddress, ConstructFromInvalidIpv4) {
102 EXPECT_THROW(SocketAddress("1.2.3.256", 1234), std::runtime_error);
105 TEST(SocketAddress, SetFromInvalidIpv4) {
106 SocketAddress addr("12.34.56.78", 80);
108 // Try setting to an invalid value
109 // Since setFromIpPort() shouldn't allow hostname lookups, setting to
110 // "localhost" should fail, even if localhost is resolvable
111 EXPECT_THROW(addr.setFromIpPort("localhost", 1234),
114 // Make sure the address still has the old contents
115 EXPECT_EQ(addr.getFamily(), AF_INET);
116 EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
117 EXPECT_EQ(addr.getPort(), 80);
118 sockaddr_storage addrStorage;
119 addr.getAddress(&addrStorage);
120 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
121 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
124 TEST(SocketAddress, SetFromHostname) {
125 // hopefully "localhost" is resolvable on any system that will run the tests
126 EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
127 SocketAddress addr("localhost", 80, true);
130 EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
131 addr2.setFromHostPort("localhost", 0);
134 TEST(SocketAddress, SetFromStrings) {
137 // Set from a numeric port string
138 addr.setFromLocalPort("1234");
139 EXPECT_EQ(addr.getPort(), 1234);
141 // setFromLocalPort() should not accept service names
142 EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
144 // Call setFromLocalIpPort() with just a port, no IP
145 addr.setFromLocalIpPort("80");
146 EXPECT_EQ(addr.getPort(), 80);
148 // Call setFromLocalIpPort() with an IP and port.
149 if (SocketAddressTestHelper::isIPv4Enabled()) {
150 addr.setFromLocalIpPort("127.0.0.1:4321");
151 EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
152 EXPECT_EQ(addr.getPort(), 4321);
154 if (SocketAddressTestHelper::isIPv6Enabled()) {
155 addr.setFromLocalIpPort("::1:4321");
156 EXPECT_EQ(addr.getAddressStr(), "::1");
157 EXPECT_EQ(addr.getPort(), 4321);
160 // setFromIpPort() without an address should fail
161 EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
163 // Call setFromIpPort() with an IPv6 address and port
164 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
165 EXPECT_EQ(addr.getFamily(), AF_INET6);
166 EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
167 EXPECT_EQ(addr.getPort(), 65535);
169 // Call setFromIpPort() with an IPv4 address and port
170 addr.setFromIpPort("1.2.3.4:9999");
171 EXPECT_EQ(addr.getFamily(), AF_INET);
172 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
173 EXPECT_EQ(addr.getPort(), 9999);
175 // Call setFromIpPort() with a bracketed IPv6
176 addr.setFromIpPort("[::]:1234");
177 EXPECT_EQ(addr.getFamily(), AF_INET6);
178 EXPECT_EQ(addr.getAddressStr(), "::");
179 EXPECT_EQ(addr.getPort(), 1234);
181 // Call setFromIpPort() with a bracketed IPv6
182 addr.setFromIpPort("[9:8::2]:1234");
183 EXPECT_EQ(addr.getFamily(), AF_INET6);
184 EXPECT_EQ(addr.getAddressStr(), "9:8::2");
185 EXPECT_EQ(addr.getPort(), 1234);
187 // Call setFromIpPort() with a bracketed IPv6 and no port
188 EXPECT_THROW(addr.setFromIpPort("[::]"), std::system_error);
191 TEST(SocketAddress, EqualityAndHash) {
193 SocketAddress local1("127.0.0.1", 1234);
194 EXPECT_EQ(local1, local1);
195 EXPECT_EQ(local1.hash(), local1.hash());
197 SocketAddress local2("127.0.0.1", 1234);
198 EXPECT_EQ(local1, local2);
199 EXPECT_EQ(local1.hash(), local2.hash());
201 SocketAddress local3("127.0.0.1", 4321);
202 EXPECT_NE(local1, local3);
203 EXPECT_NE(local1.hash(), local3.hash());
205 SocketAddress other1("1.2.3.4", 1234);
206 EXPECT_EQ(other1, other1);
207 EXPECT_EQ(other1.hash(), other1.hash());
208 EXPECT_NE(local1, other1);
209 EXPECT_NE(local1.hash(), other1.hash());
211 SocketAddress other2("4.3.2.1", 1234);
212 EXPECT_NE(other1.hash(), other2.hash());
213 EXPECT_NE(other1.hash(), other2.hash());
215 other2.setFromIpPort("1.2.3.4", 0);
216 EXPECT_NE(other1.hash(), other2.hash());
217 EXPECT_NE(other1.hash(), other2.hash());
218 other2.setPort(1234);
219 EXPECT_EQ(other1.hash(), other2.hash());
220 EXPECT_EQ(other1.hash(), other2.hash());
223 SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
224 SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
225 SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
226 EXPECT_EQ(v6_1, v6_2);
227 EXPECT_EQ(v6_1.hash(), v6_2.hash());
228 EXPECT_NE(v6_1, v6_3);
229 EXPECT_NE(v6_1.hash(), v6_3.hash());
231 // IPv4 versus IPv6 comparison
232 SocketAddress localIPv6("::1", 1234);
233 // Even though these both refer to localhost,
234 // IPv4 and IPv6 addresses are never treated as the same address
235 EXPECT_NE(local1, localIPv6);
236 EXPECT_NE(local1.hash(), localIPv6.hash());
238 // IPv4-mapped IPv6 addresses are not treated as equal
239 // to the equivalent IPv4 address
240 SocketAddress v4("10.0.0.3", 99);
241 SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
242 SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
243 EXPECT_NE(v4, v6_mapped1);
244 EXPECT_NE(v4, v6_mapped2);
245 EXPECT_EQ(v6_mapped1, v6_mapped2);
247 // However, after calling convertToIPv4(), the mapped address should now be
248 // equal to the v4 version.
249 EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
250 v6_mapped1.convertToIPv4();
251 EXPECT_EQ(v6_mapped1, v4);
252 EXPECT_NE(v6_mapped1, v6_mapped2);
256 unix1.setFromPath("/foo");
258 unix2.setFromPath("/foo");
260 unix3.setFromPath("/bar");
261 SocketAddress unixAnon;
262 unixAnon.setFromPath("");
264 EXPECT_EQ(unix1, unix2);
265 EXPECT_EQ(unix1.hash(), unix2.hash());
266 EXPECT_NE(unix1, unix3);
267 EXPECT_NE(unix1, unixAnon);
268 EXPECT_NE(unix2, unix3);
269 EXPECT_NE(unix2, unixAnon);
270 // anonymous addresses aren't equal to any other address,
271 // including themselves
272 EXPECT_NE(unixAnon, unixAnon);
274 // It isn't strictly required that hashes for different addresses be
275 // different, but we should have very few collisions. It generally indicates
276 // a problem if these collide
277 EXPECT_NE(unix1.hash(), unix3.hash());
278 EXPECT_NE(unix1.hash(), unixAnon.hash());
279 EXPECT_NE(unix3.hash(), unixAnon.hash());
282 TEST(SocketAddress, IsPrivate) {
284 SocketAddress addr("9.255.255.255", 0);
285 EXPECT_TRUE(!addr.isPrivateAddress());
286 addr.setFromIpPort("10.0.0.0", 0);
287 EXPECT_TRUE(addr.isPrivateAddress());
288 addr.setFromIpPort("10.255.255.255", 0);
289 EXPECT_TRUE(addr.isPrivateAddress());
290 addr.setFromIpPort("11.0.0.0", 0);
291 EXPECT_TRUE(!addr.isPrivateAddress());
293 addr.setFromIpPort("172.15.255.255", 0);
294 EXPECT_TRUE(!addr.isPrivateAddress());
295 addr.setFromIpPort("172.16.0.0", 0);
296 EXPECT_TRUE(addr.isPrivateAddress());
297 addr.setFromIpPort("172.31.255.255", 0);
298 EXPECT_TRUE(addr.isPrivateAddress());
299 addr.setFromIpPort("172.32.0.0", 0);
300 EXPECT_TRUE(!addr.isPrivateAddress());
302 addr.setFromIpPort("192.167.255.255", 0);
303 EXPECT_TRUE(!addr.isPrivateAddress());
304 addr.setFromIpPort("192.168.0.0", 0);
305 EXPECT_TRUE(addr.isPrivateAddress());
306 addr.setFromIpPort("192.168.255.255", 0);
307 EXPECT_TRUE(addr.isPrivateAddress());
308 addr.setFromIpPort("192.169.0.0", 0);
309 EXPECT_TRUE(!addr.isPrivateAddress());
311 addr.setFromIpPort("126.255.255.255", 0);
312 EXPECT_TRUE(!addr.isPrivateAddress());
313 addr.setFromIpPort("127.0.0.0", 0);
314 EXPECT_TRUE(addr.isPrivateAddress());
315 addr.setFromIpPort("127.0.0.1", 0);
316 EXPECT_TRUE(addr.isPrivateAddress());
317 addr.setFromIpPort("127.255.255.255", 0);
318 EXPECT_TRUE(addr.isPrivateAddress());
319 addr.setFromIpPort("128.0.0.0", 0);
320 EXPECT_TRUE(!addr.isPrivateAddress());
322 addr.setFromIpPort("1.2.3.4", 0);
323 EXPECT_TRUE(!addr.isPrivateAddress());
324 addr.setFromIpPort("69.171.239.10", 0);
325 EXPECT_TRUE(!addr.isPrivateAddress());
328 addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
329 EXPECT_TRUE(!addr.isPrivateAddress());
330 addr.setFromIpPort("fc00::", 0);
331 EXPECT_TRUE(addr.isPrivateAddress());
332 addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
333 EXPECT_TRUE(addr.isPrivateAddress());
334 addr.setFromIpPort("fe00::", 0);
335 EXPECT_TRUE(!addr.isPrivateAddress());
337 addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
338 EXPECT_TRUE(!addr.isPrivateAddress());
339 addr.setFromIpPort("fe80::", 0);
340 EXPECT_TRUE(addr.isPrivateAddress());
341 addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
342 EXPECT_TRUE(addr.isPrivateAddress());
343 addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
344 EXPECT_TRUE(addr.isPrivateAddress());
345 addr.setFromIpPort("fec0::", 0);
346 EXPECT_TRUE(!addr.isPrivateAddress());
348 addr.setFromIpPort("::0", 0);
349 EXPECT_TRUE(!addr.isPrivateAddress());
350 addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
351 EXPECT_TRUE(!addr.isPrivateAddress());
354 addr.setFromIpPort("::ffff:127.0.0.1", 0);
355 EXPECT_TRUE(addr.isPrivateAddress());
356 addr.setFromIpPort("::ffff:10.1.2.3", 0);
357 EXPECT_TRUE(addr.isPrivateAddress());
358 addr.setFromIpPort("::ffff:172.24.0.115", 0);
359 EXPECT_TRUE(addr.isPrivateAddress());
360 addr.setFromIpPort("::ffff:192.168.0.1", 0);
361 EXPECT_TRUE(addr.isPrivateAddress());
362 addr.setFromIpPort("::ffff:69.171.239.10", 0);
363 EXPECT_TRUE(!addr.isPrivateAddress());
365 // Unix sockets are considered private addresses
366 addr.setFromPath("/tmp/mysock");
367 EXPECT_TRUE(addr.isPrivateAddress());
370 TEST(SocketAddress, IsLoopback) {
372 SocketAddress addr("127.0.0.1", 0);
373 EXPECT_TRUE(addr.isLoopbackAddress());
374 addr.setFromIpPort("127.0.0.0", 0xffff);
375 EXPECT_TRUE(addr.isLoopbackAddress());
376 addr.setFromIpPort("127.1.1.1", 0xffff);
377 EXPECT_TRUE(addr.isLoopbackAddress());
378 addr.setFromIpPort("127.255.255.255", 80);
379 EXPECT_TRUE(addr.isLoopbackAddress());
381 addr.setFromIpPort("128.0.0.0", 0);
382 EXPECT_TRUE(!addr.isLoopbackAddress());
383 addr.setFromIpPort("126.255.255.255", 0);
384 EXPECT_TRUE(!addr.isLoopbackAddress());
385 addr.setFromIpPort("10.1.2.3", 0);
386 EXPECT_TRUE(!addr.isLoopbackAddress());
389 addr.setFromIpPort("::1", 0);
390 EXPECT_TRUE(addr.isLoopbackAddress());
391 addr.setFromIpPort("::0", 0);
392 EXPECT_TRUE(!addr.isLoopbackAddress());
393 addr.setFromIpPort("::2", 0);
394 EXPECT_TRUE(!addr.isLoopbackAddress());
397 addr.setFromIpPort("::ffff:127.0.0.1", 0);
398 EXPECT_TRUE(addr.isLoopbackAddress());
399 addr.setFromIpPort("::ffff:7f0a:141e", 0);
400 EXPECT_TRUE(addr.isLoopbackAddress());
401 addr.setFromIpPort("::ffff:169.254.0.13", 0);
402 EXPECT_TRUE(!addr.isLoopbackAddress());
404 // Unix sockets are considered loopback addresses
405 addr.setFromPath("/tmp/mysock");
406 EXPECT_TRUE(addr.isLoopbackAddress());
409 void CheckPrefixMatch(const SocketAddress& first,
410 const SocketAddress& second, unsigned matchingPrefixLen) {
412 for (i = 0; i <= matchingPrefixLen; i++) {
413 EXPECT_TRUE(first.prefixMatch(second, i));
415 unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
416 for (; i <= addrLen; i++) {
417 EXPECT_TRUE(!first.prefixMatch(second, i));
421 TEST(SocketAddress, PrefixMatch) {
423 SocketAddress addr1("127.0.0.1", 0);
424 SocketAddress addr2("127.0.0.1", 0);
425 CheckPrefixMatch(addr1, addr2, 32);
427 addr2.setFromIpPort("127.0.1.1", 0);
428 CheckPrefixMatch(addr1, addr2, 23);
430 addr2.setFromIpPort("1.1.0.127", 0);
431 CheckPrefixMatch(addr1, addr2, 1);
433 // Address family mismatch
434 addr2.setFromIpPort("::ffff:127.0.0.1", 0);
435 EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
438 addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
439 CheckPrefixMatch(addr1, addr2, 2);
441 addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
442 CheckPrefixMatch(addr1, addr2, 128);
444 addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
445 CheckPrefixMatch(addr1, addr2, 42);
448 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
449 EXPECT_TRUE(!(first < first));
450 EXPECT_TRUE(!(second < second));
451 EXPECT_TRUE(first < second);
452 EXPECT_TRUE(!(first == second));
453 EXPECT_TRUE(!(second < first));
456 TEST(SocketAddress, CheckComparatorBehavior) {
457 SocketAddress first, second;
458 // The following comparison are strict (so if first and second were
459 // inverted that is ok.
464 first.setFromIpPort("128.0.0.0", 0);
465 second.setFromIpPort("128.0.0.0", 0xFFFF);
466 CheckFirstLessThanSecond(first, second);
467 first.setFromIpPort("128.0.0.100", 0);
468 second.setFromIpPort("128.0.0.0", 0xFFFF);
469 CheckFirstLessThanSecond(first, second);
471 // Address comparisons
472 first.setFromIpPort("128.0.0.0", 10);
473 second.setFromIpPort("128.0.0.100", 10);
474 CheckFirstLessThanSecond(first, second);
476 // Comaprision between IPV4 and IPV6
477 first.setFromIpPort("128.0.0.0", 0);
478 second.setFromIpPort("::ffff:127.0.0.1", 0);
479 CheckFirstLessThanSecond(first, second);
480 first.setFromIpPort("128.0.0.0", 100);
481 second.setFromIpPort("::ffff:127.0.0.1", 0);
482 CheckFirstLessThanSecond(first, second);
487 first.setFromIpPort("::0", 0);
488 second.setFromIpPort("::0", 0xFFFF);
489 CheckFirstLessThanSecond(first, second);
490 first.setFromIpPort("::0", 0);
491 second.setFromIpPort("::1", 0xFFFF);
492 CheckFirstLessThanSecond(first, second);
494 // Address comparisons
495 first.setFromIpPort("::0", 10);
496 second.setFromIpPort("::1", 10);
497 CheckFirstLessThanSecond(first, second);
500 first.setFromPath("/foo");
501 second.setFromPath("/1234");
502 // The exact comparison order doesn't really matter, as long as
503 // (a < b), (b < a), and (a == b) are consistent.
504 // This checks our current comparison rules, which checks the path length
505 // before the path contents.
506 CheckFirstLessThanSecond(first, second);
507 first.setFromPath("/1234");
508 second.setFromPath("/5678");
509 CheckFirstLessThanSecond(first, second);
512 // We currently compare the address family values, and AF_UNIX < AF_INET
513 first.setFromPath("/foo");
514 second.setFromIpPort("127.0.0.1", 80);
515 CheckFirstLessThanSecond(first, second);
518 TEST(SocketAddress, Unix) {
522 addr.setFromPath("foo");
523 EXPECT_EQ(addr.getFamily(), AF_UNIX);
524 EXPECT_EQ(addr.describe(), "foo");
525 EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
526 EXPECT_THROW(addr.getPort(), std::invalid_argument);
527 EXPECT_TRUE(addr.isPrivateAddress());
528 EXPECT_TRUE(addr.isLoopbackAddress());
530 // Test a path that is too large
531 const char longPath[] =
532 "abcdefghijklmnopqrstuvwxyz0123456789"
533 "abcdefghijklmnopqrstuvwxyz0123456789"
534 "abcdefghijklmnopqrstuvwxyz0123456789"
535 "abcdefghijklmnopqrstuvwxyz0123456789";
536 EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
537 // The original address should still be the same
538 EXPECT_EQ(addr.getFamily(), AF_UNIX);
539 EXPECT_EQ(addr.describe(), "foo");
541 // Test a path that exactly fits in sockaddr_un
542 // (not including the NUL terminator)
543 const char exactLengthPath[] =
544 "abcdefghijklmnopqrstuvwxyz0123456789"
545 "abcdefghijklmnopqrstuvwxyz0123456789"
546 "abcdefghijklmnopqrstuvwxyz0123456789";
547 addr.setFromPath(exactLengthPath);
548 EXPECT_EQ(addr.describe(), exactLengthPath);
550 // Test converting a unix socket address to an IPv4 one, then back
551 addr.setFromHostPort("127.0.0.1", 1234);
552 EXPECT_EQ(addr.getFamily(), AF_INET);
553 EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
554 addr.setFromPath("/i/am/a/unix/address");
555 EXPECT_EQ(addr.getFamily(), AF_UNIX);
556 EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
558 // Test copy constructor and assignment operator
560 SocketAddress copy(addr);
561 EXPECT_EQ(copy, addr);
562 copy.setFromPath("/abc");
563 EXPECT_NE(copy, addr);
565 EXPECT_EQ(copy, addr);
566 copy.setFromIpPort("127.0.0.1", 80);
567 EXPECT_NE(copy, addr);
569 EXPECT_EQ(copy, addr);
573 SocketAddress copy(addr);
574 EXPECT_EQ(copy, addr);
575 EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
576 EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
578 SocketAddress other("127.0.0.1", 80);
579 EXPECT_NE(other, addr);
581 EXPECT_EQ(other, copy);
582 EXPECT_EQ(other, addr);
583 EXPECT_EQ(copy, addr);
586 #if __GXX_EXPERIMENTAL_CXX0X__
590 // move a unix address into a non-unix address
591 SocketAddress tmpCopy(addr);
592 copy = std::move(tmpCopy);
594 EXPECT_EQ(copy, addr);
596 copy.setFromPath("/another/path");
598 // move a unix address into a unix address
599 SocketAddress tmpCopy(addr);
600 copy = std::move(tmpCopy);
602 EXPECT_EQ(copy, addr);
605 // move a non-unix address into a unix address
606 SocketAddress tmp("127.0.0.1", 80);
607 copy = std::move(tmp);
609 EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
610 EXPECT_EQ(copy.getPort(), 80);
613 // move construct a unix address
614 SocketAddress other(std::move(copy));
615 EXPECT_EQ(other, addr);
616 EXPECT_EQ(other.getPath(), addr.getPath());
621 TEST(SocketAddress, AnonymousUnix) {
622 // Create a unix socket pair, and get the addresses.
624 int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
631 addr0.setFromLocalAddress(fds[0]);
632 peer0.setFromPeerAddress(fds[0]);
633 addr1.setFromLocalAddress(fds[1]);
634 peer1.setFromPeerAddress(fds[1]);
638 EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
639 EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
640 EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
641 EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
643 // Anonymous addresses should never compare equal
644 EXPECT_NE(addr0, addr1);
645 EXPECT_NE(peer0, peer1);
647 // Note that logically addr0 and peer1 are the same,
648 // but since they are both anonymous we have no way to determine this
649 EXPECT_NE(addr0, peer1);
650 // We can't even tell if an anonymous address is equal to itself
651 EXPECT_NE(addr0, addr0);
654 #define REQUIRE_ERRNO(cond, msg) \
656 int _requireErrnoCopy_ = errno; \
657 std::ostringstream _requireMsg_; \
658 _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
662 void testSetFromSocket(const SocketAddress *serverBindAddr,
663 const SocketAddress *clientBindAddr,
664 SocketAddress *listenAddrRet,
665 SocketAddress *acceptAddrRet,
666 SocketAddress *serverAddrRet,
667 SocketAddress *serverPeerAddrRet,
668 SocketAddress *clientAddrRet,
669 SocketAddress *clientPeerAddrRet) {
670 int listenSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
671 REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
672 sockaddr_storage laddr;
673 serverBindAddr->getAddress(&laddr);
674 socklen_t laddrLen = serverBindAddr->getActualSize();
675 int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
676 REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
677 rc = listen(listenSock, 10);
678 REQUIRE_ERRNO(rc == 0, "failed to listen");
680 listenAddrRet->setFromLocalAddress(listenSock);
682 SocketAddress listenPeerAddr;
683 EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
686 // Note that we use the family from serverBindAddr here, since we allow
687 // clientBindAddr to be nullptr.
688 int clientSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
689 REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
690 if (clientBindAddr != nullptr) {
691 sockaddr_storage clientAddr;
692 clientBindAddr->getAddress(&clientAddr);
694 rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
695 clientBindAddr->getActualSize());
696 REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
699 sockaddr_storage listenAddr;
700 listenAddrRet->getAddress(&listenAddr);
701 rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
702 listenAddrRet->getActualSize());
703 REQUIRE_ERRNO(rc == 0, "failed to connect");
705 sockaddr_storage acceptAddr;
706 socklen_t acceptAddrLen = sizeof(acceptAddr);
707 int serverSock = accept(listenSock,
708 reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
709 REQUIRE_ERRNO(serverSock > 0, "failed to accept");
710 acceptAddrRet->setFromSockaddr(
711 reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
713 serverAddrRet->setFromLocalAddress(serverSock);
714 serverPeerAddrRet->setFromPeerAddress(serverSock);
715 clientAddrRet->setFromLocalAddress(clientSock);
716 clientPeerAddrRet->setFromPeerAddress(clientSock);
723 TEST(SocketAddress, SetFromSocketIPv4) {
724 SocketAddress serverBindAddr("0.0.0.0", 0);
725 SocketAddress clientBindAddr("0.0.0.0", 0);
726 SocketAddress listenAddr;
727 SocketAddress acceptAddr;
728 SocketAddress serverAddr;
729 SocketAddress serverPeerAddr;
730 SocketAddress clientAddr;
731 SocketAddress clientPeerAddr;
733 testSetFromSocket(&serverBindAddr, &clientBindAddr,
734 &listenAddr, &acceptAddr,
735 &serverAddr, &serverPeerAddr,
736 &clientAddr, &clientPeerAddr);
738 // The server socket's local address should have the same port as the listen
739 // address. The IP will be different, since the listening socket is
740 // listening on INADDR_ANY, but the server socket will have a concrete IP
741 // address assigned to it.
742 EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
744 // The client's peer address should always be the same as the server
746 EXPECT_EQ(clientPeerAddr, serverAddr);
747 // The address returned by getpeername() on the server socket should
748 // be the same as the address returned by accept()
749 EXPECT_EQ(serverPeerAddr, acceptAddr);
750 EXPECT_EQ(serverPeerAddr, clientAddr);
751 EXPECT_EQ(acceptAddr, clientAddr);
755 * Note this test exercises Linux-specific Unix socket behavior
757 TEST(SocketAddress, SetFromSocketUnixAbstract) {
758 // Explicitly binding to an empty path results in an abstract socket
759 // name being picked for us automatically.
760 SocketAddress serverBindAddr;
762 path.append("test address");
763 serverBindAddr.setFromPath(path);
764 SocketAddress clientBindAddr;
765 clientBindAddr.setFromPath("");
767 SocketAddress listenAddr;
768 SocketAddress acceptAddr;
769 SocketAddress serverAddr;
770 SocketAddress serverPeerAddr;
771 SocketAddress clientAddr;
772 SocketAddress clientPeerAddr;
774 testSetFromSocket(&serverBindAddr, &clientBindAddr,
775 &listenAddr, &acceptAddr,
776 &serverAddr, &serverPeerAddr,
777 &clientAddr, &clientPeerAddr);
779 // The server socket's local address should be the same as the listen
781 EXPECT_EQ(serverAddr, listenAddr);
783 // The client's peer address should always be the same as the server
785 EXPECT_EQ(clientPeerAddr, serverAddr);
787 EXPECT_EQ(serverPeerAddr, clientAddr);
788 // Oddly, the address returned by accept() does not seem to match the address
789 // returned by getpeername() on the server socket or getsockname() on the
791 // EXPECT_EQ(serverPeerAddr, acceptAddr);
792 // EXPECT_EQ(acceptAddr, clientAddr);
795 TEST(SocketAddress, SetFromSocketUnixExplicit) {
796 // Pick two temporary path names.
797 // We use mkstemp() just to avoid warnings about mktemp,
798 // but we need to remove the file to let the socket code bind to it.
799 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
800 int serverPathFd = mkstemp(serverPath);
801 EXPECT_GE(serverPathFd, 0);
802 char clientPath[] = "/tmp/SocketAddressTest.client.XXXXXX";
803 int clientPathFd = mkstemp(clientPath);
804 EXPECT_GE(clientPathFd, 0);
806 int rc = unlink(serverPath);
808 rc = unlink(clientPath);
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);
821 clientBindAddr.setFromPath(clientPath);
823 testSetFromSocket(&serverBindAddr, &clientBindAddr,
824 &listenAddr, &acceptAddr,
825 &serverAddr, &serverPeerAddr,
826 &clientAddr, &clientPeerAddr);
828 // Remove the socket files after we are done
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 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
852 int serverPathFd = mkstemp(serverPath);
853 EXPECT_GE(serverPathFd, 0);
854 int rc = unlink(serverPath);
857 SocketAddress serverBindAddr;
858 SocketAddress listenAddr;
859 SocketAddress acceptAddr;
860 SocketAddress serverAddr;
861 SocketAddress serverPeerAddr;
862 SocketAddress clientAddr;
863 SocketAddress clientPeerAddr;
865 serverBindAddr.setFromPath(serverPath);
867 testSetFromSocket(&serverBindAddr, nullptr,
868 &listenAddr, &acceptAddr,
869 &serverAddr, &serverPeerAddr,
870 &clientAddr, &clientPeerAddr);
872 // Remove the socket file after we are done
878 // The server socket's local address should be the same as the listen
880 EXPECT_EQ(serverAddr, listenAddr);
882 // The client's peer address should always be the same as the server
884 EXPECT_EQ(clientPeerAddr, serverAddr);
886 // Since the client is using an anonymous address, it won't compare equal to
887 // any other anonymous addresses. Make sure the addresses are anonymous.
888 EXPECT_EQ(serverPeerAddr.getPath(), "");
889 EXPECT_EQ(clientAddr.getPath(), "");
890 EXPECT_EQ(acceptAddr.getPath(), "");
893 TEST(SocketAddress, ResetUnixAddress) {
895 addy.setFromPath("/foo");
898 EXPECT_EQ(addy.getFamily(), AF_UNSPEC);
901 TEST(SocketAddress, ResetIPAddress) {
903 addr.setFromIpPort("127.0.0.1", 80);
905 EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
906 EXPECT_FALSE(addr.isInitialized());
907 EXPECT_TRUE(addr.empty());
909 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
911 EXPECT_EQ(addr.getFamily(), AF_UNSPEC);
912 EXPECT_FALSE(addr.isInitialized());
913 EXPECT_TRUE(addr.empty());