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/test/SocketAddressTestHelper.h>
26 using namespace boost;
30 using folly::SocketAddress;
31 using folly::SocketAddressTestHelper;
33 TEST(SocketAddress, Size) {
35 EXPECT_EQ(sizeof(addr), 32);
38 TEST(SocketAddress, ConstructFromIpv4) {
39 SocketAddress addr("1.2.3.4", 4321);
40 EXPECT_EQ(addr.getFamily(), AF_INET);
41 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
42 EXPECT_EQ(addr.getPort(), 4321);
43 sockaddr_storage addrStorage;
44 addr.getAddress(&addrStorage);
45 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
46 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x01020304));
47 EXPECT_EQ(inaddr->sin_port, htons(4321));
50 TEST(SocketAddress, IPv4ToStringConversion) {
51 // testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
53 for (int pos = 0; pos < 4; ++pos) {
54 for (int i = 0; i < 256; ++i) {
55 int fragments[] = {5,5,5,5};
57 std::ostringstream ss;
58 ss << fragments[0] << "." << fragments[1] << "."
59 << fragments[2] << "." << fragments[3];
60 string ipString = ss.str();
61 addr.setFromIpPort(ipString, 1234);
62 EXPECT_EQ(addr.getAddressStr(), ipString);
67 TEST(SocketAddress, SetFromIpAddressPort) {
69 folly::IPAddress ipAddr("123.234.0.23");
70 addr.setFromIpAddrPort(ipAddr, 8888);
71 EXPECT_EQ(addr.getFamily(), AF_INET);
72 EXPECT_EQ(addr.getAddressStr(), "123.234.0.23");
73 EXPECT_EQ(addr.getIPAddress(), ipAddr);
74 EXPECT_EQ(addr.getPort(), 8888);
76 folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
77 SocketAddress addr6(ip6Addr, 8888);
78 EXPECT_EQ(addr6.getFamily(), AF_INET6);
79 EXPECT_EQ(addr6.getAddressStr(), "2620:0:1cfe:face:b00c::3");
80 EXPECT_EQ(addr6.getIPAddress(), ip6Addr);
81 EXPECT_EQ(addr6.getPort(), 8888);
84 TEST(SocketAddress, SetFromIpv4) {
86 addr.setFromIpPort("255.254.253.252", 8888);
87 EXPECT_EQ(addr.getFamily(), AF_INET);
88 EXPECT_EQ(addr.getAddressStr(), "255.254.253.252");
89 EXPECT_EQ(addr.getPort(), 8888);
90 sockaddr_storage addrStorage;
91 addr.getAddress(&addrStorage);
92 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
93 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0xfffefdfc));
94 EXPECT_EQ(inaddr->sin_port, htons(8888));
97 TEST(SocketAddress, ConstructFromInvalidIpv4) {
98 EXPECT_THROW(SocketAddress("1.2.3.256", 1234), std::runtime_error);
101 TEST(SocketAddress, SetFromInvalidIpv4) {
102 SocketAddress addr("12.34.56.78", 80);
104 // Try setting to an invalid value
105 // Since setFromIpPort() shouldn't allow hostname lookups, setting to
106 // "localhost" should fail, even if localhost is resolvable
107 EXPECT_THROW(addr.setFromIpPort("localhost", 1234),
110 // Make sure the address still has the old contents
111 EXPECT_EQ(addr.getFamily(), AF_INET);
112 EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
113 EXPECT_EQ(addr.getPort(), 80);
114 sockaddr_storage addrStorage;
115 addr.getAddress(&addrStorage);
116 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
117 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
120 TEST(SocketAddress, SetFromHostname) {
121 // hopefully "localhost" is resolvable on any system that will run the tests
122 EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
123 SocketAddress addr("localhost", 80, true);
126 EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
127 addr2.setFromHostPort("localhost", 0);
130 TEST(SocketAddress, SetFromStrings) {
133 // Set from a numeric port string
134 addr.setFromLocalPort("1234");
135 EXPECT_EQ(addr.getPort(), 1234);
137 // setFromLocalPort() should not accept service names
138 EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
140 // Call setFromLocalIpPort() with just a port, no IP
141 addr.setFromLocalIpPort("80");
142 EXPECT_EQ(addr.getPort(), 80);
144 // Call setFromLocalIpPort() with an IP and port.
145 if (SocketAddressTestHelper::isIPv4Enabled()) {
146 addr.setFromLocalIpPort("127.0.0.1:4321");
147 EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
148 EXPECT_EQ(addr.getPort(), 4321);
150 if (SocketAddressTestHelper::isIPv6Enabled()) {
151 addr.setFromLocalIpPort("::1:4321");
152 EXPECT_EQ(addr.getAddressStr(), "::1");
153 EXPECT_EQ(addr.getPort(), 4321);
156 // setFromIpPort() without an address should fail
157 EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
159 // Call setFromIpPort() with an IPv6 address and port
160 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
161 EXPECT_EQ(addr.getFamily(), AF_INET6);
162 EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
163 EXPECT_EQ(addr.getPort(), 65535);
165 // Call setFromIpPort() with an IPv4 address and port
166 addr.setFromIpPort("1.2.3.4:9999");
167 EXPECT_EQ(addr.getFamily(), AF_INET);
168 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
169 EXPECT_EQ(addr.getPort(), 9999);
171 // Call setFromIpPort() with a bracketed IPv6
172 addr.setFromIpPort("[::]:1234");
173 EXPECT_EQ(addr.getFamily(), AF_INET6);
174 EXPECT_EQ(addr.getAddressStr(), "::");
175 EXPECT_EQ(addr.getPort(), 1234);
177 // Call setFromIpPort() with a bracketed IPv6
178 addr.setFromIpPort("[9:8::2]:1234");
179 EXPECT_EQ(addr.getFamily(), AF_INET6);
180 EXPECT_EQ(addr.getAddressStr(), "9:8::2");
181 EXPECT_EQ(addr.getPort(), 1234);
183 // Call setFromIpPort() with a bracketed IPv6 and no port
184 EXPECT_THROW(addr.setFromIpPort("[::]"), std::system_error);
187 TEST(SocketAddress, EqualityAndHash) {
189 SocketAddress local1("127.0.0.1", 1234);
190 EXPECT_EQ(local1, local1);
191 EXPECT_EQ(local1.hash(), local1.hash());
193 SocketAddress local2("127.0.0.1", 1234);
194 EXPECT_EQ(local1, local2);
195 EXPECT_EQ(local1.hash(), local2.hash());
197 SocketAddress local3("127.0.0.1", 4321);
198 EXPECT_NE(local1, local3);
199 EXPECT_NE(local1.hash(), local3.hash());
201 SocketAddress other1("1.2.3.4", 1234);
202 EXPECT_EQ(other1, other1);
203 EXPECT_EQ(other1.hash(), other1.hash());
204 EXPECT_NE(local1, other1);
205 EXPECT_NE(local1.hash(), other1.hash());
207 SocketAddress other2("4.3.2.1", 1234);
208 EXPECT_NE(other1.hash(), other2.hash());
209 EXPECT_NE(other1.hash(), other2.hash());
211 other2.setFromIpPort("1.2.3.4", 0);
212 EXPECT_NE(other1.hash(), other2.hash());
213 EXPECT_NE(other1.hash(), other2.hash());
214 other2.setPort(1234);
215 EXPECT_EQ(other1.hash(), other2.hash());
216 EXPECT_EQ(other1.hash(), other2.hash());
219 SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
220 SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
221 SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
222 EXPECT_EQ(v6_1, v6_2);
223 EXPECT_EQ(v6_1.hash(), v6_2.hash());
224 EXPECT_NE(v6_1, v6_3);
225 EXPECT_NE(v6_1.hash(), v6_3.hash());
227 // IPv4 versus IPv6 comparison
228 SocketAddress localIPv6("::1", 1234);
229 // Even though these both refer to localhost,
230 // IPv4 and IPv6 addresses are never treated as the same address
231 EXPECT_NE(local1, localIPv6);
232 EXPECT_NE(local1.hash(), localIPv6.hash());
234 // IPv4-mapped IPv6 addresses are not treated as equal
235 // to the equivalent IPv4 address
236 SocketAddress v4("10.0.0.3", 99);
237 SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
238 SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
239 EXPECT_NE(v4, v6_mapped1);
240 EXPECT_NE(v4, v6_mapped2);
241 EXPECT_EQ(v6_mapped1, v6_mapped2);
243 // However, after calling convertToIPv4(), the mapped address should now be
244 // equal to the v4 version.
245 EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
246 v6_mapped1.convertToIPv4();
247 EXPECT_EQ(v6_mapped1, v4);
248 EXPECT_NE(v6_mapped1, v6_mapped2);
252 unix1.setFromPath("/foo");
254 unix2.setFromPath("/foo");
256 unix3.setFromPath("/bar");
257 SocketAddress unixAnon;
258 unixAnon.setFromPath("");
260 EXPECT_EQ(unix1, unix2);
261 EXPECT_EQ(unix1.hash(), unix2.hash());
262 EXPECT_NE(unix1, unix3);
263 EXPECT_NE(unix1, unixAnon);
264 EXPECT_NE(unix2, unix3);
265 EXPECT_NE(unix2, unixAnon);
266 // anonymous addresses aren't equal to any other address,
267 // including themselves
268 EXPECT_NE(unixAnon, unixAnon);
270 // It isn't strictly required that hashes for different addresses be
271 // different, but we should have very few collisions. It generally indicates
272 // a problem if these collide
273 EXPECT_NE(unix1.hash(), unix3.hash());
274 EXPECT_NE(unix1.hash(), unixAnon.hash());
275 EXPECT_NE(unix3.hash(), unixAnon.hash());
278 TEST(SocketAddress, IsPrivate) {
280 SocketAddress addr("9.255.255.255", 0);
281 EXPECT_TRUE(!addr.isPrivateAddress());
282 addr.setFromIpPort("10.0.0.0", 0);
283 EXPECT_TRUE(addr.isPrivateAddress());
284 addr.setFromIpPort("10.255.255.255", 0);
285 EXPECT_TRUE(addr.isPrivateAddress());
286 addr.setFromIpPort("11.0.0.0", 0);
287 EXPECT_TRUE(!addr.isPrivateAddress());
289 addr.setFromIpPort("172.15.255.255", 0);
290 EXPECT_TRUE(!addr.isPrivateAddress());
291 addr.setFromIpPort("172.16.0.0", 0);
292 EXPECT_TRUE(addr.isPrivateAddress());
293 addr.setFromIpPort("172.31.255.255", 0);
294 EXPECT_TRUE(addr.isPrivateAddress());
295 addr.setFromIpPort("172.32.0.0", 0);
296 EXPECT_TRUE(!addr.isPrivateAddress());
298 addr.setFromIpPort("192.167.255.255", 0);
299 EXPECT_TRUE(!addr.isPrivateAddress());
300 addr.setFromIpPort("192.168.0.0", 0);
301 EXPECT_TRUE(addr.isPrivateAddress());
302 addr.setFromIpPort("192.168.255.255", 0);
303 EXPECT_TRUE(addr.isPrivateAddress());
304 addr.setFromIpPort("192.169.0.0", 0);
305 EXPECT_TRUE(!addr.isPrivateAddress());
307 addr.setFromIpPort("126.255.255.255", 0);
308 EXPECT_TRUE(!addr.isPrivateAddress());
309 addr.setFromIpPort("127.0.0.0", 0);
310 EXPECT_TRUE(addr.isPrivateAddress());
311 addr.setFromIpPort("127.0.0.1", 0);
312 EXPECT_TRUE(addr.isPrivateAddress());
313 addr.setFromIpPort("127.255.255.255", 0);
314 EXPECT_TRUE(addr.isPrivateAddress());
315 addr.setFromIpPort("128.0.0.0", 0);
316 EXPECT_TRUE(!addr.isPrivateAddress());
318 addr.setFromIpPort("1.2.3.4", 0);
319 EXPECT_TRUE(!addr.isPrivateAddress());
320 addr.setFromIpPort("69.171.239.10", 0);
321 EXPECT_TRUE(!addr.isPrivateAddress());
324 addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
325 EXPECT_TRUE(!addr.isPrivateAddress());
326 addr.setFromIpPort("fc00::", 0);
327 EXPECT_TRUE(addr.isPrivateAddress());
328 addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
329 EXPECT_TRUE(addr.isPrivateAddress());
330 addr.setFromIpPort("fe00::", 0);
331 EXPECT_TRUE(!addr.isPrivateAddress());
333 addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
334 EXPECT_TRUE(!addr.isPrivateAddress());
335 addr.setFromIpPort("fe80::", 0);
336 EXPECT_TRUE(addr.isPrivateAddress());
337 addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
338 EXPECT_TRUE(addr.isPrivateAddress());
339 addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
340 EXPECT_TRUE(addr.isPrivateAddress());
341 addr.setFromIpPort("fec0::", 0);
342 EXPECT_TRUE(!addr.isPrivateAddress());
344 addr.setFromIpPort("::0", 0);
345 EXPECT_TRUE(!addr.isPrivateAddress());
346 addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
347 EXPECT_TRUE(!addr.isPrivateAddress());
350 addr.setFromIpPort("::ffff:127.0.0.1", 0);
351 EXPECT_TRUE(addr.isPrivateAddress());
352 addr.setFromIpPort("::ffff:10.1.2.3", 0);
353 EXPECT_TRUE(addr.isPrivateAddress());
354 addr.setFromIpPort("::ffff:172.24.0.115", 0);
355 EXPECT_TRUE(addr.isPrivateAddress());
356 addr.setFromIpPort("::ffff:192.168.0.1", 0);
357 EXPECT_TRUE(addr.isPrivateAddress());
358 addr.setFromIpPort("::ffff:69.171.239.10", 0);
359 EXPECT_TRUE(!addr.isPrivateAddress());
361 // Unix sockets are considered private addresses
362 addr.setFromPath("/tmp/mysock");
363 EXPECT_TRUE(addr.isPrivateAddress());
366 TEST(SocketAddress, IsLoopback) {
368 SocketAddress addr("127.0.0.1", 0);
369 EXPECT_TRUE(addr.isLoopbackAddress());
370 addr.setFromIpPort("127.0.0.0", 0xffff);
371 EXPECT_TRUE(addr.isLoopbackAddress());
372 addr.setFromIpPort("127.1.1.1", 0xffff);
373 EXPECT_TRUE(addr.isLoopbackAddress());
374 addr.setFromIpPort("127.255.255.255", 80);
375 EXPECT_TRUE(addr.isLoopbackAddress());
377 addr.setFromIpPort("128.0.0.0", 0);
378 EXPECT_TRUE(!addr.isLoopbackAddress());
379 addr.setFromIpPort("126.255.255.255", 0);
380 EXPECT_TRUE(!addr.isLoopbackAddress());
381 addr.setFromIpPort("10.1.2.3", 0);
382 EXPECT_TRUE(!addr.isLoopbackAddress());
385 addr.setFromIpPort("::1", 0);
386 EXPECT_TRUE(addr.isLoopbackAddress());
387 addr.setFromIpPort("::0", 0);
388 EXPECT_TRUE(!addr.isLoopbackAddress());
389 addr.setFromIpPort("::2", 0);
390 EXPECT_TRUE(!addr.isLoopbackAddress());
393 addr.setFromIpPort("::ffff:127.0.0.1", 0);
394 EXPECT_TRUE(addr.isLoopbackAddress());
395 addr.setFromIpPort("::ffff:7f0a:141e", 0);
396 EXPECT_TRUE(addr.isLoopbackAddress());
397 addr.setFromIpPort("::ffff:169.254.0.13", 0);
398 EXPECT_TRUE(!addr.isLoopbackAddress());
400 // Unix sockets are considered loopback addresses
401 addr.setFromPath("/tmp/mysock");
402 EXPECT_TRUE(addr.isLoopbackAddress());
405 void CheckPrefixMatch(const SocketAddress& first,
406 const SocketAddress& second, unsigned matchingPrefixLen) {
408 for (i = 0; i <= matchingPrefixLen; i++) {
409 EXPECT_TRUE(first.prefixMatch(second, i));
411 unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
412 for (; i <= addrLen; i++) {
413 EXPECT_TRUE(!first.prefixMatch(second, i));
417 TEST(SocketAddress, PrefixMatch) {
419 SocketAddress addr1("127.0.0.1", 0);
420 SocketAddress addr2("127.0.0.1", 0);
421 CheckPrefixMatch(addr1, addr2, 32);
423 addr2.setFromIpPort("127.0.1.1", 0);
424 CheckPrefixMatch(addr1, addr2, 23);
426 addr2.setFromIpPort("1.1.0.127", 0);
427 CheckPrefixMatch(addr1, addr2, 1);
429 // Address family mismatch
430 addr2.setFromIpPort("::ffff:127.0.0.1", 0);
431 EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
434 addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
435 CheckPrefixMatch(addr1, addr2, 2);
437 addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
438 CheckPrefixMatch(addr1, addr2, 128);
440 addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
441 CheckPrefixMatch(addr1, addr2, 42);
444 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
445 EXPECT_TRUE(!(first < first));
446 EXPECT_TRUE(!(second < second));
447 EXPECT_TRUE(first < second);
448 EXPECT_TRUE(!(first == second));
449 EXPECT_TRUE(!(second < first));
452 TEST(SocketAddress, CheckComparatorBehavior) {
453 SocketAddress first, second;
454 // The following comparison are strict (so if first and second were
455 // inverted that is ok.
460 first.setFromIpPort("128.0.0.0", 0);
461 second.setFromIpPort("128.0.0.0", 0xFFFF);
462 CheckFirstLessThanSecond(first, second);
463 first.setFromIpPort("128.0.0.100", 0);
464 second.setFromIpPort("128.0.0.0", 0xFFFF);
465 CheckFirstLessThanSecond(first, second);
467 // Address comparisons
468 first.setFromIpPort("128.0.0.0", 10);
469 second.setFromIpPort("128.0.0.100", 10);
470 CheckFirstLessThanSecond(first, second);
472 // Comaprision between IPV4 and IPV6
473 first.setFromIpPort("128.0.0.0", 0);
474 second.setFromIpPort("::ffff:127.0.0.1", 0);
475 CheckFirstLessThanSecond(first, second);
476 first.setFromIpPort("128.0.0.0", 100);
477 second.setFromIpPort("::ffff:127.0.0.1", 0);
478 CheckFirstLessThanSecond(first, second);
483 first.setFromIpPort("::0", 0);
484 second.setFromIpPort("::0", 0xFFFF);
485 CheckFirstLessThanSecond(first, second);
486 first.setFromIpPort("::0", 0);
487 second.setFromIpPort("::1", 0xFFFF);
488 CheckFirstLessThanSecond(first, second);
490 // Address comparisons
491 first.setFromIpPort("::0", 10);
492 second.setFromIpPort("::1", 10);
493 CheckFirstLessThanSecond(first, second);
496 first.setFromPath("/foo");
497 second.setFromPath("/1234");
498 // The exact comparison order doesn't really matter, as long as
499 // (a < b), (b < a), and (a == b) are consistent.
500 // This checks our current comparison rules, which checks the path length
501 // before the path contents.
502 CheckFirstLessThanSecond(first, second);
503 first.setFromPath("/1234");
504 second.setFromPath("/5678");
505 CheckFirstLessThanSecond(first, second);
508 // We currently compare the address family values, and AF_UNIX < AF_INET
509 first.setFromPath("/foo");
510 second.setFromIpPort("127.0.0.1", 80);
511 CheckFirstLessThanSecond(first, second);
514 TEST(SocketAddress, Unix) {
518 addr.setFromPath("foo");
519 EXPECT_EQ(addr.getFamily(), AF_UNIX);
520 EXPECT_EQ(addr.describe(), "foo");
521 EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
522 EXPECT_THROW(addr.getPort(), std::invalid_argument);
523 EXPECT_TRUE(addr.isPrivateAddress());
524 EXPECT_TRUE(addr.isLoopbackAddress());
526 // Test a path that is too large
527 const char longPath[] =
528 "abcdefghijklmnopqrstuvwxyz0123456789"
529 "abcdefghijklmnopqrstuvwxyz0123456789"
530 "abcdefghijklmnopqrstuvwxyz0123456789"
531 "abcdefghijklmnopqrstuvwxyz0123456789";
532 EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
533 // The original address should still be the same
534 EXPECT_EQ(addr.getFamily(), AF_UNIX);
535 EXPECT_EQ(addr.describe(), "foo");
537 // Test a path that exactly fits in sockaddr_un
538 // (not including the NUL terminator)
539 const char exactLengthPath[] =
540 "abcdefghijklmnopqrstuvwxyz0123456789"
541 "abcdefghijklmnopqrstuvwxyz0123456789"
542 "abcdefghijklmnopqrstuvwxyz0123456789";
543 addr.setFromPath(exactLengthPath);
544 EXPECT_EQ(addr.describe(), exactLengthPath);
546 // Test converting a unix socket address to an IPv4 one, then back
547 addr.setFromHostPort("127.0.0.1", 1234);
548 EXPECT_EQ(addr.getFamily(), AF_INET);
549 EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
550 addr.setFromPath("/i/am/a/unix/address");
551 EXPECT_EQ(addr.getFamily(), AF_UNIX);
552 EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
554 // Test copy constructor and assignment operator
556 SocketAddress copy(addr);
557 EXPECT_EQ(copy, addr);
558 copy.setFromPath("/abc");
559 EXPECT_NE(copy, addr);
561 EXPECT_EQ(copy, addr);
562 copy.setFromIpPort("127.0.0.1", 80);
563 EXPECT_NE(copy, addr);
565 EXPECT_EQ(copy, addr);
569 SocketAddress copy(addr);
570 EXPECT_EQ(copy, addr);
571 EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
572 EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
574 SocketAddress other("127.0.0.1", 80);
575 EXPECT_NE(other, addr);
577 EXPECT_EQ(other, copy);
578 EXPECT_EQ(other, addr);
579 EXPECT_EQ(copy, addr);
582 #if __GXX_EXPERIMENTAL_CXX0X__
586 // move a unix address into a non-unix address
587 SocketAddress tmpCopy(addr);
588 copy = std::move(tmpCopy);
590 EXPECT_EQ(copy, addr);
592 copy.setFromPath("/another/path");
594 // move a unix address into a unix address
595 SocketAddress tmpCopy(addr);
596 copy = std::move(tmpCopy);
598 EXPECT_EQ(copy, addr);
601 // move a non-unix address into a unix address
602 SocketAddress tmp("127.0.0.1", 80);
603 copy = std::move(tmp);
605 EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
606 EXPECT_EQ(copy.getPort(), 80);
609 // move construct a unix address
610 SocketAddress other(std::move(copy));
611 EXPECT_EQ(other, addr);
612 EXPECT_EQ(other.getPath(), addr.getPath());
617 TEST(SocketAddress, AnonymousUnix) {
618 // Create a unix socket pair, and get the addresses.
620 int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
627 addr0.setFromLocalAddress(fds[0]);
628 peer0.setFromPeerAddress(fds[0]);
629 addr1.setFromLocalAddress(fds[1]);
630 peer1.setFromPeerAddress(fds[1]);
634 EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
635 EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
636 EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
637 EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
639 // Anonymous addresses should never compare equal
640 EXPECT_NE(addr0, addr1);
641 EXPECT_NE(peer0, peer1);
643 // Note that logically addr0 and peer1 are the same,
644 // but since they are both anonymous we have no way to determine this
645 EXPECT_NE(addr0, peer1);
646 // We can't even tell if an anonymous address is equal to itself
647 EXPECT_NE(addr0, addr0);
650 #define REQUIRE_ERRNO(cond, msg) \
652 int _requireErrnoCopy_ = errno; \
653 std::ostringstream _requireMsg_; \
654 _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
658 void testSetFromSocket(const SocketAddress *serverBindAddr,
659 const SocketAddress *clientBindAddr,
660 SocketAddress *listenAddrRet,
661 SocketAddress *acceptAddrRet,
662 SocketAddress *serverAddrRet,
663 SocketAddress *serverPeerAddrRet,
664 SocketAddress *clientAddrRet,
665 SocketAddress *clientPeerAddrRet) {
666 int listenSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
667 REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
668 sockaddr_storage laddr;
669 serverBindAddr->getAddress(&laddr);
670 socklen_t laddrLen = serverBindAddr->getActualSize();
671 int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
672 REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
673 rc = listen(listenSock, 10);
674 REQUIRE_ERRNO(rc == 0, "failed to listen");
676 listenAddrRet->setFromLocalAddress(listenSock);
678 SocketAddress listenPeerAddr;
679 EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
682 // Note that we use the family from serverBindAddr here, since we allow
683 // clientBindAddr to be nullptr.
684 int clientSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
685 REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
686 if (clientBindAddr != nullptr) {
687 sockaddr_storage clientAddr;
688 clientBindAddr->getAddress(&clientAddr);
690 rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
691 clientBindAddr->getActualSize());
692 REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
695 sockaddr_storage listenAddr;
696 listenAddrRet->getAddress(&listenAddr);
697 rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
698 listenAddrRet->getActualSize());
699 REQUIRE_ERRNO(rc == 0, "failed to connect");
701 sockaddr_storage acceptAddr;
702 socklen_t acceptAddrLen = sizeof(acceptAddr);
703 int serverSock = accept(listenSock,
704 reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
705 REQUIRE_ERRNO(serverSock > 0, "failed to accept");
706 acceptAddrRet->setFromSockaddr(
707 reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
709 serverAddrRet->setFromLocalAddress(serverSock);
710 serverPeerAddrRet->setFromPeerAddress(serverSock);
711 clientAddrRet->setFromLocalAddress(clientSock);
712 clientPeerAddrRet->setFromPeerAddress(clientSock);
719 TEST(SocketAddress, SetFromSocketIPv4) {
720 SocketAddress serverBindAddr("0.0.0.0", 0);
721 SocketAddress clientBindAddr("0.0.0.0", 0);
722 SocketAddress listenAddr;
723 SocketAddress acceptAddr;
724 SocketAddress serverAddr;
725 SocketAddress serverPeerAddr;
726 SocketAddress clientAddr;
727 SocketAddress clientPeerAddr;
729 testSetFromSocket(&serverBindAddr, &clientBindAddr,
730 &listenAddr, &acceptAddr,
731 &serverAddr, &serverPeerAddr,
732 &clientAddr, &clientPeerAddr);
734 // The server socket's local address should have the same port as the listen
735 // address. The IP will be different, since the listening socket is
736 // listening on INADDR_ANY, but the server socket will have a concrete IP
737 // address assigned to it.
738 EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
740 // The client's peer address should always be the same as the server
742 EXPECT_EQ(clientPeerAddr, serverAddr);
743 // The address returned by getpeername() on the server socket should
744 // be the same as the address returned by accept()
745 EXPECT_EQ(serverPeerAddr, acceptAddr);
746 EXPECT_EQ(serverPeerAddr, clientAddr);
747 EXPECT_EQ(acceptAddr, clientAddr);
751 * Note this test exercises Linux-specific Unix socket behavior
753 TEST(SocketAddress, SetFromSocketUnixAbstract) {
754 // Explicitly binding to an empty path results in an abstract socket
755 // name being picked for us automatically.
756 SocketAddress serverBindAddr;
758 path.append("test address");
759 serverBindAddr.setFromPath(path);
760 SocketAddress clientBindAddr;
761 clientBindAddr.setFromPath("");
763 SocketAddress listenAddr;
764 SocketAddress acceptAddr;
765 SocketAddress serverAddr;
766 SocketAddress serverPeerAddr;
767 SocketAddress clientAddr;
768 SocketAddress clientPeerAddr;
770 testSetFromSocket(&serverBindAddr, &clientBindAddr,
771 &listenAddr, &acceptAddr,
772 &serverAddr, &serverPeerAddr,
773 &clientAddr, &clientPeerAddr);
775 // The server socket's local address should be the same as the listen
777 EXPECT_EQ(serverAddr, listenAddr);
779 // The client's peer address should always be the same as the server
781 EXPECT_EQ(clientPeerAddr, serverAddr);
783 EXPECT_EQ(serverPeerAddr, clientAddr);
784 // Oddly, the address returned by accept() does not seem to match the address
785 // returned by getpeername() on the server socket or getsockname() on the
787 // EXPECT_EQ(serverPeerAddr, acceptAddr);
788 // EXPECT_EQ(acceptAddr, clientAddr);
791 TEST(SocketAddress, SetFromSocketUnixExplicit) {
792 // Pick two temporary path names.
793 // We use mkstemp() just to avoid warnings about mktemp,
794 // but we need to remove the file to let the socket code bind to it.
795 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
796 int serverPathFd = mkstemp(serverPath);
797 EXPECT_GE(serverPathFd, 0);
798 char clientPath[] = "/tmp/SocketAddressTest.client.XXXXXX";
799 int clientPathFd = mkstemp(clientPath);
800 EXPECT_GE(clientPathFd, 0);
802 int rc = unlink(serverPath);
804 rc = unlink(clientPath);
807 SocketAddress serverBindAddr;
808 SocketAddress clientBindAddr;
809 SocketAddress listenAddr;
810 SocketAddress acceptAddr;
811 SocketAddress serverAddr;
812 SocketAddress serverPeerAddr;
813 SocketAddress clientAddr;
814 SocketAddress clientPeerAddr;
816 serverBindAddr.setFromPath(serverPath);
817 clientBindAddr.setFromPath(clientPath);
819 testSetFromSocket(&serverBindAddr, &clientBindAddr,
820 &listenAddr, &acceptAddr,
821 &serverAddr, &serverPeerAddr,
822 &clientAddr, &clientPeerAddr);
824 // Remove the socket files after we are done
832 // The server socket's local address should be the same as the listen
834 EXPECT_EQ(serverAddr, listenAddr);
836 // The client's peer address should always be the same as the server
838 EXPECT_EQ(clientPeerAddr, serverAddr);
840 EXPECT_EQ(serverPeerAddr, clientAddr);
841 EXPECT_EQ(serverPeerAddr, acceptAddr);
842 EXPECT_EQ(acceptAddr, clientAddr);
845 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
846 // Test an anonymous client talking to a fixed-path unix socket.
847 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
848 int serverPathFd = mkstemp(serverPath);
849 EXPECT_GE(serverPathFd, 0);
850 int rc = unlink(serverPath);
853 SocketAddress serverBindAddr;
854 SocketAddress listenAddr;
855 SocketAddress acceptAddr;
856 SocketAddress serverAddr;
857 SocketAddress serverPeerAddr;
858 SocketAddress clientAddr;
859 SocketAddress clientPeerAddr;
861 serverBindAddr.setFromPath(serverPath);
863 testSetFromSocket(&serverBindAddr, nullptr,
864 &listenAddr, &acceptAddr,
865 &serverAddr, &serverPeerAddr,
866 &clientAddr, &clientPeerAddr);
868 // Remove the socket file after we are done
874 // The server socket's local address should be the same as the listen
876 EXPECT_EQ(serverAddr, listenAddr);
878 // The client's peer address should always be the same as the server
880 EXPECT_EQ(clientPeerAddr, serverAddr);
882 // Since the client is using an anonymous address, it won't compare equal to
883 // any other anonymous addresses. Make sure the addresses are anonymous.
884 EXPECT_EQ(serverPeerAddr.getPath(), "");
885 EXPECT_EQ(clientAddr.getPath(), "");
886 EXPECT_EQ(acceptAddr.getPath(), "");
889 TEST(SocketAddress, ResetUnixAddress) {
891 addy.setFromPath("/foo");
894 EXPECT_EQ(addy.getFamily(), AF_UNSPEC);