Commissioning State Machine

examples/chip-tool/BUILD.gn

@@ -72,6 +72,7 @@ static_library("chip-tool-utils") {
     "${chip_root}/src/app/tests/suites/commands/log",
     "${chip_root}/src/app/tests/suites/commands/system",
     "${chip_root}/src/app/tests/suites/pics",
+    "${chip_root}/src/commissioner",
     "${chip_root}/src/controller/data_model",
     "${chip_root}/src/lib",
     "${chip_root}/src/platform",

examples/chip-tool/commands/clusters/ModelCommand.cpp

@@ -26,7 +26,7 @@ using namespace ::chip;
 CHIP_ERROR ModelCommand::RunCommand()
 {
     ChipLogProgress(chipTool, "Sending command to node 0x%" PRIx64, mNodeId);
-    return CurrentCommissioner().GetConnectedDevice(mNodeId, &mOnDeviceConnectedCallback, &mOnDeviceConnectionFailureCallback);
+    return CurrentController().GetConnectedDevice(mNodeId, &mOnDeviceConnectedCallback, &mOnDeviceConnectionFailureCallback);
 }
 
 void ModelCommand::OnDeviceConnectedFn(void * context, ChipDevice * device)

examples/chip-tool/commands/common/CHIPCommand.cpp

@@ -49,13 +49,13 @@ CHIP_ERROR CHIPCommand::Run()
 
     chip::Controller::FactoryInitParams factoryInitParams;
     factoryInitParams.fabricStorage = &mFabricStorage;
-    factoryInitParams.listenPort    = static_cast<uint16_t>(mDefaultStorage.GetListenPort() + CurrentCommissionerId());
+    factoryInitParams.listenPort    = static_cast<uint16_t>(mDefaultStorage.GetListenPort() + CurrentControllerId());
     ReturnLogErrorOnFailure(DeviceControllerFactory::GetInstance().Init(factoryInitParams));
 
-    ReturnLogErrorOnFailure(InitializeCommissioner(kIdentityNull, kIdentityNullFabricId));
-    ReturnLogErrorOnFailure(InitializeCommissioner(kIdentityAlpha, kIdentityAlphaFabricId));
-    ReturnLogErrorOnFailure(InitializeCommissioner(kIdentityBeta, kIdentityBetaFabricId));
-    ReturnLogErrorOnFailure(InitializeCommissioner(kIdentityGamma, kIdentityGammaFabricId));
+    ReturnLogErrorOnFailure(InitializeController(kIdentityNull, kIdentityNullFabricId));
+    ReturnLogErrorOnFailure(InitializeController(kIdentityAlpha, kIdentityAlphaFabricId));
+    ReturnLogErrorOnFailure(InitializeController(kIdentityBeta, kIdentityBetaFabricId));
+    ReturnLogErrorOnFailure(InitializeController(kIdentityGamma, kIdentityGammaFabricId));
 
     chip::DeviceLayer::PlatformMgr().ScheduleWork(RunQueuedCommand, reinterpret_cast<intptr_t>(this));
     ReturnLogErrorOnFailure(StartWaiting(GetWaitDuration()));
@@ -67,10 +67,10 @@ CHIP_ERROR CHIPCommand::Run()
     // since the CHIP thread and event queue have been stopped, preventing any thread
     // races.
     //
-    ReturnLogErrorOnFailure(ShutdownCommissioner(kIdentityNull));
-    ReturnLogErrorOnFailure(ShutdownCommissioner(kIdentityAlpha));
-    ReturnLogErrorOnFailure(ShutdownCommissioner(kIdentityBeta));
-    ReturnLogErrorOnFailure(ShutdownCommissioner(kIdentityGamma));
+    ReturnLogErrorOnFailure(ShutdownController(kIdentityNull));
+    ReturnLogErrorOnFailure(ShutdownController(kIdentityAlpha));
+    ReturnLogErrorOnFailure(ShutdownController(kIdentityBeta));
+    ReturnLogErrorOnFailure(ShutdownController(kIdentityGamma));
 
     StopTracing();
     return CHIP_NO_ERROR;
@@ -105,29 +105,29 @@ void CHIPCommand::SetIdentity(const char * identity)
     if (name.compare(kIdentityAlpha) != 0 && name.compare(kIdentityBeta) != 0 && name.compare(kIdentityGamma) != 0 &&
         name.compare(kIdentityNull) != 0)
     {
-        ChipLogError(chipTool, "Unknown commissioner name: %s. Supported names are [%s, %s, %s]", name.c_str(), kIdentityAlpha,
+        ChipLogError(chipTool, "Unknown controller name: %s. Supported names are [%s, %s, %s]", name.c_str(), kIdentityAlpha,
                      kIdentityBeta, kIdentityGamma);
         chipDie();
     }
 
-    mCommissionerName.SetValue(const_cast<char *>(identity));
+    mControllerName.SetValue(const_cast<char *>(identity));
 }
 
 std::string CHIPCommand::GetIdentity()
 {
-    std::string name = mCommissionerName.HasValue() ? mCommissionerName.Value() : kIdentityAlpha;
+    std::string name = mControllerName.HasValue() ? mControllerName.Value() : kIdentityAlpha;
     if (name.compare(kIdentityAlpha) != 0 && name.compare(kIdentityBeta) != 0 && name.compare(kIdentityGamma) != 0 &&
         name.compare(kIdentityNull) != 0)
     {
-        ChipLogError(chipTool, "Unknown commissioner name: %s. Supported names are [%s, %s, %s]", name.c_str(), kIdentityAlpha,
+        ChipLogError(chipTool, "Unknown controller name: %s. Supported names are [%s, %s, %s]", name.c_str(), kIdentityAlpha,
                      kIdentityBeta, kIdentityGamma);
         chipDie();
     }
 
     return name;
 }
 
-chip::FabricId CHIPCommand::CurrentCommissionerId()
+chip::FabricId CHIPCommand::CurrentControllerId()
 {
     chip::FabricId id;
 
@@ -150,35 +150,35 @@ chip::FabricId CHIPCommand::CurrentCommissionerId()
     }
     else
     {
-        VerifyOrDieWithMsg(false, chipTool, "Unknown commissioner name: %s. Supported names are [%s, %s, %s]", name.c_str(),
+        VerifyOrDieWithMsg(false, chipTool, "Unknown controller name: %s. Supported names are [%s, %s, %s]", name.c_str(),
                            kIdentityAlpha, kIdentityBeta, kIdentityGamma);
     }
 
     return id;
 }
 
-chip::Controller::DeviceCommissioner & CHIPCommand::CurrentCommissioner()
+chip::Controller::DeviceController & CHIPCommand::CurrentController()
 {
-    auto item = mCommissioners.find(GetIdentity());
+    auto item = mControllers.find(GetIdentity());
     return *item->second.get();
 }
 
-CHIP_ERROR CHIPCommand::ShutdownCommissioner(std::string key)
+CHIP_ERROR CHIPCommand::ShutdownController(std::string key)
 {
-    return mCommissioners[key].get()->Shutdown();
+    return mControllers[key].get()->Shutdown();
 }
 
-CHIP_ERROR CHIPCommand::InitializeCommissioner(std::string key, chip::FabricId fabricId)
+CHIP_ERROR CHIPCommand::InitializeController(std::string key, chip::FabricId fabricId)
 {
     chip::Platform::ScopedMemoryBuffer<uint8_t> noc;
     chip::Platform::ScopedMemoryBuffer<uint8_t> icac;
     chip::Platform::ScopedMemoryBuffer<uint8_t> rcac;
 
-    std::unique_ptr<ChipDeviceCommissioner> commissioner = std::make_unique<ChipDeviceCommissioner>();
-    chip::Controller::SetupParams commissionerParams;
+    std::unique_ptr<ChipDeviceController> controller = std::make_unique<ChipDeviceController>();
+    chip::Controller::SetupParams controllerParams;
 
-    ReturnLogErrorOnFailure(mCredIssuerCmds->SetupDeviceAttestation(commissionerParams));
-    chip::Credentials::SetDeviceAttestationVerifier(commissionerParams.deviceAttestationVerifier);
+    ReturnLogErrorOnFailure(mCredIssuerCmds->SetupDeviceAttestation(controllerParams));
+    chip::Credentials::SetDeviceAttestationVerifier(controllerParams.deviceAttestationVerifier);
 
     VerifyOrReturnError(noc.Alloc(chip::Controller::kMaxCHIPDERCertLength), CHIP_ERROR_NO_MEMORY);
     VerifyOrReturnError(icac.Alloc(chip::Controller::kMaxCHIPDERCertLength), CHIP_ERROR_NO_MEMORY);
@@ -192,28 +192,28 @@ CHIP_ERROR CHIPCommand::InitializeCommissioner(std::string key, chip::FabricId f
         // TODO - OpCreds should only be generated for pairing command
         //        store the credentials in persistent storage, and
         //        generate when not available in the storage.
-        ReturnLogErrorOnFailure(mCommissionerStorage.Init(key.c_str()));
-        ReturnLogErrorOnFailure(mCredIssuerCmds->InitializeCredentialsIssuer(mCommissionerStorage));
+        ReturnLogErrorOnFailure(mControllerStorage.Init(key.c_str()));
+        ReturnLogErrorOnFailure(mCredIssuerCmds->InitializeCredentialsIssuer(mControllerStorage));
 
         chip::MutableByteSpan nocSpan(noc.Get(), chip::Controller::kMaxCHIPDERCertLength);
         chip::MutableByteSpan icacSpan(icac.Get(), chip::Controller::kMaxCHIPDERCertLength);
         chip::MutableByteSpan rcacSpan(rcac.Get(), chip::Controller::kMaxCHIPDERCertLength);
 
         ReturnLogErrorOnFailure(ephemeralKey.Initialize());
-        ReturnLogErrorOnFailure(mCredIssuerCmds->GenerateControllerNOCChain(mCommissionerStorage.GetLocalNodeId(), fabricId,
+        ReturnLogErrorOnFailure(mCredIssuerCmds->GenerateControllerNOCChain(mControllerStorage.GetLocalNodeId(), fabricId,
                                                                             ephemeralKey, rcacSpan, icacSpan, nocSpan));
-        commissionerParams.operationalKeypair = &ephemeralKey;
-        commissionerParams.controllerRCAC     = rcacSpan;
-        commissionerParams.controllerICAC     = icacSpan;
-        commissionerParams.controllerNOC      = nocSpan;
+        controllerParams.operationalKeypair = &ephemeralKey;
+        controllerParams.controllerRCAC     = rcacSpan;
+        controllerParams.controllerICAC     = icacSpan;
+        controllerParams.controllerNOC      = nocSpan;
     }
 
-    commissionerParams.storageDelegate                = &mCommissionerStorage;
-    commissionerParams.operationalCredentialsDelegate = mCredIssuerCmds->GetCredentialIssuer();
-    commissionerParams.controllerVendorId             = chip::VendorId::TestVendor1;
+    controllerParams.storageDelegate                = &mControllerStorage;
+    controllerParams.operationalCredentialsDelegate = mCredIssuerCmds->GetCredentialIssuer();
+    controllerParams.controllerVendorId             = chip::VendorId::TestVendor1;
 
-    ReturnLogErrorOnFailure(DeviceControllerFactory::GetInstance().SetupCommissioner(commissionerParams, *(commissioner.get())));
-    mCommissioners[key] = std::move(commissioner);
+    ReturnLogErrorOnFailure(DeviceControllerFactory::GetInstance().SetupController(controllerParams, *(controller.get())));
+    mControllers[key] = std::move(controller);
 
     return CHIP_NO_ERROR;
 }

examples/chip-tool/commands/common/CHIPCommand.h

@@ -30,32 +30,31 @@ class PersistentStorage;
 constexpr const char kIdentityAlpha[] = "alpha";
 constexpr const char kIdentityBeta[]  = "beta";
 constexpr const char kIdentityGamma[] = "gamma";
-// The null fabric commissioner is a commissioner that isn't on a fabric.
-// This is a legal configuration in which the commissioner delegates
+// The null fabric controller is a controller that isn't on a fabric.
+// This is a legal configuration in which the controller delegates
 // operational communication and invocation of the commssioning complete
 // command to a separate on-fabric administrator node.
 //
-// The null-fabric-commissioner identity is provided here to demonstrate the
-// commissioner portion of such an architecture.  The null-fabric-commissioner
+// The null-fabric-controller identity is provided here to demonstrate the
+// controller portion of such an architecture.  The null-fabric-controller
 // can carry a commissioning flow up until the point of operational channel
 // (CASE) communcation.
-constexpr const char kIdentityNull[] = "null-fabric-commissioner";
+constexpr const char kIdentityNull[] = "null-fabric-controller";
 
 class CHIPCommand : public Command
 {
 public:
-    using ChipDevice             = ::chip::DeviceProxy;
-    using ChipDeviceCommissioner = ::chip::Controller::DeviceCommissioner;
-    using ChipDeviceController   = ::chip::Controller::DeviceController;
-    using IPAddress              = ::chip::Inet::IPAddress;
-    using NodeId                 = ::chip::NodeId;
-    using PeerId                 = ::chip::PeerId;
-    using PeerAddress            = ::chip::Transport::PeerAddress;
+    using ChipDevice           = ::chip::DeviceProxy;
+    using ChipDeviceController = ::chip::Controller::DeviceController;
+    using IPAddress            = ::chip::Inet::IPAddress;
+    using NodeId               = ::chip::NodeId;
+    using PeerId               = ::chip::PeerId;
+    using PeerAddress          = ::chip::Transport::PeerAddress;
 
     CHIPCommand(const char * commandName, CredentialIssuerCommands * credIssuerCmds) :
         Command(commandName), mCredIssuerCmds(credIssuerCmds)
     {
-        AddArgument("commissioner-name", &mCommissionerName);
+        AddArgument("controller-name", &mControllerName);
 #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED
         AddArgument("trace_file", &mTraceFile);
         AddArgument("trace_log", 0, 1, &mTraceLog);
@@ -88,24 +87,24 @@ class CHIPCommand : public Command
     virtual void Shutdown() {}
 
     PersistentStorage mDefaultStorage;
-    PersistentStorage mCommissionerStorage;
+    PersistentStorage mControllerStorage;
     chip::SimpleFabricStorage mFabricStorage;
     CredentialIssuerCommands * mCredIssuerCmds;
 
     std::string GetIdentity();
     void SetIdentity(const char * name);
 
-    // This method returns the commissioner instance to be used for running the command.
-    // The default commissioner instance name is "alpha", but it can be overridden by passing
+    // This method returns the controller instance to be used for running the command.
+    // The default controller instance name is "alpha", but it can be overridden by passing
     // --identity "instance name" when running a command.
-    ChipDeviceCommissioner & CurrentCommissioner();
+    ChipDeviceController & CurrentController();
 
 private:
-    CHIP_ERROR InitializeCommissioner(std::string key, chip::FabricId fabricId);
-    CHIP_ERROR ShutdownCommissioner(std::string key);
-    chip::FabricId CurrentCommissionerId();
-    std::map<std::string, std::unique_ptr<ChipDeviceCommissioner>> mCommissioners;
-    chip::Optional<char *> mCommissionerName;
+    CHIP_ERROR InitializeController(std::string key, chip::FabricId fabricId);
+    CHIP_ERROR ShutdownController(std::string key);
+    chip::FabricId CurrentControllerId();
+    std::map<std::string, std::unique_ptr<ChipDeviceController>> mControllers;
+    chip::Optional<char *> mControllerName;
 
     static void RunQueuedCommand(intptr_t commandArg);
 

examples/chip-tool/commands/discover/Commands.h

@@ -83,8 +83,8 @@ class Update : public DiscoverCommand
     CHIP_ERROR RunCommand(NodeId remoteId, uint64_t fabricId) override
     {
         ChipLogProgress(chipTool, "Mdns: Updating NodeId: %" PRIx64 " Compressed FabricId: %" PRIx64 " ...", remoteId,
-                        CurrentCommissioner().GetCompressedFabricId());
-        return CurrentCommissioner().UpdateDevice(remoteId);
+                        CurrentController().GetCompressedFabricId());
+        return CurrentController().UpdateDevice(remoteId);
     }
 
     /////////// DeviceAddressUpdateDelegate Interface /////////

examples/chip-tool/commands/discover/DiscoverCommand.cpp

@@ -20,6 +20,6 @@
 
 CHIP_ERROR DiscoverCommand::RunCommand()
 {
-    CurrentCommissioner().RegisterDeviceAddressUpdateDelegate(this);
+    CurrentController().RegisterDeviceAddressUpdateDelegate(this);
     return RunCommand(mNodeId, mFabricId);
 }

examples/chip-tool/commands/discover/DiscoverCommissionablesCommand.cpp

@@ -17,18 +17,26 @@
  */
 
 #include "DiscoverCommissionablesCommand.h"
+#include <controller/CHIPDeviceControllerFactory.h>
 #include <lib/support/BytesToHex.h>
 
 using namespace ::chip;
 
 CHIP_ERROR DiscoverCommissionablesCommand::RunCommand()
 {
-    CurrentCommissioner().RegisterDeviceDiscoveryDelegate(this);
+    ReturnErrorOnFailure(
+        mDnsResolver.Init(chip::Controller::DeviceControllerFactory::GetInstance().GetSystemState()->UDPEndPointManager()));
+    mDnsResolver.SetResolverDelegate(this);
     Dnssd::DiscoveryFilter filter(Dnssd::DiscoveryFilterType::kNone, (uint64_t) 0);
-    return CurrentCommissioner().DiscoverCommissionableNodes(filter);
+    ReturnErrorOnFailure(mDnsResolver.FindCommissionableNodes(filter));
+    return CHIP_NO_ERROR;
 }
 
-void DiscoverCommissionablesCommand::OnDiscoveredDevice(const chip::Dnssd::DiscoveredNodeData & nodeData)
+void DiscoverCommissionablesCommand::OnNodeDiscoveryComplete(const chip::Dnssd::DiscoveredNodeData & nodeData)
 {
     nodeData.LogDetail();
 }
+
+void DiscoverCommissionablesCommand::OnNodeIdResolved(const chip::Dnssd::ResolvedNodeData & nodeData) {}
+
+void DiscoverCommissionablesCommand::OnNodeIdResolutionFailed(const PeerId & peerId, CHIP_ERROR error) {}

examples/chip-tool/commands/discover/DiscoverCommissionablesCommand.h

@@ -20,16 +20,21 @@
 
 #include "../common/CHIPCommand.h"
 
-class DiscoverCommissionablesCommand : public CHIPCommand, public chip::Controller::DeviceDiscoveryDelegate
+class DiscoverCommissionablesCommand : public CHIPCommand, public chip::Dnssd::ResolverDelegate
 {
 public:
     DiscoverCommissionablesCommand(CredentialIssuerCommands * credsIssuerConfig) : CHIPCommand("commissionables", credsIssuerConfig)
     {}
 
-    /////////// DeviceDiscoveryDelegate Interface /////////
-    void OnDiscoveredDevice(const chip::Dnssd::DiscoveredNodeData & nodeData) override;
+    /////////// ResolverDelegate Interface /////////
+    void OnNodeIdResolved(const chip::Dnssd::ResolvedNodeData & nodeData) override;
+    void OnNodeIdResolutionFailed(const PeerId & peerId, CHIP_ERROR error) override;
+    void OnNodeDiscoveryComplete(const chip::Dnssd::DiscoveredNodeData & nodeData) override;
 
     /////////// CHIPCommand Interface /////////
     CHIP_ERROR RunCommand() override;
     chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(30); }
+
+private:
+    chip::Dnssd::ResolverProxy mDnsResolver;
 };

examples/chip-tool/commands/discover/DiscoverCommissionersCommand.cpp

@@ -23,18 +23,18 @@ using namespace ::chip;
 
 CHIP_ERROR DiscoverCommissionersCommand::RunCommand()
 {
-    return mCommissionableNodeController.DiscoverCommissioners();
+    return mCommissionableNodeCommissioner.DiscoverCommissioners();
 }
 
 void DiscoverCommissionersCommand::Shutdown()
 {
     int commissionerCount = 0;
     for (int i = 0; i < CHIP_DEVICE_CONFIG_MAX_DISCOVERED_NODES; i++)
     {
-        const Dnssd::DiscoveredNodeData * commissioner = mCommissionableNodeController.GetDiscoveredCommissioner(i);
+        const Dnssd::DiscoveredNodeData * commissioner = mCommissionableNodeCommissioner.GetDiscoveredCommissioner(i);
         if (commissioner != nullptr)
         {
-            ChipLogProgress(chipTool, "Discovered Commissioner #%d", commissionerCount);
+            ChipLogProgress(chipTool, "Discovered Commissioner#%d", commissionerCount);
             commissioner->LogDetail();
             commissionerCount++;
         }

examples/chip-tool/commands/discover/DiscoverCommissionersCommand.h

@@ -32,5 +32,5 @@ class DiscoverCommissionersCommand : public CHIPCommand
     void Shutdown() override;
 
 private:
-    chip::Controller::CommissionableNodeController mCommissionableNodeController;
+    chip::Controller::CommissionableNodeController mCommissionableNodeCommissioner;
 };

examples/chip-tool/commands/pairing/OpenCommissioningWindowCommand.cpp

@@ -22,7 +22,7 @@ using namespace ::chip;
 
 CHIP_ERROR OpenCommissioningWindowCommand::RunCommand()
 {
-    return CurrentCommissioner().GetConnectedDevice(mNodeId, &mOnDeviceConnectedCallback, &mOnDeviceConnectionFailureCallback);
+    return CurrentController().GetConnectedDevice(mNodeId, &mOnDeviceConnectedCallback, &mOnDeviceConnectionFailureCallback);
 }
 
 void OpenCommissioningWindowCommand::OnDeviceConnectedFn(void * context, chip::OperationalDeviceProxy * device)
@@ -52,7 +52,7 @@ void OpenCommissioningWindowCommand::OnOpenCommissioningWindowResponse(void * co
 
 CHIP_ERROR OpenCommissioningWindowCommand::OpenCommissioningWindow()
 {
-    return CurrentCommissioner().OpenCommissioningWindowWithCallback(
-        mNodeId, mTimeout, mIteration, mDiscriminator, mCommissioningWindowOption, &mOnOpenCommissioningWindowCallback,
-        /* readVIDPIDAttributes */ true);
+    return CurrentController().OpenCommissioningWindowWithCallback(mNodeId, mTimeout, mIteration, mDiscriminator,
+                                                                   mCommissioningWindowOption, &mOnOpenCommissioningWindowCallback,
+                                                                   /* readVIDPIDAttributes */ true);
 }