2 * Copyright 2014 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>
23 using namespace boost;
27 using folly::SocketAddress;
29 TEST(SocketAddress, Size) {
31 EXPECT_EQ(sizeof(addr), 32);
34 TEST(SocketAddress, ConstructFromIpv4) {
35 SocketAddress addr("1.2.3.4", 4321);
36 EXPECT_EQ(addr.getFamily(), AF_INET);
37 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
38 EXPECT_EQ(addr.getPort(), 4321);
39 sockaddr_storage addrStorage;
40 addr.getAddress(&addrStorage);
41 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
42 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x01020304));
43 EXPECT_EQ(inaddr->sin_port, htons(4321));
46 TEST(SocketAddress, IPv4ToStringConversion) {
47 // testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
49 for (int pos = 0; pos < 4; ++pos) {
50 for (int i = 0; i < 256; ++i) {
51 int fragments[] = {5,5,5,5};
53 std::ostringstream ss;
54 ss << fragments[0] << "." << fragments[1] << "."
55 << fragments[2] << "." << fragments[3];
56 string ipString = ss.str();
57 addr.setFromIpPort(ipString, 1234);
58 EXPECT_EQ(addr.getAddressStr(), ipString);
63 TEST(SocketAddress, SetFromIpv4) {
65 addr.setFromIpPort("255.254.253.252", 8888);
66 EXPECT_EQ(addr.getFamily(), AF_INET);
67 EXPECT_EQ(addr.getAddressStr(), "255.254.253.252");
68 EXPECT_EQ(addr.getPort(), 8888);
69 sockaddr_storage addrStorage;
70 addr.getAddress(&addrStorage);
71 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
72 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0xfffefdfc));
73 EXPECT_EQ(inaddr->sin_port, htons(8888));
76 TEST(SocketAddress, ConstructFromInvalidIpv4) {
77 EXPECT_THROW(SocketAddress("1.2.3.256", 1234), std::runtime_error);
80 TEST(SocketAddress, SetFromInvalidIpv4) {
81 SocketAddress addr("12.34.56.78", 80);
83 // Try setting to an invalid value
84 // Since setFromIpPort() shouldn't allow hostname lookups, setting to
85 // "localhost" should fail, even if localhost is resolvable
86 EXPECT_THROW(addr.setFromIpPort("localhost", 1234),
89 // Make sure the address still has the old contents
90 EXPECT_EQ(addr.getFamily(), AF_INET);
91 EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
92 EXPECT_EQ(addr.getPort(), 80);
93 sockaddr_storage addrStorage;
94 addr.getAddress(&addrStorage);
95 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
96 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
99 TEST(SocketAddress, SetFromHostname) {
100 // hopefully "localhost" is resolvable on any system that will run the tests
101 EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
102 SocketAddress addr("localhost", 80, true);
105 EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
106 addr2.setFromHostPort("localhost", 0);
109 TEST(SocketAddress, SetFromStrings) {
112 // Set from a numeric port string
113 addr.setFromLocalPort("1234");
114 EXPECT_EQ(addr.getPort(), 1234);
116 // setFromLocalPort() should not accept service names
117 EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
119 // Call setFromLocalIpPort() with just a port, no IP
120 addr.setFromLocalIpPort("80");
121 EXPECT_EQ(addr.getPort(), 80);
123 // Call setFromLocalIpPort() with an IP and port.
124 addr.setFromLocalIpPort("127.0.0.1:4321");
125 EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
126 EXPECT_EQ(addr.getPort(), 4321);
128 // setFromIpPort() without an address should fail
129 EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
131 // Call setFromIpPort() with an IPv6 address and port
132 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
133 EXPECT_EQ(addr.getFamily(), AF_INET6);
134 EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
135 EXPECT_EQ(addr.getPort(), 65535);
137 // Call setFromIpPort() with an IPv4 address and port
138 addr.setFromIpPort("1.2.3.4:9999");
139 EXPECT_EQ(addr.getFamily(), AF_INET);
140 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
141 EXPECT_EQ(addr.getPort(), 9999);
144 TEST(SocketAddress, EqualityAndHash) {
146 SocketAddress local1("127.0.0.1", 1234);
147 EXPECT_EQ(local1, local1);
148 EXPECT_EQ(local1.hash(), local1.hash());
150 SocketAddress local2("127.0.0.1", 1234);
151 EXPECT_EQ(local1, local2);
152 EXPECT_EQ(local1.hash(), local2.hash());
154 SocketAddress local3("127.0.0.1", 4321);
155 EXPECT_NE(local1, local3);
156 EXPECT_NE(local1.hash(), local3.hash());
158 SocketAddress other1("1.2.3.4", 1234);
159 EXPECT_EQ(other1, other1);
160 EXPECT_EQ(other1.hash(), other1.hash());
161 EXPECT_NE(local1, other1);
162 EXPECT_NE(local1.hash(), other1.hash());
164 SocketAddress other2("4.3.2.1", 1234);
165 EXPECT_NE(other1.hash(), other2.hash());
166 EXPECT_NE(other1.hash(), other2.hash());
168 other2.setFromIpPort("1.2.3.4", 0);
169 EXPECT_NE(other1.hash(), other2.hash());
170 EXPECT_NE(other1.hash(), other2.hash());
171 other2.setPort(1234);
172 EXPECT_EQ(other1.hash(), other2.hash());
173 EXPECT_EQ(other1.hash(), other2.hash());
176 SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
177 SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
178 SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
179 EXPECT_EQ(v6_1, v6_2);
180 EXPECT_EQ(v6_1.hash(), v6_2.hash());
181 EXPECT_NE(v6_1, v6_3);
182 EXPECT_NE(v6_1.hash(), v6_3.hash());
184 // IPv4 versus IPv6 comparison
185 SocketAddress localIPv6("::1", 1234);
186 // Even though these both refer to localhost,
187 // IPv4 and IPv6 addresses are never treated as the same address
188 EXPECT_NE(local1, localIPv6);
189 EXPECT_NE(local1.hash(), localIPv6.hash());
191 // IPv4-mapped IPv6 addresses are not treated as equal
192 // to the equivalent IPv4 address
193 SocketAddress v4("10.0.0.3", 99);
194 SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
195 SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
196 EXPECT_NE(v4, v6_mapped1);
197 EXPECT_NE(v4, v6_mapped2);
198 EXPECT_EQ(v6_mapped1, v6_mapped2);
200 // However, after calling convertToIPv4(), the mapped address should now be
201 // equal to the v4 version.
202 EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
203 v6_mapped1.convertToIPv4();
204 EXPECT_EQ(v6_mapped1, v4);
205 EXPECT_NE(v6_mapped1, v6_mapped2);
209 unix1.setFromPath("/foo");
211 unix2.setFromPath("/foo");
213 unix3.setFromPath("/bar");
214 SocketAddress unixAnon;
215 unixAnon.setFromPath("");
217 EXPECT_EQ(unix1, unix2);
218 EXPECT_EQ(unix1.hash(), unix2.hash());
219 EXPECT_NE(unix1, unix3);
220 EXPECT_NE(unix1, unixAnon);
221 EXPECT_NE(unix2, unix3);
222 EXPECT_NE(unix2, unixAnon);
223 // anonymous addresses aren't equal to any other address,
224 // including themselves
225 EXPECT_NE(unixAnon, unixAnon);
227 // It isn't strictly required that hashes for different addresses be
228 // different, but we should have very few collisions. It generally indicates
229 // a problem if these collide
230 EXPECT_NE(unix1.hash(), unix3.hash());
231 EXPECT_NE(unix1.hash(), unixAnon.hash());
232 EXPECT_NE(unix3.hash(), unixAnon.hash());
235 TEST(SocketAddress, IsPrivate) {
237 SocketAddress addr("9.255.255.255", 0);
238 EXPECT_TRUE(!addr.isPrivateAddress());
239 addr.setFromIpPort("10.0.0.0", 0);
240 EXPECT_TRUE(addr.isPrivateAddress());
241 addr.setFromIpPort("10.255.255.255", 0);
242 EXPECT_TRUE(addr.isPrivateAddress());
243 addr.setFromIpPort("11.0.0.0", 0);
244 EXPECT_TRUE(!addr.isPrivateAddress());
246 addr.setFromIpPort("172.15.255.255", 0);
247 EXPECT_TRUE(!addr.isPrivateAddress());
248 addr.setFromIpPort("172.16.0.0", 0);
249 EXPECT_TRUE(addr.isPrivateAddress());
250 addr.setFromIpPort("172.31.255.255", 0);
251 EXPECT_TRUE(addr.isPrivateAddress());
252 addr.setFromIpPort("172.32.0.0", 0);
253 EXPECT_TRUE(!addr.isPrivateAddress());
255 addr.setFromIpPort("192.167.255.255", 0);
256 EXPECT_TRUE(!addr.isPrivateAddress());
257 addr.setFromIpPort("192.168.0.0", 0);
258 EXPECT_TRUE(addr.isPrivateAddress());
259 addr.setFromIpPort("192.168.255.255", 0);
260 EXPECT_TRUE(addr.isPrivateAddress());
261 addr.setFromIpPort("192.169.0.0", 0);
262 EXPECT_TRUE(!addr.isPrivateAddress());
264 addr.setFromIpPort("126.255.255.255", 0);
265 EXPECT_TRUE(!addr.isPrivateAddress());
266 addr.setFromIpPort("127.0.0.0", 0);
267 EXPECT_TRUE(addr.isPrivateAddress());
268 addr.setFromIpPort("127.0.0.1", 0);
269 EXPECT_TRUE(addr.isPrivateAddress());
270 addr.setFromIpPort("127.255.255.255", 0);
271 EXPECT_TRUE(addr.isPrivateAddress());
272 addr.setFromIpPort("128.0.0.0", 0);
273 EXPECT_TRUE(!addr.isPrivateAddress());
275 addr.setFromIpPort("1.2.3.4", 0);
276 EXPECT_TRUE(!addr.isPrivateAddress());
277 addr.setFromIpPort("69.171.239.10", 0);
278 EXPECT_TRUE(!addr.isPrivateAddress());
281 addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
282 EXPECT_TRUE(!addr.isPrivateAddress());
283 addr.setFromIpPort("fc00::", 0);
284 EXPECT_TRUE(addr.isPrivateAddress());
285 addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
286 EXPECT_TRUE(addr.isPrivateAddress());
287 addr.setFromIpPort("fe00::", 0);
288 EXPECT_TRUE(!addr.isPrivateAddress());
290 addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
291 EXPECT_TRUE(!addr.isPrivateAddress());
292 addr.setFromIpPort("fe80::", 0);
293 EXPECT_TRUE(addr.isPrivateAddress());
294 addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
295 EXPECT_TRUE(addr.isPrivateAddress());
296 addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
297 EXPECT_TRUE(addr.isPrivateAddress());
298 addr.setFromIpPort("fec0::", 0);
299 EXPECT_TRUE(!addr.isPrivateAddress());
301 addr.setFromIpPort("::0", 0);
302 EXPECT_TRUE(!addr.isPrivateAddress());
303 addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
304 EXPECT_TRUE(!addr.isPrivateAddress());
307 addr.setFromIpPort("::ffff:127.0.0.1", 0);
308 EXPECT_TRUE(addr.isPrivateAddress());
309 addr.setFromIpPort("::ffff:10.1.2.3", 0);
310 EXPECT_TRUE(addr.isPrivateAddress());
311 addr.setFromIpPort("::ffff:172.24.0.115", 0);
312 EXPECT_TRUE(addr.isPrivateAddress());
313 addr.setFromIpPort("::ffff:192.168.0.1", 0);
314 EXPECT_TRUE(addr.isPrivateAddress());
315 addr.setFromIpPort("::ffff:69.171.239.10", 0);
316 EXPECT_TRUE(!addr.isPrivateAddress());
318 // Unix sockets are considered private addresses
319 addr.setFromPath("/tmp/mysock");
320 EXPECT_TRUE(addr.isPrivateAddress());
323 TEST(SocketAddress, IsLoopback) {
325 SocketAddress addr("127.0.0.1", 0);
326 EXPECT_TRUE(addr.isLoopbackAddress());
327 addr.setFromIpPort("127.0.0.0", 0xffff);
328 EXPECT_TRUE(addr.isLoopbackAddress());
329 addr.setFromIpPort("127.1.1.1", 0xffff);
330 EXPECT_TRUE(addr.isLoopbackAddress());
331 addr.setFromIpPort("127.255.255.255", 80);
332 EXPECT_TRUE(addr.isLoopbackAddress());
334 addr.setFromIpPort("128.0.0.0", 0);
335 EXPECT_TRUE(!addr.isLoopbackAddress());
336 addr.setFromIpPort("126.255.255.255", 0);
337 EXPECT_TRUE(!addr.isLoopbackAddress());
338 addr.setFromIpPort("10.1.2.3", 0);
339 EXPECT_TRUE(!addr.isLoopbackAddress());
342 addr.setFromIpPort("::1", 0);
343 EXPECT_TRUE(addr.isLoopbackAddress());
344 addr.setFromIpPort("::0", 0);
345 EXPECT_TRUE(!addr.isLoopbackAddress());
346 addr.setFromIpPort("::2", 0);
347 EXPECT_TRUE(!addr.isLoopbackAddress());
350 addr.setFromIpPort("::ffff:127.0.0.1", 0);
351 EXPECT_TRUE(addr.isLoopbackAddress());
352 addr.setFromIpPort("::ffff:7f0a:141e", 0);
353 EXPECT_TRUE(addr.isLoopbackAddress());
354 addr.setFromIpPort("::ffff:169.254.0.13", 0);
355 EXPECT_TRUE(!addr.isLoopbackAddress());
357 // Unix sockets are considered loopback addresses
358 addr.setFromPath("/tmp/mysock");
359 EXPECT_TRUE(addr.isLoopbackAddress());
362 void CheckPrefixMatch(const SocketAddress& first,
363 const SocketAddress& second, unsigned matchingPrefixLen) {
365 for (i = 0; i <= matchingPrefixLen; i++) {
366 EXPECT_TRUE(first.prefixMatch(second, i));
368 unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
369 for (; i <= addrLen; i++) {
370 EXPECT_TRUE(!first.prefixMatch(second, i));
374 TEST(SocketAddress, PrefixMatch) {
376 SocketAddress addr1("127.0.0.1", 0);
377 SocketAddress addr2("127.0.0.1", 0);
378 CheckPrefixMatch(addr1, addr2, 32);
380 addr2.setFromIpPort("127.0.1.1", 0);
381 CheckPrefixMatch(addr1, addr2, 23);
383 addr2.setFromIpPort("1.1.0.127", 0);
384 CheckPrefixMatch(addr1, addr2, 1);
386 // Address family mismatch
387 addr2.setFromIpPort("::ffff:127.0.0.1", 0);
388 EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
391 addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
392 CheckPrefixMatch(addr1, addr2, 2);
394 addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
395 CheckPrefixMatch(addr1, addr2, 128);
397 addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
398 CheckPrefixMatch(addr1, addr2, 42);
401 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
402 EXPECT_TRUE(!(first < first));
403 EXPECT_TRUE(!(second < second));
404 EXPECT_TRUE(first < second);
405 EXPECT_TRUE(!(first == second));
406 EXPECT_TRUE(!(second < first));
409 TEST(SocketAddress, CheckComparatorBehavior) {
410 SocketAddress first, second;
411 // The following comparison are strict (so if first and second were
412 // inverted that is ok.
417 first.setFromIpPort("128.0.0.0", 0);
418 second.setFromIpPort("128.0.0.0", 0xFFFF);
419 CheckFirstLessThanSecond(first, second);
420 first.setFromIpPort("128.0.0.100", 0);
421 second.setFromIpPort("128.0.0.0", 0xFFFF);
422 CheckFirstLessThanSecond(first, second);
424 // Address comparisons
425 first.setFromIpPort("128.0.0.0", 10);
426 second.setFromIpPort("128.0.0.100", 10);
427 CheckFirstLessThanSecond(first, second);
429 // Comaprision between IPV4 and IPV6
430 first.setFromIpPort("128.0.0.0", 0);
431 second.setFromIpPort("::ffff:127.0.0.1", 0);
432 CheckFirstLessThanSecond(first, second);
433 first.setFromIpPort("128.0.0.0", 100);
434 second.setFromIpPort("::ffff:127.0.0.1", 0);
435 CheckFirstLessThanSecond(first, second);
440 first.setFromIpPort("::0", 0);
441 second.setFromIpPort("::0", 0xFFFF);
442 CheckFirstLessThanSecond(first, second);
443 first.setFromIpPort("::0", 0);
444 second.setFromIpPort("::1", 0xFFFF);
445 CheckFirstLessThanSecond(first, second);
447 // Address comparisons
448 first.setFromIpPort("::0", 10);
449 second.setFromIpPort("::1", 10);
450 CheckFirstLessThanSecond(first, second);
453 first.setFromPath("/foo");
454 second.setFromPath("/1234");
455 // The exact comparison order doesn't really matter, as long as
456 // (a < b), (b < a), and (a == b) are consistent.
457 // This checks our current comparison rules, which checks the path length
458 // before the path contents.
459 CheckFirstLessThanSecond(first, second);
460 first.setFromPath("/1234");
461 second.setFromPath("/5678");
462 CheckFirstLessThanSecond(first, second);
465 // We currently compare the address family values, and AF_UNIX < AF_INET
466 first.setFromPath("/foo");
467 second.setFromIpPort("127.0.0.1", 80);
468 CheckFirstLessThanSecond(first, second);
471 TEST(SocketAddress, Unix) {
475 addr.setFromPath("foo");
476 EXPECT_EQ(addr.getFamily(), AF_UNIX);
477 EXPECT_EQ(addr.describe(), "foo");
478 EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
479 EXPECT_THROW(addr.getPort(), std::invalid_argument);
480 EXPECT_TRUE(addr.isPrivateAddress());
481 EXPECT_TRUE(addr.isLoopbackAddress());
483 // Test a path that is too large
484 const char longPath[] =
485 "abcdefghijklmnopqrstuvwxyz0123456789"
486 "abcdefghijklmnopqrstuvwxyz0123456789"
487 "abcdefghijklmnopqrstuvwxyz0123456789"
488 "abcdefghijklmnopqrstuvwxyz0123456789";
489 EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
490 // The original address should still be the same
491 EXPECT_EQ(addr.getFamily(), AF_UNIX);
492 EXPECT_EQ(addr.describe(), "foo");
494 // Test a path that exactly fits in sockaddr_un
495 // (not including the NUL terminator)
496 const char exactLengthPath[] =
497 "abcdefghijklmnopqrstuvwxyz0123456789"
498 "abcdefghijklmnopqrstuvwxyz0123456789"
499 "abcdefghijklmnopqrstuvwxyz0123456789";
500 addr.setFromPath(exactLengthPath);
501 EXPECT_EQ(addr.describe(), exactLengthPath);
503 // Test converting a unix socket address to an IPv4 one, then back
504 addr.setFromHostPort("127.0.0.1", 1234);
505 EXPECT_EQ(addr.getFamily(), AF_INET);
506 EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
507 addr.setFromPath("/i/am/a/unix/address");
508 EXPECT_EQ(addr.getFamily(), AF_UNIX);
509 EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
511 // Test copy constructor and assignment operator
513 SocketAddress copy(addr);
514 EXPECT_EQ(copy, addr);
515 copy.setFromPath("/abc");
516 EXPECT_NE(copy, addr);
518 EXPECT_EQ(copy, addr);
519 copy.setFromIpPort("127.0.0.1", 80);
520 EXPECT_NE(copy, addr);
522 EXPECT_EQ(copy, addr);
526 SocketAddress copy(addr);
527 EXPECT_EQ(copy, addr);
528 EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
529 EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
531 SocketAddress other("127.0.0.1", 80);
532 EXPECT_NE(other, addr);
534 EXPECT_EQ(other, copy);
535 EXPECT_EQ(other, addr);
536 EXPECT_EQ(copy, addr);
539 #if __GXX_EXPERIMENTAL_CXX0X__
543 // move a unix address into a non-unix address
544 SocketAddress tmpCopy(addr);
545 copy = std::move(tmpCopy);
547 EXPECT_EQ(copy, addr);
549 copy.setFromPath("/another/path");
551 // move a unix address into a unix address
552 SocketAddress tmpCopy(addr);
553 copy = std::move(tmpCopy);
555 EXPECT_EQ(copy, addr);
558 // move a non-unix address into a unix address
559 SocketAddress tmp("127.0.0.1", 80);
560 copy = std::move(tmp);
562 EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
563 EXPECT_EQ(copy.getPort(), 80);
566 // move construct a unix address
567 SocketAddress other(std::move(copy));
568 EXPECT_EQ(other, addr);
569 EXPECT_EQ(other.getPath(), addr.getPath());
574 TEST(SocketAddress, AnonymousUnix) {
575 // Create a unix socket pair, and get the addresses.
577 int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
584 addr0.setFromLocalAddress(fds[0]);
585 peer0.setFromPeerAddress(fds[0]);
586 addr1.setFromLocalAddress(fds[1]);
587 peer1.setFromPeerAddress(fds[1]);
591 EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
592 EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
593 EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
594 EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
596 // Anonymous addresses should never compare equal
597 EXPECT_NE(addr0, addr1);
598 EXPECT_NE(peer0, peer1);
600 // Note that logically addr0 and peer1 are the same,
601 // but since they are both anonymous we have no way to determine this
602 EXPECT_NE(addr0, peer1);
603 // We can't even tell if an anonymous address is equal to itself
604 EXPECT_NE(addr0, addr0);
607 #define REQUIRE_ERRNO(cond, msg) \
609 int _requireErrnoCopy_ = errno; \
610 std::ostringstream _requireMsg_; \
611 _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
615 void testSetFromSocket(const SocketAddress *serverBindAddr,
616 const SocketAddress *clientBindAddr,
617 SocketAddress *listenAddrRet,
618 SocketAddress *acceptAddrRet,
619 SocketAddress *serverAddrRet,
620 SocketAddress *serverPeerAddrRet,
621 SocketAddress *clientAddrRet,
622 SocketAddress *clientPeerAddrRet) {
623 int listenSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
624 REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
625 sockaddr_storage laddr;
626 serverBindAddr->getAddress(&laddr);
627 socklen_t laddrLen = serverBindAddr->getActualSize();
628 int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
629 REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
630 rc = listen(listenSock, 10);
631 REQUIRE_ERRNO(rc == 0, "failed to listen");
633 listenAddrRet->setFromLocalAddress(listenSock);
635 SocketAddress listenPeerAddr;
636 EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
639 // Note that we use the family from serverBindAddr here, since we allow
640 // clientBindAddr to be nullptr.
641 int clientSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
642 REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
643 if (clientBindAddr != nullptr) {
644 sockaddr_storage clientAddr;
645 clientBindAddr->getAddress(&clientAddr);
647 rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
648 clientBindAddr->getActualSize());
649 REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
652 sockaddr_storage listenAddr;
653 listenAddrRet->getAddress(&listenAddr);
654 rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
655 listenAddrRet->getActualSize());
656 REQUIRE_ERRNO(rc == 0, "failed to connect");
658 sockaddr_storage acceptAddr;
659 socklen_t acceptAddrLen = sizeof(acceptAddr);
660 int serverSock = accept(listenSock, reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
661 REQUIRE_ERRNO(serverSock > 0, "failed to accept");
662 acceptAddrRet->setFromSockaddr(reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
664 serverAddrRet->setFromLocalAddress(serverSock);
665 serverPeerAddrRet->setFromPeerAddress(serverSock);
666 clientAddrRet->setFromLocalAddress(clientSock);
667 clientPeerAddrRet->setFromPeerAddress(clientSock);
674 TEST(SocketAddress, SetFromSocketIPv4) {
675 SocketAddress serverBindAddr("0.0.0.0", 0);
676 SocketAddress clientBindAddr("0.0.0.0", 0);
677 SocketAddress listenAddr;
678 SocketAddress acceptAddr;
679 SocketAddress serverAddr;
680 SocketAddress serverPeerAddr;
681 SocketAddress clientAddr;
682 SocketAddress clientPeerAddr;
684 testSetFromSocket(&serverBindAddr, &clientBindAddr,
685 &listenAddr, &acceptAddr,
686 &serverAddr, &serverPeerAddr,
687 &clientAddr, &clientPeerAddr);
689 // The server socket's local address should have the same port as the listen
690 // address. The IP will be different, since the listening socket is
691 // listening on INADDR_ANY, but the server socket will have a concrete IP
692 // address assigned to it.
693 EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
695 // The client's peer address should always be the same as the server
697 EXPECT_EQ(clientPeerAddr, serverAddr);
698 // The address returned by getpeername() on the server socket should
699 // be the same as the address returned by accept()
700 EXPECT_EQ(serverPeerAddr, acceptAddr);
701 EXPECT_EQ(serverPeerAddr, clientAddr);
702 EXPECT_EQ(acceptAddr, clientAddr);
706 * Note this test exercises Linux-specific Unix socket behavior
708 TEST(SocketAddress, SetFromSocketUnixAbstract) {
709 // Explicitly binding to an empty path results in an abstract socket
710 // name being picked for us automatically.
711 SocketAddress serverBindAddr;
713 path.append("test address");
714 serverBindAddr.setFromPath(path);
715 SocketAddress clientBindAddr;
716 clientBindAddr.setFromPath("");
718 SocketAddress listenAddr;
719 SocketAddress acceptAddr;
720 SocketAddress serverAddr;
721 SocketAddress serverPeerAddr;
722 SocketAddress clientAddr;
723 SocketAddress clientPeerAddr;
725 testSetFromSocket(&serverBindAddr, &clientBindAddr,
726 &listenAddr, &acceptAddr,
727 &serverAddr, &serverPeerAddr,
728 &clientAddr, &clientPeerAddr);
730 // The server socket's local address should be the same as the listen
732 EXPECT_EQ(serverAddr, listenAddr);
734 // The client's peer address should always be the same as the server
736 EXPECT_EQ(clientPeerAddr, serverAddr);
738 EXPECT_EQ(serverPeerAddr, clientAddr);
739 // Oddly, the address returned by accept() does not seem to match the address
740 // returned by getpeername() on the server socket or getsockname() on the
742 // EXPECT_EQ(serverPeerAddr, acceptAddr);
743 // EXPECT_EQ(acceptAddr, clientAddr);
746 TEST(SocketAddress, SetFromSocketUnixExplicit) {
747 // Pick two temporary path names.
748 // We use mkstemp() just to avoid warnings about mktemp,
749 // but we need to remove the file to let the socket code bind to it.
750 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
751 int serverPathFd = mkstemp(serverPath);
752 EXPECT_GE(serverPathFd, 0);
753 char clientPath[] = "/tmp/SocketAddressTest.client.XXXXXX";
754 int clientPathFd = mkstemp(clientPath);
755 EXPECT_GE(clientPathFd, 0);
757 int rc = unlink(serverPath);
759 rc = unlink(clientPath);
762 SocketAddress serverBindAddr;
763 SocketAddress clientBindAddr;
764 SocketAddress listenAddr;
765 SocketAddress acceptAddr;
766 SocketAddress serverAddr;
767 SocketAddress serverPeerAddr;
768 SocketAddress clientAddr;
769 SocketAddress clientPeerAddr;
771 serverBindAddr.setFromPath(serverPath);
772 clientBindAddr.setFromPath(clientPath);
774 testSetFromSocket(&serverBindAddr, &clientBindAddr,
775 &listenAddr, &acceptAddr,
776 &serverAddr, &serverPeerAddr,
777 &clientAddr, &clientPeerAddr);
779 // Remove the socket files after we are done
787 // The server socket's local address should be the same as the listen
789 EXPECT_EQ(serverAddr, listenAddr);
791 // The client's peer address should always be the same as the server
793 EXPECT_EQ(clientPeerAddr, serverAddr);
795 EXPECT_EQ(serverPeerAddr, clientAddr);
796 EXPECT_EQ(serverPeerAddr, acceptAddr);
797 EXPECT_EQ(acceptAddr, clientAddr);
800 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
801 // Test an anonymous client talking to a fixed-path unix socket.
802 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
803 int serverPathFd = mkstemp(serverPath);
804 EXPECT_GE(serverPathFd, 0);
805 int rc = unlink(serverPath);
808 SocketAddress serverBindAddr;
809 SocketAddress listenAddr;
810 SocketAddress acceptAddr;
811 SocketAddress serverAddr;
812 SocketAddress serverPeerAddr;
813 SocketAddress clientAddr;
814 SocketAddress clientPeerAddr;
816 serverBindAddr.setFromPath(serverPath);
818 testSetFromSocket(&serverBindAddr, nullptr,
819 &listenAddr, &acceptAddr,
820 &serverAddr, &serverPeerAddr,
821 &clientAddr, &clientPeerAddr);
823 // Remove the socket file after we are done
829 // The server socket's local address should be the same as the listen
831 EXPECT_EQ(serverAddr, listenAddr);
833 // The client's peer address should always be the same as the server
835 EXPECT_EQ(clientPeerAddr, serverAddr);
837 // Since the client is using an anonymous address, it won't compare equal to
838 // any other anonymous addresses. Make sure the addresses are anonymous.
839 EXPECT_EQ(serverPeerAddr.getPath(), "");
840 EXPECT_EQ(clientAddr.getPath(), "");
841 EXPECT_EQ(acceptAddr.getPath(), "");
844 TEST(SocketAddress, ResetUnixAddress) {
846 addy.setFromPath("/foo");
849 EXPECT_EQ(addy.getFamily(), AF_UNSPEC);