src/connectivity/network/mdns/service/transport/mdns_interface_transceiver.cc - fuchsia - Git at Google

 // Copyright 2017 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_interface_transceiver.h"

 #include <arpa/inet.h>
 #include <errno.h>
 #include <lib/async/cpp/task.h>
 #include <lib/async/default.h>
 #include <lib/syslog/cpp/macros.h>
 #include <net/if.h>
 #include <poll.h>
 #include <sys/socket.h>

 #include <algorithm>
 #include <iostream>

 #include <fbl/unique_fd.h>

 #include "src/connectivity/network/mdns/service/common/formatters.h"
 #include "src/connectivity/network/mdns/service/common/mdns_addresses.h"
 #include "src/connectivity/network/mdns/service/encoding/dns_formatting.h"
 #include "src/connectivity/network/mdns/service/encoding/dns_reading.h"
 #include "src/connectivity/network/mdns/service/encoding/dns_writing.h"
 #include "src/connectivity/network/mdns/service/transport/mdns_interface_transceiver_v4.h"
 #include "src/connectivity/network/mdns/service/transport/mdns_interface_transceiver_v6.h"
 #include "src/lib/fostr/hex_dump.h"

 namespace mdns {

 // static
 std::unique_ptr<MdnsInterfaceTransceiver> MdnsInterfaceTransceiver::Create(inet::IpAddress address,
                                                                            const std::string& name,
                                                                            uint32_t id,
                                                                            Media media) {
   if (address.is_v4()) {
     return std::make_unique<MdnsInterfaceTransceiverV4>(address, name, id, media);
   } else {
     return std::make_unique<MdnsInterfaceTransceiverV6>(address, name, id, media);
   }
 }

 MdnsInterfaceTransceiver::MdnsInterfaceTransceiver(inet::IpAddress address, const std::string& name,
                                                    uint32_t id, Media media)
     : address_(address),
       name_(name),
       id_(id),
       media_(media),
       inbound_buffer_(kMaxPacketSize),
       outbound_buffer_(kMaxPacketSize) {
   FX_DCHECK(media_ == Media::kWired || media_ == Media::kWireless);
 }

 MdnsInterfaceTransceiver::~MdnsInterfaceTransceiver() {}

 bool MdnsInterfaceTransceiver::Start(InboundMessageCallback callback) {
   FX_DCHECK(callback);
   FX_DCHECK(!socket_fd_.is_valid()) << "Start called when already started.";

   FX_LOGS(INFO) << "Starting mDNS on interface " << name_ << " using port "
                 << MdnsAddresses::port();

   socket_fd_ = fbl::unique_fd(socket(address_.family(), SOCK_DGRAM, 0));

   if (!socket_fd_.is_valid()) {
     FX_LOGS(ERROR) << "Failed to open socket, " << strerror(errno);
     return false;
   }

   // Set socket options and bind.
   if (SetOptionSharePort() != 0 || SetOptionDisableMulticastLoop() != 0 ||
       SetOptionJoinMulticastGroup() != 0 || SetOptionOutboundInterface() != 0 ||
       SetOptionUnicastTtl() != 0 || SetOptionMulticastTtl() != 0 ||
       SetOptionFamilySpecific() != 0 || SetOptionBindToDevice() != 0 || Bind() != 0) {
     socket_fd_.reset();
     return false;
   }

   inbound_message_callback_ = std::move(callback);

   WaitForInbound();
   return true;
 }

 void MdnsInterfaceTransceiver::Stop() {
   FX_DCHECK(socket_fd_.is_valid()) << "Stop called when stopped.";
   fd_waiter_.Cancel();
   socket_fd_.reset();
 }

 void MdnsInterfaceTransceiver::SetInterfaceAddresses(
     const std::vector<inet::IpAddress>& interface_addresses) {
   FX_DCHECK(!interface_addresses.empty());

   interface_addresses_ = interface_addresses;

   // These resources are a cached version of |interface_addresses_|. Make sure they get regenerated.
   interface_address_resources_.clear();
 }

 void MdnsInterfaceTransceiver::SendMessage(const DnsMessage& message,
                                            const inet::SocketAddress& address) {
   FX_DCHECK(address.is_valid());
   FX_DCHECK(address.family() == address_.family() || address == MdnsAddresses::v4_multicast());

   DnsMessage fixed_up_message;
   fixed_up_message.header_ = message.header_;
   fixed_up_message.questions_ = message.questions_;
   fixed_up_message.answers_ = FixUpAddresses(message.answers_);
   fixed_up_message.authorities_ = FixUpAddresses(message.authorities_);
   fixed_up_message.additionals_ = FixUpAddresses(message.additionals_);
   fixed_up_message.UpdateCounts();

   PacketWriter writer(std::move(outbound_buffer_));
   writer << fixed_up_message;
   size_t packet_size = writer.position();
   outbound_buffer_ = writer.GetPacket();

   ssize_t result = SendTo(outbound_buffer_.data(), packet_size, address);

   ++messages_sent_;
   bytes_sent_ += packet_size;

   // Host down errors are expected. See https://fxbug.dev/42140430.
   if (result < 0 && errno != EHOSTDOWN && errno != ENETUNREACH) {
     FX_LOGS(ERROR) << "Failed to sendto " << address << " from " << name_ << " (" << address_
                    << "), size " << packet_size << ", " << strerror(errno);
   }
 }

 void MdnsInterfaceTransceiver::SendAddress(const std::string& host_full_name) {
   DnsMessage message;
   message.answers_.push_back(GetAddressResource(host_full_name));

   SendMessage(message, MdnsAddresses::v4_multicast());
 }

 void MdnsInterfaceTransceiver::SendAddressGoodbye(const std::string& host_full_name) {
   DnsMessage message;
   // Not using |GetAddressResource| here, because we want to modify the ttl.
   message.answers_.push_back(std::make_shared<DnsResource>(host_full_name, address_));
   message.answers_.back()->time_to_live_ = 0;

   SendMessage(message, MdnsAddresses::v4_multicast());
 }

 void MdnsInterfaceTransceiver::LogTraffic() {
   std::cout << "interface " << name_ << " " << address_ << "\n";
   std::cout << "    messages received:  " << messages_received_ << "\n";
   std::cout << "    bytes received:     " << bytes_received_ << "\n";
   std::cout << "    messages sent:      " << messages_sent_ << "\n";
   std::cout << "    bytes sent:         " << bytes_sent_ << "\n";
 }

 int MdnsInterfaceTransceiver::SetOptionBindToDevice() {
   char ifname[IF_NAMESIZE];
   uint32_t id = this->id();
   if (if_indextoname(id, ifname) == nullptr) {
     FX_LOGS(ERROR) << "Failed to look up interface name with index=" << id << ", error "
                    << strerror(errno);
   }
   int result = setsockopt(socket_fd_.get(), SOL_SOCKET, SO_BINDTODEVICE, &ifname,
                           static_cast<socklen_t>(strnlen(ifname, IF_NAMESIZE)));
   if (result < 0) {
     FX_LOGS(ERROR) << "Failed to set socket option SO_BINDTODEVICE with ifname=" << ifname
                    << ", error" << strerror(errno);
   }
   return result;
 }

 int MdnsInterfaceTransceiver::SetOptionSharePort() {
   int param = 1;
   int result = setsockopt(socket_fd_.get(), SOL_SOCKET, SO_REUSEPORT, &param, sizeof(param));
   if (result < 0) {
     FX_LOGS(ERROR) << "Failed to set socket option SO_REUSEPORT, " << strerror(errno);
   }

   return result;
 }

 void MdnsInterfaceTransceiver::WaitForInbound() {
   fd_waiter_.Wait([this](zx_status_t status, uint32_t events) { InboundReady(status, events); },
                   socket_fd_.get(), POLLIN);
 }

 void MdnsInterfaceTransceiver::InboundReady(zx_status_t status, uint32_t events) {
   sockaddr_storage source_address_storage;
   socklen_t source_address_length = address_.is_v4() ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
   ssize_t result =
       recvfrom(socket_fd_.get(), inbound_buffer_.data(), inbound_buffer_.size(), 0,
                reinterpret_cast<sockaddr*>(&source_address_storage), &source_address_length);
   if (result < 0) {
     FX_LOGS(ERROR) << "Failed to recvfrom, " << strerror(errno);
     // Wait a bit before trying again to avoid spamming the log.
     async::PostDelayedTask(
         async_get_default_dispatcher(), [this]() { WaitForInbound(); }, zx::sec(10));
     return;
   }

   ++messages_received_;
   bytes_received_ += result;

   ReplyAddress reply_address(source_address_storage, address_, id_, media_, IpVersions());

   if (reply_address.socket_address().address() == address_) {
     // This is an outgoing message that's bounced back to us. Drop it.
     WaitForInbound();
     return;
   }

   PacketReader reader(inbound_buffer_);
   reader.SetBytesRemaining(static_cast<size_t>(result));
   std::unique_ptr<DnsMessage> message = std::make_unique<DnsMessage>();
   reader >> *message.get();

   if (reader.complete()) {
     FX_DCHECK(inbound_message_callback_);
     inbound_message_callback_(std::move(message), reply_address);
   } else {
 #ifdef MDNS_TRACE
     FX_LOGS(WARNING) << "Couldn't parse message from " << reply_address << ", " << result
                      << " bytes: " << fostr::HexDump(inbound_buffer_.data(), result, 0);
 #else
     FX_LOGS(WARNING) << "Couldn't parse message from " << reply_address << ", " << result
                      << " bytes";
 #endif  // MDNS_TRACE
   }

   WaitForInbound();
 }

 std::shared_ptr<DnsResource> MdnsInterfaceTransceiver::GetAddressResource(
     const std::string& host_full_name) {
   FX_DCHECK(address_.is_valid());

   if (!address_resource_ || address_resource_->name_.dotted_string_ != host_full_name) {
     address_resource_ = std::make_shared<DnsResource>(host_full_name, address_);
   }

   return address_resource_;
 }

 const std::vector<std::shared_ptr<DnsResource>>&
 MdnsInterfaceTransceiver::GetInterfaceAddressResources(const std::string& host_full_name) {
   FX_DCHECK(!interface_addresses_.empty());

   // Generate new resources if there currently are none or if the host name has changed.
   if (interface_address_resources_.empty() ||
       interface_address_resources_[0]->name_.dotted_string_ != host_full_name) {
     interface_address_resources_.clear();

     // We need to generate new address resources for this interface. An A/AAAA resource
     // is generated for each V4/V6 address in the |interface_addresses_| collection. The first
     // A resource and the first AAAA resource should have the cache_flush bit and other resources
     // should not.
     bool v4_cache_flush = true;
     bool v6_cache_flush = true;
     std::transform(
         interface_addresses_.begin(), interface_addresses_.end(),
         std::back_inserter(interface_address_resources_),
         [&host_full_name, &v4_cache_flush, &v6_cache_flush](const inet::IpAddress& address) {
           bool cache_flush;
           if (address.is_v4()) {
             // Set cache_flush on the first A resource but not subsequent ones.
             cache_flush = v4_cache_flush;
             v4_cache_flush = false;
           } else {
             // Set cache_flush on the first AAAA resource but not subsequent ones.
             cache_flush = v6_cache_flush;
             v6_cache_flush = false;
           }
           return std::make_shared<DnsResource>(host_full_name, address, cache_flush);
         });
   }

   return interface_address_resources_;
 }

 std::vector<std::shared_ptr<DnsResource>> MdnsInterfaceTransceiver::FixUpAddresses(
     const std::vector<std::shared_ptr<DnsResource>>& resources) {
   std::string name;
   std::vector<std::shared_ptr<DnsResource>> result;
   std::copy_if(resources.begin(), resources.end(), std::back_inserter(result),
                [&name](std::shared_ptr<DnsResource> resource) {
                  switch (resource->type_) {
                    case DnsType::kA:
                      if (resource->a_.address_.address_.is_valid()) {
                        // Not a placeholder.
                        return true;
                      }
                      break;
                    case DnsType::kAaaa:
                      if (resource->aaaa_.address_.address_.is_valid()) {
                        // Not a placeholder.
                        return true;
                      }
                      break;
                    default:
                      // Not an address.
                      return true;
                  }

                  if (name.empty()) {
                    name = resource->name_.dotted_string_;
                  }

                  return false;
                });

   if (name.empty()) {
     // No placeholder address records found.
     return result;
   }

   auto& addr_resources = GetInterfaceAddressResources(name);
   std::copy(addr_resources.begin(), addr_resources.end(), std::back_inserter(result));

   return result;
 }

 }  // namespace mdns
	// Copyright 2017 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_interface_transceiver.h"

	#include <arpa/inet.h>
	#include <errno.h>
	#include <lib/async/cpp/task.h>
	#include <lib/async/default.h>
	#include <lib/syslog/cpp/macros.h>
	#include <net/if.h>
	#include <poll.h>
	#include <sys/socket.h>

	#include <algorithm>
	#include <iostream>

	#include <fbl/unique_fd.h>

	#include "src/connectivity/network/mdns/service/common/formatters.h"
	#include "src/connectivity/network/mdns/service/common/mdns_addresses.h"
	#include "src/connectivity/network/mdns/service/encoding/dns_formatting.h"
	#include "src/connectivity/network/mdns/service/encoding/dns_reading.h"
	#include "src/connectivity/network/mdns/service/encoding/dns_writing.h"
	#include "src/connectivity/network/mdns/service/transport/mdns_interface_transceiver_v4.h"
	#include "src/connectivity/network/mdns/service/transport/mdns_interface_transceiver_v6.h"
	#include "src/lib/fostr/hex_dump.h"

	namespace mdns {

	// static
	std::unique_ptr<MdnsInterfaceTransceiver> MdnsInterfaceTransceiver::Create(inet::IpAddress address,
	const std::string& name,
	uint32_t id,
	Media media) {
	if (address.is_v4()) {
	return std::make_unique<MdnsInterfaceTransceiverV4>(address, name, id, media);
	} else {
	return std::make_unique<MdnsInterfaceTransceiverV6>(address, name, id, media);
	}
	}

	MdnsInterfaceTransceiver::MdnsInterfaceTransceiver(inet::IpAddress address, const std::string& name,
	uint32_t id, Media media)
	: address_(address),
	name_(name),
	id_(id),
	media_(media),
	inbound_buffer_(kMaxPacketSize),
	outbound_buffer_(kMaxPacketSize) {
	FX_DCHECK(media_ == Media::kWired \|\| media_ == Media::kWireless);
	}

	MdnsInterfaceTransceiver::~MdnsInterfaceTransceiver() {}

	bool MdnsInterfaceTransceiver::Start(InboundMessageCallback callback) {
	FX_DCHECK(callback);
	FX_DCHECK(!socket_fd_.is_valid()) << "Start called when already started.";

	FX_LOGS(INFO) << "Starting mDNS on interface " << name_ << " using port "
	<< MdnsAddresses::port();

	socket_fd_ = fbl::unique_fd(socket(address_.family(), SOCK_DGRAM, 0));

	if (!socket_fd_.is_valid()) {
	FX_LOGS(ERROR) << "Failed to open socket, " << strerror(errno);
	return false;
	}

	// Set socket options and bind.
	if (SetOptionSharePort() != 0 \|\| SetOptionDisableMulticastLoop() != 0 \|\|
	SetOptionJoinMulticastGroup() != 0 \|\| SetOptionOutboundInterface() != 0 \|\|
	SetOptionUnicastTtl() != 0 \|\| SetOptionMulticastTtl() != 0 \|\|
	SetOptionFamilySpecific() != 0 \|\| SetOptionBindToDevice() != 0 \|\| Bind() != 0) {
	socket_fd_.reset();
	return false;
	}

	inbound_message_callback_ = std::move(callback);

	WaitForInbound();
	return true;
	}

	void MdnsInterfaceTransceiver::Stop() {
	FX_DCHECK(socket_fd_.is_valid()) << "Stop called when stopped.";
	fd_waiter_.Cancel();
	socket_fd_.reset();
	}

	void MdnsInterfaceTransceiver::SetInterfaceAddresses(
	const std::vector<inet::IpAddress>& interface_addresses) {
	FX_DCHECK(!interface_addresses.empty());

	interface_addresses_ = interface_addresses;

	// These resources are a cached version of \|interface_addresses_\|. Make sure they get regenerated.
	interface_address_resources_.clear();
	}

	void MdnsInterfaceTransceiver::SendMessage(const DnsMessage& message,
	const inet::SocketAddress& address) {
	FX_DCHECK(address.is_valid());
	FX_DCHECK(address.family() == address_.family() \|\| address == MdnsAddresses::v4_multicast());

	DnsMessage fixed_up_message;
	fixed_up_message.header_ = message.header_;
	fixed_up_message.questions_ = message.questions_;
	fixed_up_message.answers_ = FixUpAddresses(message.answers_);
	fixed_up_message.authorities_ = FixUpAddresses(message.authorities_);
	fixed_up_message.additionals_ = FixUpAddresses(message.additionals_);
	fixed_up_message.UpdateCounts();

	PacketWriter writer(std::move(outbound_buffer_));
	writer << fixed_up_message;
	size_t packet_size = writer.position();
	outbound_buffer_ = writer.GetPacket();

	ssize_t result = SendTo(outbound_buffer_.data(), packet_size, address);

	++messages_sent_;
	bytes_sent_ += packet_size;

	// Host down errors are expected. See https://fxbug.dev/42140430.
	if (result < 0 && errno != EHOSTDOWN && errno != ENETUNREACH) {
	FX_LOGS(ERROR) << "Failed to sendto " << address << " from " << name_ << " (" << address_
	<< "), size " << packet_size << ", " << strerror(errno);
	}
	}

	void MdnsInterfaceTransceiver::SendAddress(const std::string& host_full_name) {
	DnsMessage message;
	message.answers_.push_back(GetAddressResource(host_full_name));

	SendMessage(message, MdnsAddresses::v4_multicast());
	}

	void MdnsInterfaceTransceiver::SendAddressGoodbye(const std::string& host_full_name) {
	DnsMessage message;
	// Not using \|GetAddressResource\| here, because we want to modify the ttl.
	message.answers_.push_back(std::make_shared<DnsResource>(host_full_name, address_));
	message.answers_.back()->time_to_live_ = 0;

	SendMessage(message, MdnsAddresses::v4_multicast());
	}

	void MdnsInterfaceTransceiver::LogTraffic() {
	std::cout << "interface " << name_ << " " << address_ << "\n";
	std::cout << " messages received: " << messages_received_ << "\n";
	std::cout << " bytes received: " << bytes_received_ << "\n";
	std::cout << " messages sent: " << messages_sent_ << "\n";
	std::cout << " bytes sent: " << bytes_sent_ << "\n";
	}

	int MdnsInterfaceTransceiver::SetOptionBindToDevice() {
	char ifname[IF_NAMESIZE];
	uint32_t id = this->id();
	if (if_indextoname(id, ifname) == nullptr) {
	FX_LOGS(ERROR) << "Failed to look up interface name with index=" << id << ", error "
	<< strerror(errno);
	}
	int result = setsockopt(socket_fd_.get(), SOL_SOCKET, SO_BINDTODEVICE, &ifname,
	static_cast<socklen_t>(strnlen(ifname, IF_NAMESIZE)));
	if (result < 0) {
	FX_LOGS(ERROR) << "Failed to set socket option SO_BINDTODEVICE with ifname=" << ifname
	<< ", error" << strerror(errno);
	}
	return result;
	}

	int MdnsInterfaceTransceiver::SetOptionSharePort() {
	int param = 1;
	int result = setsockopt(socket_fd_.get(), SOL_SOCKET, SO_REUSEPORT, &param, sizeof(param));
	if (result < 0) {
	FX_LOGS(ERROR) << "Failed to set socket option SO_REUSEPORT, " << strerror(errno);
	}

	return result;
	}

	void MdnsInterfaceTransceiver::WaitForInbound() {
	fd_waiter_.Wait([this](zx_status_t status, uint32_t events) { InboundReady(status, events); },
	socket_fd_.get(), POLLIN);
	}

	void MdnsInterfaceTransceiver::InboundReady(zx_status_t status, uint32_t events) {
	sockaddr_storage source_address_storage;
	socklen_t source_address_length = address_.is_v4() ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
	ssize_t result =
	recvfrom(socket_fd_.get(), inbound_buffer_.data(), inbound_buffer_.size(), 0,
	reinterpret_cast<sockaddr*>(&source_address_storage), &source_address_length);
	if (result < 0) {
	FX_LOGS(ERROR) << "Failed to recvfrom, " << strerror(errno);
	// Wait a bit before trying again to avoid spamming the log.
	async::PostDelayedTask(
	async_get_default_dispatcher(), [this]() { WaitForInbound(); }, zx::sec(10));
	return;
	}

	++messages_received_;
	bytes_received_ += result;

	ReplyAddress reply_address(source_address_storage, address_, id_, media_, IpVersions());

	if (reply_address.socket_address().address() == address_) {
	// This is an outgoing message that's bounced back to us. Drop it.
	WaitForInbound();
	return;
	}

	PacketReader reader(inbound_buffer_);
	reader.SetBytesRemaining(static_cast<size_t>(result));
	std::unique_ptr<DnsMessage> message = std::make_unique<DnsMessage>();
	reader >> *message.get();

	if (reader.complete()) {
	FX_DCHECK(inbound_message_callback_);
	inbound_message_callback_(std::move(message), reply_address);
	} else {
	#ifdef MDNS_TRACE
	FX_LOGS(WARNING) << "Couldn't parse message from " << reply_address << ", " << result
	<< " bytes: " << fostr::HexDump(inbound_buffer_.data(), result, 0);
	#else
	FX_LOGS(WARNING) << "Couldn't parse message from " << reply_address << ", " << result
	<< " bytes";
	#endif // MDNS_TRACE
	}

	WaitForInbound();
	}

	std::shared_ptr<DnsResource> MdnsInterfaceTransceiver::GetAddressResource(
	const std::string& host_full_name) {
	FX_DCHECK(address_.is_valid());

	if (!address_resource_ \|\| address_resource_->name_.dotted_string_ != host_full_name) {
	address_resource_ = std::make_shared<DnsResource>(host_full_name, address_);
	}

	return address_resource_;
	}

	const std::vector<std::shared_ptr<DnsResource>>&
	MdnsInterfaceTransceiver::GetInterfaceAddressResources(const std::string& host_full_name) {
	FX_DCHECK(!interface_addresses_.empty());

	// Generate new resources if there currently are none or if the host name has changed.
	if (interface_address_resources_.empty() \|\|
	interface_address_resources_[0]->name_.dotted_string_ != host_full_name) {
	interface_address_resources_.clear();

	// We need to generate new address resources for this interface. An A/AAAA resource
	// is generated for each V4/V6 address in the \|interface_addresses_\| collection. The first
	// A resource and the first AAAA resource should have the cache_flush bit and other resources
	// should not.
	bool v4_cache_flush = true;
	bool v6_cache_flush = true;
	std::transform(
	interface_addresses_.begin(), interface_addresses_.end(),
	std::back_inserter(interface_address_resources_),
	[&host_full_name, &v4_cache_flush, &v6_cache_flush](const inet::IpAddress& address) {
	bool cache_flush;
	if (address.is_v4()) {
	// Set cache_flush on the first A resource but not subsequent ones.
	cache_flush = v4_cache_flush;
	v4_cache_flush = false;
	} else {
	// Set cache_flush on the first AAAA resource but not subsequent ones.
	cache_flush = v6_cache_flush;
	v6_cache_flush = false;
	}
	return std::make_shared<DnsResource>(host_full_name, address, cache_flush);
	});
	}

	return interface_address_resources_;
	}

	std::vector<std::shared_ptr<DnsResource>> MdnsInterfaceTransceiver::FixUpAddresses(
	const std::vector<std::shared_ptr<DnsResource>>& resources) {
	std::string name;
	std::vector<std::shared_ptr<DnsResource>> result;
	std::copy_if(resources.begin(), resources.end(), std::back_inserter(result),
	[&name](std::shared_ptr<DnsResource> resource) {
	switch (resource->type_) {
	case DnsType::kA:
	if (resource->a_.address_.address_.is_valid()) {
	// Not a placeholder.
	return true;
	}
	break;
	case DnsType::kAaaa:
	if (resource->aaaa_.address_.address_.is_valid()) {
	// Not a placeholder.
	return true;
	}
	break;
	default:
	// Not an address.
	return true;
	}

	if (name.empty()) {
	name = resource->name_.dotted_string_;
	}

	return false;
	});

	if (name.empty()) {
	// No placeholder address records found.
	return result;
	}

	auto& addr_resources = GetInterfaceAddressResources(name);
	std::copy(addr_resources.begin(), addr_resources.end(), std::back_inserter(result));

	return result;
	}

	} // namespace mdns