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>
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, SetFromIpAddressPort) {
65 folly::IPAddress ipAddr("123.234.0.23");
66 addr.setFromIpAddrPort(ipAddr, 8888);
67 EXPECT_EQ(addr.getFamily(), AF_INET);
68 EXPECT_EQ(addr.getAddressStr(), "123.234.0.23");
69 EXPECT_EQ(addr.getIPAddress(), ipAddr);
70 EXPECT_EQ(addr.getPort(), 8888);
72 folly::IPAddress ip6Addr("2620:0:1cfe:face:b00c::3");
73 SocketAddress addr6(ip6Addr, 8888);
74 EXPECT_EQ(addr6.getFamily(), AF_INET6);
75 EXPECT_EQ(addr6.getAddressStr(), "2620:0:1cfe:face:b00c::3");
76 EXPECT_EQ(addr6.getIPAddress(), ip6Addr);
77 EXPECT_EQ(addr6.getPort(), 8888);
80 TEST(SocketAddress, SetFromIpv4) {
82 addr.setFromIpPort("255.254.253.252", 8888);
83 EXPECT_EQ(addr.getFamily(), AF_INET);
84 EXPECT_EQ(addr.getAddressStr(), "255.254.253.252");
85 EXPECT_EQ(addr.getPort(), 8888);
86 sockaddr_storage addrStorage;
87 addr.getAddress(&addrStorage);
88 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
89 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0xfffefdfc));
90 EXPECT_EQ(inaddr->sin_port, htons(8888));
93 TEST(SocketAddress, ConstructFromInvalidIpv4) {
94 EXPECT_THROW(SocketAddress("1.2.3.256", 1234), std::runtime_error);
97 TEST(SocketAddress, SetFromInvalidIpv4) {
98 SocketAddress addr("12.34.56.78", 80);
100 // Try setting to an invalid value
101 // Since setFromIpPort() shouldn't allow hostname lookups, setting to
102 // "localhost" should fail, even if localhost is resolvable
103 EXPECT_THROW(addr.setFromIpPort("localhost", 1234),
106 // Make sure the address still has the old contents
107 EXPECT_EQ(addr.getFamily(), AF_INET);
108 EXPECT_EQ(addr.getAddressStr(), "12.34.56.78");
109 EXPECT_EQ(addr.getPort(), 80);
110 sockaddr_storage addrStorage;
111 addr.getAddress(&addrStorage);
112 const sockaddr_in* inaddr = reinterpret_cast<sockaddr_in*>(&addrStorage);
113 EXPECT_EQ(inaddr->sin_addr.s_addr, htonl(0x0c22384e));
116 TEST(SocketAddress, SetFromHostname) {
117 // hopefully "localhost" is resolvable on any system that will run the tests
118 EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
119 SocketAddress addr("localhost", 80, true);
122 EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
123 addr2.setFromHostPort("localhost", 0);
126 TEST(SocketAddress, SetFromStrings) {
129 // Set from a numeric port string
130 addr.setFromLocalPort("1234");
131 EXPECT_EQ(addr.getPort(), 1234);
133 // setFromLocalPort() should not accept service names
134 EXPECT_THROW(addr.setFromLocalPort("http"), std::runtime_error);
136 // Call setFromLocalIpPort() with just a port, no IP
137 addr.setFromLocalIpPort("80");
138 EXPECT_EQ(addr.getPort(), 80);
140 // Call setFromLocalIpPort() with an IP and port.
141 addr.setFromLocalIpPort("127.0.0.1:4321");
142 EXPECT_EQ(addr.getAddressStr(), "127.0.0.1");
143 EXPECT_EQ(addr.getPort(), 4321);
145 // setFromIpPort() without an address should fail
146 EXPECT_THROW(addr.setFromIpPort("4321"), std::invalid_argument);
148 // Call setFromIpPort() with an IPv6 address and port
149 addr.setFromIpPort("2620:0:1cfe:face:b00c::3:65535");
150 EXPECT_EQ(addr.getFamily(), AF_INET6);
151 EXPECT_EQ(addr.getAddressStr(), "2620:0:1cfe:face:b00c::3");
152 EXPECT_EQ(addr.getPort(), 65535);
154 // Call setFromIpPort() with an IPv4 address and port
155 addr.setFromIpPort("1.2.3.4:9999");
156 EXPECT_EQ(addr.getFamily(), AF_INET);
157 EXPECT_EQ(addr.getAddressStr(), "1.2.3.4");
158 EXPECT_EQ(addr.getPort(), 9999);
160 // Call setFromIpPort() with a bracketed IPv6
161 addr.setFromIpPort("[::]:1234");
162 EXPECT_EQ(addr.getFamily(), AF_INET6);
163 EXPECT_EQ(addr.getAddressStr(), "::");
164 EXPECT_EQ(addr.getPort(), 1234);
166 // Call setFromIpPort() with a bracketed IPv6
167 addr.setFromIpPort("[9:8::2]:1234");
168 EXPECT_EQ(addr.getFamily(), AF_INET6);
169 EXPECT_EQ(addr.getAddressStr(), "9:8::2");
170 EXPECT_EQ(addr.getPort(), 1234);
172 // Call setFromIpPort() with a bracketed IPv6 and no port
173 EXPECT_THROW(addr.setFromIpPort("[::]"), std::system_error);
176 TEST(SocketAddress, EqualityAndHash) {
178 SocketAddress local1("127.0.0.1", 1234);
179 EXPECT_EQ(local1, local1);
180 EXPECT_EQ(local1.hash(), local1.hash());
182 SocketAddress local2("127.0.0.1", 1234);
183 EXPECT_EQ(local1, local2);
184 EXPECT_EQ(local1.hash(), local2.hash());
186 SocketAddress local3("127.0.0.1", 4321);
187 EXPECT_NE(local1, local3);
188 EXPECT_NE(local1.hash(), local3.hash());
190 SocketAddress other1("1.2.3.4", 1234);
191 EXPECT_EQ(other1, other1);
192 EXPECT_EQ(other1.hash(), other1.hash());
193 EXPECT_NE(local1, other1);
194 EXPECT_NE(local1.hash(), other1.hash());
196 SocketAddress other2("4.3.2.1", 1234);
197 EXPECT_NE(other1.hash(), other2.hash());
198 EXPECT_NE(other1.hash(), other2.hash());
200 other2.setFromIpPort("1.2.3.4", 0);
201 EXPECT_NE(other1.hash(), other2.hash());
202 EXPECT_NE(other1.hash(), other2.hash());
203 other2.setPort(1234);
204 EXPECT_EQ(other1.hash(), other2.hash());
205 EXPECT_EQ(other1.hash(), other2.hash());
208 SocketAddress v6_1("2620:0:1c00:face:b00c:0:0:abcd", 1234);
209 SocketAddress v6_2("2620:0:1c00:face:b00c::abcd", 1234);
210 SocketAddress v6_3("2620:0:1c00:face:b00c::bcda", 1234);
211 EXPECT_EQ(v6_1, v6_2);
212 EXPECT_EQ(v6_1.hash(), v6_2.hash());
213 EXPECT_NE(v6_1, v6_3);
214 EXPECT_NE(v6_1.hash(), v6_3.hash());
216 // IPv4 versus IPv6 comparison
217 SocketAddress localIPv6("::1", 1234);
218 // Even though these both refer to localhost,
219 // IPv4 and IPv6 addresses are never treated as the same address
220 EXPECT_NE(local1, localIPv6);
221 EXPECT_NE(local1.hash(), localIPv6.hash());
223 // IPv4-mapped IPv6 addresses are not treated as equal
224 // to the equivalent IPv4 address
225 SocketAddress v4("10.0.0.3", 99);
226 SocketAddress v6_mapped1("::ffff:10.0.0.3", 99);
227 SocketAddress v6_mapped2("::ffff:0a00:0003", 99);
228 EXPECT_NE(v4, v6_mapped1);
229 EXPECT_NE(v4, v6_mapped2);
230 EXPECT_EQ(v6_mapped1, v6_mapped2);
232 // However, after calling convertToIPv4(), the mapped address should now be
233 // equal to the v4 version.
234 EXPECT_TRUE(v6_mapped1.isIPv4Mapped());
235 v6_mapped1.convertToIPv4();
236 EXPECT_EQ(v6_mapped1, v4);
237 EXPECT_NE(v6_mapped1, v6_mapped2);
241 unix1.setFromPath("/foo");
243 unix2.setFromPath("/foo");
245 unix3.setFromPath("/bar");
246 SocketAddress unixAnon;
247 unixAnon.setFromPath("");
249 EXPECT_EQ(unix1, unix2);
250 EXPECT_EQ(unix1.hash(), unix2.hash());
251 EXPECT_NE(unix1, unix3);
252 EXPECT_NE(unix1, unixAnon);
253 EXPECT_NE(unix2, unix3);
254 EXPECT_NE(unix2, unixAnon);
255 // anonymous addresses aren't equal to any other address,
256 // including themselves
257 EXPECT_NE(unixAnon, unixAnon);
259 // It isn't strictly required that hashes for different addresses be
260 // different, but we should have very few collisions. It generally indicates
261 // a problem if these collide
262 EXPECT_NE(unix1.hash(), unix3.hash());
263 EXPECT_NE(unix1.hash(), unixAnon.hash());
264 EXPECT_NE(unix3.hash(), unixAnon.hash());
267 TEST(SocketAddress, IsPrivate) {
269 SocketAddress addr("9.255.255.255", 0);
270 EXPECT_TRUE(!addr.isPrivateAddress());
271 addr.setFromIpPort("10.0.0.0", 0);
272 EXPECT_TRUE(addr.isPrivateAddress());
273 addr.setFromIpPort("10.255.255.255", 0);
274 EXPECT_TRUE(addr.isPrivateAddress());
275 addr.setFromIpPort("11.0.0.0", 0);
276 EXPECT_TRUE(!addr.isPrivateAddress());
278 addr.setFromIpPort("172.15.255.255", 0);
279 EXPECT_TRUE(!addr.isPrivateAddress());
280 addr.setFromIpPort("172.16.0.0", 0);
281 EXPECT_TRUE(addr.isPrivateAddress());
282 addr.setFromIpPort("172.31.255.255", 0);
283 EXPECT_TRUE(addr.isPrivateAddress());
284 addr.setFromIpPort("172.32.0.0", 0);
285 EXPECT_TRUE(!addr.isPrivateAddress());
287 addr.setFromIpPort("192.167.255.255", 0);
288 EXPECT_TRUE(!addr.isPrivateAddress());
289 addr.setFromIpPort("192.168.0.0", 0);
290 EXPECT_TRUE(addr.isPrivateAddress());
291 addr.setFromIpPort("192.168.255.255", 0);
292 EXPECT_TRUE(addr.isPrivateAddress());
293 addr.setFromIpPort("192.169.0.0", 0);
294 EXPECT_TRUE(!addr.isPrivateAddress());
296 addr.setFromIpPort("126.255.255.255", 0);
297 EXPECT_TRUE(!addr.isPrivateAddress());
298 addr.setFromIpPort("127.0.0.0", 0);
299 EXPECT_TRUE(addr.isPrivateAddress());
300 addr.setFromIpPort("127.0.0.1", 0);
301 EXPECT_TRUE(addr.isPrivateAddress());
302 addr.setFromIpPort("127.255.255.255", 0);
303 EXPECT_TRUE(addr.isPrivateAddress());
304 addr.setFromIpPort("128.0.0.0", 0);
305 EXPECT_TRUE(!addr.isPrivateAddress());
307 addr.setFromIpPort("1.2.3.4", 0);
308 EXPECT_TRUE(!addr.isPrivateAddress());
309 addr.setFromIpPort("69.171.239.10", 0);
310 EXPECT_TRUE(!addr.isPrivateAddress());
313 addr.setFromIpPort("fbff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
314 EXPECT_TRUE(!addr.isPrivateAddress());
315 addr.setFromIpPort("fc00::", 0);
316 EXPECT_TRUE(addr.isPrivateAddress());
317 addr.setFromIpPort("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
318 EXPECT_TRUE(addr.isPrivateAddress());
319 addr.setFromIpPort("fe00::", 0);
320 EXPECT_TRUE(!addr.isPrivateAddress());
322 addr.setFromIpPort("fe7f:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
323 EXPECT_TRUE(!addr.isPrivateAddress());
324 addr.setFromIpPort("fe80::", 0);
325 EXPECT_TRUE(addr.isPrivateAddress());
326 addr.setFromIpPort("fe80::ffff:ffff:ffff:ffff", 0);
327 EXPECT_TRUE(addr.isPrivateAddress());
328 addr.setFromIpPort("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0);
329 EXPECT_TRUE(addr.isPrivateAddress());
330 addr.setFromIpPort("fec0::", 0);
331 EXPECT_TRUE(!addr.isPrivateAddress());
333 addr.setFromIpPort("::0", 0);
334 EXPECT_TRUE(!addr.isPrivateAddress());
335 addr.setFromIpPort("2620:0:1c00:face:b00c:0:0:abcd", 0);
336 EXPECT_TRUE(!addr.isPrivateAddress());
339 addr.setFromIpPort("::ffff:127.0.0.1", 0);
340 EXPECT_TRUE(addr.isPrivateAddress());
341 addr.setFromIpPort("::ffff:10.1.2.3", 0);
342 EXPECT_TRUE(addr.isPrivateAddress());
343 addr.setFromIpPort("::ffff:172.24.0.115", 0);
344 EXPECT_TRUE(addr.isPrivateAddress());
345 addr.setFromIpPort("::ffff:192.168.0.1", 0);
346 EXPECT_TRUE(addr.isPrivateAddress());
347 addr.setFromIpPort("::ffff:69.171.239.10", 0);
348 EXPECT_TRUE(!addr.isPrivateAddress());
350 // Unix sockets are considered private addresses
351 addr.setFromPath("/tmp/mysock");
352 EXPECT_TRUE(addr.isPrivateAddress());
355 TEST(SocketAddress, IsLoopback) {
357 SocketAddress addr("127.0.0.1", 0);
358 EXPECT_TRUE(addr.isLoopbackAddress());
359 addr.setFromIpPort("127.0.0.0", 0xffff);
360 EXPECT_TRUE(addr.isLoopbackAddress());
361 addr.setFromIpPort("127.1.1.1", 0xffff);
362 EXPECT_TRUE(addr.isLoopbackAddress());
363 addr.setFromIpPort("127.255.255.255", 80);
364 EXPECT_TRUE(addr.isLoopbackAddress());
366 addr.setFromIpPort("128.0.0.0", 0);
367 EXPECT_TRUE(!addr.isLoopbackAddress());
368 addr.setFromIpPort("126.255.255.255", 0);
369 EXPECT_TRUE(!addr.isLoopbackAddress());
370 addr.setFromIpPort("10.1.2.3", 0);
371 EXPECT_TRUE(!addr.isLoopbackAddress());
374 addr.setFromIpPort("::1", 0);
375 EXPECT_TRUE(addr.isLoopbackAddress());
376 addr.setFromIpPort("::0", 0);
377 EXPECT_TRUE(!addr.isLoopbackAddress());
378 addr.setFromIpPort("::2", 0);
379 EXPECT_TRUE(!addr.isLoopbackAddress());
382 addr.setFromIpPort("::ffff:127.0.0.1", 0);
383 EXPECT_TRUE(addr.isLoopbackAddress());
384 addr.setFromIpPort("::ffff:7f0a:141e", 0);
385 EXPECT_TRUE(addr.isLoopbackAddress());
386 addr.setFromIpPort("::ffff:169.254.0.13", 0);
387 EXPECT_TRUE(!addr.isLoopbackAddress());
389 // Unix sockets are considered loopback addresses
390 addr.setFromPath("/tmp/mysock");
391 EXPECT_TRUE(addr.isLoopbackAddress());
394 void CheckPrefixMatch(const SocketAddress& first,
395 const SocketAddress& second, unsigned matchingPrefixLen) {
397 for (i = 0; i <= matchingPrefixLen; i++) {
398 EXPECT_TRUE(first.prefixMatch(second, i));
400 unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
401 for (; i <= addrLen; i++) {
402 EXPECT_TRUE(!first.prefixMatch(second, i));
406 TEST(SocketAddress, PrefixMatch) {
408 SocketAddress addr1("127.0.0.1", 0);
409 SocketAddress addr2("127.0.0.1", 0);
410 CheckPrefixMatch(addr1, addr2, 32);
412 addr2.setFromIpPort("127.0.1.1", 0);
413 CheckPrefixMatch(addr1, addr2, 23);
415 addr2.setFromIpPort("1.1.0.127", 0);
416 CheckPrefixMatch(addr1, addr2, 1);
418 // Address family mismatch
419 addr2.setFromIpPort("::ffff:127.0.0.1", 0);
420 EXPECT_TRUE(!addr1.prefixMatch(addr2, 1));
423 addr1.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
424 CheckPrefixMatch(addr1, addr2, 2);
426 addr2.setFromIpPort("2a03:2880:10:8f02:face:b00c:0:25", 0);
427 CheckPrefixMatch(addr1, addr2, 128);
429 addr2.setFromIpPort("2a03:2880:30:8f02:face:b00c:0:25", 0);
430 CheckPrefixMatch(addr1, addr2, 42);
433 void CheckFirstLessThanSecond(SocketAddress first, SocketAddress second) {
434 EXPECT_TRUE(!(first < first));
435 EXPECT_TRUE(!(second < second));
436 EXPECT_TRUE(first < second);
437 EXPECT_TRUE(!(first == second));
438 EXPECT_TRUE(!(second < first));
441 TEST(SocketAddress, CheckComparatorBehavior) {
442 SocketAddress first, second;
443 // The following comparison are strict (so if first and second were
444 // inverted that is ok.
449 first.setFromIpPort("128.0.0.0", 0);
450 second.setFromIpPort("128.0.0.0", 0xFFFF);
451 CheckFirstLessThanSecond(first, second);
452 first.setFromIpPort("128.0.0.100", 0);
453 second.setFromIpPort("128.0.0.0", 0xFFFF);
454 CheckFirstLessThanSecond(first, second);
456 // Address comparisons
457 first.setFromIpPort("128.0.0.0", 10);
458 second.setFromIpPort("128.0.0.100", 10);
459 CheckFirstLessThanSecond(first, second);
461 // Comaprision between IPV4 and IPV6
462 first.setFromIpPort("128.0.0.0", 0);
463 second.setFromIpPort("::ffff:127.0.0.1", 0);
464 CheckFirstLessThanSecond(first, second);
465 first.setFromIpPort("128.0.0.0", 100);
466 second.setFromIpPort("::ffff:127.0.0.1", 0);
467 CheckFirstLessThanSecond(first, second);
472 first.setFromIpPort("::0", 0);
473 second.setFromIpPort("::0", 0xFFFF);
474 CheckFirstLessThanSecond(first, second);
475 first.setFromIpPort("::0", 0);
476 second.setFromIpPort("::1", 0xFFFF);
477 CheckFirstLessThanSecond(first, second);
479 // Address comparisons
480 first.setFromIpPort("::0", 10);
481 second.setFromIpPort("::1", 10);
482 CheckFirstLessThanSecond(first, second);
485 first.setFromPath("/foo");
486 second.setFromPath("/1234");
487 // The exact comparison order doesn't really matter, as long as
488 // (a < b), (b < a), and (a == b) are consistent.
489 // This checks our current comparison rules, which checks the path length
490 // before the path contents.
491 CheckFirstLessThanSecond(first, second);
492 first.setFromPath("/1234");
493 second.setFromPath("/5678");
494 CheckFirstLessThanSecond(first, second);
497 // We currently compare the address family values, and AF_UNIX < AF_INET
498 first.setFromPath("/foo");
499 second.setFromIpPort("127.0.0.1", 80);
500 CheckFirstLessThanSecond(first, second);
503 TEST(SocketAddress, Unix) {
507 addr.setFromPath("foo");
508 EXPECT_EQ(addr.getFamily(), AF_UNIX);
509 EXPECT_EQ(addr.describe(), "foo");
510 EXPECT_THROW(addr.getAddressStr(), std::invalid_argument);
511 EXPECT_THROW(addr.getPort(), std::invalid_argument);
512 EXPECT_TRUE(addr.isPrivateAddress());
513 EXPECT_TRUE(addr.isLoopbackAddress());
515 // Test a path that is too large
516 const char longPath[] =
517 "abcdefghijklmnopqrstuvwxyz0123456789"
518 "abcdefghijklmnopqrstuvwxyz0123456789"
519 "abcdefghijklmnopqrstuvwxyz0123456789"
520 "abcdefghijklmnopqrstuvwxyz0123456789";
521 EXPECT_THROW(addr.setFromPath(longPath), std::invalid_argument);
522 // The original address should still be the same
523 EXPECT_EQ(addr.getFamily(), AF_UNIX);
524 EXPECT_EQ(addr.describe(), "foo");
526 // Test a path that exactly fits in sockaddr_un
527 // (not including the NUL terminator)
528 const char exactLengthPath[] =
529 "abcdefghijklmnopqrstuvwxyz0123456789"
530 "abcdefghijklmnopqrstuvwxyz0123456789"
531 "abcdefghijklmnopqrstuvwxyz0123456789";
532 addr.setFromPath(exactLengthPath);
533 EXPECT_EQ(addr.describe(), exactLengthPath);
535 // Test converting a unix socket address to an IPv4 one, then back
536 addr.setFromHostPort("127.0.0.1", 1234);
537 EXPECT_EQ(addr.getFamily(), AF_INET);
538 EXPECT_EQ(addr.describe(), "127.0.0.1:1234");
539 addr.setFromPath("/i/am/a/unix/address");
540 EXPECT_EQ(addr.getFamily(), AF_UNIX);
541 EXPECT_EQ(addr.describe(), "/i/am/a/unix/address");
543 // Test copy constructor and assignment operator
545 SocketAddress copy(addr);
546 EXPECT_EQ(copy, addr);
547 copy.setFromPath("/abc");
548 EXPECT_NE(copy, addr);
550 EXPECT_EQ(copy, addr);
551 copy.setFromIpPort("127.0.0.1", 80);
552 EXPECT_NE(copy, addr);
554 EXPECT_EQ(copy, addr);
558 SocketAddress copy(addr);
559 EXPECT_EQ(copy, addr);
560 EXPECT_EQ(copy.describe(), "/i/am/a/unix/address");
561 EXPECT_EQ(copy.getPath(), "/i/am/a/unix/address");
563 SocketAddress other("127.0.0.1", 80);
564 EXPECT_NE(other, addr);
566 EXPECT_EQ(other, copy);
567 EXPECT_EQ(other, addr);
568 EXPECT_EQ(copy, addr);
571 #if __GXX_EXPERIMENTAL_CXX0X__
575 // move a unix address into a non-unix address
576 SocketAddress tmpCopy(addr);
577 copy = std::move(tmpCopy);
579 EXPECT_EQ(copy, addr);
581 copy.setFromPath("/another/path");
583 // move a unix address into a unix address
584 SocketAddress tmpCopy(addr);
585 copy = std::move(tmpCopy);
587 EXPECT_EQ(copy, addr);
590 // move a non-unix address into a unix address
591 SocketAddress tmp("127.0.0.1", 80);
592 copy = std::move(tmp);
594 EXPECT_EQ(copy.getAddressStr(), "127.0.0.1");
595 EXPECT_EQ(copy.getPort(), 80);
598 // move construct a unix address
599 SocketAddress other(std::move(copy));
600 EXPECT_EQ(other, addr);
601 EXPECT_EQ(other.getPath(), addr.getPath());
606 TEST(SocketAddress, AnonymousUnix) {
607 // Create a unix socket pair, and get the addresses.
609 int rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
616 addr0.setFromLocalAddress(fds[0]);
617 peer0.setFromPeerAddress(fds[0]);
618 addr1.setFromLocalAddress(fds[1]);
619 peer1.setFromPeerAddress(fds[1]);
623 EXPECT_EQ(addr0.describe(), "<anonymous unix address>");
624 EXPECT_EQ(addr1.describe(), "<anonymous unix address>");
625 EXPECT_EQ(peer0.describe(), "<anonymous unix address>");
626 EXPECT_EQ(peer1.describe(), "<anonymous unix address>");
628 // Anonymous addresses should never compare equal
629 EXPECT_NE(addr0, addr1);
630 EXPECT_NE(peer0, peer1);
632 // Note that logically addr0 and peer1 are the same,
633 // but since they are both anonymous we have no way to determine this
634 EXPECT_NE(addr0, peer1);
635 // We can't even tell if an anonymous address is equal to itself
636 EXPECT_NE(addr0, addr0);
639 #define REQUIRE_ERRNO(cond, msg) \
641 int _requireErrnoCopy_ = errno; \
642 std::ostringstream _requireMsg_; \
643 _requireMsg_ << (msg) << ": " << strerror(_requireErrnoCopy_); \
647 void testSetFromSocket(const SocketAddress *serverBindAddr,
648 const SocketAddress *clientBindAddr,
649 SocketAddress *listenAddrRet,
650 SocketAddress *acceptAddrRet,
651 SocketAddress *serverAddrRet,
652 SocketAddress *serverPeerAddrRet,
653 SocketAddress *clientAddrRet,
654 SocketAddress *clientPeerAddrRet) {
655 int listenSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
656 REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
657 sockaddr_storage laddr;
658 serverBindAddr->getAddress(&laddr);
659 socklen_t laddrLen = serverBindAddr->getActualSize();
660 int rc = bind(listenSock, reinterpret_cast<sockaddr*>(&laddr), laddrLen);
661 REQUIRE_ERRNO(rc == 0, "failed to bind to server socket");
662 rc = listen(listenSock, 10);
663 REQUIRE_ERRNO(rc == 0, "failed to listen");
665 listenAddrRet->setFromLocalAddress(listenSock);
667 SocketAddress listenPeerAddr;
668 EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
671 // Note that we use the family from serverBindAddr here, since we allow
672 // clientBindAddr to be nullptr.
673 int clientSock = socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
674 REQUIRE_ERRNO(clientSock > 0, "failed to create client socket");
675 if (clientBindAddr != nullptr) {
676 sockaddr_storage clientAddr;
677 clientBindAddr->getAddress(&clientAddr);
679 rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
680 clientBindAddr->getActualSize());
681 REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
684 sockaddr_storage listenAddr;
685 listenAddrRet->getAddress(&listenAddr);
686 rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
687 listenAddrRet->getActualSize());
688 REQUIRE_ERRNO(rc == 0, "failed to connect");
690 sockaddr_storage acceptAddr;
691 socklen_t acceptAddrLen = sizeof(acceptAddr);
692 int serverSock = accept(listenSock,
693 reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
694 REQUIRE_ERRNO(serverSock > 0, "failed to accept");
695 acceptAddrRet->setFromSockaddr(
696 reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
698 serverAddrRet->setFromLocalAddress(serverSock);
699 serverPeerAddrRet->setFromPeerAddress(serverSock);
700 clientAddrRet->setFromLocalAddress(clientSock);
701 clientPeerAddrRet->setFromPeerAddress(clientSock);
708 TEST(SocketAddress, SetFromSocketIPv4) {
709 SocketAddress serverBindAddr("0.0.0.0", 0);
710 SocketAddress clientBindAddr("0.0.0.0", 0);
711 SocketAddress listenAddr;
712 SocketAddress acceptAddr;
713 SocketAddress serverAddr;
714 SocketAddress serverPeerAddr;
715 SocketAddress clientAddr;
716 SocketAddress clientPeerAddr;
718 testSetFromSocket(&serverBindAddr, &clientBindAddr,
719 &listenAddr, &acceptAddr,
720 &serverAddr, &serverPeerAddr,
721 &clientAddr, &clientPeerAddr);
723 // The server socket's local address should have the same port as the listen
724 // address. The IP will be different, since the listening socket is
725 // listening on INADDR_ANY, but the server socket will have a concrete IP
726 // address assigned to it.
727 EXPECT_EQ(serverAddr.getPort(), listenAddr.getPort());
729 // The client's peer address should always be the same as the server
731 EXPECT_EQ(clientPeerAddr, serverAddr);
732 // The address returned by getpeername() on the server socket should
733 // be the same as the address returned by accept()
734 EXPECT_EQ(serverPeerAddr, acceptAddr);
735 EXPECT_EQ(serverPeerAddr, clientAddr);
736 EXPECT_EQ(acceptAddr, clientAddr);
740 * Note this test exercises Linux-specific Unix socket behavior
742 TEST(SocketAddress, SetFromSocketUnixAbstract) {
743 // Explicitly binding to an empty path results in an abstract socket
744 // name being picked for us automatically.
745 SocketAddress serverBindAddr;
747 path.append("test address");
748 serverBindAddr.setFromPath(path);
749 SocketAddress clientBindAddr;
750 clientBindAddr.setFromPath("");
752 SocketAddress listenAddr;
753 SocketAddress acceptAddr;
754 SocketAddress serverAddr;
755 SocketAddress serverPeerAddr;
756 SocketAddress clientAddr;
757 SocketAddress clientPeerAddr;
759 testSetFromSocket(&serverBindAddr, &clientBindAddr,
760 &listenAddr, &acceptAddr,
761 &serverAddr, &serverPeerAddr,
762 &clientAddr, &clientPeerAddr);
764 // The server socket's local address should be the same as the listen
766 EXPECT_EQ(serverAddr, listenAddr);
768 // The client's peer address should always be the same as the server
770 EXPECT_EQ(clientPeerAddr, serverAddr);
772 EXPECT_EQ(serverPeerAddr, clientAddr);
773 // Oddly, the address returned by accept() does not seem to match the address
774 // returned by getpeername() on the server socket or getsockname() on the
776 // EXPECT_EQ(serverPeerAddr, acceptAddr);
777 // EXPECT_EQ(acceptAddr, clientAddr);
780 TEST(SocketAddress, SetFromSocketUnixExplicit) {
781 // Pick two temporary path names.
782 // We use mkstemp() just to avoid warnings about mktemp,
783 // but we need to remove the file to let the socket code bind to it.
784 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
785 int serverPathFd = mkstemp(serverPath);
786 EXPECT_GE(serverPathFd, 0);
787 char clientPath[] = "/tmp/SocketAddressTest.client.XXXXXX";
788 int clientPathFd = mkstemp(clientPath);
789 EXPECT_GE(clientPathFd, 0);
791 int rc = unlink(serverPath);
793 rc = unlink(clientPath);
796 SocketAddress serverBindAddr;
797 SocketAddress clientBindAddr;
798 SocketAddress listenAddr;
799 SocketAddress acceptAddr;
800 SocketAddress serverAddr;
801 SocketAddress serverPeerAddr;
802 SocketAddress clientAddr;
803 SocketAddress clientPeerAddr;
805 serverBindAddr.setFromPath(serverPath);
806 clientBindAddr.setFromPath(clientPath);
808 testSetFromSocket(&serverBindAddr, &clientBindAddr,
809 &listenAddr, &acceptAddr,
810 &serverAddr, &serverPeerAddr,
811 &clientAddr, &clientPeerAddr);
813 // Remove the socket files after we are done
821 // The server socket's local address should be the same as the listen
823 EXPECT_EQ(serverAddr, listenAddr);
825 // The client's peer address should always be the same as the server
827 EXPECT_EQ(clientPeerAddr, serverAddr);
829 EXPECT_EQ(serverPeerAddr, clientAddr);
830 EXPECT_EQ(serverPeerAddr, acceptAddr);
831 EXPECT_EQ(acceptAddr, clientAddr);
834 TEST(SocketAddress, SetFromSocketUnixAnonymous) {
835 // Test an anonymous client talking to a fixed-path unix socket.
836 char serverPath[] = "/tmp/SocketAddressTest.server.XXXXXX";
837 int serverPathFd = mkstemp(serverPath);
838 EXPECT_GE(serverPathFd, 0);
839 int rc = unlink(serverPath);
842 SocketAddress serverBindAddr;
843 SocketAddress listenAddr;
844 SocketAddress acceptAddr;
845 SocketAddress serverAddr;
846 SocketAddress serverPeerAddr;
847 SocketAddress clientAddr;
848 SocketAddress clientPeerAddr;
850 serverBindAddr.setFromPath(serverPath);
852 testSetFromSocket(&serverBindAddr, nullptr,
853 &listenAddr, &acceptAddr,
854 &serverAddr, &serverPeerAddr,
855 &clientAddr, &clientPeerAddr);
857 // Remove the socket file after we are done
863 // The server socket's local address should be the same as the listen
865 EXPECT_EQ(serverAddr, listenAddr);
867 // The client's peer address should always be the same as the server
869 EXPECT_EQ(clientPeerAddr, serverAddr);
871 // Since the client is using an anonymous address, it won't compare equal to
872 // any other anonymous addresses. Make sure the addresses are anonymous.
873 EXPECT_EQ(serverPeerAddr.getPath(), "");
874 EXPECT_EQ(clientAddr.getPath(), "");
875 EXPECT_EQ(acceptAddr.getPath(), "");
878 TEST(SocketAddress, ResetUnixAddress) {
880 addy.setFromPath("/foo");
883 EXPECT_EQ(addy.getFamily(), AF_UNSPEC);