Merge "[mdns] support resolving a host" into mainHEADmastermain

4 files changed, 167 insertions, 4 deletions

diff --git a/src/android/aidl/com/android/server/thread/openthread/INsdPublisher.aidl b/src/android/aidl/com/android/server/thread/openthread/INsdPublisher.aidl
index 84549f9b..74bec2fb 100644
--- a/src/android/aidl/com/android/server/thread/openthread/INsdPublisher.aidl
+++ b/src/android/aidl/com/android/server/thread/openthread/INsdPublisher.aidl
@@ -32,6 +32,7 @@ import com.android.server.thread.openthread.DnsTxtAttribute;
 import com.android.server.thread.openthread.INsdStatusReceiver;
 import com.android.server.thread.openthread.INsdDiscoverServiceCallback;
 import com.android.server.thread.openthread.INsdResolveServiceCallback;
+import com.android.server.thread.openthread.INsdResolveHostCallback;
 
 /**
  * The service which supports mDNS advertising and discovery by {@link NsdManager}.
@@ -150,4 +151,29 @@ oneway interface INsdPublisher {
      *                             service resolution operation
      */
     void stopServiceResolution(int listenerId);
+
+    /**
+     * Resolves an mDNS host.
+     *
+     * <p>To stop resolving a host, use stopHostResolution.
+     *
+     * @param name the hostname
+     * @param callback the callback when a host is resolved.
+     * @param listenerId the ID of DnsResolver.Callback which is used to identify the
+     *                             host resolution operation
+     */
+    void resolveHost(in String name,
+                     in INsdResolveHostCallback callback,
+                     int listenerId);
+
+    /**
+     * Stops resolving an mDNS host.
+     *
+     * <p>To stop resolving a host, the caller must pass in the same listener ID which was used
+     * when starting resolving the host.
+     *
+     * @param listenerId the ID of the DnsResolver.Callback which is used to identify the
+     *                             host resolution operation
+     */
+    void stopHostResolution(int listenerId);
 }
diff --git a/src/android/aidl/com/android/server/thread/openthread/INsdResolveHostCallback.aidl b/src/android/aidl/com/android/server/thread/openthread/INsdResolveHostCallback.aidl
new file mode 100644
index 00000000..920a181e
--- /dev/null
+++ b/src/android/aidl/com/android/server/thread/openthread/INsdResolveHostCallback.aidl
@@ -0,0 +1,35 @@
+/*
+ *    Copyright (c) 2024, The OpenThread Authors.
+ *    All rights reserved.
+ *
+ *    Redistribution and use in source and binary forms, with or without
+ *    modification, are permitted provided that the following conditions are met:
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *    2. Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *    3. Neither the name of the copyright holder nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ *    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ *    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *    POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.android.server.thread.openthread;
+
+/** Receives the information of a resolved host. */
+oneway interface INsdResolveHostCallback {
+    void onHostResolved(in String name,
+                        in List<String> addresses);
+}
diff --git a/src/android/mdns_publisher.cpp b/src/android/mdns_publisher.cpp
index 6febeccb..0bade461 100644
--- a/src/android/mdns_publisher.cpp
+++ b/src/android/mdns_publisher.cpp
@@ -108,6 +108,30 @@ Status MdnsPublisher::NsdResolveServiceCallback::onServiceResolved(const std::st
     return Status::ok();
 }
 
+Status MdnsPublisher::NsdResolveHostCallback::onHostResolved(const std::string              &aName,
+                                                             const std::vector<std::string> &aAddresses)
+{
+    DiscoveredHostInfo info;
+
+    info.mTtl = kDefaultResolvedTtl;
+    for (const auto &addressStr : aAddresses)
+    {
+        Ip6Address address;
+        int        error = Ip6Address::FromString(addressStr.c_str(), address);
+
+        if (error != OTBR_ERROR_NONE)
+        {
+            otbrLogInfo("Failed to parse resolved IPv6 address: %s", addressStr.c_str());
+            continue;
+        }
+        info.mAddresses.push_back(address);
+    }
+
+    mSubscription.mPublisher.OnHostResolved(aName, info);
+
+    return Status::ok();
+}
+
 void MdnsPublisher::SetINsdPublisher(std::shared_ptr<INsdPublisher> aINsdPublisher)
 {
     otbrLogInfo("Set INsdPublisher %p", aINsdPublisher.get());
@@ -151,6 +175,12 @@ std::shared_ptr<MdnsPublisher::NsdResolveServiceCallback> CreateNsdResolveServic
     return ndk::SharedRefBase::make<MdnsPublisher::NsdResolveServiceCallback>(aServiceSubscription);
 }
 
