[controller] rename Controller Openthread

src/agent/application.cpp

@@ -60,33 +60,33 @@ Application::Application(const std::string               &aInterfaceName,
 #else
     , mBackboneInterfaceName(aBackboneInterfaceNames.empty() ? "" : aBackboneInterfaceNames.front())
 #endif
-    , mNcp(mInterfaceName.c_str(), aRadioUrls, mBackboneInterfaceName, /* aDryRun */ false, aEnableAutoAttach)
+    , mCtrlr(mInterfaceName.c_str(), aRadioUrls, mBackboneInterfaceName, /* aDryRun */ false, aEnableAutoAttach)
 #if OTBR_ENABLE_MDNS
     , mPublisher(Mdns::Publisher::Create([this](Mdns::Publisher::State aState) { this->HandleMdnsState(aState); }))
 #endif
 #if OTBR_ENABLE_BORDER_AGENT
-    , mBorderAgent(mNcp, *mPublisher)
+    , mBorderAgent(mCtrlr, *mPublisher)
 #endif
 #if OTBR_ENABLE_BACKBONE_ROUTER
-    , mBackboneAgent(mNcp, aInterfaceName, mBackboneInterfaceName)
+    , mBackboneAgent(mCtrlr, aInterfaceName, mBackboneInterfaceName)
 #endif
 #if OTBR_ENABLE_SRP_ADVERTISING_PROXY
-    , mAdvertisingProxy(mNcp, *mPublisher)
+    , mAdvertisingProxy(mCtrlr, *mPublisher)
 #endif
 #if OTBR_ENABLE_DNSSD_DISCOVERY_PROXY
-    , mDiscoveryProxy(mNcp, *mPublisher)
+    , mDiscoveryProxy(mCtrlr, *mPublisher)
 #endif
 #if OTBR_ENABLE_TREL
-    , mTrelDnssd(mNcp, *mPublisher)
+    , mTrelDnssd(mCtrlr, *mPublisher)
 #endif
 #if OTBR_ENABLE_OPENWRT
-    , mUbusAgent(mNcp)
+    , mUbusAgent(mCtrlr)
 #endif
 #if OTBR_ENABLE_REST_SERVER
-    , mRestWebServer(mNcp, aRestListenAddress, aRestListenPort)
+    , mRestWebServer(mCtrlr, aRestListenAddress, aRestListenPort)
 #endif
 #if OTBR_ENABLE_DBUS_SERVER && OTBR_ENABLE_BORDER_AGENT
-    , mDBusAgent(mNcp, *mPublisher)
+    , mDBusAgent(mCtrlr, *mPublisher)
 #endif
 #if OTBR_ENABLE_VENDOR_SERVER
     , mVendorServer(vendor::VendorServer::newInstance(*this))
@@ -98,7 +98,7 @@ Application::Application(const std::string               &aInterfaceName,
 
 void Application::Init(void)
 {
-    mNcp.Init();
+    mCtrlr.Init();
 
 #if OTBR_ENABLE_MDNS
     mPublisher->Start();
@@ -150,7 +150,7 @@ void Application::Deinit(void)
     mPublisher->Stop();
 #endif
 
-    mNcp.Deinit();
+    mCtrlr.Deinit();
 }
 
 otbrError Application::Run(void)

src/agent/application.hpp

@@ -44,7 +44,7 @@
 #if OTBR_ENABLE_BORDER_AGENT
 #include "border_agent/border_agent.hpp"
 #endif
-#include "ncp/ncp_openthread.hpp"
+#include "ncp/controller_openthread_rcp.hpp"
 #if OTBR_ENABLE_BACKBONE_ROUTER
 #include "backbone_router/backbone_agent.hpp"
 #endif
@@ -132,7 +132,7 @@ class Application : private NonCopyable
      *
      * @returns The OpenThread controller object.
      */
-    Ncp::ControllerOpenThread &GetNcp(void) { return mNcp; }
+    Ncp::ControllerOpenThreadRcp &GetNcp(void) { return mCtrlr; }
 
 #if OTBR_ENABLE_MDNS
     /**
@@ -260,8 +260,8 @@ class Application : private NonCopyable
 #if __linux__
     otbr::Utils::InfraLinkSelector mInfraLinkSelector;
 #endif
-    const char               *mBackboneInterfaceName;
-    Ncp::ControllerOpenThread mNcp;
+    const char                  *mBackboneInterfaceName;
+    Ncp::ControllerOpenThreadRcp mCtrlr;
 #if OTBR_ENABLE_MDNS
     std::unique_ptr<Mdns::Publisher> mPublisher;
 #endif

src/agent/main.cpp

@@ -56,7 +56,7 @@
 #include "common/logging.hpp"
 #include "common/mainloop.hpp"
 #include "common/types.hpp"
-#include "ncp/ncp_openthread.hpp"
+#include "ncp/controller_openthread_rcp.hpp"
 
 static const char kDefaultInterfaceName[] = "wpan0";
 
@@ -176,9 +176,10 @@ static otbrLogLevel GetDefaultLogLevel(void)
 
 static void PrintRadioVersionAndExit(const std::vector<const char *> &aRadioUrls)
 {
-    otbr::Ncp::ControllerOpenThread ncpOpenThread{/* aInterfaceName */ "", aRadioUrls, /* aBackboneInterfaceName */ "",
-                                                  /* aDryRun */ true, /* aEnableAutoAttach */ false};
-    const char                     *radioVersion;
+    otbr::Ncp::ControllerOpenThreadRcp ncpOpenThread{/* aInterfaceName */ "", aRadioUrls,
+                                                     /* aBackboneInterfaceName */ "",
+                                                     /* aDryRun */ true, /* aEnableAutoAttach */ false};
+    const char                        *radioVersion;
 
     ncpOpenThread.Init();
 
@@ -279,7 +280,7 @@ static int realmain(int argc, char *argv[])
 
     otbrLogInit(argv[0], logLevel, verbose, syslogDisable);
     otbrLogNotice("Running %s", OTBR_PACKAGE_VERSION);
-    otbrLogNotice("Thread version: %s", otbr::Ncp::ControllerOpenThread::GetThreadVersion());
+    otbrLogNotice("Thread version: %s", otbr::Ncp::ControllerOpenThreadRcp::GetThreadVersion());
     otbrLogNotice("Thread interface: %s", interfaceName);
 
     if (backboneInterfaceNames.empty())

src/backbone_router/backbone_agent.cpp

@@ -47,13 +47,13 @@
 namespace otbr {
 namespace BackboneRouter {
 
-BackboneAgent::BackboneAgent(otbr::Ncp::ControllerOpenThread &aNcp,
-                             std::string                      aInterfaceName,
-                             std::string                      aBackboneInterfaceName)
-    : mNcp(aNcp)
+BackboneAgent::BackboneAgent(otbr::Ncp::ControllerOpenThreadRcp &aCtrlr,
+                             std::string                         aInterfaceName,
+                             std::string                         aBackboneInterfaceName)
+    : mCtrlr(aCtrlr)
     , mBackboneRouterState(OT_BACKBONE_ROUTER_STATE_DISABLED)
 #if OTBR_ENABLE_DUA_ROUTING
-    , mNdProxyManager(aNcp, aBackboneInterfaceName)
+    , mNdProxyManager(aCtrlr, aBackboneInterfaceName)
     , mDuaRoutingManager(aInterfaceName, aBackboneInterfaceName)
 #endif
 {
@@ -63,16 +63,16 @@ BackboneAgent::BackboneAgent(otbr::Ncp::ControllerOpenThread &aNcp,
 
 void BackboneAgent::Init(void)
 {
-    mNcp.AddThreadStateChangedCallback([this](otChangedFlags aFlags) { HandleThreadStateChanged(aFlags); });
-    otBackboneRouterSetDomainPrefixCallback(mNcp.GetInstance(), &BackboneAgent::HandleBackboneRouterDomainPrefixEvent,
+    mCtrlr.AddThreadStateChangedCallback([this](otChangedFlags aFlags) { HandleThreadStateChanged(aFlags); });
+    otBackboneRouterSetDomainPrefixCallback(mCtrlr.GetInstance(), &BackboneAgent::HandleBackboneRouterDomainPrefixEvent,
                                             this);
 #if OTBR_ENABLE_DUA_ROUTING
-    otBackboneRouterSetNdProxyCallback(mNcp.GetInstance(), &BackboneAgent::HandleBackboneRouterNdProxyEvent, this);
+    otBackboneRouterSetNdProxyCallback(mCtrlr.GetInstance(), &BackboneAgent::HandleBackboneRouterNdProxyEvent, this);
     mNdProxyManager.Init();
 #endif
 
 #if OTBR_ENABLE_BACKBONE_ROUTER_ON_INIT
-    otBackboneRouterSetEnabled(mNcp.GetInstance(), /* aEnabled */ true);
+    otBackboneRouterSetEnabled(mCtrlr.GetInstance(), /* aEnabled */ true);
 #endif
 }
 
@@ -86,7 +86,7 @@ void BackboneAgent::HandleThreadStateChanged(otChangedFlags aFlags)
 
 void BackboneAgent::HandleBackboneRouterState(void)
 {
-    otBackboneRouterState state      = otBackboneRouterGetState(mNcp.GetInstance());
+    otBackboneRouterState state      = otBackboneRouterGetState(mCtrlr.GetInstance());
     bool                  wasPrimary = (mBackboneRouterState == OT_BACKBONE_ROUTER_STATE_PRIMARY);
 
     otbrLogDebug("BackboneAgent: HandleBackboneRouterState: state=%d, mBackboneRouterState=%d", state,

src/backbone_router/backbone_agent.hpp

@@ -47,7 +47,7 @@
 #include "backbone_router/dua_routing_manager.hpp"
 #include "backbone_router/nd_proxy.hpp"
 #include "common/code_utils.hpp"
-#include "ncp/ncp_openthread.hpp"
+#include "ncp/controller_openthread_rcp.hpp"
 
 namespace otbr {
 namespace BackboneRouter {
@@ -73,12 +73,12 @@ class BackboneAgent : private NonCopyable
     /**
      * This constructor intiializes the `BackboneAgent` instance.
      *
-     * @param[in] aNcp  The Thread instance.
+     * @param[in] aCtrlr  The Thread controller instance.
      *
      */
-    BackboneAgent(otbr::Ncp::ControllerOpenThread &aNcp,
-                  std::string                      aInterfaceName,
-                  std::string                      aBackboneInterfaceName);
+    BackboneAgent(otbr::Ncp::ControllerOpenThreadRcp &aCtrlr,
+                  std::string                         aInterfaceName,
+                  std::string                         aBackboneInterfaceName);
 
     /**
      * This method initializes the Backbone agent.
@@ -106,9 +106,9 @@ class BackboneAgent : private NonCopyable
 
     static const char *StateToString(otBackboneRouterState aState);
 
-    otbr::Ncp::ControllerOpenThread &mNcp;
-    otBackboneRouterState            mBackboneRouterState;
-    Ip6Prefix                        mDomainPrefix;
+    otbr::Ncp::ControllerOpenThreadRcp &mCtrlr;
+    otBackboneRouterState               mBackboneRouterState;
+    Ip6Prefix                           mDomainPrefix;
 #if OTBR_ENABLE_DUA_ROUTING
     NdProxyManager    mNdProxyManager;
     DuaRoutingManager mDuaRoutingManager;

src/backbone_router/dua_routing_manager.hpp

@@ -43,7 +43,7 @@
 #include <openthread/backbone_router_ftd.h>
 
 #include "common/code_utils.hpp"
-#include "ncp/ncp_openthread.hpp"
+#include "ncp/controller_openthread_rcp.hpp"
 #include "utils/system_utils.hpp"
 
 namespace otbr {

src/backbone_router/nd_proxy.cpp

@@ -311,7 +311,7 @@ void NdProxyManager::SendNeighborAdvertisement(const Ip6Address &aTarget, const
     otbrError                  error = OTBR_ERROR_NONE;
     otBackboneRouterNdProxyInfo aNdProxyInfo;
 
-    VerifyOrExit(otBackboneRouterGetNdProxyInfo(mNcp.GetInstance(), reinterpret_cast<const otIp6Address *>(&aTarget),
+    VerifyOrExit(otBackboneRouterGetNdProxyInfo(mCtrlr.GetInstance(), reinterpret_cast<const otIp6Address *>(&aTarget),
                                                 &aNdProxyInfo) == OT_ERROR_NONE,
                  error = OTBR_ERROR_OPENTHREAD);
 

src/backbone_router/nd_proxy.hpp

@@ -55,7 +55,7 @@
 #include "common/code_utils.hpp"
 #include "common/mainloop.hpp"
 #include "common/types.hpp"
-#include "ncp/ncp_openthread.hpp"
+#include "ncp/controller_openthread_rcp.hpp"
 
 namespace otbr {
 namespace BackboneRouter {
@@ -80,8 +80,8 @@ class NdProxyManager : public MainloopProcessor, private NonCopyable
      * This constructor initializes a NdProxyManager instance.
      *
      */
-    explicit NdProxyManager(otbr::Ncp::ControllerOpenThread &aNcp, std::string aBackboneInterfaceName)
-        : mNcp(aNcp)
+    explicit NdProxyManager(otbr::Ncp::ControllerOpenThreadRcp &aCtrlr, std::string aBackboneInterfaceName)
+        : mCtrlr(aCtrlr)
         , mBackboneInterfaceName(std::move(aBackboneInterfaceName))
         , mIcmp6RawSock(-1)
         , mUnicastNsQueueSock(-1)
@@ -153,16 +153,16 @@ class NdProxyManager : public MainloopProcessor, private NonCopyable
                                     void                *aContext);
     int HandleNetfilterQueue(struct nfq_q_handle *aNfQueueHandler, struct nfgenmsg *aNfMsg, struct nfq_data *aNfData);
 
-    otbr::Ncp::ControllerOpenThread &mNcp;
-    std::string                      mBackboneInterfaceName;
-    std::set<Ip6Address>             mNdProxySet;
-    uint32_t                         mBackboneIfIndex;
-    int                              mIcmp6RawSock;
-    int                              mUnicastNsQueueSock;
-    struct nfq_handle               *mNfqHandler;      ///< A pointer to an NFQUEUE handler.
-    struct nfq_q_handle             *mNfqQueueHandler; ///< A pointer to a newly created queue.
-    MacAddress                       mMacAddress;
-    Ip6Prefix                        mDomainPrefix;
+    otbr::Ncp::ControllerOpenThreadRcp &mCtrlr;
+    std::string                         mBackboneInterfaceName;
+    std::set<Ip6Address>                mNdProxySet;
+    uint32_t                            mBackboneIfIndex;
+    int                                 mIcmp6RawSock;
+    int                                 mUnicastNsQueueSock;
+    struct nfq_handle                  *mNfqHandler;      ///< A pointer to an NFQUEUE handler.
+    struct nfq_q_handle                *mNfqQueueHandler; ///< A pointer to a newly created queue.
+    MacAddress                          mMacAddress;
+    Ip6Prefix                           mDomainPrefix;
 };
 
 /**

src/border_agent/border_agent.cpp

@@ -56,7 +56,7 @@
 #include <openthread/platform/toolchain.h>
 
 #include "agent/uris.hpp"
-#include "ncp/ncp_openthread.hpp"
+#include "ncp/controller_openthread_rcp.hpp"
 #if OTBR_ENABLE_BACKBONE_ROUTER
 #include "backbone_router/backbone_agent.hpp"
 #endif
@@ -138,15 +138,15 @@ struct StateBitmap
     }
 };
 
-BorderAgent::BorderAgent(otbr::Ncp::ControllerOpenThread &aNcp, Mdns::Publisher &aPublisher)
-    : mNcp(aNcp)
+BorderAgent::BorderAgent(otbr::Ncp::ControllerOpenThreadRcp &aCtrlr, Mdns::Publisher &aPublisher)
+    : mCtrlr(aCtrlr)
     , mPublisher(aPublisher)
     , mIsEnabled(false)
     , mVendorName(OTBR_VENDOR_NAME)
     , mProductName(OTBR_PRODUCT_NAME)
     , mBaseServiceInstanceName(OTBR_MESHCOP_SERVICE_INSTANCE_NAME)
 {
-    mNcp.AddThreadStateChangedCallback([this](otChangedFlags aFlags) { HandleThreadStateChanged(aFlags); });
+    mCtrlr.AddThreadStateChangedCallback([this](otChangedFlags aFlags) { HandleThreadStateChanged(aFlags); });
 }
 
 otbrError BorderAgent::SetMeshCopServiceValues(const std::string          &aServiceInstanceName,
@@ -191,20 +191,21 @@ void BorderAgent::Start(void)
     otbrLogInfo("Start Thread Border Agent");
 
 #if OTBR_ENABLE_DBUS_SERVER
-    mNcp.GetThreadHelper()->SetUpdateMeshCopTxtHandler([this](std::map<std::string, std::vector<uint8_t>> aUpdate) {
+    mCtrlr.GetThreadHelper()->SetUpdateMeshCopTxtHandler([this](std::map<std::string, std::vector<uint8_t>> aUpdate) {
         HandleUpdateVendorMeshCoPTxtEntries(std::move(aUpdate));
     });
-    mNcp.RegisterResetHandler([this]() {
-        mNcp.GetThreadHelper()->SetUpdateMeshCopTxtHandler([this](std::map<std::string, std::vector<uint8_t>> aUpdate) {
-            HandleUpdateVendorMeshCoPTxtEntries(std::move(aUpdate));
-        });
+    mCtrlr.RegisterResetHandler([this]() {
+        mCtrlr.GetThreadHelper()->SetUpdateMeshCopTxtHandler(
+            [this](std::map<std::string, std::vector<uint8_t>> aUpdate) {
+                HandleUpdateVendorMeshCoPTxtEntries(std::move(aUpdate));
+            });
     });
 #endif
 
     mServiceInstanceName = GetServiceInstanceNameWithExtAddr(mBaseServiceInstanceName);
     UpdateMeshCopService();
 
-    otBorderAgentSetEphemeralKeyCallback(mNcp.GetInstance(), BorderAgent::HandleEpskcStateChanged, this);
+    otBorderAgentSetEphemeralKeyCallback(mCtrlr.GetInstance(), BorderAgent::HandleEpskcStateChanged, this);
 }
 
 void BorderAgent::Stop(void)
@@ -217,7 +218,7 @@ void BorderAgent::HandleEpskcStateChanged(void *aContext)
 {
     BorderAgent *borderAgent = static_cast<BorderAgent *>(aContext);
 
-    if (otBorderAgentIsEphemeralKeyActive(borderAgent->mNcp.GetInstance()))
+    if (otBorderAgentIsEphemeralKeyActive(borderAgent->mCtrlr.GetInstance()))
     {
         borderAgent->PublishEpskcService();
     }
@@ -229,7 +230,7 @@ void BorderAgent::HandleEpskcStateChanged(void *aContext)
 
 void BorderAgent::PublishEpskcService()
 {
-    otInstance *instance = mNcp.GetInstance();
+    otInstance *instance = mCtrlr.GetInstance();
     int         port     = otBorderAgentGetUdpPort(instance);
 
     otbrLogInfo("Publish meshcop-e service %s.%s.local. port %d", mServiceInstanceName.c_str(),
@@ -415,7 +416,7 @@ void BorderAgent::PublishMeshCopService(void)
 {
     StateBitmap              state;
     uint32_t                 stateUint32;
-    otInstance              *instance    = mNcp.GetInstance();
+    otInstance              *instance    = mCtrlr.GetInstance();
     const otExtendedPanId   *extPanId    = otThreadGetExtendedPanId(instance);
     const otExtAddress      *extAddr     = otLinkGetExtendedAddress(instance);
     const char              *networkName = otThreadGetNetworkName(instance);
@@ -459,7 +460,7 @@ void BorderAgent::PublishMeshCopService(void)
     }
     txtList.emplace_back("nn", networkName);
     txtList.emplace_back("xp", extPanId->m8, sizeof(extPanId->m8));
-    txtList.emplace_back("tv", mNcp.GetThreadVersion());
+    txtList.emplace_back("tv", mCtrlr.GetThreadVersion());
 
     // "xa" stands for Extended MAC Address (64-bit) of the Thread Interface of the Border Agent.
     txtList.emplace_back("xa", extAddr->m8, sizeof(extAddr->m8));
@@ -579,14 +580,14 @@ void BorderAgent::HandleThreadStateChanged(otChangedFlags aFlags)
 
 bool BorderAgent::IsThreadStarted(void) const
 {
-    otDeviceRole role = otThreadGetDeviceRole(mNcp.GetInstance());
+    otDeviceRole role = otThreadGetDeviceRole(mCtrlr.GetInstance());
 
     return role == OT_DEVICE_ROLE_CHILD || role == OT_DEVICE_ROLE_ROUTER || role == OT_DEVICE_ROLE_LEADER;
 }
 
 std::string BorderAgent::GetServiceInstanceNameWithExtAddr(const std::string &aServiceInstanceName) const
 {
-    const otExtAddress *extAddress = otLinkGetExtendedAddress(mNcp.GetInstance());
+    const otExtAddress *extAddress = otLinkGetExtendedAddress(mCtrlr.GetInstance());
     std::stringstream   ss;
 
     ss << aServiceInstanceName << " #";