[ncp] implement dbus server for NCP mode (#2339)

This commit refactors the `DBusAgent` so that it can work under NCP
mode.

The DBus server will provide different methods under RCP mode and NCP
mode. Currently under NCP mode, only `GetDeviceRole` is provided.

This commit renames `DBusThreadObject` to `DBusThreadObjectRcp` and
added a new class `DBusThreadObjectNcp` which will handle the DBus
requests under NCP mode. This PR also implements
`AsyncPropertyHandler` to handle GetProperty requests by calling async
methods of `NcpHost`.

A test case is added to test `GetDeviceRole` under NCP.

src/agent/application.cpp

@@ -68,6 +68,9 @@ Application::Application(const std::string               &aInterfaceName,
 #if OTBR_ENABLE_MDNS
     , mPublisher(Mdns::Publisher::Create([this](Mdns::Publisher::State aState) { this->HandleMdnsState(aState); }))
 #endif
+#if OTBR_ENABLE_DBUS_SERVER && OTBR_ENABLE_BORDER_AGENT
+    , mDBusAgent(MakeUnique<DBus::DBusAgent>(*mHost, *mPublisher))
+#endif
 #if OTBR_ENABLE_VENDOR_SERVER
     , mVendorServer(vendor::VendorServer::newInstance(*this))
 #endif
@@ -82,19 +85,35 @@ void Application::Init(void)
 {
     mHost->Init();
 
-    if (mHost->GetCoprocessorType() == OT_COPROCESSOR_RCP)
+    switch (mHost->GetCoprocessorType())
     {
+    case OT_COPROCESSOR_RCP:
         InitRcpMode();
+        break;
+    case OT_COPROCESSOR_NCP:
+        InitNcpMode();
+        break;
+    default:
+        DieNow("Unknown coprocessor type!");
+        break;
     }
 
     otbrLogInfo("Co-processor version: %s", mHost->GetCoprocessorVersion());
 }
 
 void Application::Deinit(void)
 {
-    if (mHost->GetCoprocessorType() == OT_COPROCESSOR_RCP)
+    switch (mHost->GetCoprocessorType())
     {
+    case OT_COPROCESSOR_RCP:
         DeinitRcpMode();
+        break;
+    case OT_COPROCESSOR_NCP:
+        DeinitNcpMode();
+        break;
+    default:
+        DieNow("Unknown coprocessor type!");
+        break;
     }
 
     mHost->Deinit();
@@ -223,9 +242,6 @@ void Application::CreateRcpMode(const std::string &aRestListenAddress, int aRest
 #if OTBR_ENABLE_REST_SERVER
     mRestWebServer = MakeUnique<rest::RestWebServer>(rcpHost, aRestListenAddress, aRestListenPort);
 #endif
-#if OTBR_ENABLE_DBUS_SERVER && OTBR_ENABLE_BORDER_AGENT
-    mDBusAgent = MakeUnique<DBus::DBusAgent>(rcpHost, *mPublisher);
-#endif
 
     OT_UNUSED_VARIABLE(aRestListenAddress);
     OT_UNUSED_VARIABLE(aRestListenPort);
@@ -284,4 +300,16 @@ void Application::DeinitRcpMode(void)
 #endif
 }
 
+void Application::InitNcpMode(void)
+{
+#if OTBR_ENABLE_DBUS_SERVER
+    mDBusAgent->Init();
+#endif
+}
+
+void Application::DeinitNcpMode(void)
+{
+    /* empty */
+}
+
 } // namespace otbr

src/agent/application.hpp

@@ -260,6 +260,9 @@ class Application : private NonCopyable
     void InitRcpMode(void);
     void DeinitRcpMode(void);
 
+    void InitNcpMode(void);
+    void DeinitNcpMode(void);
+
     std::string mInterfaceName;
 #if __linux__
     otbr::Utils::InfraLinkSelector mInfraLinkSelector;

src/common/types.cpp

@@ -159,4 +159,46 @@ std::string MacAddress::ToString(void) const
     return std::string(strbuf);
 }
 
+otError OtbrErrorToOtError(otbrError aError)
+{
+    otError error;
+
+    switch (aError)
+    {
+    case OTBR_ERROR_NONE:
+        error = OT_ERROR_NONE;
+        break;
+
+    case OTBR_ERROR_NOT_FOUND:
+        error = OT_ERROR_NOT_FOUND;
+        break;
+
+    case OTBR_ERROR_PARSE:
+        error = OT_ERROR_PARSE;
+        break;
+
+    case OTBR_ERROR_NOT_IMPLEMENTED:
+        error = OT_ERROR_NOT_IMPLEMENTED;
+        break;
+
+    case OTBR_ERROR_INVALID_ARGS:
+        error = OT_ERROR_INVALID_ARGS;
+        break;
+
+    case OTBR_ERROR_DUPLICATED:
+        error = OT_ERROR_DUPLICATED;
+        break;
+
+    case OTBR_ERROR_INVALID_STATE:
+        error = OT_ERROR_INVALID_STATE;
+        break;
+
+    default:
+        error = OT_ERROR_FAILED;
+        break;
+    }
+
+    return error;
+}
+
 } // namespace otbr