+std::shared_ptr<MdnsPublisher::NsdResolveHostCallback> CreateNsdResolveHostCallback(
+    MdnsPublisher::HostSubscription &aHostSubscription)
+{
+    return ndk::SharedRefBase::make<MdnsPublisher::NsdResolveHostCallback>(aHostSubscription);
+}
+
 void DieForNotImplemented(const char *aFuncName)
 {
     VerifyOrDie(false, (std::string(aFuncName) + " is not implemented").c_str());
@@ -359,12 +389,42 @@ exit:
 
 void MdnsPublisher::SubscribeHost(const std::string &aHostName)
 {
-    OTBR_UNUSED_VARIABLE(aHostName);
+    auto host = MakeUnique<HostSubscription>(aHostName, *this, mNsdPublisher, AllocateListenerId());
+
+    VerifyOrExit(IsStarted(), otbrLogWarning("No platform mDNS implementation registered!"));
+
+    mNsdPublisher->resolveHost(aHostName, CreateNsdResolveHostCallback(*host), host->mListenerId);
+    mHostSubscriptions.push_back(std::move(host));
+
+    otbrLogInfo("Subscribe host %s (total %zu)", aHostName.c_str(), mHostSubscriptions.size());
+
+exit:
+    return;
 }
 
 void MdnsPublisher::UnsubscribeHost(const std::string &aHostName)
 {
-    OTBR_UNUSED_VARIABLE(aHostName);
+    HostSubscriptionList::iterator it;
+
+    VerifyOrExit(IsStarted());
+
+    it = std::find_if(
+        mHostSubscriptions.begin(), mHostSubscriptions.end(),
+        [&aHostName](const std::unique_ptr<HostSubscription> &aHost) { return aHost->mName == aHostName; });
+
+    VerifyOrExit(it != mHostSubscriptions.end(),
+                 otbrLogWarning("The host %s is already unsubscribed.", aHostName.c_str()));
+
+    {
+        std::unique_ptr<HostSubscription> host = std::move(*it);
+
+        mHostSubscriptions.erase(it);
+    }
+
+    otbrLogInfo("Unsubscribe host %s (left %zu)", aHostName.c_str(), mHostSubscriptions.size());
+
+exit:
+    return;
 }
 
 void MdnsPublisher::OnServiceResolveFailedImpl(const std::string &aType,
diff --git a/src/android/mdns_publisher.hpp b/src/android/mdns_publisher.hpp
index 64793dc5..723532ea 100644
--- a/src/android/mdns_publisher.hpp
+++ b/src/android/mdns_publisher.hpp
@@ -32,6 +32,7 @@
 #include "mdns/mdns.hpp"
 
 #include <aidl/com/android/server/thread/openthread/BnNsdDiscoverServiceCallback.h>
+#include <aidl/com/android/server/thread/openthread/BnNsdResolveHostCallback.h>
 #include <aidl/com/android/server/thread/openthread/BnNsdResolveServiceCallback.h>
 #include <aidl/com/android/server/thread/openthread/BnNsdStatusReceiver.h>
 #include <aidl/com/android/server/thread/openthread/DnsTxtAttribute.h>
@@ -42,6 +43,7 @@ namespace otbr {
 namespace Android {
 using Status = ::ndk::ScopedAStatus;
 using aidl::com::android::server::thread::openthread::BnNsdDiscoverServiceCallback;
+using aidl::com::android::server::thread::openthread::BnNsdResolveHostCallback;
 using aidl::com::android::server::thread::openthread::BnNsdResolveServiceCallback;
 using aidl::com::android::server::thread::openthread::BnNsdStatusReceiver;
 using aidl::com::android::server::thread::openthread::DnsTxtAttribute;
@@ -157,6 +159,29 @@ public:
         std::map<std::string, std::set<ServiceResolver *>> mResolvers;
     };
 
+    struct HostSubscription : private ::NonCopyable
+    {
+        explicit HostSubscription(std::string                    aName,
+                                  MdnsPublisher                 &aPublisher,
+                                  std::shared_ptr<INsdPublisher> aNsdPublisher,
+                                  int                            listenerId)
+            : mName(std::move(aName))
+            , mPublisher(aPublisher)
+            , mNsdPublisher(std::move(aNsdPublisher))
+            , mListenerId(listenerId)
+        {
+        }
+
+        ~HostSubscription(void) { Release(); }
+
+        void Release(void) { mNsdPublisher->stopHostResolution(mListenerId); }
+
+        std::string                    mName;
+        MdnsPublisher                 &mPublisher;
+        std::shared_ptr<INsdPublisher> mNsdPublisher;
+        const int32_t                  mListenerId;
+    };
+
     class NsdDiscoverServiceCallback : public BnNsdDiscoverServiceCallback
     {
     public:
@@ -191,6 +216,20 @@ public:
         ServiceSubscription &mSubscription;
     };
 
+    class NsdResolveHostCallback : public BnNsdResolveHostCallback
+    {
+    public:
+        explicit NsdResolveHostCallback(HostSubscription &aSubscription)
+            : mSubscription(aSubscription)
+        {
+        }
+
+        Status onHostResolved(const std::string &aName, const std::vector<std::string> &aAddresses);
+
+    private:
+        HostSubscription &mSubscription;
+    };
+
 protected:
     otbrError PublishServiceImpl(const std::string &aHostName,
                                  const std::string &aName,
@@ -272,9 +311,11 @@ private:
     };
 
     typedef std::vector<std::unique_ptr<ServiceSubscription>> ServiceSubscriptionList;
+    typedef std::vector<std::unique_ptr<HostSubscription>>    HostSubscriptionList;
 
-    static constexpr int kMinResolvedTtl = 1;
-    static constexpr int kMaxResolvedTtl = 10;
+    static constexpr int kDefaultResolvedTtl = 10;
+    static constexpr int kMinResolvedTtl     = 1;
+    static constexpr int kMaxResolvedTtl     = 10;
 
     int32_t AllocateListenerId(void);
 
@@ -282,6 +323,7 @@ private:
     int32_t                        mNextListenerId;
     std::shared_ptr<INsdPublisher> mNsdPublisher = nullptr;
     ServiceSubscriptionList        mServiceSubscriptions;
+    HostSubscriptionList           mHostSubscriptions;
 };
 
 } // namespace Android