2 * Copyright 2015 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 <folly/test/SocketAddressTestHelper.h>
24 using namespace boost;
28 using folly::SocketAddress;
29 using folly::SocketAddressTestHelper;
31 TEST(SocketAddress, Size) {
33 EXPECT_EQ(sizeof(addr), 32);
36 TEST(SocketAddress, ConstructFromIpv4) {
37 SocketAddress addr("1.2.3.4", 4321);
38 EXPECT_EQ(addr.getFamily(), AF_INET);
39 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
40 EXPECT_EQ(addr.getPort(), 4321);
41 sockaddr_storage addrStorage;
42 addr.getAddress(&addrStorage);
43 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
44 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x01020304));
45 EXPECT_EQ(inaddr->sin_port, htons(4321));
48 TEST(SocketAddress, IPv4ToStringConversion) {
49 // testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
51 for (int pos = 0; pos < 4; ++pos) {
52 for (int i = 0; i < 256; ++i) {
53 int fragments[] = {5,5,5,5};
55 std::ostringstream ss;
56 ss << fragments[0] << "." << fragments[1] << "."
57 << fragments[2] << "." << fragments[3];
58 string ipString = ss.str();
59 addr.setFromIpPort(ipString, 1234);
60 EXPECT_EQ(addr.getAddressStr(), ipString);
65 TEST(SocketAddress, SetFromIpAddressPort) {
67 folly::IPAddress ipAddr("123.234.0.23");
68 addr.setFromIpAddrPort(ipAddr, 8888);
69 EXPECT_EQ(addr.getFamily(), AF_INET);
70 EXPECT_EQ(addr.getAddressStr(), "123.234.0.23");
71 EXPECT_EQ(addr.getIPAddress(), ipAddr);
72 EXPECT_EQ(addr.getPort(), 8888);
74 folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
75 SocketAddress addr6(ip6Addr, 8888);
76 EXPECT_EQ(addr6.getFamily(), AF_INET6);
77 EXPECT_EQ(addr6.getAddressStr(), "2620:0:1cfe:face:b00c::3");
78 EXPECT_EQ(addr6.getIPAddress(), ip6Addr);
79 EXPECT_EQ(addr6.getPort(), 8888);
82 TEST(SocketAddress, SetFromIpv4) {
84 addr.setFromIpPort("255.254.253.252", 8888);
85 EXPECT_EQ(addr.getFamily(), AF_INET);
86 EXPECT_EQ(addr.getAddressStr(), "255.254.253.252");
87 EXPECT_EQ(addr.getPort(), 8888);
88 sockaddr_storage addrStorage;
89 addr.getAddress(&addrStorage);
90 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
91 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0xfffefdfc));
92 EXPECT_EQ(inaddr->sin_port, htons(8888));
95 TEST(SocketAddress, ConstructFromInvalidIpv4) {
96 EXPECT_THROW(SocketAddress("1.2.3.256", 1234), std::runtime_error);
99 TEST(SocketAddress, SetFromInvalidIpv4) {
100 SocketAddress addr("12.34.56.78", 80);
102 // Try setting to an invalid value
103 // Since setFromIpPort() shouldn't allow hostname lookups, setting to
104 // "localhost" should fail, even if localhost is resolvable
105 EXPECT_THROW(addr.setFromIpPort("localhost", 1234),
108 // Make sure the address still has the old contents
109 EXPECT_EQ(addr.getFamily(), AF_INET);
110 EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
111 EXPECT_EQ(addr.getPort(), 80);
112 sockaddr_storage addrStorage;
113 addr.getAddress(&addrStorage);
114 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
115 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
118 TEST(SocketAddress, SetFromHostname) {
119 // hopefully "localhost" is resolvable on any system that will run the tests
120 EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
121 SocketAddress addr("localhost", 80, true);
124 EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
125 addr2.setFromHostPort("localhost", 0);
128 TEST(SocketAddress, SetFromStrings) {
131 // Set from a numeric port string
132 addr.setFromLocalPort("1234");
133 EXPECT_EQ(addr.getPort(), 1234);
135 // setFromLocalPort() should not accept service names
136 EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
138 // Call setFromLocalIpPort() with just a port, no IP
139 addr.setFromLocalIpPort("80");
140 EXPECT_EQ(addr.getPort(), 80);
142 // Call setFromLocalIpPort() with an IP and port.
143 if (SocketAddressTestHelper::isIPv4Enabled()) {
144 addr.setFromLocalIpPort("127.0.0.1:4321");
145 EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
146 EXPECT_EQ(addr.getPort(), 4321);
148 if (SocketAddressTestHelper::isIPv6Enabled()) {
149 addr.setFromLocalIpPort("::1:4321");
150 EXPECT_EQ(addr.getAddressStr(), "::1");
151 EXPECT_EQ(addr.getPort(), 4321);
154 // setFromIpPort() without an address should fail
155 EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
157 // Call setFromIpPort() with an IPv6 address and port
158 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
159 EXPECT_EQ(addr.getFamily(), AF_INET6);
160 EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
161 EXPECT_EQ(addr.getPort(), 65535);
163 // Call setFromIpPort() with an IPv4 address and port
164 addr.setFromIpPort("1.2.3.4:9999");
165 EXPECT_EQ(addr.getFamily(), AF_INET);
166 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
167 EXPECT_EQ(addr.getPort(), 9999);
169 // Call setFromIpPort() with a bracketed IPv6
170 addr.setFromIpPort("[::]:1234");
171 EXPECT_EQ(addr.getFamily(), AF_INET6);
172 EXPECT_EQ(addr.getAddressStr(), "::");
173 EXPECT_EQ(addr.getPort(), 1234);
175 // Call setFromIpPort() with a bracketed IPv6
176 addr.setFromIpPort("[9:8::2]:1234");
177 EXPECT_EQ(addr.getFamily(), AF_INET6);
178 EXPECT_EQ(addr.getAddressStr(), "9:8::2");
179 EXPECT_EQ(addr.getPort(), 1234);
181 // Call setFromIpPort() with a bracketed IPv6 and no port
182 EXPECT_THROW(addr.setFromIpPort("[::]"), std::system_error);
185 TEST(SocketAddress, EqualityAndHash) {
187 SocketAddress local1("127.0.0.1", 1234);
188 EXPECT_EQ(local1, local1);
189 EXPECT_EQ(local1.hash(), local1.hash());
191 SocketAddress local2("127.0.0.1", 1234);
192 EXPECT_EQ(local1, local2);
193 EXPECT_EQ(local1.hash(), local2.hash());
195 SocketAddress local3("127.0.0.1", 4321);
196 EXPECT_NE(local1, local3);
197 EXPECT_NE(local1.hash(), local3.hash());
199 SocketAddress other1("1.2.3.4", 1234);
200 EXPECT_EQ(other1, other1);
201 EXPECT_EQ(other1.hash(), other1.hash());
202 EXPECT_NE(local1, other1);
203 EXPECT_NE(local1.hash(), other1.hash());
205 SocketAddress other2("4.3.2.1", 1234);
206 EXPECT_NE(other1.hash(), other2.hash());
207 EXPECT_NE(other1.hash(), other2.hash());
209 other2.setFromIpPort("1.2.3.4", 0);
210 EXPECT_NE(other1.hash(), other2.hash());
211 EXPECT_NE(other1.hash(), other2.hash());
212 other2.setPort(1234);
213 EXPECT_EQ(other1.hash(), other2.hash());
214 EXPECT_EQ(other1.hash(), other2.hash());
217 SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
218 SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
219 SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
220 EXPECT_EQ(v6_1, v6_2);
221 EXPECT_EQ(v6_1.hash(), v6_2.hash());
222 EXPECT_NE(v6_1, v6_3);
223 EXPECT_NE(v6_1.hash(), v6_3.hash());
225 // IPv4 versus IPv6 comparison
226 SocketAddress localIPv6("::1", 1234);
227 // Even though these both refer to localhost,
228 // IPv4 and IPv6 addresses are never treated as the same address
229 EXPECT_NE(local1, localIPv6);
230 EXPECT_NE(local1.hash(), localIPv6.hash());
232 // IPv4-mapped IPv6 addresses are not treated as equal
233 // to the equivalent IPv4 address
234 SocketAddress v4("10.0.0.3", 99);
235 SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
236 SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
237 EXPECT_NE(v4, v6_mapped1);
238 EXPECT_NE(v4, v6_mapped2);
239 EXPECT_EQ(v6_mapped1, v6_mapped2);
241 // However, after calling convertToIPv4(), the mapped address should now be
242 // equal to the v4 version.
243 EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
244 v6_mapped1.convertToIPv4();
245 EXPECT_EQ(v6_mapped1, v4);
246 EXPECT_NE(v6_mapped1, v6_mapped2);
250 unix1.setFromPath("/foo");
252 unix2.setFromPath("/foo");
254 unix3.setFromPath("/bar");
255 SocketAddress unixAnon;
256 unixAnon.setFromPath("");
258 EXPECT_EQ(unix1, unix2);
259 EXPECT_EQ(unix1.hash(), unix2.hash());
260 EXPECT_NE(unix1, unix3);
261 EXPECT_NE(unix1, unixAnon);
262 EXPECT_NE(unix2, unix3);
263 EXPECT_NE(unix2, unixAnon);
264 // anonymous addresses aren't equal to any other address,
265 // including themselves
266 EXPECT_NE(unixAnon, unixAnon);
268 // It isn't strictly required that hashes for different addresses be
269 // different, but we should have very few collisions. It generally indicates
270 // a problem if these collide
271 EXPECT_NE(unix1.hash(), unix3.hash());
272 EXPECT_NE(unix1.hash(), unixAnon.hash());
273 EXPECT_NE(unix3.hash(), unixAnon.hash());
276 TEST(SocketAddress, IsPrivate) {
278 SocketAddress addr("9.255.255.255", 0);
279 EXPECT_TRUE(!addr.isPrivateAddress());
280 addr.setFromIpPort("10.0.0.0", 0);
281 EXPECT_TRUE(addr.isPrivateAddress());
282 addr.setFromIpPort("10.255.255.255", 0);
283 EXPECT_TRUE(addr.isPrivateAddress());
284 addr.setFromIpPort("11.0.0.0", 0);
285 EXPECT_TRUE(!addr.isPrivateAddress());
287 addr.setFromIpPort("172.15.255.255", 0);
288 EXPECT_TRUE(!addr.isPrivateAddress());
289 addr.setFromIpPort("172.16.0.0", 0);
290 EXPECT_TRUE(addr.isPrivateAddress());
291 addr.setFromIpPort("172.31.255.255", 0);
292 EXPECT_TRUE(addr.isPrivateAddress());
293 addr.setFromIpPort("172.32.0.0", 0);
294 EXPECT_TRUE(!addr.isPrivateAddress());
296 addr.setFromIpPort("192.167.255.255", 0);
297 EXPECT_TRUE(!addr.isPrivateAddress());
298 addr.setFromIpPort("192.168.0.0", 0);
299 EXPECT_TRUE(addr.isPrivateAddress());
300 addr.setFromIpPort("192.168.255.255", 0);
301 EXPECT_TRUE(addr.isPrivateAddress());
302 addr.setFromIpPort("192.169.0.0", 0);
303 EXPECT_TRUE(!addr.isPrivateAddress());
305 addr.setFromIpPort("126.255.255.255", 0);
306 EXPECT_TRUE(!addr.isPrivateAddress());
307 addr.setFromIpPort("127.0.0.0", 0);
308 EXPECT_TRUE(addr.isPrivateAddress());
309 addr.setFromIpPort("127.0.0.1", 0);
310 EXPECT_TRUE(addr.isPrivateAddress());
311 addr.setFromIpPort("127.255.255.255", 0);
312 EXPECT_TRUE(addr.isPrivateAddress());
313 addr.setFromIpPort("128.0.0.0", 0);
314 EXPECT_TRUE(!addr.isPrivateAddress());
316 addr.setFromIpPort("1.2.3.4", 0);
317 EXPECT_TRUE(!addr.isPrivateAddress());
318 addr.setFromIpPort("69.171.239.10", 0);
319 EXPECT_TRUE(!addr.isPrivateAddress());
322 addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
323 EXPECT_TRUE(!addr.isPrivateAddress());
324 addr.setFromIpPort("fc00::", 0);
325 EXPECT_TRUE(addr.isPrivateAddress());
326 addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
327 EXPECT_TRUE(addr.isPrivateAddress());
328 addr.setFromIpPort("fe00::", 0);
329 EXPECT_TRUE(!addr.isPrivateAddress());
331 addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
332 EXPECT_TRUE(!addr.isPrivateAddress());
333 addr.setFromIpPort("fe80::", 0);
334 EXPECT_TRUE(addr.isPrivateAddress());
335 addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
336 EXPECT_TRUE(addr.isPrivateAddress());
337 addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
338 EXPECT_TRUE(addr.isPrivateAddress());
339 addr.setFromIpPort("fec0::", 0);
340 EXPECT_TRUE(!addr.isPrivateAddress());
342 addr.setFromIpPort("::0", 0);
343 EXPECT_TRUE(!addr.isPrivateAddress());
344 addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
345 EXPECT_TRUE(!addr.isPrivateAddress());
348 addr.setFromIpPort("::ffff:127.0.0.1", 0);
349 EXPECT_TRUE(addr.isPrivateAddress());
350 addr.setFromIpPort("::ffff:10.1.2.3", 0);
351 EXPECT_TRUE(addr.isPrivateAddress());
352 addr.setFromIpPort("::ffff:172.24.0.115", 0);
353 EXPECT_TRUE(addr.isPrivateAddress());
354 addr.setFromIpPort("::ffff:192.168.0.1", 0);
355 EXPECT_TRUE(addr.isPrivateAddress());
356 addr.setFromIpPort("::ffff:69.171.239.10", 0);
357 EXPECT_TRUE(!addr.isPrivateAddress());
359 // Unix sockets are considered private addresses
360 addr.setFromPath("/tmp/mysock");
361 EXPECT_TRUE(addr.isPrivateAddress());
364 TEST(SocketAddress, IsLoopback) {
366 SocketAddress addr("127.0.0.1", 0);
367 EXPECT_TRUE(addr.isLoopbackAddress());
368 addr.setFromIpPort("127.0.0.0", 0xffff);
369 EXPECT_TRUE(addr.isLoopbackAddress());
370 addr.setFromIpPort("127.1.1.1", 0xffff);
371 EXPECT_TRUE(addr.isLoopbackAddress());
372 addr.setFromIpPort("127.255.255.255", 80);
373 EXPECT_TRUE(addr.isLoopbackAddress());
375 addr.setFromIpPort("128.0.0.0", 0);
376 EXPECT_TRUE(!addr.isLoopbackAddress());
377 addr.setFromIpPort("126.255.255.255", 0);
378 EXPECT_TRUE(!addr.isLoopbackAddress());
379 addr.setFromIpPort("10.1.2.3", 0);
380 EXPECT_TRUE(!addr.isLoopbackAddress());
383 addr.setFromIpPort("::1", 0);
384 EXPECT_TRUE(addr.isLoopbackAddress());
385 addr.setFromIpPort("::0", 0);
386 EXPECT_TRUE(!addr.isLoopbackAddress());
387 addr.setFromIpPort("::2", 0);
388 EXPECT_TRUE(!addr.isLoopbackAddress());
391 addr.setFromIpPort("::ffff:127.0.0.1", 0);
392 EXPECT_TRUE(addr.isLoopbackAddress());
393 addr.setFromIpPort("::ffff:7f0a:141e", 0);
394 EXPECT_TRUE(addr.isLoopbackAddress());
395 addr.setFromIpPort("::ffff:169.254.0.13", 0);
396 EXPECT_TRUE(!addr.isLoopbackAddress());
398 // Unix sockets are considered loopback addresses
399 addr.setFromPath("/tmp/mysock");
400 EXPECT_TRUE(addr.isLoopbackAddress());
403 void CheckPrefixMatch(const SocketAddress& first,
404 const SocketAddress& second, unsigned matchingPrefixLen) {
406 for (i = 0; i <= matchingPrefixLen; i++) {
407 EXPECT_TRUE(first.prefixMatch(second, i));
409 unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
410 for (; i <= addrLen; i++) {
411 EXPECT_TRUE(!first.prefixMatch(second, i));
415 TEST(SocketAddress, PrefixMatch) {
417 SocketAddress addr1("127.0.0.1", 0);
418 SocketAddress addr2("127.0.0.1", 0);
419 CheckPrefixMatch(addr1, addr2, 32);
421 addr2.setFromIpPort("127.0.1.1", 0);
422 CheckPrefixMatch(addr1, addr2, 23);
424 addr2.setFromIpPort("1.1.0.127", 0);
425 CheckPrefixMatch(addr1, addr2, 1);
427 // Address family mismatch
428 addr2.setFromIpPort("::ffff:127.0.0.1", 0);
429 EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
432 addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
433 CheckPrefixMatch(addr1, addr2, 2);
435 addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
436 CheckPrefixMatch(addr1, addr2, 128);
438 addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
439 CheckPrefixMatch(addr1, addr2, 42);
442 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
443 EXPECT_TRUE(!(first < first));
444 EXPECT_TRUE(!(second < second));
445 EXPECT_TRUE(first < second);
446 EXPECT_TRUE(!(first == second));
447 EXPECT_TRUE(!(second < first));
450 TEST(SocketAddress, CheckComparatorBehavior) {
451 SocketAddress first, second;
452 // The following comparison are strict (so if first and second were
453 // inverted that is ok.
458 first.setFromIpPort("128.0.0.0", 0);
459 second.setFromIpPort("128.0.0.0", 0xFFFF);
460 CheckFirstLessThanSecond(first, second);
461 first.setFromIpPort("128.0.0.100", 0);
462 second.setFromIpPort("128.0.0.0", 0xFFFF);
463 CheckFirstLessThanSecond(first, second);
465 // Address comparisons
466 first.setFromIpPort("128.0.0.0", 10);
467 second.setFromIpPort("128.0.0.100", 10);
468 CheckFirstLessThanSecond(first, second);
470 // Comaprision between IPV4 and IPV6
471 first.setFromIpPort("128.0.0.0", 0);
472 second.setFromIpPort("::ffff:127.0.0.1", 0);
473 CheckFirstLessThanSecond(first, second);
474 first.setFromIpPort("128.0.0.0", 100);
475 second.setFromIpPort("::ffff:127.0.0.1", 0);
476 CheckFirstLessThanSecond(first, second);
481 first.setFromIpPort("::0", 0);
482 second.setFromIpPort("::0", 0xFFFF);
483 CheckFirstLessThanSecond(first, second);
484 first.setFromIpPort("::0", 0);
485 second.setFromIpPort("::1", 0xFFFF);
486 CheckFirstLessThanSecond(first, second);
488 // Address comparisons
489 first.setFromIpPort("::0", 10);
490 second.setFromIpPort("::1", 10);
491 CheckFirstLessThanSecond(first, second);
494 first.setFromPath("/foo");
495 second.setFromPath("/1234");
496 // The exact comparison order doesn't really matter, as long as
497 // (a < b), (b < a), and (a == b) are consistent.
498 // This checks our current comparison rules, which checks the path length
499 // before the path contents.
500 CheckFirstLessThanSecond(first, second);
501 first.setFromPath("/1234");
502 second.setFromPath("/5678");
503 CheckFirstLessThanSecond(first, second);
506 // We currently compare the address family values, and AF_UNIX < AF_INET
507 first.setFromPath("/foo");
508 second.setFromIpPort("127.0.0.1", 80);
509 CheckFirstLessThanSecond(first, second);
512 TEST(SocketAddress, Unix) {
516 addr.setFromPath("foo");
517 EXPECT_EQ(addr.getFamily(), AF_UNIX);
518 EXPECT_EQ(addr.describe(), "foo");
519 EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
520 EXPECT_THROW(addr.getPort(), std::invalid_argument);
521 EXPECT_TRUE(addr.isPrivateAddress());
522 EXPECT_TRUE(addr.isLoopbackAddress());
524 // Test a path that is too large
525 const char longPath[] =
526 "abcdefghijklmnopqrstuvwxyz0123456789"
527 "abcdefghijklmnopqrstuvwxyz0123456789"
528 "abcdefghijklmnopqrstuvwxyz0123456789"
529 "abcdefghijklmnopqrstuvwxyz0123456789";
530 EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
531 // The original address should still be the same
532 EXPECT_EQ(addr.getFamily(), AF_UNIX);
533 EXPECT_EQ(addr.describe(), "foo");
535 // Test a path that exactly fits in sockaddr_un
536 // (not including the NUL terminator)
537 const char exactLengthPath[] =
538 "abcdefghijklmnopqrstuvwxyz0123456789"
539 "abcdefghijklmnopqrstuvwxyz0123456789"
540 "abcdefghijklmnopqrstuvwxyz0123456789";
541 addr.setFromPath(exactLengthPath);
542 EXPECT_EQ(addr.describe(), exactLengthPath);
544 // Test converting a unix socket address to an IPv4 one, then back
545 addr.setFromHostPort("127.0.0.1", 1234);
546 EXPECT_EQ(addr.getFamily(), AF_INET);
547 EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
548 addr.setFromPath("/i/am/a/unix/address");
549 EXPECT_EQ(addr.getFamily(), AF_UNIX);
550 EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
552 // Test copy constructor and assignment operator
554 SocketAddress copy(addr);
555 EXPECT_EQ(copy, addr);
556 copy.setFromPath("/abc");
557 EXPECT_NE(copy, addr);
559 EXPECT_EQ(copy, addr);
560 copy.setFromIpPort("127.0.0.1", 80);
561 EXPECT_NE(copy, addr);
563 EXPECT_EQ(copy, addr);
567 SocketAddress copy(addr);
568 EXPECT_EQ(copy, addr);
569 EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
570 EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
572 SocketAddress other("127.0.0.1", 80);
573 EXPECT_NE(other, addr);
575 EXPECT_EQ(other, copy);
576 EXPECT_EQ(other, addr);
577 EXPECT_EQ(copy, addr);
580 #if __GXX_EXPERIMENTAL_CXX0X__
584 // move a unix address into a non-unix address
585 SocketAddress tmpCopy(addr);
586 copy = std::move(tmpCopy);
588 EXPECT_EQ(copy, addr);
590 copy.setFromPath("/another/path");
592 // move a unix address into a unix address
593 SocketAddress tmpCopy(addr);
594 copy = std::move(tmpCopy);
596 EXPECT_EQ(copy, addr);
599 // move a non-unix address into a unix address
600 SocketAddress tmp("127.0.0.1", 80);
601 copy = std::move(tmp);
603 EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
604 EXPECT_EQ(copy.getPort(), 80);
607 // move construct a unix address
608 SocketAddress other(std::move(copy));
609 EXPECT_EQ(other, addr);
610 EXPECT_EQ(other.getPath(), addr.getPath());
615 TEST(SocketAddress, AnonymousUnix) {
616 // Create a unix socket pair, and get the addresses.
618 int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
625 addr0.setFromLocalAddress(fds[0]);
626 peer0.setFromPeerAddress(fds[0]);
627 addr1.setFromLocalAddress(fds[1]);
628 peer1.setFromPeerAddress(fds[1]);
632 EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
633 EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
634 EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
635 EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
637 // Anonymous addresses should never compare equal
638 EXPECT_NE(addr0, addr1);
639 EXPECT_NE(peer0, peer1);
641 // Note that logically addr0 and peer1 are the same,
642 // but since they are both anonymous we have no way to determine this
643 EXPECT_NE(addr0, peer1);
644 // We can't even tell if an anonymous address is equal to itself
645 EXPECT_NE(addr0, addr0);
648 #define REQUIRE_ERRNO(cond, msg) \
650 int _requireErrnoCopy_ = errno; \
651 std::ostringstream _requireMsg_; \
652 _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
656 void testSetFromSocket(const SocketAddress *serverBindAddr,
657 const SocketAddress *clientBindAddr,
658 SocketAddress *listenAddrRet,
659 SocketAddress *acceptAddrRet,
660 SocketAddress *serverAddrRet,
661 SocketAddress *serverPeerAddrRet,
662 SocketAddress *clientAddrRet,
663 SocketAddress *clientPeerAddrRet) {
664 int listenSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
665 REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
666 sockaddr_storage laddr;
667 serverBindAddr->getAddress(&laddr);
668 socklen_t laddrLen = serverBindAddr->getActualSize();
669 int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
670 REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
671 rc = listen(listenSock, 10);
672 REQUIRE_ERRNO(rc == 0, "failed to listen");
674 listenAddrRet->setFromLocalAddress(listenSock);
676 SocketAddress listenPeerAddr;
677 EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
680 // Note that we use the family from serverBindAddr here, since we allow
681 // clientBindAddr to be nullptr.
682 int clientSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
683 REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
684 if (clientBindAddr != nullptr) {
685 sockaddr_storage clientAddr;
686 clientBindAddr->getAddress(&clientAddr);
688 rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
689 clientBindAddr->getActualSize());
690 REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
693 sockaddr_storage listenAddr;
694 listenAddrRet->getAddress(&listenAddr);
695 rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
696 listenAddrRet->getActualSize());
697 REQUIRE_ERRNO(rc == 0, "failed to connect");
699 sockaddr_storage acceptAddr;
700 socklen_t acceptAddrLen = sizeof(acceptAddr);
701 int serverSock = accept(listenSock,
702 reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
703 REQUIRE_ERRNO(serverSock > 0, "failed to accept");
704 acceptAddrRet->setFromSockaddr(
705 reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
707 serverAddrRet->setFromLocalAddress(serverSock);
708 serverPeerAddrRet->setFromPeerAddress(serverSock);
709 clientAddrRet->setFromLocalAddress(clientSock);
710 clientPeerAddrRet->setFromPeerAddress(clientSock);
717 TEST(SocketAddress, SetFromSocketIPv4) {
718 SocketAddress serverBindAddr("0.0.0.0", 0);
719 SocketAddress clientBindAddr("0.0.0.0", 0);
720 SocketAddress listenAddr;
721 SocketAddress acceptAddr;
722 SocketAddress serverAddr;
723 SocketAddress serverPeerAddr;
724 SocketAddress clientAddr;
725 SocketAddress clientPeerAddr;
727 testSetFromSocket(&serverBindAddr, &clientBindAddr,
728 &listenAddr, &acceptAddr,
729 &serverAddr, &serverPeerAddr,
730 &clientAddr, &clientPeerAddr);
732 // The server socket's local address should have the same port as the listen
733 // address. The IP will be different, since the listening socket is
734 // listening on INADDR_ANY, but the server socket will have a concrete IP
735 // address assigned to it.
736 EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
738 // The client's peer address should always be the same as the server
740 EXPECT_EQ(clientPeerAddr, serverAddr);
741 // The address returned by getpeername() on the server socket should
742 // be the same as the address returned by accept()
743 EXPECT_EQ(serverPeerAddr, acceptAddr);
744 EXPECT_EQ(serverPeerAddr, clientAddr);
745 EXPECT_EQ(acceptAddr, clientAddr);
749 * Note this test exercises Linux-specific Unix socket behavior
751 TEST(SocketAddress, SetFromSocketUnixAbstract) {
752 // Explicitly binding to an empty path results in an abstract socket
753 // name being picked for us automatically.
754 SocketAddress serverBindAddr;
756 path.append("test address");
757 serverBindAddr.setFromPath(path);
758 SocketAddress clientBindAddr;
759 clientBindAddr.setFromPath("");
761 SocketAddress listenAddr;
762 SocketAddress acceptAddr;
763 SocketAddress serverAddr;
764 SocketAddress serverPeerAddr;
765 SocketAddress clientAddr;
766 SocketAddress clientPeerAddr;
768 testSetFromSocket(&serverBindAddr, &clientBindAddr,
769 &listenAddr, &acceptAddr,
770 &serverAddr, &serverPeerAddr,
771 &clientAddr, &clientPeerAddr);
773 // The server socket's local address should be the same as the listen
775 EXPECT_EQ(serverAddr, listenAddr);
777 // The client's peer address should always be the same as the server
779 EXPECT_EQ(clientPeerAddr, serverAddr);
781 EXPECT_EQ(serverPeerAddr, clientAddr);
782 // Oddly, the address returned by accept() does not seem to match the address
783 // returned by getpeername() on the server socket or getsockname() on the
785 // EXPECT_EQ(serverPeerAddr, acceptAddr);
786 // EXPECT_EQ(acceptAddr, clientAddr);
789 TEST(SocketAddress, SetFromSocketUnixExplicit) {
790 // Pick two temporary path names.
791 // We use mkstemp() just to avoid warnings about mktemp,
792 // but we need to remove the file to let the socket code bind to it.
793 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
794 int serverPathFd = mkstemp(serverPath);
795 EXPECT_GE(serverPathFd, 0);
796 char clientPath[] = "/tmp/SocketAddressTest.client.XXXXXX";
797 int clientPathFd = mkstemp(clientPath);
798 EXPECT_GE(clientPathFd, 0);
800 int rc = unlink(serverPath);
802 rc = unlink(clientPath);
805 SocketAddress serverBindAddr;
806 SocketAddress clientBindAddr;
807 SocketAddress listenAddr;
808 SocketAddress acceptAddr;
809 SocketAddress serverAddr;
810 SocketAddress serverPeerAddr;
811 SocketAddress clientAddr;
812 SocketAddress clientPeerAddr;
814 serverBindAddr.setFromPath(serverPath);
815 clientBindAddr.setFromPath(clientPath);
817 testSetFromSocket(&serverBindAddr, &clientBindAddr,
818 &listenAddr, &acceptAddr,
819 &serverAddr, &serverPeerAddr,
820 &clientAddr, &clientPeerAddr);
822 // Remove the socket files after we are done
830 // The server socket's local address should be the same as the listen
832 EXPECT_EQ(serverAddr, listenAddr);
834 // The client's peer address should always be the same as the server
836 EXPECT_EQ(clientPeerAddr, serverAddr);
838 EXPECT_EQ(serverPeerAddr, clientAddr);
839 EXPECT_EQ(serverPeerAddr, acceptAddr);
840 EXPECT_EQ(acceptAddr, clientAddr);
843 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
844 // Test an anonymous client talking to a fixed-path unix socket.
845 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
846 int serverPathFd = mkstemp(serverPath);
847 EXPECT_GE(serverPathFd, 0);
848 int rc = unlink(serverPath);
851 SocketAddress serverBindAddr;
852 SocketAddress listenAddr;
853 SocketAddress acceptAddr;
854 SocketAddress serverAddr;
855 SocketAddress serverPeerAddr;
856 SocketAddress clientAddr;
857 SocketAddress clientPeerAddr;
859 serverBindAddr.setFromPath(serverPath);
861 testSetFromSocket(&serverBindAddr, nullptr,
862 &listenAddr, &acceptAddr,
863 &serverAddr, &serverPeerAddr,
864 &clientAddr, &clientPeerAddr);
866 // Remove the socket file after we are done
872 // The server socket's local address should be the same as the listen
874 EXPECT_EQ(serverAddr, listenAddr);
876 // The client's peer address should always be the same as the server
878 EXPECT_EQ(clientPeerAddr, serverAddr);
880 // Since the client is using an anonymous address, it won't compare equal to
881 // any other anonymous addresses. Make sure the addresses are anonymous.
882 EXPECT_EQ(serverPeerAddr.getPath(), "");
883 EXPECT_EQ(clientAddr.getPath(), "");
884 EXPECT_EQ(acceptAddr.getPath(), "");
887 TEST(SocketAddress, ResetUnixAddress) {
889 addy.setFromPath("/foo");
892 EXPECT_EQ(addy.getFamily(), AF_UNSPEC);