| // Copyright 2021 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/connectivity/network/mdns/service/transport/mdns_transceiver.h" |
| |
| #include <fuchsia/hardware/network/cpp/fidl.h> |
| #include <fuchsia/net/interfaces/cpp/fidl.h> |
| #include <fuchsia/net/interfaces/cpp/fidl_test_base.h> |
| #include <lib/fidl/cpp/binding.h> |
| |
| #include "src/connectivity/network/mdns/service/common/mdns_addresses.h" |
| #include "src/lib/testing/loop_fixture/test_loop_fixture.h" |
| #include "src/lib/testing/predicates/status.h" |
| |
| namespace mdns::test { |
| |
| constexpr std::array<uint8_t, 4> kIPv4Address1 = {1, 2, 3, 1}; |
| constexpr std::array<uint8_t, 4> kIPv4Address2 = {4, 5, 6, 1}; |
| constexpr std::array<uint8_t, 16> kIPv6Address1 = {0xfe, 0x80, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 1, 2, 3, 4}; |
| constexpr std::array<uint8_t, 16> kIPv6Address2 = {0xfe, 0x80, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 4, 3, 2, 1}; |
| constexpr std::array<uint8_t, 16> kIPv6AddressNotLinkLocal = {0xff, 0x80, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 4, 3, 2, 1}; |
| constexpr std::array<uint8_t, 16> kIPv6AddressNotLinkLocal2 = {0xff, 0x80, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 4, 3, 2, 2}; |
| constexpr std::array<uint8_t, 16> kIPv6AddressNotLinkLocal3 = {0xff, 0x80, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 4, 3, 2, 3}; |
| constexpr std::array<uint8_t, 16> kIPv6AddressNotLinkLocal4 = {0xff, 0x80, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 4, 3, 2, 4}; |
| constexpr uint8_t kIPv4PrefixLength = 24; |
| constexpr uint8_t kIPv6PrefixLength = 64; |
| constexpr uint8_t kID = 1; |
| constexpr const char kName[] = "test01"; |
| constexpr const char kHostName[] = "testhostname"; |
| |
| namespace { |
| |
| fuchsia::net::Ipv4Address ToFIDL(const std::array<uint8_t, 4>& bytes) { |
| fuchsia::net::Ipv4Address addr; |
| std::copy(bytes.cbegin(), bytes.cend(), addr.addr.begin()); |
| return addr; |
| } |
| |
| fuchsia::net::Ipv6Address ToFIDL(const std::array<uint8_t, 16>& bytes) { |
| fuchsia::net::Ipv6Address addr; |
| std::copy(bytes.cbegin(), bytes.cend(), addr.addr.begin()); |
| return addr; |
| } |
| |
| void InitAddress(fuchsia::net::interfaces::Address& addr, const std::array<uint8_t, 4>& bytes) { |
| fuchsia::net::Subnet subnet{ |
| .prefix_len = kIPv4PrefixLength, |
| }; |
| subnet.addr.set_ipv4(ToFIDL(bytes)); |
| addr.set_addr(std::move(subnet)); |
| } |
| |
| void InitAddress(fuchsia::net::interfaces::Address& addr, const std::array<uint8_t, 16>& bytes) { |
| fuchsia::net::Subnet subnet{ |
| .prefix_len = kIPv6PrefixLength, |
| }; |
| subnet.addr.set_ipv6(ToFIDL(bytes)); |
| addr.set_addr(std::move(subnet)); |
| } |
| |
| std::vector<fuchsia::net::interfaces::Address> Addresses1() { |
| std::vector<fuchsia::net::interfaces::Address> addresses; |
| addresses.reserve(2); |
| InitAddress(addresses.emplace_back(), kIPv4Address1); |
| InitAddress(addresses.emplace_back(), kIPv6Address1); |
| // To verify that non-link-local addresses do not cause a transceiver to be created. |
| InitAddress(addresses.emplace_back(), kIPv6AddressNotLinkLocal); |
| return addresses; |
| } |
| |
| std::vector<fuchsia::net::interfaces::Address> Addresses1Extra() { |
| std::vector<fuchsia::net::interfaces::Address> addresses; |
| addresses.reserve(2); |
| InitAddress(addresses.emplace_back(), kIPv4Address1); |
| InitAddress(addresses.emplace_back(), kIPv6Address1); |
| InitAddress(addresses.emplace_back(), kIPv6AddressNotLinkLocal); |
| InitAddress(addresses.emplace_back(), kIPv6AddressNotLinkLocal2); |
| InitAddress(addresses.emplace_back(), kIPv6AddressNotLinkLocal3); |
| InitAddress(addresses.emplace_back(), kIPv6AddressNotLinkLocal4); |
| return addresses; |
| } |
| |
| std::vector<fuchsia::net::interfaces::Address> Addresses2() { |
| std::vector<fuchsia::net::interfaces::Address> addresses; |
| addresses.reserve(2); |
| InitAddress(addresses.emplace_back(), kIPv4Address2); |
| InitAddress(addresses.emplace_back(), kIPv6Address2); |
| return addresses; |
| } |
| |
| bool VerifyAddressResource(std::shared_ptr<DnsResource> resource, inet::IpAddress expected_address, |
| bool cache_flush) { |
| EXPECT_TRUE(!!resource); |
| if (!resource) { |
| return false; |
| } |
| |
| EXPECT_EQ(kHostName, resource->name_.dotted_string_); |
| EXPECT_EQ(expected_address.is_v4() ? DnsType::kA : DnsType::kAaaa, resource->type_); |
| EXPECT_EQ(DnsClass::kIn, resource->class_); |
| EXPECT_EQ(cache_flush, resource->cache_flush_); |
| EXPECT_EQ(DnsResource::kShortTimeToLive, resource->time_to_live_); |
| |
| if (resource->type_ == DnsType::kA) { |
| EXPECT_EQ(expected_address, resource->a_.address_.address_); |
| if (expected_address != resource->a_.address_.address_) { |
| return false; |
| } |
| } else { |
| EXPECT_EQ(expected_address, resource->aaaa_.address_.address_); |
| if (expected_address != resource->aaaa_.address_.address_) { |
| return false; |
| } |
| } |
| |
| return (kHostName == resource->name_.dotted_string_) && |
| ((expected_address.is_v4() ? DnsType::kA : DnsType::kAaaa) == resource->type_) && |
| (DnsClass::kIn == resource->class_) && (cache_flush == resource->cache_flush_) && |
| (DnsResource::kShortTimeToLive == resource->time_to_live_); |
| } |
| |
| } // namespace |
| |
| class InterfacesWatcherImpl : public fuchsia::net::interfaces::testing::Watcher_TestBase { |
| public: |
| void NotImplemented_(const std::string& name) override { |
| std::cout << "Not implemented: " << name << std::endl; |
| } |
| |
| void Watch(WatchCallback callback) override { |
| ASSERT_FALSE(watch_cb_.has_value()); |
| watch_cb_ = std::move(callback); |
| } |
| |
| bool CompleteWatchCallback(fuchsia::net::interfaces::Event event) { |
| if (watch_cb_.has_value()) { |
| (*watch_cb_)(std::move(event)); |
| watch_cb_.reset(); |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| private: |
| std::optional<WatchCallback> watch_cb_; |
| }; |
| |
| class StubInterfaceTransceiver : public MdnsInterfaceTransceiver { |
| public: |
| StubInterfaceTransceiver(inet::IpAddress address, const std::string& name, uint32_t id, |
| Media media) |
| : MdnsInterfaceTransceiver(address, name, id, media), |
| ip_versions_(address.is_v4() ? IpVersions::kV4 : IpVersions::kV6) {} |
| |
| static std::unique_ptr<MdnsInterfaceTransceiver> Create(inet::IpAddress address, |
| const std::string& name, uint32_t id, |
| Media media) { |
| return std::make_unique<StubInterfaceTransceiver>(address, name, id, media); |
| } |
| |
| const std::vector<std::shared_ptr<DnsResource>>& GetInterfaceAddressResources( |
| const std::string& host_full_name) { |
| return MdnsInterfaceTransceiver::GetInterfaceAddressResources(host_full_name); |
| } |
| |
| protected: |
| enum IpVersions IpVersions() override { return ip_versions_; } |
| int SetOptionDisableMulticastLoop() override { return 0; } |
| int SetOptionJoinMulticastGroup() override { return 0; } |
| int SetOptionOutboundInterface() override { return 0; } |
| int SetOptionUnicastTtl() override { return 0; } |
| int SetOptionMulticastTtl() override { return 0; } |
| int SetOptionFamilySpecific() override { return 0; } |
| int Bind() override { return 0; } |
| ssize_t SendTo(const void* buffer, size_t size, const inet::SocketAddress& address) override { |
| return 0; |
| } |
| |
| bool Start(InboundMessageCallback callback) override { return true; } |
| void Stop() override {} |
| |
| private: |
| enum IpVersions ip_versions_; |
| }; |
| |
| class MdnsTransceiverTests : public gtest::TestLoopFixture { |
| public: |
| MdnsTransceiverTests() |
| : binding_(std::make_unique<fidl::Binding<fuchsia::net::interfaces::Watcher>>( |
| &fake_watcher_impl_)), |
| v4_address1_(inet::IpAddress(ToFIDL(kIPv4Address1))), |
| v4_address2_(inet::IpAddress(ToFIDL(kIPv4Address2))), |
| v6_address1_(inet::IpAddress(ToFIDL(kIPv6Address1))), |
| v6_address2_(inet::IpAddress(ToFIDL(kIPv6Address2))), |
| v6_address_not_link_local_(inet::IpAddress(ToFIDL(kIPv6AddressNotLinkLocal))), |
| v6_address_not_link_local_2_(inet::IpAddress(ToFIDL(kIPv6AddressNotLinkLocal2))), |
| v6_address_not_link_local_3_(inet::IpAddress(ToFIDL(kIPv6AddressNotLinkLocal3))), |
| v6_address_not_link_local_4_(inet::IpAddress(ToFIDL(kIPv6AddressNotLinkLocal4))) { |
| properties_ = fuchsia::net::interfaces::Properties(); |
| properties_.set_id(kID); |
| properties_.set_name(kName); |
| properties_.set_device_class(fuchsia::net::interfaces::DeviceClass::WithDevice( |
| fuchsia::hardware::network::DeviceClass::WLAN)); |
| properties_.set_online(true); |
| properties_.set_has_default_ipv4_route(false); |
| properties_.set_has_default_ipv6_route(false); |
| |
| properties_.set_addresses(Addresses1()); |
| } |
| |
| protected: |
| void SetUp() override { |
| TestLoopFixture::SetUp(); |
| |
| fuchsia::net::interfaces::WatcherPtr watcher; |
| ASSERT_OK(binding_->Bind(watcher.NewRequest())); |
| transceiver_.Start( |
| std::move(watcher), []() {}, [](auto, auto) {}, StubInterfaceTransceiver::Create); |
| } |
| |
| void TearDown() override { |
| transceiver_.Stop(); |
| |
| TestLoopFixture::TearDown(); |
| } |
| |
| MdnsTransceiver transceiver_; |
| InterfacesWatcherImpl fake_watcher_impl_; |
| const std::unique_ptr<fidl::Binding<fuchsia::net::interfaces::Watcher>> binding_; |
| fuchsia::net::interfaces::Properties properties_; |
| const inet::IpAddress v4_address1_, v4_address2_, v6_address1_, v6_address2_, |
| v6_address_not_link_local_, v6_address_not_link_local_2_, v6_address_not_link_local_3_, |
| v6_address_not_link_local_4_; |
| }; |
| |
| TEST_F(MdnsTransceiverTests, IgnoreLoopback) { |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| properties_.set_device_class( |
| fuchsia::net::interfaces::DeviceClass::WithLoopback(fuchsia::net::interfaces::Empty())); |
| |
| RunLoopUntilIdle(); |
| |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithExisting(std::move(properties_)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| } |
| |
| TEST_F(MdnsTransceiverTests, OnlineChange) { |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| RunLoopUntilIdle(); |
| |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithExisting(std::move(properties_)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| fuchsia::net::interfaces::Properties online_false; |
| online_false.set_id(kID); |
| online_false.set_online(false); |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithChanged(std::move(online_false)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| fuchsia::net::interfaces::Properties online_true; |
| online_false.set_id(kID); |
| online_false.set_online(true); |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithChanged(std::move(online_false)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| } |
| |
| TEST_F(MdnsTransceiverTests, AddressesChange) { |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| RunLoopUntilIdle(); |
| |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithExisting(std::move(properties_)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| fuchsia::net::interfaces::Properties addresses_change; |
| addresses_change.set_id(kID); |
| addresses_change.set_addresses(Addresses2()); |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithChanged(std::move(addresses_change)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v4_address2_), nullptr); |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v6_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| } |
| |
| TEST_F(MdnsTransceiverTests, OnlineAndAddressesChange) { |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| RunLoopUntilIdle(); |
| |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithExisting(std::move(properties_)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| fuchsia::net::interfaces::Properties offline_and_addresses_change; |
| offline_and_addresses_change.set_id(kID); |
| offline_and_addresses_change.set_online(false); |
| offline_and_addresses_change.set_addresses(Addresses2()); |
| |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithChanged(std::move(offline_and_addresses_change)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| |
| fuchsia::net::interfaces::Properties online_and_addresses_change; |
| online_and_addresses_change.set_id(kID); |
| online_and_addresses_change.set_online(true); |
| online_and_addresses_change.set_addresses(Addresses1()); |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithChanged(std::move(online_and_addresses_change)))); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v4_address1_), nullptr); |
| EXPECT_NE(transceiver_.GetInterfaceTransceiver(v6_address1_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v4_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address2_), nullptr); |
| EXPECT_EQ(transceiver_.GetInterfaceTransceiver(v6_address_not_link_local_), nullptr); |
| } |
| |
| // Tests that interface address resources at the transceivers are updated properly when address |
| // changes occur and that cache_flush and other resource properties are properly set. |
| TEST_F(MdnsTransceiverTests, InterfaceAddressResources) { |
| RunLoopUntilIdle(); |
| |
| // Send the initial NIC configuration. Initial addresses are |v4_address1_|, |v6_address1_| and |
| // |v6_address_not_link_local_|. |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithExisting(std::move(properties_)))); |
| |
| RunLoopUntilIdle(); |
| |
| // Get the expected transceivers created based on the NIC configuration. |
| auto v4_transceiver = reinterpret_cast<StubInterfaceTransceiver*>( |
| transceiver_.GetInterfaceTransceiver(v4_address1_)); |
| auto v6_transceiver = reinterpret_cast<StubInterfaceTransceiver*>( |
| transceiver_.GetInterfaceTransceiver(v6_address1_)); |
| |
| EXPECT_NE(v4_transceiver, nullptr); |
| EXPECT_NE(v6_transceiver, nullptr); |
| |
| // Expect that the correct address resources are generated by the transceivers with the |
| // correct cache_flush bits. For a given transceiver, the first A (V4) and the first AAAA (V6) |
| // resource should have cache_flush set and the remainder of the A/AAAA resources should not. |
| auto& v4_addr = v4_transceiver->GetInterfaceAddressResources(kHostName); |
| EXPECT_EQ(3u, v4_addr.size()); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr[0], v4_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr[1], v6_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr[2], v6_address_not_link_local_, false)); |
| |
| auto& v6_addr = v6_transceiver->GetInterfaceAddressResources(kHostName); |
| EXPECT_EQ(3u, v6_addr.size()); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr[0], v4_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr[1], v6_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr[2], v6_address_not_link_local_, false)); |
| |
| // Send an address change that adds new V6 addresses. |
| fuchsia::net::interfaces::Properties addresses_change; |
| addresses_change.set_id(kID); |
| addresses_change.set_addresses(Addresses1Extra()); |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithChanged(std::move(addresses_change)))); |
| |
| RunLoopUntilIdle(); |
| |
| // Ensure that the transceivers have not been deleted or replaced. |
| EXPECT_EQ(v4_transceiver, reinterpret_cast<StubInterfaceTransceiver*>( |
| transceiver_.GetInterfaceTransceiver(v4_address1_))); |
| EXPECT_EQ(v6_transceiver, reinterpret_cast<StubInterfaceTransceiver*>( |
| transceiver_.GetInterfaceTransceiver(v6_address1_))); |
| |
| // Expect that the correct address resources are generated by the transceivers with the |
| // correct cache_flush bits. For a given transceiver, the first A (V4) and the first AAAA (V6) |
| // resource should have cache_flush set and the remainder of the A/AAAA resources should not. |
| auto& v4_addr_2 = v4_transceiver->GetInterfaceAddressResources(kHostName); |
| EXPECT_EQ(6u, v4_addr.size()); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_2[0], v4_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_2[1], v6_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_2[2], v6_address_not_link_local_, false)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_2[3], v6_address_not_link_local_2_, false)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_2[4], v6_address_not_link_local_3_, false)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_2[5], v6_address_not_link_local_4_, false)); |
| |
| auto& v6_addr_2 = v6_transceiver->GetInterfaceAddressResources(kHostName); |
| EXPECT_EQ(6u, v6_addr_2.size()); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_2[0], v4_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_2[1], v6_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_2[2], v6_address_not_link_local_, false)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_2[3], v6_address_not_link_local_2_, false)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_2[4], v6_address_not_link_local_3_, false)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_2[5], v6_address_not_link_local_4_, false)); |
| |
| // Send an address change that remove some V6 addresses. |
| fuchsia::net::interfaces::Properties addresses_change_2; |
| addresses_change_2.set_id(kID); |
| addresses_change_2.set_addresses(Addresses1()); |
| ASSERT_TRUE(fake_watcher_impl_.CompleteWatchCallback( |
| fuchsia::net::interfaces::Event::WithChanged(std::move(addresses_change_2)))); |
| |
| RunLoopUntilIdle(); |
| |
| // Ensure that the transceivers have not been deleted or replaced. |
| EXPECT_EQ(v4_transceiver, reinterpret_cast<StubInterfaceTransceiver*>( |
| transceiver_.GetInterfaceTransceiver(v4_address1_))); |
| EXPECT_EQ(v6_transceiver, reinterpret_cast<StubInterfaceTransceiver*>( |
| transceiver_.GetInterfaceTransceiver(v6_address1_))); |
| |
| // Expect that the correct address resources are generated by the transceivers with the |
| // correct cache_flush bits. For a given transceiver, the first A (V4) and the first AAAA (V6) |
| // resource should have cache_flush set and the remainder of the A/AAAA resources should not. |
| auto& v4_addr_3 = v4_transceiver->GetInterfaceAddressResources(kHostName); |
| EXPECT_EQ(3u, v4_addr_3.size()); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_3[0], v4_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_3[1], v6_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v4_addr_3[2], v6_address_not_link_local_, false)); |
| |
| auto& v6_addr_3 = v6_transceiver->GetInterfaceAddressResources(kHostName); |
| EXPECT_EQ(3u, v6_addr_3.size()); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_3[0], v4_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_3[1], v6_address1_, true)); |
| EXPECT_TRUE(VerifyAddressResource(v6_addr_3[2], v6_address_not_link_local_, false)); |
| } |
| |
| } // namespace mdns::test |
