[dnssd] use queries in dns-sd server rather than local map (#841)

The newly introduces `otDnssdGetQuery` apis allows platform
implementations to use the queries stored in the dns-sd server. Remove
the local map to reduce complexity.

2 files changed, 92 insertions, 159 deletions

diff --git a/src/agent/discovery_proxy.cpp b/src/agent/discovery_proxy.cpp
index 16e9a1bd..407fe3a8 100644
--- a/src/agent/discovery_proxy.cpp
+++ b/src/agent/discovery_proxy.cpp
@@ -89,41 +89,24 @@ void DiscoveryProxy::OnDiscoveryProxySubscribe(void *aContext, const char *aFull
 
 void DiscoveryProxy::OnDiscoveryProxySubscribe(const char *aFullName)
 {
-    std::string                    fullName(aFullName);
-    otbrError                      error = OTBR_ERROR_NONE;
-    MdnsSubscriptionList::iterator it;
-    DnsNameInfo                    nameInfo = SplitFullDnsName(fullName);
+    std::string fullName(aFullName);
+    otbrError   error    = OTBR_ERROR_NONE;
+    DnsNameInfo nameInfo = SplitFullDnsName(fullName);
 
     otbrLogInfo("subscribe: %s", fullName.c_str());
 
-    it = std::find_if(mSubscriptions.begin(), mSubscriptions.end(), [&](const MdnsSubscription &aSubscription) {
-        return aSubscription.Matches(nameInfo.mInstanceName, nameInfo.mServiceName, nameInfo.mHostName,
-                                     nameInfo.mDomain);
-    });
-
-    VerifyOrExit(it == mSubscriptions.end(), it->mSubscriptionCount++);
-
-    mSubscriptions.emplace_back(nameInfo.mInstanceName, nameInfo.mServiceName, nameInfo.mHostName, nameInfo.mDomain);
-
+    if (GetServiceSubscriptionCount(nameInfo) == 1)
     {
-        MdnsSubscription &subscription = mSubscriptions.back();
-
-        otbrLogDebug("subscriptions: %sx%d", subscription.ToString().c_str(), subscription.mSubscriptionCount);
-
-        if (GetServiceSubscriptionCount(nameInfo.mInstanceName, nameInfo.mServiceName, nameInfo.mHostName) == 1)
+        if (nameInfo.mHostName.empty())
+        {
+            mMdnsPublisher.SubscribeService(nameInfo.mServiceName, nameInfo.mInstanceName);
+        }
+        else
         {
-            if (subscription.mHostName.empty())
-            {
-                mMdnsPublisher.SubscribeService(nameInfo.mServiceName, nameInfo.mInstanceName);
-            }
-            else
-            {
-                mMdnsPublisher.SubscribeHost(nameInfo.mHostName);
-            }
+            mMdnsPublisher.SubscribeHost(nameInfo.mHostName);
         }
     }
 
-exit:
     if (error != OTBR_ERROR_NONE)
     {
         otbrLogWarning("failed to subscribe %s: %s", fullName.c_str(), otbrErrorString(error));
@@ -137,46 +120,23 @@ void DiscoveryProxy::OnDiscoveryProxyUnsubscribe(void *aContext, const char *aFu
 
 void DiscoveryProxy::OnDiscoveryProxyUnsubscribe(const char *aFullName)
 {
-    std::string                    fullName(aFullName);
-    otbrError                      error = OTBR_ERROR_NONE;
-    MdnsSubscriptionList::iterator it;
-    DnsNameInfo                    nameInfo = SplitFullDnsName(fullName);
+    std::string fullName(aFullName);
+    otbrError   error    = OTBR_ERROR_NONE;
+    DnsNameInfo nameInfo = SplitFullDnsName(fullName);
 
     otbrLogInfo("unsubscribe: %s", fullName.c_str());
 
-    it = std::find_if(mSubscriptions.begin(), mSubscriptions.end(), [&](const MdnsSubscription &aSubscription) {
-        return aSubscription.Matches(nameInfo.mInstanceName, nameInfo.mServiceName, nameInfo.mHostName,
-                                     nameInfo.mDomain);
-    });
-
-    VerifyOrExit(it != mSubscriptions.end(), error = OTBR_ERROR_NOT_FOUND);
-
+    if (GetServiceSubscriptionCount(nameInfo) == 1)
     {
-        MdnsSubscription &subscription = *it;
-
-        subscription.mSubscriptionCount--;
-        assert(subscription.mSubscriptionCount >= 0);
-
-        otbrLogDebug("service subscriptions: %sx%d", it->ToString().c_str(), it->mSubscriptionCount);
-
-        if (subscription.mSubscriptionCount == 0)
+        if (nameInfo.mHostName.empty())
         {
-            mSubscriptions.erase(it);
+            mMdnsPublisher.UnsubscribeService(nameInfo.mServiceName, nameInfo.mInstanceName);
         }
-
-        if (GetServiceSubscriptionCount(nameInfo.mInstanceName, nameInfo.mServiceName, nameInfo.mHostName) == 0)
+        else
         {
-            if (subscription.mHostName.empty())
-            {
-                mMdnsPublisher.UnsubscribeService(nameInfo.mServiceName, nameInfo.mInstanceName);
-            }
-            else
-            {
-                mMdnsPublisher.UnsubscribeHost(nameInfo.mHostName);
-            }
+            mMdnsPublisher.UnsubscribeHost(nameInfo.mHostName);
         }
     }
-exit:
     if (error != OTBR_ERROR_NONE)
     {
         otbrLogWarning("failed to unsubscribe %s: %s", fullName.c_str(), otbrErrorString(error));
@@ -187,6 +147,7 @@ void DiscoveryProxy::OnServiceDiscovered(const std::string &
                                          const Mdns::Publisher::DiscoveredInstanceInfo &aInstanceInfo)
 {
     otDnssdServiceInstanceInfo instanceInfo;
+    const otDnssdQuery *       query = nullptr;
 
     otbrLogInfo("service discovered: %s, instance %s hostname %s addresses %zu port %d priority %d "
                 "weight %d",
@@ -214,11 +175,39 @@ void DiscoveryProxy::OnServiceDiscovered(const std::string &
     instanceInfo.mTxtData   = aInstanceInfo.mTxtData.data();
     instanceInfo.mTtl       = CapTtl(aInstanceInfo.mTtl);
 
-    std::for_each(mSubscriptions.begin(), mSubscriptions.end(), [&](const MdnsSubscription &aSubscription) {
-        if (aSubscription.MatchesServiceInstance(aType, aInstanceInfo.mName))
+    while ((query = otDnssdGetNextQuery(mNcp.GetInstance(), query)) != nullptr)
+    {
+        std::string      instanceName;
+        std::string      serviceName;
+        std::string      hostName;
+        std::string      domain;
+        char             queryName[OT_DNS_MAX_NAME_SIZE];
+        otDnssdQueryType type = otDnssdGetQueryTypeAndName(query, &queryName);
+        otbrError        splitError;
+
+        switch (type)
+        {
+        case OT_DNSSD_QUERY_TYPE_BROWSE:
+            splitError = SplitFullServiceName(queryName, serviceName, domain);
+            assert(splitError == OTBR_ERROR_NONE);
+            break;
+        case OT_DNSSD_QUERY_TYPE_RESOLVE:
+            splitError = SplitFullServiceInstanceName(queryName, instanceName, serviceName, domain);
+            assert(splitError == OTBR_ERROR_NONE);
+            break;
+        default:
+            splitError = OTBR_ERROR_NOT_FOUND;
+            break;
+        }
+        if (splitError != OTBR_ERROR_NONE)
+        {
+            continue;
+        }
+
+        if (serviceName == aType && (instanceName.empty() || instanceName == aInstanceInfo.mName))
         {
-            std::string serviceFullName  = aType + "." + aSubscription.mDomain;
-            std::string hostName         = TranslateDomain(aInstanceInfo.mHostName, aSubscription.mDomain);
+            std::string serviceFullName  = aType + "." + domain;
+            std::string hostName         = TranslateDomain(aInstanceInfo.mHostName, domain);
             std::string instanceFullName = aInstanceInfo.mName + "." + serviceFullName;
 
             instanceInfo.mFullName = instanceFullName.c_str();
@@ -226,13 +215,14 @@ void DiscoveryProxy::OnServiceDiscovered(const std::string &
 
             otDnssdQueryHandleDiscoveredServiceInstance(mNcp.GetInstance(), serviceFullName.c_str(), &instanceInfo);
         }
-    });
+    }
 }
 
 void DiscoveryProxy::OnHostDiscovered(const std::string &                        aHostName,
                                       const Mdns::Publisher::DiscoveredHostInfo &aHostInfo)
 {
-    otDnssdHostInfo hostInfo;
+    otDnssdHostInfo     hostInfo;
+    const otDnssdQuery *query = nullptr;
 
     otbrLogInfo("host discovered: %s hostname %s addresses %zu", aHostName.c_str(), aHostInfo.mHostName.c_str(),
                 aHostInfo.mAddresses.size());
@@ -251,20 +241,34 @@ void DiscoveryProxy::OnHostDiscovered(const std::string &
 
     hostInfo.mTtl = CapTtl(aHostInfo.mTtl);
 
-    std::for_each(mSubscriptions.begin(), mSubscriptions.end(), [&](const MdnsSubscription &aSubscription) {
-        if (aSubscription.MatchesHost(aHostName))
+    while ((query = otDnssdGetNextQuery(mNcp.GetInstance(), query)) != nullptr)
+    {
+        std::string      hostName, domain;
+        char             queryName[OT_DNS_MAX_NAME_SIZE];
+        otDnssdQueryType type = otDnssdGetQueryTypeAndName(query, &queryName);
+        otbrError        splitError;
+
+        if (type != OT_DNSSD_QUERY_TYPE_RESOLVE_HOST)
         {
-            std::string hostFullName = TranslateDomain(aHostInfo.mHostName, aSubscription.mDomain);
+            continue;
+        }
+        splitError = SplitFullHostName(queryName, hostName, domain);
+        assert(splitError == OTBR_ERROR_NONE);
+
+        if (hostName == aHostName)
+        {
+            std::string hostFullName = TranslateDomain(aHostInfo.mHostName, domain);
 
             otDnssdQueryHandleDiscoveredHost(mNcp.GetInstance(), hostFullName.c_str(), &hostInfo);
         }
-    });
+    }
 }
 
 std::string DiscoveryProxy::TranslateDomain(const std::string &aName, const std::string &aTargetDomain)
 {
     std::string targetName;
-    std::string hostName, domain;
+    std::string hostName;
+    std::string domain;
 
     VerifyOrExit(OTBR_ERROR_NONE == SplitFullHostName(aName, hostName, domain), targetName = aName);
     VerifyOrExit(domain == "local.", targetName = aName);
@@ -276,17 +280,24 @@ exit:
     return targetName;
 }
 
-int DiscoveryProxy::GetServiceSubscriptionCount(const std::string &aInstanceName,
-                                                const std::string &aServiceName,
-                                                const std::string &aHostName)
+int DiscoveryProxy::GetServiceSubscriptionCount(const DnsNameInfo &aNameInfo) const
 {
-    return std::accumulate(
-        mSubscriptions.begin(), mSubscriptions.end(), 0, [&](int aAccum, const MdnsSubscription &aSubscription) {
-            return aAccum + ((aSubscription.mInstanceName == aInstanceName &&
-                              aSubscription.mServiceName == aServiceName && aSubscription.mHostName == aHostName)
-                                 ? aSubscription.mSubscriptionCount
-                                 : 0);
-        });
+    const otDnssdQuery *query = nullptr;
+    int                 count = 0;
+
+    while ((query = otDnssdGetNextQuery(mNcp.GetInstance(), query)) != nullptr)
+    {
+        char        queryName[OT_DNS_MAX_NAME_SIZE];
+        DnsNameInfo queryInfo;
+
+        otDnssdGetQueryTypeAndName(query, &queryName);
+        queryInfo = SplitFullDnsName(queryName);
+
+        count += (aNameInfo.mInstanceName == queryInfo.mInstanceName &&
+                  aNameInfo.mServiceName == queryInfo.mServiceName && aNameInfo.mHostName == queryInfo.mHostName);
+    }
+
+    return count;
 }
 
 void DiscoveryProxy::CheckServiceNameSanity(const std::string &aType)
@@ -316,46 +327,6 @@ uint32_t DiscoveryProxy::CapTtl(uint32_t aTtl)
     return std::min(aTtl, static_cast<uint32_t>(kServiceTtlCapLimit));
 }
 
-std::string DiscoveryProxy::MdnsSubscription::ToString(void) const
-{
-    std::string str;
-
-    if (!mHostName.empty())
-    {
-        str = mHostName + "." + mDomain;
-    }
-    else if (!mInstanceName.empty())
-    {
-        str = mInstanceName + "." + mServiceName + "." + mDomain;
-    }
-    else
-    {
-        str = mServiceName + "." + mDomain;
-    }
-
-    return str;
-}
-
-bool DiscoveryProxy::MdnsSubscription::Matches(const std::string &aInstanceName,
-                                               const std::string &aServiceName,
-                                               const std::string &aHostName,
-                                               const std::string &aDomain) const
-{
-    return mInstanceName == aInstanceName && mServiceName == aServiceName && mHostName == aHostName &&
-           mDomain == aDomain;
-}
-
-bool DiscoveryProxy::MdnsSubscription::MatchesServiceInstance(const std::string &aType,
-                                                              const std::string &aInstanceName) const
-{
-    return mServiceName == aType && (mInstanceName.empty() || mInstanceName == aInstanceName);
-}
-
-bool DiscoveryProxy::MdnsSubscription::MatchesHost(const std::string &aHostName) const
-{
-    return mHostName == aHostName;
-}
-
 } // namespace Dnssd
 } // namespace otbr
 
diff --git a/src/agent/discovery_proxy.hpp b/src/agent/discovery_proxy.hpp
index 2f7bc586..ac8748bd 100644
--- a/src/agent/discovery_proxy.hpp
+++ b/src/agent/discovery_proxy.hpp
@@ -45,6 +45,7 @@
 #include <openthread/instance.h>
 
 #include "agent/ncp_openthread.hpp"
+#include "common/dns_utils.hpp"
 #include "mdns/mdns.hpp"
 
 namespace otbr {
@@ -84,49 +85,11 @@ private:
         kServiceTtlCapLimit = 10, // TTL cap limit for Discovery Proxy (in seconds).
     };
 
-    struct MdnsSubscription
-    {
-        explicit MdnsSubscription()
-            : mSubscriptionCount(0)
-        {
-        }
-
-        MdnsSubscription(std::string aInstanceName,
-                         std::string aServiceName,
-                         std::string aHostName,
-                         std::string aDomain)
-            : mInstanceName(std::move(aInstanceName))
-            , mServiceName(std::move(aServiceName))
-            , mHostName(std::move(aHostName))
-            , mDomain(std::move(aDomain))
-            , mSubscriptionCount(1)
-        {
-        }
-
-        std::string ToString(void) const;
-
-        std::string mInstanceName;
-        std::string mServiceName;
-        std::string mHostName;
-        std::string mDomain;
-        int         mSubscriptionCount;
-        bool        Matches(const std::string &aInstanceName,
-                            const std::string &aServiceName,
-                            const std::string &aHostName,
-                            const std::string &aDomain) const;
-        bool        MatchesServiceInstance(const std::string &aType, const std::string &aInstanceName) const;
-        bool        MatchesHost(const std::string &aHostName) const;
-    };
-
-    typedef std::vector<MdnsSubscription> MdnsSubscriptionList;
-
     static void        OnDiscoveryProxySubscribe(void *aContext, const char *aFullName);
     void               OnDiscoveryProxySubscribe(const char *aSubscription);
     static void        OnDiscoveryProxyUnsubscribe(void *aContext, const char *aFullName);
     void               OnDiscoveryProxyUnsubscribe(const char *aSubscription);
-    int                GetServiceSubscriptionCount(const std::string &aInstanceName,
-                                                   const std::string &aServiceName,
-                                                   const std::string &aHostName);
+    int                GetServiceSubscriptionCount(const DnsNameInfo &aNameInfo) const;
     static std::string TranslateDomain(const std::string &aName, const std::string &aTargetDomain);
     static void        CheckServiceNameSanity(const std::string &aType);
     static void        CheckHostnameSanity(const std::string &aHostName);
@@ -137,7 +100,6 @@ private:
 
     Ncp::ControllerOpenThread &mNcp;
     Mdns::Publisher &          mMdnsPublisher;
-    MdnsSubscriptionList       mSubscriptions;
 };
 
 } // namespace Dnssd