3 * Copyright 2017 gRPC authors.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
19 #include <grpc/grpc.h>
20 #include <grpc/support/alloc.h>
21 #include <grpc/support/log.h>
22 #include <grpc/support/string_util.h>
23 #include <grpc/support/sync.h>
24 #include <grpc/support/time.h>
27 #include <gflags/gflags.h>
28 #include <gmock/gmock.h>
29 #include <sys/types.h>
32 #include <address_sorting/address_sorting.h>
33 #include "test/cpp/util/subprocess.h"
34 #include "test/cpp/util/test_config.h"
36 #include "src/core/ext/filters/client_channel/client_channel.h"
37 #include "src/core/ext/filters/client_channel/resolver.h"
38 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
39 #include "src/core/ext/filters/client_channel/resolver/dns/dns_resolver_selection.h"
40 #include "src/core/ext/filters/client_channel/resolver_registry.h"
41 #include "src/core/ext/filters/client_channel/server_address.h"
42 #include "src/core/lib/channel/channel_args.h"
43 #include "src/core/lib/gpr/string.h"
44 #include "src/core/lib/gprpp/host_port.h"
45 #include "src/core/lib/iomgr/combiner.h"
46 #include "src/core/lib/iomgr/executor.h"
47 #include "src/core/lib/iomgr/iomgr.h"
48 #include "src/core/lib/iomgr/resolve_address.h"
49 #include "src/core/lib/iomgr/sockaddr_utils.h"
50 #include "test/core/util/port.h"
51 #include "test/core/util/test_config.h"
54 #include <arpa/inet.h>
55 #include <netinet/in.h>
56 #include <sys/socket.h>
62 std::string dest_addr;
66 grpc_resolved_address TestAddressToGrpcResolvedAddress(TestAddress test_addr) {
69 grpc_resolved_address resolved_addr;
70 grpc_core::SplitHostPort(test_addr.dest_addr.c_str(), &host, &port);
71 if (test_addr.family == AF_INET) {
73 memset(&in_dest, 0, sizeof(sockaddr_in));
74 in_dest.sin_port = htons(atoi(port.c_str()));
75 in_dest.sin_family = AF_INET;
76 GPR_ASSERT(inet_pton(AF_INET, host.c_str(), &in_dest.sin_addr) == 1);
77 memcpy(&resolved_addr.addr, &in_dest, sizeof(sockaddr_in));
78 resolved_addr.len = sizeof(sockaddr_in);
80 GPR_ASSERT(test_addr.family == AF_INET6);
81 sockaddr_in6 in6_dest;
82 memset(&in6_dest, 0, sizeof(sockaddr_in6));
83 in6_dest.sin6_port = htons(atoi(port.c_str()));
84 in6_dest.sin6_family = AF_INET6;
85 GPR_ASSERT(inet_pton(AF_INET6, host.c_str(), &in6_dest.sin6_addr) == 1);
86 memcpy(&resolved_addr.addr, &in6_dest, sizeof(sockaddr_in6));
87 resolved_addr.len = sizeof(sockaddr_in6);
92 class MockSourceAddrFactory : public address_sorting_source_addr_factory {
94 MockSourceAddrFactory(
95 bool ipv4_supported, bool ipv6_supported,
96 const std::map<std::string, TestAddress>& dest_addr_to_src_addr)
97 : ipv4_supported_(ipv4_supported),
98 ipv6_supported_(ipv6_supported),
99 dest_addr_to_src_addr_(dest_addr_to_src_addr) {}
101 bool GetSourceAddr(const address_sorting_address* dest_addr,
102 address_sorting_address* source_addr) {
103 if ((address_sorting_abstract_get_family(dest_addr) ==
104 ADDRESS_SORTING_AF_INET &&
106 (address_sorting_abstract_get_family(dest_addr) ==
107 ADDRESS_SORTING_AF_INET6 &&
111 grpc_resolved_address dest_addr_as_resolved_addr;
112 memcpy(&dest_addr_as_resolved_addr.addr, dest_addr, dest_addr->len);
113 dest_addr_as_resolved_addr.len = dest_addr->len;
114 std::string ip_addr_str = grpc_sockaddr_to_string(
115 &dest_addr_as_resolved_addr, false /* normalize */);
116 auto it = dest_addr_to_src_addr_.find(ip_addr_str);
117 if (it == dest_addr_to_src_addr_.end()) {
118 gpr_log(GPR_DEBUG, "can't find |%s| in dest to src map",
119 ip_addr_str.c_str());
122 grpc_resolved_address source_addr_as_resolved_addr =
123 TestAddressToGrpcResolvedAddress(it->second);
124 memcpy(source_addr->addr, &source_addr_as_resolved_addr.addr,
125 source_addr_as_resolved_addr.len);
126 source_addr->len = source_addr_as_resolved_addr.len;
131 // user provided test config
132 bool ipv4_supported_;
133 bool ipv6_supported_;
134 std::map<std::string, TestAddress> dest_addr_to_src_addr_;
137 static bool mock_source_addr_factory_wrapper_get_source_addr(
138 address_sorting_source_addr_factory* factory,
139 const address_sorting_address* dest_addr,
140 address_sorting_address* source_addr) {
141 MockSourceAddrFactory* mock =
142 reinterpret_cast<MockSourceAddrFactory*>(factory);
143 return mock->GetSourceAddr(dest_addr, source_addr);
146 void mock_source_addr_factory_wrapper_destroy(
147 address_sorting_source_addr_factory* factory) {
148 MockSourceAddrFactory* mock =
149 reinterpret_cast<MockSourceAddrFactory*>(factory);
153 const address_sorting_source_addr_factory_vtable kMockSourceAddrFactoryVtable =
155 mock_source_addr_factory_wrapper_get_source_addr,
156 mock_source_addr_factory_wrapper_destroy,
159 void OverrideAddressSortingSourceAddrFactory(
160 bool ipv4_supported, bool ipv6_supported,
161 const std::map<std::string, TestAddress>& dest_addr_to_src_addr) {
162 address_sorting_source_addr_factory* factory = new MockSourceAddrFactory(
163 ipv4_supported, ipv6_supported, dest_addr_to_src_addr);
164 factory->vtable = &kMockSourceAddrFactoryVtable;
165 address_sorting_override_source_addr_factory_for_testing(factory);
168 grpc_core::ServerAddressList BuildLbAddrInputs(
169 const std::vector<TestAddress>& test_addrs) {
170 grpc_core::ServerAddressList addresses;
171 for (const auto& addr : test_addrs) {
172 addresses.emplace_back(TestAddressToGrpcResolvedAddress(addr), nullptr);
177 void VerifyLbAddrOutputs(const grpc_core::ServerAddressList& addresses,
178 std::vector<std::string> expected_addrs) {
179 EXPECT_EQ(addresses.size(), expected_addrs.size());
180 for (size_t i = 0; i < addresses.size(); ++i) {
181 std::string ip_addr_str =
182 grpc_sockaddr_to_string(&addresses[i].address(), false /* normalize */);
183 EXPECT_EQ(expected_addrs[i], ip_addr_str);
187 /* We need to run each test case inside of its own
188 * isolated grpc_init/grpc_shutdown pair, so that
189 * the "address sorting source addr factory" can be
190 * restored to its default for each test case. */
191 class AddressSortingTest : public ::testing::Test {
193 void SetUp() override { grpc_init(); }
194 void TearDown() override { grpc_shutdown_blocking(); }
197 /* Tests for rule 1 */
198 TEST_F(AddressSortingTest, TestDepriotizesUnreachableAddresses) {
199 bool ipv4_supported = true;
200 bool ipv6_supported = true;
201 OverrideAddressSortingSourceAddrFactory(
202 ipv4_supported, ipv6_supported,
204 {"1.2.3.4:443", {"4.3.2.1:443", AF_INET}},
206 auto lb_addrs = BuildLbAddrInputs({
207 {"1.2.3.4:443", AF_INET},
208 {"5.6.7.8:443", AF_INET},
210 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
211 VerifyLbAddrOutputs(lb_addrs, {
217 TEST_F(AddressSortingTest, TestDepriotizesUnsupportedDomainIpv6) {
218 bool ipv4_supported = true;
219 bool ipv6_supported = false;
220 OverrideAddressSortingSourceAddrFactory(
221 ipv4_supported, ipv6_supported,
223 {"1.2.3.4:443", {"4.3.2.1:0", AF_INET}},
225 auto lb_addrs = BuildLbAddrInputs({
226 {"[2607:f8b0:400a:801::1002]:443", AF_INET6},
227 {"1.2.3.4:443", AF_INET},
229 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
230 VerifyLbAddrOutputs(lb_addrs, {
232 "[2607:f8b0:400a:801::1002]:443",
236 TEST_F(AddressSortingTest, TestDepriotizesUnsupportedDomainIpv4) {
237 bool ipv4_supported = false;
238 bool ipv6_supported = true;
239 OverrideAddressSortingSourceAddrFactory(
240 ipv4_supported, ipv6_supported,
242 {"1.2.3.4:443", {"4.3.2.1:0", AF_INET}},
243 {"[2607:f8b0:400a:801::1002]:443", {"[fec0::1234]:0", AF_INET6}},
245 auto lb_addrs = BuildLbAddrInputs({
246 {"[2607:f8b0:400a:801::1002]:443", AF_INET6},
247 {"1.2.3.4:443", AF_INET},
249 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
250 VerifyLbAddrOutputs(lb_addrs, {
251 "[2607:f8b0:400a:801::1002]:443",
256 /* Tests for rule 2 */
258 TEST_F(AddressSortingTest, TestDepriotizesNonMatchingScope) {
259 bool ipv4_supported = true;
260 bool ipv6_supported = true;
261 OverrideAddressSortingSourceAddrFactory(
262 ipv4_supported, ipv6_supported,
264 {"[2000:f8b0:400a:801::1002]:443",
265 {"[fec0::1000]:0", AF_INET6}}, // global and site-local scope
267 {"[fec0::5001]:0", AF_INET6}}, // site-local and site-local scope
269 auto lb_addrs = BuildLbAddrInputs({
270 {"[2000:f8b0:400a:801::1002]:443", AF_INET6},
271 {"[fec0::5000]:443", AF_INET6},
273 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
274 VerifyLbAddrOutputs(lb_addrs, {
276 "[2000:f8b0:400a:801::1002]:443",
280 /* Tests for rule 5 */
282 TEST_F(AddressSortingTest, TestUsesLabelFromDefaultTable) {
283 bool ipv4_supported = true;
284 bool ipv6_supported = true;
285 OverrideAddressSortingSourceAddrFactory(
286 ipv4_supported, ipv6_supported,
288 {"[2002::5001]:443", {"[2001::5002]:0", AF_INET6}},
290 {"[2001::5002]:0", AF_INET6}}, // matching labels
292 auto lb_addrs = BuildLbAddrInputs({
293 {"[2002::5001]:443", AF_INET6},
294 {"[2001::5001]:443", AF_INET6},
296 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
297 VerifyLbAddrOutputs(lb_addrs, {
303 /* Flip the input on the test above to reorder the sort function's
304 * comparator's inputs. */
305 TEST_F(AddressSortingTest, TestUsesLabelFromDefaultTableInputFlipped) {
306 bool ipv4_supported = true;
307 bool ipv6_supported = true;
308 OverrideAddressSortingSourceAddrFactory(
309 ipv4_supported, ipv6_supported,
311 {"[2002::5001]:443", {"[2001::5002]:0", AF_INET6}},
313 {"[2001::5002]:0", AF_INET6}}, // matching labels
315 auto lb_addrs = BuildLbAddrInputs({
316 {"[2001::5001]:443", AF_INET6},
317 {"[2002::5001]:443", AF_INET6},
319 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
320 VerifyLbAddrOutputs(lb_addrs, {
326 /* Tests for rule 6 */
328 TEST_F(AddressSortingTest,
329 TestUsesDestinationWithHigherPrecedenceWithAnIpv4Address) {
330 bool ipv4_supported = true;
331 bool ipv6_supported = true;
332 OverrideAddressSortingSourceAddrFactory(
333 ipv4_supported, ipv6_supported,
335 {"[3ffe::5001]:443", {"[3ffe::5002]:0", AF_INET6}},
336 {"1.2.3.4:443", {"5.6.7.8:0", AF_INET}},
338 auto lb_addrs = BuildLbAddrInputs({
339 {"[3ffe::5001]:443", AF_INET6},
340 {"1.2.3.4:443", AF_INET},
342 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
345 // The AF_INET address should be IPv4-mapped by the sort,
347 // addresses have higher precedence than 3ffe::/16 by spec.
353 TEST_F(AddressSortingTest,
354 TestUsesDestinationWithHigherPrecedenceWithV4CompatAndLocalhostAddress) {
355 bool ipv4_supported = true;
356 bool ipv6_supported = true;
357 // Handle unique observed behavior of inet_ntop(v4-compatible-address) on OS X.
359 const char* v4_compat_dest = "[::0.0.0.2]:443";
360 const char* v4_compat_src = "[::0.0.0.2]:0";
362 const char* v4_compat_dest = "[::2]:443";
363 const char* v4_compat_src = "[::2]:0";
365 OverrideAddressSortingSourceAddrFactory(
366 ipv4_supported, ipv6_supported,
368 {"[::1]:443", {"[::1]:0", AF_INET6}},
369 {v4_compat_dest, {v4_compat_src, AF_INET6}},
371 auto lb_addrs = BuildLbAddrInputs({
372 {v4_compat_dest, AF_INET6},
373 {"[::1]:443", AF_INET6},
375 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
376 VerifyLbAddrOutputs(lb_addrs, {
382 TEST_F(AddressSortingTest,
383 TestUsesDestinationWithHigherPrecedenceWithCatchAllAndLocalhostAddress) {
384 bool ipv4_supported = true;
385 bool ipv6_supported = true;
386 OverrideAddressSortingSourceAddrFactory(
387 ipv4_supported, ipv6_supported,
389 // 1234::2 for src and dest to make sure that prefix matching has no
390 // influence on this test.
391 {"[1234::2]:443", {"[1234::2]:0", AF_INET6}},
392 {"[::1]:443", {"[::1]:0", AF_INET6}},
394 auto lb_addrs = BuildLbAddrInputs({
395 {"[1234::2]:443", AF_INET6},
396 {"[::1]:443", AF_INET6},
398 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
402 // ::1 should match the localhost precedence entry and be prioritized
408 TEST_F(AddressSortingTest,
409 TestUsesDestinationWithHigherPrecedenceWith2000PrefixedAddress) {
410 bool ipv4_supported = true;
411 bool ipv6_supported = true;
412 OverrideAddressSortingSourceAddrFactory(
413 ipv4_supported, ipv6_supported,
415 {"[2001::1234]:443", {"[2001::5678]:0", AF_INET6}},
416 {"[2000::5001]:443", {"[2000::5002]:0", AF_INET6}},
418 auto lb_addrs = BuildLbAddrInputs({
419 {"[2001::1234]:443", AF_INET6},
420 {"[2000::5001]:443", AF_INET6},
422 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
425 // The 2000::/16 address should match the ::/0 prefix rule
433 TestUsesDestinationWithHigherPrecedenceWith2000PrefixedAddressEnsurePrefixMatchHasNoEffect) {
434 bool ipv4_supported = true;
435 bool ipv6_supported = true;
436 OverrideAddressSortingSourceAddrFactory(
437 ipv4_supported, ipv6_supported,
439 {"[2001::1231]:443", {"[2001::1232]:0", AF_INET6}},
440 {"[2000::5001]:443", {"[2000::5002]:0", AF_INET6}},
442 auto lb_addrs = BuildLbAddrInputs({
443 {"[2001::1231]:443", AF_INET6},
444 {"[2000::5001]:443", AF_INET6},
446 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
447 VerifyLbAddrOutputs(lb_addrs, {
453 TEST_F(AddressSortingTest,
454 TestUsesDestinationWithHigherPrecedenceWithLinkAndSiteLocalAddresses) {
455 bool ipv4_supported = true;
456 bool ipv6_supported = true;
457 OverrideAddressSortingSourceAddrFactory(
458 ipv4_supported, ipv6_supported,
460 {"[fec0::1234]:443", {"[fec0::5678]:0", AF_INET6}},
461 {"[fc00::5001]:443", {"[fc00::5002]:0", AF_INET6}},
463 auto lb_addrs = BuildLbAddrInputs({
464 {"[fec0::1234]:443", AF_INET6},
465 {"[fc00::5001]:443", AF_INET6},
467 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
468 VerifyLbAddrOutputs(lb_addrs, {
476 TestUsesDestinationWithHigherPrecedenceWithCatchAllAndAndV4MappedAddresses) {
477 bool ipv4_supported = true;
478 bool ipv6_supported = true;
479 // Use embedded ipv4 addresses with leading 1's instead of zero's to be
480 // compatible with inet_ntop implementations that can display such
481 // addresses with leading zero's as e.g.: "::ffff:0:2", as on windows.
482 OverrideAddressSortingSourceAddrFactory(
483 ipv4_supported, ipv6_supported,
485 {"[::ffff:1.1.1.2]:443", {"[::ffff:1.1.1.3]:0", AF_INET6}},
486 {"[1234::2]:443", {"[1234::3]:0", AF_INET6}},
488 auto lb_addrs = BuildLbAddrInputs({
489 {"[::ffff:1.1.1.2]:443", AF_INET6},
490 {"[1234::2]:443", AF_INET6},
492 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
493 VerifyLbAddrOutputs(lb_addrs, {
494 // ::ffff:0:2 should match the v4-mapped
495 // precedence entry and be deprioritized.
497 "[::ffff:1.1.1.2]:443",
501 /* Tests for rule 8 */
503 TEST_F(AddressSortingTest, TestPrefersSmallerScope) {
504 bool ipv4_supported = true;
505 bool ipv6_supported = true;
506 OverrideAddressSortingSourceAddrFactory(
507 ipv4_supported, ipv6_supported,
509 // Both of these destinations have the same precedence in default
512 {"[fec0::1234]:443", {"[fec0::5678]:0", AF_INET6}},
513 {"[3ffe::5001]:443", {"[3ffe::5002]:0", AF_INET6}},
515 auto lb_addrs = BuildLbAddrInputs({
516 {"[3ffe::5001]:443", AF_INET6},
517 {"[fec0::1234]:443", AF_INET6},
519 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
520 VerifyLbAddrOutputs(lb_addrs, {
526 /* Tests for rule 9 */
528 TEST_F(AddressSortingTest, TestPrefersLongestMatchingSrcDstPrefix) {
529 bool ipv4_supported = true;
530 bool ipv6_supported = true;
531 OverrideAddressSortingSourceAddrFactory(
532 ipv4_supported, ipv6_supported,
534 // Both of these destinations have the same precedence in default
537 {"[3ffe:1234::]:443", {"[3ffe:1235::]:0", AF_INET6}},
538 {"[3ffe:5001::]:443", {"[3ffe:4321::]:0", AF_INET6}},
540 auto lb_addrs = BuildLbAddrInputs({
541 {"[3ffe:5001::]:443", AF_INET6},
542 {"[3ffe:1234::]:443", AF_INET6},
544 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
545 VerifyLbAddrOutputs(lb_addrs, {
551 TEST_F(AddressSortingTest,
552 TestPrefersLongestMatchingSrcDstPrefixMatchesWholeAddress) {
553 bool ipv4_supported = true;
554 bool ipv6_supported = true;
555 OverrideAddressSortingSourceAddrFactory(
556 ipv4_supported, ipv6_supported,
558 {"[3ffe::1234]:443", {"[3ffe::1235]:0", AF_INET6}},
559 {"[3ffe::5001]:443", {"[3ffe::4321]:0", AF_INET6}},
561 auto lb_addrs = BuildLbAddrInputs({
562 {"[3ffe::5001]:443", AF_INET6},
563 {"[3ffe::1234]:443", AF_INET6},
565 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
566 VerifyLbAddrOutputs(lb_addrs, {
572 TEST_F(AddressSortingTest, TestPrefersLongestPrefixStressInnerBytePrefix) {
573 bool ipv4_supported = true;
574 bool ipv6_supported = true;
575 OverrideAddressSortingSourceAddrFactory(
576 ipv4_supported, ipv6_supported,
578 {"[3ffe:8000::]:443", {"[3ffe:C000::]:0", AF_INET6}},
579 {"[3ffe:2000::]:443", {"[3ffe:3000::]:0", AF_INET6}},
581 auto lb_addrs = BuildLbAddrInputs({
582 {"[3ffe:8000::]:443", AF_INET6},
583 {"[3ffe:2000::]:443", AF_INET6},
585 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
586 VerifyLbAddrOutputs(lb_addrs, {
592 TEST_F(AddressSortingTest, TestPrefersLongestPrefixDiffersOnHighestBitOfByte) {
593 bool ipv4_supported = true;
594 bool ipv6_supported = true;
595 OverrideAddressSortingSourceAddrFactory(
596 ipv4_supported, ipv6_supported,
598 {"[3ffe:6::]:443", {"[3ffe:8::]:0", AF_INET6}},
599 {"[3ffe:c::]:443", {"[3ffe:8::]:0", AF_INET6}},
601 auto lb_addrs = BuildLbAddrInputs({
602 {"[3ffe:6::]:443", AF_INET6},
603 {"[3ffe:c::]:443", AF_INET6},
605 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
606 VerifyLbAddrOutputs(lb_addrs, {
612 TEST_F(AddressSortingTest, TestPrefersLongestPrefixDiffersByLastBit) {
613 bool ipv4_supported = true;
614 bool ipv6_supported = true;
615 OverrideAddressSortingSourceAddrFactory(
616 ipv4_supported, ipv6_supported,
618 {"[3ffe:1111:1111:1111::]:443",
619 {"[3ffe:1111:1111:1111::]:0", AF_INET6}},
620 {"[3ffe:1111:1111:1110::]:443",
621 {"[3ffe:1111:1111:1111::]:0", AF_INET6}},
623 auto lb_addrs = BuildLbAddrInputs({
624 {"[3ffe:1111:1111:1110::]:443", AF_INET6},
625 {"[3ffe:1111:1111:1111::]:443", AF_INET6},
627 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
628 VerifyLbAddrOutputs(lb_addrs, {
629 "[3ffe:1111:1111:1111::]:443",
630 "[3ffe:1111:1111:1110::]:443",
634 /* Tests for rule 10 */
636 TEST_F(AddressSortingTest, TestStableSort) {
637 bool ipv4_supported = true;
638 bool ipv6_supported = true;
639 OverrideAddressSortingSourceAddrFactory(
640 ipv4_supported, ipv6_supported,
642 {"[3ffe::1234]:443", {"[3ffe::1236]:0", AF_INET6}},
643 {"[3ffe::1235]:443", {"[3ffe::1237]:0", AF_INET6}},
645 auto lb_addrs = BuildLbAddrInputs({
646 {"[3ffe::1234]:443", AF_INET6},
647 {"[3ffe::1235]:443", AF_INET6},
649 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
650 VerifyLbAddrOutputs(lb_addrs, {
656 TEST_F(AddressSortingTest, TestStableSortFiveElements) {
657 bool ipv4_supported = true;
658 bool ipv6_supported = true;
659 OverrideAddressSortingSourceAddrFactory(
660 ipv4_supported, ipv6_supported,
662 {"[3ffe::1231]:443", {"[3ffe::1201]:0", AF_INET6}},
663 {"[3ffe::1232]:443", {"[3ffe::1202]:0", AF_INET6}},
664 {"[3ffe::1233]:443", {"[3ffe::1203]:0", AF_INET6}},
665 {"[3ffe::1234]:443", {"[3ffe::1204]:0", AF_INET6}},
666 {"[3ffe::1235]:443", {"[3ffe::1205]:0", AF_INET6}},
668 auto lb_addrs = BuildLbAddrInputs({
669 {"[3ffe::1231]:443", AF_INET6},
670 {"[3ffe::1232]:443", AF_INET6},
671 {"[3ffe::1233]:443", AF_INET6},
672 {"[3ffe::1234]:443", AF_INET6},
673 {"[3ffe::1235]:443", AF_INET6},
675 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
676 VerifyLbAddrOutputs(lb_addrs, {
685 TEST_F(AddressSortingTest, TestStableSortNoSrcAddrsExist) {
686 bool ipv4_supported = true;
687 bool ipv6_supported = true;
688 OverrideAddressSortingSourceAddrFactory(ipv4_supported, ipv6_supported, {});
689 auto lb_addrs = BuildLbAddrInputs({
690 {"[3ffe::1231]:443", AF_INET6},
691 {"[3ffe::1232]:443", AF_INET6},
692 {"[3ffe::1233]:443", AF_INET6},
693 {"[3ffe::1234]:443", AF_INET6},
694 {"[3ffe::1235]:443", AF_INET6},
696 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
697 VerifyLbAddrOutputs(lb_addrs, {
706 TEST_F(AddressSortingTest, TestStableSortNoSrcAddrsExistWithIpv4) {
707 bool ipv4_supported = true;
708 bool ipv6_supported = true;
709 OverrideAddressSortingSourceAddrFactory(ipv4_supported, ipv6_supported, {});
710 auto lb_addrs = BuildLbAddrInputs({
711 {"[::ffff:5.6.7.8]:443", AF_INET6},
712 {"1.2.3.4:443", AF_INET},
714 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
715 VerifyLbAddrOutputs(lb_addrs, {
716 "[::ffff:5.6.7.8]:443",
721 TEST_F(AddressSortingTest, TestStableSortV4CompatAndSiteLocalAddresses) {
722 bool ipv4_supported = true;
723 bool ipv6_supported = true;
724 // Handle unique observed behavior of inet_ntop(v4-compatible-address) on OS X.
726 const char* v4_compat_dest = "[::0.0.0.2]:443";
727 const char* v4_compat_src = "[::0.0.0.3]:0";
729 const char* v4_compat_dest = "[::2]:443";
730 const char* v4_compat_src = "[::3]:0";
732 OverrideAddressSortingSourceAddrFactory(
733 ipv4_supported, ipv6_supported,
735 {"[fec0::2000]:443", {"[fec0::2001]:0", AF_INET6}},
736 {v4_compat_dest, {v4_compat_src, AF_INET6}},
738 auto lb_addrs = BuildLbAddrInputs({
739 {"[fec0::2000]:443", AF_INET6},
740 {v4_compat_dest, AF_INET6},
742 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
743 VerifyLbAddrOutputs(lb_addrs,
745 // The sort should be stable since
746 // v4-compatible has same precedence as site-local.
752 /* TestPrefersIpv6Loopback tests the actual "address probing" code
753 * for the current platform, without any mocks.
754 * This test relies on the assumption that the ipv6 loopback address is
755 * available in the hosts/containers that grpc C/C++ tests run on
756 * (whether ipv4 loopback is available or not, an available ipv6
757 * loopback should be preferred). */
758 TEST_F(AddressSortingTest, TestPrefersIpv6Loopback) {
759 auto lb_addrs = BuildLbAddrInputs({
760 {"[::1]:443", AF_INET6},
761 {"127.0.0.1:443", AF_INET},
763 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
764 VerifyLbAddrOutputs(lb_addrs, {
770 /* Flip the order of the inputs above and expect the same output order
771 * (try to rule out influence of arbitrary qsort ordering) */
772 TEST_F(AddressSortingTest, TestPrefersIpv6LoopbackInputsFlipped) {
773 auto lb_addrs = BuildLbAddrInputs({
774 {"127.0.0.1:443", AF_INET},
775 {"[::1]:443", AF_INET6},
777 grpc_cares_wrapper_address_sorting_sort(nullptr, &lb_addrs);
778 VerifyLbAddrOutputs(lb_addrs, {
784 /* Try to rule out false positives in the above two tests in which
785 * the sorter might think that neither ipv6 or ipv4 loopback is
786 * available, but ipv6 loopback is still preferred only due
787 * to precedence table lookups. */
788 TEST_F(AddressSortingTest, TestSorterKnowsIpv6LoopbackIsAvailable) {
789 sockaddr_in6 ipv6_loopback;
790 memset(&ipv6_loopback, 0, sizeof(ipv6_loopback));
791 ipv6_loopback.sin6_family = AF_INET6;
792 ((char*)&ipv6_loopback.sin6_addr)[15] = 1;
793 ipv6_loopback.sin6_port = htons(443);
794 // Set up the source and destination parameters of
795 // address_sorting_get_source_addr
796 address_sorting_address sort_input_dest;
797 memcpy(&sort_input_dest.addr, &ipv6_loopback, sizeof(ipv6_loopback));
798 sort_input_dest.len = sizeof(ipv6_loopback);
799 address_sorting_address source_for_sort_input_dest;
800 memset(&source_for_sort_input_dest, 0, sizeof(source_for_sort_input_dest));
801 // address_sorting_get_source_addr returns true if a source address was found
802 // for the destination address, otherwise false.
803 EXPECT_TRUE(address_sorting_get_source_addr_for_testing(
804 &sort_input_dest, &source_for_sort_input_dest));
805 // Now also check that the source address was filled in correctly.
806 EXPECT_GT(source_for_sort_input_dest.len, 0u);
807 sockaddr_in6* source_addr_output =
808 (sockaddr_in6*)source_for_sort_input_dest.addr;
809 EXPECT_EQ(source_addr_output->sin6_family, AF_INET6);
810 char* buf = static_cast<char*>(gpr_zalloc(100));
811 EXPECT_NE(inet_ntop(AF_INET6, &source_addr_output->sin6_addr, buf, 100),
813 << "inet_ntop failed. Errno: " + std::to_string(errno);
814 std::string source_addr_str(buf);
817 // assumes that the source address for any loopback destination is also the
819 EXPECT_EQ(source_addr_str, "::1");
824 int main(int argc, char** argv) {
825 grpc_core::UniquePtr<char> resolver =
826 GPR_GLOBAL_CONFIG_GET(grpc_dns_resolver);
827 if (strlen(resolver.get()) == 0) {
828 GPR_GLOBAL_CONFIG_SET(grpc_dns_resolver, "ares");
829 } else if (strcmp("ares", resolver.get())) {
830 gpr_log(GPR_INFO, "GRPC_DNS_RESOLVER != ares: %s.", resolver.get());
832 grpc::testing::TestEnvironment env(argc, argv);
833 ::testing::InitGoogleTest(&argc, argv);
834 auto result = RUN_ALL_TESTS();
835 // Test sequential and nested inits and shutdowns.