src/platform/Darwin/DnssdHostNameRegistrar.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    Copyright (c) 2022 Project CHIP Authors
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 #include "DnssdHostNameRegistrar.h"
 #include "DnssdImpl.h"
 #include "MdnsError.h"

 #include <arpa/inet.h>
 #include <ifaddrs.h>
 #include <net/ethernet.h>
 #include <net/if_dl.h>
 #include <netdb.h>

 #include <set>

 #include <platform/CHIPDeviceLayer.h>

 constexpr DNSServiceFlags kRegisterRecordFlags = kDNSServiceFlagsShared;

 namespace chip {
 namespace Dnssd {

 namespace {

 #if CHIP_PROGRESS_LOGGING
 constexpr const char * kPathStatusInvalid     = "Invalid";
 constexpr const char * kPathStatusUnsatisfied = "Unsatisfied";
 constexpr const char * kPathStatusSatisfied   = "Satisfied";
 constexpr const char * kPathStatusSatisfiable = "Satisfiable";
 constexpr const char * kPathStatusUnknown     = "Unknown";

 constexpr const char * kInterfaceTypeCellular = "Cellular";
 constexpr const char * kInterfaceTypeWiFi     = "WiFi";
 constexpr const char * kInterfaceTypeWired    = "Wired";
 constexpr const char * kInterfaceTypeLoopback = "Loopback";
 constexpr const char * kInterfaceTypeOther    = "Other";
 constexpr const char * kInterfaceTypeUnknown  = "Unknown";

 const char * GetPathStatusString(nw_path_status_t status)
 {
     const char * str = nullptr;

     if (status == nw_path_status_invalid)
     {
         str = kPathStatusInvalid;
     }
     else if (status == nw_path_status_unsatisfied)
     {
         str = kPathStatusUnsatisfied;
     }
     else if (status == nw_path_status_satisfied)
     {
         str = kPathStatusSatisfied;
     }
     else if (status == nw_path_status_satisfiable)
     {
         str = kPathStatusSatisfiable;
     }
     else
     {
         str = kPathStatusUnknown;
     }

     return str;
 }

 const char * GetInterfaceTypeString(nw_interface_type_t type)
 {
     const char * str = nullptr;

     if (type == nw_interface_type_cellular)
     {
         str = kInterfaceTypeCellular;
     }
     else if (type == nw_interface_type_wifi)
     {
         str = kInterfaceTypeWiFi;
     }
     else if (type == nw_interface_type_wired)
     {
         str = kInterfaceTypeWired;
     }
     else if (type == nw_interface_type_loopback)
     {
         str = kInterfaceTypeLoopback;
     }
     else if (type == nw_interface_type_other)
     {
         str = kInterfaceTypeOther;
     }
     else
     {
         str = kInterfaceTypeUnknown;
     }

     return str;
 }

 void LogDetails(uint32_t interfaceId, InetInterfacesVector inetInterfaces, Inet6InterfacesVector inet6Interfaces)
 {
     for (auto & inetInterface : inetInterfaces)
     {
         if (interfaceId == inetInterface.first)
         {
             char addr[INET_ADDRSTRLEN] = {};
             inet_ntop(AF_INET, &inetInterface.second, addr, sizeof(addr));
             ChipLogProgress(Discovery, "\t\t* ipv4: %s", addr);
         }
     }

     for (auto & inet6Interface : inet6Interfaces)
     {
         if (interfaceId == inet6Interface.first)
         {
             char addr[INET6_ADDRSTRLEN] = {};
             inet_ntop(AF_INET6, &inet6Interface.second, addr, sizeof(addr));
             ChipLogProgress(Discovery, "\t\t* ipv6: %s", addr);
         }
     }
 }

 void LogDetails(nw_path_t path)
 {
     auto status = nw_path_get_status(path);
     ChipLogProgress(Discovery, "Status: %s", GetPathStatusString(status));
 }

 void LogDetails(InetInterfacesVector inetInterfaces, Inet6InterfacesVector inet6Interfaces)
 {
     std::set<uint32_t> interfaceIds;
     for (auto & inetInterface : inetInterfaces)
     {
         interfaceIds.insert(inetInterface.first);
     }

     for (auto & inet6Interface : inet6Interfaces)
     {
         interfaceIds.insert(inet6Interface.first);
     }

     for (auto interfaceId : interfaceIds)
     {
         char interfaceName[IFNAMSIZ] = {};
         if_indextoname(interfaceId, interfaceName);
         ChipLogProgress(Discovery, "\t%s (%u)", interfaceName, interfaceId);
         LogDetails(interfaceId, inetInterfaces, inet6Interfaces);
     }
 }

 void LogDetails(nw_interface_t interface, InetInterfacesVector inetInterfaces, Inet6InterfacesVector inet6Interfaces)
 {
     auto interfaceId   = nw_interface_get_index(interface);
     auto interfaceName = nw_interface_get_name(interface);
     auto interfaceType = nw_interface_get_type(interface);
     ChipLogProgress(Discovery, "\t%s (%u / %s)", interfaceName, interfaceId, GetInterfaceTypeString(interfaceType));
     LogDetails(interfaceId, inetInterfaces, inet6Interfaces);
 }
 #endif // CHIP_PROGRESS_LOGGING

 bool HasValidFlags(unsigned int flags, bool allowLoopbackOnly)
 {
     VerifyOrReturnValue(!allowLoopbackOnly || (flags & IFF_LOOPBACK), false);
     VerifyOrReturnValue((flags & IFF_RUNNING), false);
     VerifyOrReturnValue((flags & IFF_MULTICAST), false);
     return true;
 }

 bool HasValidNetworkType(nw_interface_t interface)
 {
     auto interfaceType = nw_interface_get_type(interface);
     return interfaceType == nw_interface_type_wifi || interfaceType == nw_interface_type_wired ||
         interfaceType == nw_interface_type_other;
 }

 bool IsValidInterfaceId(uint32_t targetInterfaceId, nw_interface_t interface)
 {
     auto currentInterfaceId = nw_interface_get_index(interface);
     return targetInterfaceId == kDNSServiceInterfaceIndexAny || targetInterfaceId == currentInterfaceId;
 }

 void ShouldUseVersion(chip::Inet::IPAddressType addressType, bool & shouldUseIPv4, bool & shouldUseIPv6)
 {
 #if INET_CONFIG_ENABLE_IPV4
     shouldUseIPv4 = addressType == Inet::IPAddressType::kIPv4 || addressType == Inet::IPAddressType::kAny;
 #else
     shouldUseIPv4 = false;
 #endif // INET_CONFIG_ENABLE_IPV4
     shouldUseIPv6 = addressType == Inet::IPAddressType::kIPv6 || addressType == Inet::IPAddressType::kAny;
 }

 static void OnRegisterRecord(DNSServiceRef sdRef, DNSRecordRef recordRef, DNSServiceFlags flags, DNSServiceErrorType err,
                              void * context)
 {
     ChipLogProgress(Discovery, "Mdns: %s flags: %d", __func__, flags);
     if (kDNSServiceErr_NoError != err)
     {
         ChipLogError(Discovery, "%s (%s)", __func__, Error::ToString(err));
     }
 }

 void GetInterfaceAddresses(uint32_t interfaceId, chip::Inet::IPAddressType addressType, InetInterfacesVector & inetInterfaces,
                            Inet6InterfacesVector & inet6Interfaces, bool searchLoopbackOnly = false)
 {
     bool shouldUseIPv4, shouldUseIPv6;
     ShouldUseVersion(addressType, shouldUseIPv4, shouldUseIPv6);

     ifaddrs * ifap;
     VerifyOrReturn(getifaddrs(&ifap) >= 0);

     for (struct ifaddrs * ifa = ifap; ifa != nullptr; ifa = ifa->ifa_next)
     {
         auto interfaceAddress = ifa->ifa_addr;
         if (interfaceAddress == nullptr)
         {
             continue;
         }

         if (!HasValidFlags(ifa->ifa_flags, searchLoopbackOnly))
         {
             continue;
         }

         auto currentInterfaceId = if_nametoindex(ifa->ifa_name);
         if (interfaceId != kDNSServiceInterfaceIndexAny && interfaceId != currentInterfaceId)
         {
             continue;
         }

         if (shouldUseIPv4 && (AF_INET == interfaceAddress->sa_family))
         {
             auto inetAddress = reinterpret_cast<struct sockaddr_in *>(interfaceAddress)->sin_addr;
             inetInterfaces.push_back(InetInterface(currentInterfaceId, inetAddress));
         }
         else if (shouldUseIPv6 && (AF_INET6 == interfaceAddress->sa_family))
         {
             auto inet6Address = reinterpret_cast<struct sockaddr_in6 *>(interfaceAddress)->sin6_addr;
             inet6Interfaces.push_back(Inet6Interface(currentInterfaceId, inet6Address));
         }
     }

     freeifaddrs(ifap);
 }
 } // namespace

 HostNameRegistrar::~HostNameRegistrar()
 {
     Unregister();
     if (mLivenessTracker != nullptr)
     {
         *mLivenessTracker = false;
     }
 }

 DNSServiceErrorType HostNameRegistrar::Init(const char * hostname, Inet::IPAddressType addressType, uint32_t interfaceId)
 {
     mHostname         = hostname;
     mInterfaceId      = interfaceId;
     mAddressType      = addressType;
     mServiceRef       = nullptr;
     mInterfaceMonitor = nullptr;

     mLivenessTracker = std::make_shared<bool>(true);
     if (mLivenessTracker == nullptr)
     {
         return kDNSServiceErr_NoMemory;
     }

     return kDNSServiceErr_NoError;
 }

 CHIP_ERROR HostNameRegistrar::Register()
 {
     // If the target interface is kDNSServiceInterfaceIndexLocalOnly, just
     // register the loopback addresses.
     if (IsLocalOnly())
     {
         ReturnErrorOnFailure(ResetSharedConnection());

         InetInterfacesVector inetInterfaces;
         Inet6InterfacesVector inet6Interfaces;
         // Instead of mInterfaceId (which will not match any actual interface),
         // use kDNSServiceInterfaceIndexAny and restrict to loopback interfaces.
         GetInterfaceAddresses(kDNSServiceInterfaceIndexAny, mAddressType, inetInterfaces, inet6Interfaces,
                               true /* searchLoopbackOnly */);

         // But we register the IPs with mInterfaceId, not the actual interface
         // IDs, so that resolution code that is grouping addresses by interface
         // ends up doing the right thing, since we registered our SRV record on
         // mInterfaceId.
         //
         // And only register the IPv6 ones, for simplicity.
         for (auto & interface : inet6Interfaces)
         {
             ReturnErrorOnFailure(RegisterInterface(mInterfaceId, interface.second, kDNSServiceType_AAAA));
         }
         return CHIP_NO_ERROR;
     }

     return StartMonitorInterfaces(^(InetInterfacesVector inetInterfaces, Inet6InterfacesVector inet6Interfaces) {
         ReturnOnFailure(ResetSharedConnection());
         RegisterInterfaces(inetInterfaces, kDNSServiceType_A);
         RegisterInterfaces(inet6Interfaces, kDNSServiceType_AAAA);
     });
 }

 CHIP_ERROR HostNameRegistrar::RegisterInterface(uint32_t interfaceId, uint16_t rtype, const void * rdata, uint16_t rdlen)
 {
     DNSRecordRef dnsRecordRef;
     auto err = DNSServiceRegisterRecord(mServiceRef, &dnsRecordRef, kRegisterRecordFlags, interfaceId, mHostname.c_str(), rtype,
                                         kDNSServiceClass_IN, rdlen, rdata, 0, OnRegisterRecord, nullptr);
     return Error::ToChipError(err);
 }

 void HostNameRegistrar::Unregister()
 {
     if (!IsLocalOnly())
     {
         StopMonitorInterfaces();
     }
     StopSharedConnection();
 }

 CHIP_ERROR HostNameRegistrar::StartMonitorInterfaces(OnInterfaceChanges interfaceChangesBlock)
 {
     mInterfaceMonitor = nw_path_monitor_create();
     VerifyOrReturnError(mInterfaceMonitor != nullptr, CHIP_ERROR_NO_MEMORY);

     nw_path_monitor_set_queue(mInterfaceMonitor, chip::DeviceLayer::PlatformMgrImpl().GetWorkQueue());

     // Our update handler closes over "this", but can't keep us alive (because we
     // are not refcounted).  Make sure it closes over a shared ref to our
     // liveness tracker, which it _can_ keep alive, so it can bail out if we
     // have been destroyed between when the task was queued and when it ran.
     std::shared_ptr<bool> livenessTracker = mLivenessTracker;
     nw_path_monitor_set_update_handler(mInterfaceMonitor, ^(nw_path_t path) {
         if (!*livenessTracker)
         {
             // The HostNameRegistrar has been destroyed; just bail out.
             return;
         }

 #if CHIP_PROGRESS_LOGGING
         LogDetails(path);
 #endif // CHIP_PROGRESS_LOGGING

         __block InetInterfacesVector inet;
         __block Inet6InterfacesVector inet6;

         // The loopback interfaces needs to be manually added. While lo0 is usually 1, this is not guaranteed. So search for a
         // loopback interface with the specified interface id. If the specified interface id is kDNSServiceInterfaceIndexAny, it
         // will look for all available loopback interfaces.
         GetInterfaceAddresses(mInterfaceId, mAddressType, inet, inet6, true /* searchLoopbackOnly */);
 #if CHIP_PROGRESS_LOGGING
         LogDetails(inet, inet6);
 #endif // CHIP_PROGRESS_LOGGING

         auto status = nw_path_get_status(path);
         if (status == nw_path_status_satisfied)
         {
             nw_path_enumerate_interfaces(path, ^(nw_interface_t interface) {
                 VerifyOrReturnValue(HasValidNetworkType(interface), true);
                 VerifyOrReturnValue(IsValidInterfaceId(mInterfaceId, interface), true);

                 auto targetInterfaceId = nw_interface_get_index(interface);
                 GetInterfaceAddresses(targetInterfaceId, mAddressType, inet, inet6);
 #if CHIP_PROGRESS_LOGGING
                 LogDetails(interface, inet, inet6);
 #endif // CHIP_PROGRESS_LOGGING
                 return true;
             });
         }

         interfaceChangesBlock(inet, inet6);
     });

     nw_path_monitor_start(mInterfaceMonitor);

     return CHIP_NO_ERROR;
 }

 void HostNameRegistrar::StopMonitorInterfaces()
 {
     if (mInterfaceMonitor != nullptr)
     {
         nw_path_monitor_cancel(mInterfaceMonitor);
         nw_release(mInterfaceMonitor);
         mInterfaceMonitor = nullptr;
     }
 }

 CHIP_ERROR HostNameRegistrar::StartSharedConnection()
 {
     VerifyOrReturnError(mServiceRef == nullptr, CHIP_ERROR_INCORRECT_STATE);

     auto err = DNSServiceCreateConnection(&mServiceRef);
     VerifyOrReturnValue(kDNSServiceErr_NoError == err, Error::ToChipError(err));

     err = DNSServiceSetDispatchQueue(mServiceRef, chip::DeviceLayer::PlatformMgrImpl().GetWorkQueue());
     if (kDNSServiceErr_NoError != err)
     {
         StopSharedConnection();
     }

     return Error::ToChipError(err);
 }

 void HostNameRegistrar::StopSharedConnection()
 {
     if (mServiceRef != nullptr)
     {
         // All the DNSRecordRefs registered to the shared DNSServiceRef will be deallocated.
         DNSServiceRefDeallocate(mServiceRef);
         mServiceRef = nullptr;
     }
 }

 CHIP_ERROR HostNameRegistrar::ResetSharedConnection()
 {
     StopSharedConnection();
     ReturnLogErrorOnFailure(StartSharedConnection());
     return CHIP_NO_ERROR;
 }

 } // namespace Dnssd
 } // namespace chip
	/*
	*
	* Copyright (c) 2022 Project CHIP Authors
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "DnssdHostNameRegistrar.h"
	#include "DnssdImpl.h"
	#include "MdnsError.h"

	#include <arpa/inet.h>
	#include <ifaddrs.h>
	#include <net/ethernet.h>
	#include <net/if_dl.h>
	#include <netdb.h>

	#include <set>

	#include <platform/CHIPDeviceLayer.h>

	constexpr DNSServiceFlags kRegisterRecordFlags = kDNSServiceFlagsShared;

	namespace chip {
	namespace Dnssd {

	namespace {

	#if CHIP_PROGRESS_LOGGING
	constexpr const char * kPathStatusInvalid = "Invalid";
	constexpr const char * kPathStatusUnsatisfied = "Unsatisfied";
	constexpr const char * kPathStatusSatisfied = "Satisfied";
	constexpr const char * kPathStatusSatisfiable = "Satisfiable";
	constexpr const char * kPathStatusUnknown = "Unknown";

	constexpr const char * kInterfaceTypeCellular = "Cellular";
	constexpr const char * kInterfaceTypeWiFi = "WiFi";
	constexpr const char * kInterfaceTypeWired = "Wired";
	constexpr const char * kInterfaceTypeLoopback = "Loopback";
	constexpr const char * kInterfaceTypeOther = "Other";
	constexpr const char * kInterfaceTypeUnknown = "Unknown";

	const char * GetPathStatusString(nw_path_status_t status)
	{
	const char * str = nullptr;

	if (status == nw_path_status_invalid)
	{
	str = kPathStatusInvalid;
	}
	else if (status == nw_path_status_unsatisfied)
	{
	str = kPathStatusUnsatisfied;
	}
	else if (status == nw_path_status_satisfied)
	{
	str = kPathStatusSatisfied;
	}
	else if (status == nw_path_status_satisfiable)
	{
	str = kPathStatusSatisfiable;
	}
	else
	{
	str = kPathStatusUnknown;
	}

	return str;
	}

	const char * GetInterfaceTypeString(nw_interface_type_t type)
	{
	const char * str = nullptr;

	if (type == nw_interface_type_cellular)
	{
	str = kInterfaceTypeCellular;
	}
	else if (type == nw_interface_type_wifi)
	{
	str = kInterfaceTypeWiFi;
	}
	else if (type == nw_interface_type_wired)
	{
	str = kInterfaceTypeWired;
	}
	else if (type == nw_interface_type_loopback)
	{
	str = kInterfaceTypeLoopback;
	}
	else if (type == nw_interface_type_other)
	{
	str = kInterfaceTypeOther;
	}
	else
	{
	str = kInterfaceTypeUnknown;
	}

	return str;
	}

	void LogDetails(uint32_t interfaceId, InetInterfacesVector inetInterfaces, Inet6InterfacesVector inet6Interfaces)
	{
	for (auto & inetInterface : inetInterfaces)
	{
	if (interfaceId == inetInterface.first)
	{
	char addr[INET_ADDRSTRLEN] = {};
	inet_ntop(AF_INET, &inetInterface.second, addr, sizeof(addr));
	ChipLogProgress(Discovery, "\t\t* ipv4: %s", addr);
	}
	}

	for (auto & inet6Interface : inet6Interfaces)
	{
	if (interfaceId == inet6Interface.first)
	{
	char addr[INET6_ADDRSTRLEN] = {};
	inet_ntop(AF_INET6, &inet6Interface.second, addr, sizeof(addr));
	ChipLogProgress(Discovery, "\t\t* ipv6: %s", addr);
	}
	}
	}

	void LogDetails(nw_path_t path)
	{
	auto status = nw_path_get_status(path);
	ChipLogProgress(Discovery, "Status: %s", GetPathStatusString(status));
	}

	void LogDetails(InetInterfacesVector inetInterfaces, Inet6InterfacesVector inet6Interfaces)
	{
	std::set<uint32_t> interfaceIds;
	for (auto & inetInterface : inetInterfaces)
	{
	interfaceIds.insert(inetInterface.first);
	}

	for (auto & inet6Interface : inet6Interfaces)
	{
	interfaceIds.insert(inet6Interface.first);
	}

	for (auto interfaceId : interfaceIds)
	{
	char interfaceName[IFNAMSIZ] = {};
	if_indextoname(interfaceId, interfaceName);
	ChipLogProgress(Discovery, "\t%s (%u)", interfaceName, interfaceId);
	LogDetails(interfaceId, inetInterfaces, inet6Interfaces);
	}
	}

	void LogDetails(nw_interface_t interface, InetInterfacesVector inetInterfaces, Inet6InterfacesVector inet6Interfaces)
	{
	auto interfaceId = nw_interface_get_index(interface);
	auto interfaceName = nw_interface_get_name(interface);
	auto interfaceType = nw_interface_get_type(interface);
	ChipLogProgress(Discovery, "\t%s (%u / %s)", interfaceName, interfaceId, GetInterfaceTypeString(interfaceType));
	LogDetails(interfaceId, inetInterfaces, inet6Interfaces);
	}
	#endif // CHIP_PROGRESS_LOGGING

	bool HasValidFlags(unsigned int flags, bool allowLoopbackOnly)
	{
	VerifyOrReturnValue(!allowLoopbackOnly \|\| (flags & IFF_LOOPBACK), false);
	VerifyOrReturnValue((flags & IFF_RUNNING), false);
	VerifyOrReturnValue((flags & IFF_MULTICAST), false);
	return true;
	}

	bool HasValidNetworkType(nw_interface_t interface)
	{
	auto interfaceType = nw_interface_get_type(interface);
	return interfaceType == nw_interface_type_wifi \|\| interfaceType == nw_interface_type_wired \|\|
	interfaceType == nw_interface_type_other;
	}

	bool IsValidInterfaceId(uint32_t targetInterfaceId, nw_interface_t interface)
	{
	auto currentInterfaceId = nw_interface_get_index(interface);
	return targetInterfaceId == kDNSServiceInterfaceIndexAny \|\| targetInterfaceId == currentInterfaceId;
	}

	void ShouldUseVersion(chip::Inet::IPAddressType addressType, bool & shouldUseIPv4, bool & shouldUseIPv6)
	{
	#if INET_CONFIG_ENABLE_IPV4
	shouldUseIPv4 = addressType == Inet::IPAddressType::kIPv4 \|\| addressType == Inet::IPAddressType::kAny;
	#else
	shouldUseIPv4 = false;
	#endif // INET_CONFIG_ENABLE_IPV4
	shouldUseIPv6 = addressType == Inet::IPAddressType::kIPv6 \|\| addressType == Inet::IPAddressType::kAny;
	}

	static void OnRegisterRecord(DNSServiceRef sdRef, DNSRecordRef recordRef, DNSServiceFlags flags, DNSServiceErrorType err,
	void * context)
	{
	ChipLogProgress(Discovery, "Mdns: %s flags: %d", __func__, flags);
	if (kDNSServiceErr_NoError != err)
	{
	ChipLogError(Discovery, "%s (%s)", __func__, Error::ToString(err));
	}
	}

	void GetInterfaceAddresses(uint32_t interfaceId, chip::Inet::IPAddressType addressType, InetInterfacesVector & inetInterfaces,
	Inet6InterfacesVector & inet6Interfaces, bool searchLoopbackOnly = false)
	{
	bool shouldUseIPv4, shouldUseIPv6;
	ShouldUseVersion(addressType, shouldUseIPv4, shouldUseIPv6);

	ifaddrs * ifap;
	VerifyOrReturn(getifaddrs(&ifap) >= 0);

	for (struct ifaddrs * ifa = ifap; ifa != nullptr; ifa = ifa->ifa_next)
	{
	auto interfaceAddress = ifa->ifa_addr;
	if (interfaceAddress == nullptr)
	{
	continue;
	}

	if (!HasValidFlags(ifa->ifa_flags, searchLoopbackOnly))
	{
	continue;
	}

	auto currentInterfaceId = if_nametoindex(ifa->ifa_name);
	if (interfaceId != kDNSServiceInterfaceIndexAny && interfaceId != currentInterfaceId)
	{
	continue;
	}

	if (shouldUseIPv4 && (AF_INET == interfaceAddress->sa_family))
	{
	auto inetAddress = reinterpret_cast<struct sockaddr_in *>(interfaceAddress)->sin_addr;
	inetInterfaces.push_back(InetInterface(currentInterfaceId, inetAddress));
	}
	else if (shouldUseIPv6 && (AF_INET6 == interfaceAddress->sa_family))
	{
	auto inet6Address = reinterpret_cast<struct sockaddr_in6 *>(interfaceAddress)->sin6_addr;
	inet6Interfaces.push_back(Inet6Interface(currentInterfaceId, inet6Address));
	}
	}

	freeifaddrs(ifap);
	}
	} // namespace

	HostNameRegistrar::~HostNameRegistrar()
	{
	Unregister();
	if (mLivenessTracker != nullptr)
	{
	*mLivenessTracker = false;
	}
	}

	DNSServiceErrorType HostNameRegistrar::Init(const char * hostname, Inet::IPAddressType addressType, uint32_t interfaceId)
	{
	mHostname = hostname;
	mInterfaceId = interfaceId;
	mAddressType = addressType;
	mServiceRef = nullptr;
	mInterfaceMonitor = nullptr;

	mLivenessTracker = std::make_shared<bool>(true);
	if (mLivenessTracker == nullptr)
	{
	return kDNSServiceErr_NoMemory;
	}

	return kDNSServiceErr_NoError;
	}

	CHIP_ERROR HostNameRegistrar::Register()
	{
	// If the target interface is kDNSServiceInterfaceIndexLocalOnly, just
	// register the loopback addresses.
	if (IsLocalOnly())
	{
	ReturnErrorOnFailure(ResetSharedConnection());

	InetInterfacesVector inetInterfaces;
	Inet6InterfacesVector inet6Interfaces;
	// Instead of mInterfaceId (which will not match any actual interface),
	// use kDNSServiceInterfaceIndexAny and restrict to loopback interfaces.
	GetInterfaceAddresses(kDNSServiceInterfaceIndexAny, mAddressType, inetInterfaces, inet6Interfaces,
	true /* searchLoopbackOnly */);

	// But we register the IPs with mInterfaceId, not the actual interface
	// IDs, so that resolution code that is grouping addresses by interface
	// ends up doing the right thing, since we registered our SRV record on
	// mInterfaceId.
	//
	// And only register the IPv6 ones, for simplicity.
	for (auto & interface : inet6Interfaces)
	{
	ReturnErrorOnFailure(RegisterInterface(mInterfaceId, interface.second, kDNSServiceType_AAAA));
	}
	return CHIP_NO_ERROR;
	}

	return StartMonitorInterfaces(^(InetInterfacesVector inetInterfaces, Inet6InterfacesVector inet6Interfaces) {
	ReturnOnFailure(ResetSharedConnection());
	RegisterInterfaces(inetInterfaces, kDNSServiceType_A);
	RegisterInterfaces(inet6Interfaces, kDNSServiceType_AAAA);
	});
	}

	CHIP_ERROR HostNameRegistrar::RegisterInterface(uint32_t interfaceId, uint16_t rtype, const void * rdata, uint16_t rdlen)
	{
	DNSRecordRef dnsRecordRef;
	auto err = DNSServiceRegisterRecord(mServiceRef, &dnsRecordRef, kRegisterRecordFlags, interfaceId, mHostname.c_str(), rtype,
	kDNSServiceClass_IN, rdlen, rdata, 0, OnRegisterRecord, nullptr);
	return Error::ToChipError(err);
	}

	void HostNameRegistrar::Unregister()
	{
	if (!IsLocalOnly())
	{
	StopMonitorInterfaces();
	}
	StopSharedConnection();
	}

	CHIP_ERROR HostNameRegistrar::StartMonitorInterfaces(OnInterfaceChanges interfaceChangesBlock)
	{
	mInterfaceMonitor = nw_path_monitor_create();
	VerifyOrReturnError(mInterfaceMonitor != nullptr, CHIP_ERROR_NO_MEMORY);

	nw_path_monitor_set_queue(mInterfaceMonitor, chip::DeviceLayer::PlatformMgrImpl().GetWorkQueue());

	// Our update handler closes over "this", but can't keep us alive (because we
	// are not refcounted). Make sure it closes over a shared ref to our
	// liveness tracker, which it _can_ keep alive, so it can bail out if we
	// have been destroyed between when the task was queued and when it ran.
	std::shared_ptr<bool> livenessTracker = mLivenessTracker;
	nw_path_monitor_set_update_handler(mInterfaceMonitor, ^(nw_path_t path) {
	if (!*livenessTracker)
	{
	// The HostNameRegistrar has been destroyed; just bail out.
	return;
	}

	#if CHIP_PROGRESS_LOGGING
	LogDetails(path);
	#endif // CHIP_PROGRESS_LOGGING

	__block InetInterfacesVector inet;
	__block Inet6InterfacesVector inet6;

	// The loopback interfaces needs to be manually added. While lo0 is usually 1, this is not guaranteed. So search for a
	// loopback interface with the specified interface id. If the specified interface id is kDNSServiceInterfaceIndexAny, it
	// will look for all available loopback interfaces.
	GetInterfaceAddresses(mInterfaceId, mAddressType, inet, inet6, true /* searchLoopbackOnly */);
	#if CHIP_PROGRESS_LOGGING
	LogDetails(inet, inet6);
	#endif // CHIP_PROGRESS_LOGGING

	auto status = nw_path_get_status(path);
	if (status == nw_path_status_satisfied)
	{
	nw_path_enumerate_interfaces(path, ^(nw_interface_t interface) {
	VerifyOrReturnValue(HasValidNetworkType(interface), true);
	VerifyOrReturnValue(IsValidInterfaceId(mInterfaceId, interface), true);

	auto targetInterfaceId = nw_interface_get_index(interface);
	GetInterfaceAddresses(targetInterfaceId, mAddressType, inet, inet6);
	#if CHIP_PROGRESS_LOGGING
	LogDetails(interface, inet, inet6);
	#endif // CHIP_PROGRESS_LOGGING
	return true;
	});
	}

	interfaceChangesBlock(inet, inet6);
	});

	nw_path_monitor_start(mInterfaceMonitor);

	return CHIP_NO_ERROR;
	}

	void HostNameRegistrar::StopMonitorInterfaces()
	{
	if (mInterfaceMonitor != nullptr)
	{
	nw_path_monitor_cancel(mInterfaceMonitor);
	nw_release(mInterfaceMonitor);
	mInterfaceMonitor = nullptr;
	}
	}

	CHIP_ERROR HostNameRegistrar::StartSharedConnection()
	{
	VerifyOrReturnError(mServiceRef == nullptr, CHIP_ERROR_INCORRECT_STATE);

	auto err = DNSServiceCreateConnection(&mServiceRef);
	VerifyOrReturnValue(kDNSServiceErr_NoError == err, Error::ToChipError(err));

	err = DNSServiceSetDispatchQueue(mServiceRef, chip::DeviceLayer::PlatformMgrImpl().GetWorkQueue());
	if (kDNSServiceErr_NoError != err)
	{
	StopSharedConnection();
	}

	return Error::ToChipError(err);
	}

	void HostNameRegistrar::StopSharedConnection()
	{
	if (mServiceRef != nullptr)
	{
	// All the DNSRecordRefs registered to the shared DNSServiceRef will be deallocated.
	DNSServiceRefDeallocate(mServiceRef);
	mServiceRef = nullptr;
	}
	}

	CHIP_ERROR HostNameRegistrar::ResetSharedConnection()
	{
	StopSharedConnection();
	ReturnLogErrorOnFailure(StartSharedConnection());
	return CHIP_NO_ERROR;
	}

	} // namespace Dnssd
	} // namespace chip