src/common/types.hpp

@@ -42,6 +42,8 @@
 #include <string>
 #include <vector>
 
+#include <openthread/error.h>
+
 #include "common/byteswap.hpp"
 
 #ifndef IN6ADDR_ANY
@@ -469,6 +471,16 @@ static constexpr size_t kVendorOuiLength      = 3;
 static constexpr size_t kMaxVendorNameLength  = 24;
 static constexpr size_t kMaxProductNameLength = 24;
 
+/**
+ * This method converts a otbrError to a otError.
+ *
+ * @param[in]  aError  a otbrError code.
+ *
+ * @returns  a otError code.
+ *
+ */
+otError OtbrErrorToOtError(otbrError aError);
+
 } // namespace otbr
 
 #endif // OTBR_COMMON_TYPES_HPP_

src/dbus/server/CMakeLists.txt

@@ -37,7 +37,8 @@ add_custom_target(otbr-dbus-introspect-header ALL
 add_library(otbr-dbus-server STATIC
     dbus_agent.cpp
     dbus_object.cpp
-    dbus_thread_object.cpp
+    dbus_thread_object_ncp.cpp
+    dbus_thread_object_rcp.cpp
     error_helper.cpp
 )
 
@@ -55,7 +56,7 @@ target_link_libraries(otbr-dbus-server PUBLIC
 
 if(OTBR_DOC)
 add_custom_target(otbr-dbus-server-doc ALL
-    COMMAND gdbus-codegen --generate-docbook generated-docs ${CMAKE_CURRENT_SOURCE_DIR}/introspect.xml 
+    COMMAND gdbus-codegen --generate-docbook generated-docs ${CMAKE_CURRENT_SOURCE_DIR}/introspect.xml
     COMMAND xmlto html generated-docs-io.openthread.BorderRouter.xml
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     VERBATIM

src/dbus/server/dbus_agent.cpp

@@ -36,6 +36,8 @@
 
 #include "common/logging.hpp"
 #include "dbus/common/constants.hpp"
+#include "dbus/server/dbus_thread_object_ncp.hpp"
+#include "dbus/server/dbus_thread_object_rcp.hpp"
 #include "mdns/mdns.hpp"
 
 namespace otbr {
@@ -44,7 +46,7 @@ namespace DBus {
 const struct timeval           DBusAgent::kPollTimeout = {0, 0};
 constexpr std::chrono::seconds DBusAgent::kDBusWaitAllowance;
 
-DBusAgent::DBusAgent(otbr::Ncp::RcpHost &aHost, Mdns::Publisher &aPublisher)
+DBusAgent::DBusAgent(otbr::Ncp::ThreadHost &aHost, Mdns::Publisher &aPublisher)
     : mInterfaceName(aHost.GetInterfaceName())
     , mHost(aHost)
     , mPublisher(aPublisher)
@@ -65,8 +67,23 @@ void DBusAgent::Init(void)
 
     VerifyOrDie(mConnection != nullptr, "Failed to get DBus connection");
 
-    mThreadObject =
-        std::unique_ptr<DBusThreadObject>(new DBusThreadObject(mConnection.get(), mInterfaceName, &mHost, &mPublisher));
+    switch (mHost.GetCoprocessorType())
+    {
+    case OT_COPROCESSOR_RCP:
+        mThreadObject = MakeUnique<DBusThreadObjectRcp>(*mConnection, mInterfaceName,
+                                                        static_cast<Ncp::RcpHost &>(mHost), &mPublisher);
+        break;
+
+    case OT_COPROCESSOR_NCP:
+        mThreadObject =
+            MakeUnique<DBusThreadObjectNcp>(*mConnection, mInterfaceName, static_cast<Ncp::NcpHost &>(mHost));
+        break;
+
+    default:
+        DieNow("Unknown coprocessor type!");
+        break;
+    }
+
     error = mThreadObject->Init();
     VerifyOrDie(error == OTBR_ERROR_NONE, "Failed to initialize DBus Agent");
 }

src/dbus/server/dbus_agent.hpp

@@ -46,9 +46,9 @@
 #include "dbus/common/dbus_message_helper.hpp"
 #include "dbus/common/dbus_resources.hpp"
 #include "dbus/server/dbus_object.hpp"
-#include "dbus/server/dbus_thread_object.hpp"
-
-#include "ncp/rcp_host.hpp"
+#include "dbus/server/dbus_thread_object_ncp.hpp"
+#include "dbus/server/dbus_thread_object_rcp.hpp"
+#include "ncp/thread_host.hpp"
 
 namespace otbr {
 namespace DBus {
@@ -59,10 +59,11 @@ class DBusAgent : public MainloopProcessor, private NonCopyable
     /**
      * The constructor of dbus agent.
      *
-     * @param[in] aHost  A reference to the Thread controller.
+     * @param[in] aHost           A reference to the Thread host.
+     * @param[in] aPublisher      A reference to the MDNS publisher.
      *
      */
-    DBusAgent(otbr::Ncp::RcpHost &aHost, Mdns::Publisher &aPublisher);
+    DBusAgent(otbr::Ncp::ThreadHost &aHost, Mdns::Publisher &aPublisher);
 
     /**
      * This method initializes the dbus agent.
@@ -85,11 +86,11 @@ class DBusAgent : public MainloopProcessor, private NonCopyable
 
     static const struct timeval kPollTimeout;
 
-    std::string                       mInterfaceName;
-    std::unique_ptr<DBusThreadObject> mThreadObject;
-    UniqueDBusConnection              mConnection;
-    otbr::Ncp::RcpHost               &mHost;
-    Mdns::Publisher                  &mPublisher;
+    std::string                 mInterfaceName;
+    std::unique_ptr<DBusObject> mThreadObject;
+    UniqueDBusConnection        mConnection;
+    otbr::Ncp::ThreadHost      &mHost;
+    Mdns::Publisher            &mPublisher;
 
     /**
      * This map is used to track DBusWatch-es.

src/dbus/server/dbus_object.cpp

@@ -50,6 +50,11 @@ DBusObject::DBusObject(DBusConnection *aConnection, const std::string &aObjectPa
 }
 
 otbrError DBusObject::Init(void)
+{
+    return Initialize(/* aIsAsyncPropertyHandler */ false);
+}
+
+otbrError DBusObject::Initialize(bool aIsAsyncPropertyHandler)
 {
     otbrError            error = OTBR_ERROR_NONE;
     DBusObjectPathVTable vTable;
@@ -60,12 +65,21 @@ otbrError DBusObject::Init(void)
 
     VerifyOrExit(dbus_connection_register_object_path(mConnection, mObjectPath.c_str(), &vTable, this),
                  error = OTBR_ERROR_DBUS);
-    RegisterMethod(DBUS_INTERFACE_PROPERTIES, DBUS_PROPERTY_GET_METHOD,
-                   std::bind(&DBusObject::GetPropertyMethodHandler, this, _1));
-    RegisterMethod(DBUS_INTERFACE_PROPERTIES, DBUS_PROPERTY_SET_METHOD,
-                   std::bind(&DBusObject::SetPropertyMethodHandler, this, _1));
-    RegisterMethod(DBUS_INTERFACE_PROPERTIES, DBUS_PROPERTY_GET_ALL_METHOD,
-                   std::bind(&DBusObject::GetAllPropertiesMethodHandler, this, _1));
+
+    if (aIsAsyncPropertyHandler)
+    {
+        RegisterMethod(DBUS_INTERFACE_PROPERTIES, DBUS_PROPERTY_GET_METHOD,
+                       std::bind(&DBusObject::AsyncGetPropertyMethodHandler, this, _1));
+    }
+    else
+    {
+        RegisterMethod(DBUS_INTERFACE_PROPERTIES, DBUS_PROPERTY_GET_METHOD,
+                       std::bind(&DBusObject::GetPropertyMethodHandler, this, _1));
+        RegisterMethod(DBUS_INTERFACE_PROPERTIES, DBUS_PROPERTY_SET_METHOD,
+                       std::bind(&DBusObject::SetPropertyMethodHandler, this, _1));
+        RegisterMethod(DBUS_INTERFACE_PROPERTIES, DBUS_PROPERTY_GET_ALL_METHOD,
+                       std::bind(&DBusObject::GetAllPropertiesMethodHandler, this, _1));
+    }
 
 exit:
     return error;
@@ -98,6 +112,13 @@ void DBusObject::RegisterSetPropertyHandler(const std::string         &aInterfac
     mSetPropertyHandlers.emplace(fullPath, aHandler);
 }
 
+void DBusObject::RegisterAsyncGetPropertyHandler(const std::string              &aInterfaceName,
+                                                 const std::string              &aPropertyName,
+                                                 const AsyncPropertyHandlerType &aHandler)
+{
+    mAsyncGetPropertyHandlers[aInterfaceName].emplace(aPropertyName, aHandler);
+}
+
 DBusHandlerResult DBusObject::sMessageHandler(DBusConnection *aConnection, DBusMessage *aMessage, void *aData)
 {
     DBusObject *server = reinterpret_cast<DBusObject *>(aData);
@@ -252,6 +273,40 @@ void DBusObject::SetPropertyMethodHandler(DBusRequest &aRequest)
     return;
 }
 
+void DBusObject::AsyncGetPropertyMethodHandler(DBusRequest &aRequest)
+{
+    DBusMessageIter iter;
+    std::string     interfaceName;
+    otError         error = OT_ERROR_NONE;
+    std::string     propertyName;
+
+    VerifyOrExit(dbus_message_iter_init(aRequest.GetMessage(), &iter), error = OT_ERROR_FAILED);
+    SuccessOrExit(error = OtbrErrorToOtError(DBusMessageExtract(&iter, interfaceName)));
+    SuccessOrExit(error = OtbrErrorToOtError(DBusMessageExtract(&iter, propertyName)));
+
+    {
+        auto propertyIter = mAsyncGetPropertyHandlers.find(interfaceName);
+
+        otbrLogDebug("AsyncGetProperty %s.%s", interfaceName.c_str(), propertyName.c_str());
+        VerifyOrExit(propertyIter != mAsyncGetPropertyHandlers.end(), error = OT_ERROR_NOT_FOUND);
+        {
+            auto &interfaceHandlers = propertyIter->second;
+            auto  interfaceIter     = interfaceHandlers.find(propertyName);
+
+            VerifyOrExit(interfaceIter != interfaceHandlers.end(), error = OT_ERROR_NOT_FOUND);
+            (interfaceIter->second)(aRequest);
+        }
+    }
+
+exit:
+    if (error != OT_ERROR_NONE)
+    {
+        otbrLogWarning("GetProperty %s.%s error:%s", interfaceName.c_str(), propertyName.c_str(),
+                       ConvertToDBusErrorName(error));
+        aRequest.ReplyOtResult(error);
+    }
+}
+
 DBusObject::~DBusObject(void)
 {
 }