Merge branch 'master' into bugfix/rs911x_ble_tx_timer_issue

Author: jmartinez-silabs

src/platform/Darwin/DnssdContexts.cpp

@@ -30,6 +30,12 @@ namespace {
 
 constexpr uint8_t kDnssdKeyMaxSize          = 32;
 constexpr uint8_t kDnssdTxtRecordMaxEntries = 20;
+constexpr char kLocalDot[]                  = "local.";
+
+bool IsLocalDomain(const char * domain)
+{
+    return strcmp(kLocalDot, domain) == 0;
+}
 
 std::string GetHostNameWithoutDomain(const char * hostnameWithDomain)
 {
@@ -246,7 +252,6 @@ void MdnsContexts::Delete(GenericContext * context)
     {
         DNSServiceRefDeallocate(context->serviceRef);
     }
-
     chip::Platform::Delete(context);
 }
 
@@ -383,6 +388,7 @@ void BrowseContext::OnBrowseAdd(const char * name, const char * type, const char
     ChipLogProgress(Discovery, "Mdns: %s  name: %s, type: %s, domain: %s, interface: %" PRIu32, __func__, StringOrNullMarker(name),
                     StringOrNullMarker(type), StringOrNullMarker(domain), interfaceId);
 
+    VerifyOrReturn(IsLocalDomain(domain));
     auto service = GetService(name, type, protocol, interfaceId);
     services.push_back(service);
 }
@@ -393,6 +399,7 @@ void BrowseContext::OnBrowseRemove(const char * name, const char * type, const c
                     StringOrNullMarker(type), StringOrNullMarker(domain), interfaceId);
 
     VerifyOrReturn(name != nullptr);
+    VerifyOrReturn(IsLocalDomain(domain));
 
     services.erase(std::remove_if(services.begin(), services.end(),
                                   [name, type, interfaceId](const DnssdService & service) {
@@ -436,6 +443,8 @@ void BrowseWithDelegateContext::OnBrowseAdd(const char * name, const char * type
     ChipLogProgress(Discovery, "Mdns: %s  name: %s, type: %s, domain: %s, interface: %" PRIu32, __func__, StringOrNullMarker(name),
                     StringOrNullMarker(type), StringOrNullMarker(domain), interfaceId);
 
+    VerifyOrReturn(IsLocalDomain(domain));
+
     auto delegate = static_cast<DnssdBrowseDelegate *>(context);
     auto service  = GetService(name, type, protocol, interfaceId);
     delegate->OnBrowseAdd(service);
@@ -447,6 +456,7 @@ void BrowseWithDelegateContext::OnBrowseRemove(const char * name, const char * t
                     StringOrNullMarker(type), StringOrNullMarker(domain), interfaceId);
 
     VerifyOrReturn(name != nullptr);
+    VerifyOrReturn(IsLocalDomain(domain));
 
     auto delegate = static_cast<DnssdBrowseDelegate *>(context);
     auto service  = GetService(name, type, protocol, interfaceId);
@@ -458,35 +468,27 @@ ResolveContext::ResolveContext(void * cbContext, DnssdResolveCallback cb, chip::
                                std::shared_ptr<uint32_t> && consumerCounterToUse) :
     browseThatCausedResolve(browseCausingResolve)
 {
-    type               = ContextType::Resolve;
-    context            = cbContext;
-    callback           = cb;
-    protocol           = GetProtocol(cbAddressType);
-    instanceName       = instanceNameToResolve;
-    consumerCounter    = std::move(consumerCounterToUse);
-    hasSrpTimerStarted = false;
+    type            = ContextType::Resolve;
+    context         = cbContext;
+    callback        = cb;
+    protocol        = GetProtocol(cbAddressType);
+    instanceName    = instanceNameToResolve;
+    consumerCounter = std::move(consumerCounterToUse);
 }
 
 ResolveContext::ResolveContext(CommissioningResolveDelegate * delegate, chip::Inet::IPAddressType cbAddressType,
                                const char * instanceNameToResolve, std::shared_ptr<uint32_t> && consumerCounterToUse) :
     browseThatCausedResolve(nullptr)
 {
-    type               = ContextType::Resolve;
-    context            = delegate;
-    callback           = nullptr;
-    protocol           = GetProtocol(cbAddressType);
-    instanceName       = instanceNameToResolve;
-    consumerCounter    = std::move(consumerCounterToUse);
-    hasSrpTimerStarted = false;
+    type            = ContextType::Resolve;
+    context         = delegate;
+    callback        = nullptr;
+    protocol        = GetProtocol(cbAddressType);
+    instanceName    = instanceNameToResolve;
+    consumerCounter = std::move(consumerCounterToUse);
 }
 
-ResolveContext::~ResolveContext()
-{
-    if (this->hasSrpTimerStarted)
-    {
-        CancelSrpTimer(this);
-    }
-}
+ResolveContext::~ResolveContext() {}
 
 void ResolveContext::DispatchFailure(const char * errorStr, CHIP_ERROR err)
 {
@@ -534,16 +536,7 @@ void ResolveContext::DispatchSuccess()
 
     for (auto interfaceIndex : priorityInterfaceIndices)
     {
-        if (TryReportingResultsForInterfaceIndex(interfaceIndex))
-        {
-            if (needDelete)
-            {
-                MdnsContexts::GetInstance().Delete(this);
-            }
-            return;
-        }
-
-        if (TryReportingResultsForInterfaceIndex(interfaceIndex))
+        if (TryReportingResultsForInterfaceIndex(static_cast<uint32_t>(interfaceIndex)))
         {
             if (needDelete)
             {
@@ -555,8 +548,7 @@ void ResolveContext::DispatchSuccess()
 
     for (auto & interface : interfaces)
     {
-        auto interfaceId = interface.first.first;
-        if (TryReportingResultsForInterfaceIndex(interfaceId))
+        if (TryReportingResultsForInterfaceIndex(interface.first))
         {
             break;
         }
@@ -576,54 +568,43 @@ bool ResolveContext::TryReportingResultsForInterfaceIndex(uint32_t interfaceInde
         return false;
     }
 
-    std::map<std::pair<uint32_t, std::string>, InterfaceInfo>::iterator iter = interfaces.begin();
-    while (iter != interfaces.end())
-    {
-        std::pair<uint32_t, std::string> key = iter->first;
-        if (key.first == interfaceIndex)
-        {
-            auto & interface = interfaces[key];
-            auto & ips       = interface.addresses;
-
-            // Some interface may not have any ips, just ignore them.
-            if (ips.size() == 0)
-            {
-                return false;
-            }
+    auto & interface = interfaces[interfaceIndex];
+    auto & ips       = interface.addresses;
 
-            ChipLogProgress(Discovery, "Mdns: Resolve success on interface %" PRIu32, interfaceIndex);
+    // Some interface may not have any ips, just ignore them.
+    if (ips.size() == 0)
+    {
+        return false;
+    }
 
-            auto & service = interface.service;
-            auto addresses = Span<Inet::IPAddress>(ips.data(), ips.size());
-            if (nullptr == callback)
-            {
-                auto delegate = static_cast<CommissioningResolveDelegate *>(context);
-                DiscoveredNodeData nodeData;
-                service.ToDiscoveredNodeData(addresses, nodeData);
-                delegate->OnNodeDiscovered(nodeData);
-            }
-            else
-            {
-                callback(context, &service, addresses, CHIP_NO_ERROR);
-            }
+    ChipLogProgress(Discovery, "Mdns: Resolve success on interface %" PRIu32, interfaceIndex);
 
-            return true;
-        }
+    auto & service = interface.service;
+    auto addresses = Span<Inet::IPAddress>(ips.data(), ips.size());
+    if (nullptr == callback)
+    {
+        auto delegate = static_cast<CommissioningResolveDelegate *>(context);
+        DiscoveredNodeData nodeData;
+        service.ToDiscoveredNodeData(addresses, nodeData);
+        delegate->OnNodeDiscovered(nodeData);
     }
-    return false;
+    else
+    {
+        callback(context, &service, addresses, CHIP_NO_ERROR);
+    }
+
+    return true;
 }
 
-CHIP_ERROR ResolveContext::OnNewAddress(const std::pair<uint32_t, std::string> & interfaceKey, const struct sockaddr * address)
+CHIP_ERROR ResolveContext::OnNewAddress(uint32_t interfaceId, const struct sockaddr * address)
 {
     // If we don't have any information about this interfaceId, just ignore the
     // address, since it won't be usable anyway without things like the port.
     // This can happen if "local" is set up as a search domain in the DNS setup
     // on the system, because the hostnames we are looking up all end in
     // ".local".  In other words, we can get regular DNS results in here, not
     // just DNS-SD ones.
-    auto interfaceId = interfaceKey.first;
-
-    if (interfaces.find(interfaceKey) == interfaces.end())
+    if (interfaces.find(interfaceId) == interfaces.end())
     {
         return CHIP_NO_ERROR;
     }
@@ -646,7 +627,7 @@ CHIP_ERROR ResolveContext::OnNewAddress(const std::pair<uint32_t, std::string> &
         return CHIP_NO_ERROR;
     }
 
-    interfaces[interfaceKey].addresses.push_back(ip);
+    interfaces[interfaceId].addresses.push_back(ip);
 
     return CHIP_NO_ERROR;
 }
@@ -728,15 +709,7 @@ void ResolveContext::OnNewInterface(uint32_t interfaceId, const char * fullname,
     // resolving.
     interface.fullyQualifiedDomainName = hostnameWithDomain;
 
-    std::string domainFromHostname = GetDomainFromHostName(hostnameWithDomain);
-    if (domainFromHostname.empty())
-    {
-        ChipLogError(Discovery, "Mdns: No domain set in hostname %s", hostnameWithDomain);
-        return;
-    }
-
-    std::pair<uint32_t, std::string> interfaceKey = std::make_pair(interfaceId, domainFromHostname);
-    interfaces.insert(std::make_pair(std::move(interfaceKey), std::move(interface)));
+    interfaces.insert(std::make_pair(interfaceId, std::move(interface)));
 }
 
 bool ResolveContext::HasInterface()