Implemented the JCM mDNS advertisement and Open Commissioning Window

Author: vijs

docs/guides/joint_fabric_guide.md

@@ -2,8 +2,11 @@
 
 -   [Joint Fabric Guide](#joint-fabric-guide)
     -   [Joint Fabric Example Applications](#joint-fabric-example-applications)
-        -   [Bootstrap Joint Fabric Demo on Linux](#bootstrap-joint-fabric-demo-on-linux)
-        -   [Run Joint Fabric Demo](#run-joint-fabric-demo)
+        -   [Building the Example Application](#building-the-example-application)
+    -   [Bootstrap Joint Fabric Demo on Linux](#bootstrap-joint-fabric-demo-on-linux)
+        -   [Initialize Ecosystem A (Vendor ID = 0xFFF1)](#initialize-ecosystem-a-vendor-id--0xfff1)
+        -   [Initialize Ecosystem B (Vendor ID = 0xFFF2)](#initialize-ecosystem-b-vendor-id--0xfff2)
+    -   [Run Joint Fabric Demo](#run-joint-fabric-demo)
 
 ## Joint Fabric Example Applications
 
@@ -250,4 +253,16 @@ jf-admin-app has been installed:
 A `Subjects` field equal to `18446744065119551489` (`FFFFFFFDFFFF0001` in hex)
 should be found.
 
+-   Open Joint Commissioning Window on JF Admin App of Ecosystem B
+
+```
+>>> pairing open-joint-commissioning-window 1 400 1000 1261
+```
+
+Check for the following logs on the jf-admin-app side:
+
+```
+>>> [DIS] Advertise commission parameter vendorID=65521 productID=32769 discriminator=1261/04 cm=2 cp=0 jf=14
+```
+
 ## Run Joint Fabric Demo

examples/chip-tool/BUILD.gn

@@ -91,6 +91,8 @@ static_library("chip-tool-utils") {
     "commands/icd/ICDCommand.h",
     "commands/pairing/OpenCommissioningWindowCommand.cpp",
     "commands/pairing/OpenCommissioningWindowCommand.h",
+    "commands/pairing/OpenJointCommissioningWindowCommand.cpp",
+    "commands/pairing/OpenJointCommissioningWindowCommand.h",
     "commands/pairing/PairingCommand.cpp",
     "commands/pairing/ToTLVCert.cpp",
     "commands/payload/AdditionalDataParseCommand.cpp",

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

@@ -23,6 +23,7 @@
 #include "commands/pairing/GetCommissionerRootCertificateCommand.h"
 #include "commands/pairing/IssueNOCChainCommand.h"
 #include "commands/pairing/OpenCommissioningWindowCommand.h"
+#include "commands/pairing/OpenJointCommissioningWindowCommand.h"
 #include "commands/pairing/PairingCommand.h"
 
 #include <app/server/Dnssd.h>
@@ -272,6 +273,7 @@ void registerCommandsPairing(Commands & commands, CredentialIssuerCommands * cre
         //        make_unique<CommissionedListCommand>(),
         make_unique<StartUdcServerCommand>(credsIssuerConfig),
         make_unique<OpenCommissioningWindowCommand>(credsIssuerConfig),
+        make_unique<OpenJointCommissioningWindowCommand>(credsIssuerConfig),
         make_unique<GetCommissionerNodeIdCommand>(credsIssuerConfig),
         make_unique<GetCommissionerRootCertificateCommand>(credsIssuerConfig),
         make_unique<IssueNOCChainCommand>(credsIssuerConfig),

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

@@ -0,0 +1,48 @@
+/*
+ *   Copyright (c) 2025 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+
+#include "OpenJointCommissioningWindowCommand.h"
+
+#include <system/SystemClock.h>
+
+using namespace ::chip;
+
+CHIP_ERROR OpenJointCommissioningWindowCommand::RunCommand()
+{
+    mWindowOpener = Platform::MakeUnique<Controller::CommissioningWindowOpener>(&CurrentCommissioner());
+
+    SetupPayload ignored;
+    return mWindowOpener->OpenCommissioningWindow(Controller::CommissioningWindowPasscodeParams()
+                                                      .SetNodeId(mNodeId)
+                                                      .SetTimeout(mCommissioningWindowTimeout)
+                                                      .SetIteration(mIteration)
+                                                      .SetDiscriminator(mDiscriminator)
+                                                      .SetReadVIDPIDAttributes(true)
+                                                      .SetCallback(&mOnOpenCommissioningWindowCallback),
+                                                  ignored, true);
+}
+
+void OpenJointCommissioningWindowCommand::OnOpenCommissioningWindowResponse(void * context, NodeId remoteId, CHIP_ERROR err,
+                                                                            SetupPayload payload)
+{
+    LogErrorOnFailure(err);
+
+    OpenJointCommissioningWindowCommand * command = reinterpret_cast<OpenJointCommissioningWindowCommand *>(context);
+    VerifyOrReturn(command != nullptr, ChipLogError(chipTool, "OnOpenJointCommissioningWindowCommand: context is null"));
+    command->SetCommandExitStatus(err);
+}

examples/chip-tool/commands/pairing/OpenJointCommissioningWindowCommand.h

@@ -0,0 +1,61 @@
+/*
+ *   Copyright (c) 2025 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+
+#pragma once
+
+#include "../common/CHIPCommand.h"
+
+#include <controller/CommissioningWindowOpener.h>
+#include <lib/support/CHIPMem.h>
+
+class OpenJointCommissioningWindowCommand : public CHIPCommand
+{
+public:
+    OpenJointCommissioningWindowCommand(CredentialIssuerCommands * credIssuerCommands) :
+        CHIPCommand("open-joint-commissioning-window", credIssuerCommands),
+        mOnOpenCommissioningWindowCallback(OnOpenCommissioningWindowResponse, this)
+    {
+        AddArgument("node-id", 0, UINT64_MAX, &mNodeId, "Node to send command to.");
+        AddArgument("window-timeout", 0, UINT16_MAX, &mCommissioningWindowTimeout,
+                    "Time, in seconds, before the commissioning window closes.");
+        AddArgument("iteration", chip::Crypto::kSpake2p_Min_PBKDF_Iterations, chip::Crypto::kSpake2p_Max_PBKDF_Iterations,
+                    &mIteration, "Number of PBKDF iterations to use to derive the verifier.  Ignored if 'option' is 0.");
+        AddArgument("discriminator", 0, 4095, &mDiscriminator, "Discriminator to use for advertising.  Ignored if 'option' is 0.");
+        AddArgument("timeout", 0, UINT16_MAX, &mTimeout, "Time, in seconds, before this command is considered to have timed out.");
+    }
+
+    /////////// CHIPCommand Interface /////////
+    CHIP_ERROR RunCommand() override;
+    // We issue multiple data model operations for this command, and the default
+    // timeout for those is 10 seconds, so default to 20 seconds.
+    chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(mTimeout.ValueOr(20)); }
+
+private:
+    NodeId mNodeId;
+    uint16_t mCommissioningWindowTimeout;
+    uint32_t mIteration;
+    uint16_t mDiscriminator;
+
+    chip::Optional<uint16_t> mTimeout;
+
+    chip::Platform::UniquePtr<chip::Controller::CommissioningWindowOpener> mWindowOpener;
+
+    static void OnOpenCommissioningWindowResponse(void * context, NodeId deviceId, CHIP_ERROR status, chip::SetupPayload payload);
+
+    chip::Callback::Callback<chip::Controller::OnOpenCommissioningWindow> mOnOpenCommissioningWindowCallback;
+};

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

@@ -368,6 +368,9 @@ CHIP_ERROR PairingCommand::PairWithMdns(NodeId remoteId)
         filter.code         = 0;
         filter.instanceName = mDiscoveryFilterInstanceName;
         break;
+    case chip::Dnssd::DiscoveryFilterType::kJointFabricMode:
+        // TODO
+        break;
     }
 
     CurrentCommissioner().RegisterDeviceDiscoveryDelegate(this);

examples/chip-tool/commands/pairing/PairingCommand.h

@@ -180,6 +180,7 @@ class PairingCommand : public CHIPCommand,
             break;
         case chip::Dnssd::DiscoveryFilterType::kCommissioningMode:
         case chip::Dnssd::DiscoveryFilterType::kCommissioner:
+        case chip::Dnssd::DiscoveryFilterType::kJointFabricMode:
             break;
         case chip::Dnssd::DiscoveryFilterType::kDeviceType:
             AddArgument("device-type", 0, UINT16_MAX, &mDiscoveryFilterCode);

examples/fabric-admin/commands/pairing/PairingCommand.cpp

@@ -331,6 +331,9 @@ CHIP_ERROR PairingCommand::PairWithMdns(NodeId remoteId)
         filter.code         = 0;
         filter.instanceName = mDiscoveryFilterInstanceName;
         break;
+    case chip::Dnssd::DiscoveryFilterType::kJointFabricMode:
+        // TODO
+        break;
     }
 
     CurrentCommissioner().RegisterDeviceDiscoveryDelegate(this);

examples/fabric-admin/commands/pairing/PairingCommand.h

@@ -158,6 +158,7 @@ class PairingCommand : public CHIPCommand,
             break;
         case chip::Dnssd::DiscoveryFilterType::kCommissioningMode:
         case chip::Dnssd::DiscoveryFilterType::kCommissioner:
+        case chip::Dnssd::DiscoveryFilterType::kJointFabricMode:
             break;
         case chip::Dnssd::DiscoveryFilterType::kDeviceType:
             AddArgument("device-type", 0, UINT16_MAX, &mDiscoveryFilterCode);

examples/jf-admin-app/linux/JFAManager.cpp

@@ -40,6 +40,13 @@ CHIP_ERROR JFAManager::Init(Server & server)
     return CHIP_NO_ERROR;
 }
 
+CHIP_ERROR JFAManager::GetJointFabricMode(uint8_t & jointFabricMode)
+{
+    jointFabricMode = ((IsDeviceCommissioned() ? 0 : 1) << 0) | (IsDeviceCommissioned() ? (IsDeviceJFAdmin() ? (1 << 1) : 0) : 0) |
+        (IsDeviceCommissioned() ? (IsDeviceJFAnchor() ? (1 << 2) : 0) : 0) | (IsDeviceCommissioned() ? (1 << 3) : 0);
+    return CHIP_NO_ERROR;
+}
+
 CHIP_ERROR JFAManager::FinalizeCommissioning(NodeId nodeId)
 {
     if (jfFabricIndex == kUndefinedFabricId)
@@ -72,6 +79,46 @@ void JFAManager::HandleCommissioningCompleteEvent()
     }
 }
 
+bool JFAManager::IsDeviceJFAdmin()
+{
+    if (jfFabricIndex == kUndefinedFabricId)
+    {
+        return false;
+    }
+
+    CATValues cats;
+
+    if (mServer->GetFabricTable().FetchCATs(jfFabricIndex, cats) == CHIP_NO_ERROR)
+    {
+        if (cats.ContainsIdentifier(kAdminCATIdentifier))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool JFAManager::IsDeviceJFAnchor()
+{
+    if (jfFabricIndex == kUndefinedFabricId)
+    {
+        return false;
+    }
+
+    CATValues cats;
+
+    if (mServer->GetFabricTable().FetchCATs(jfFabricIndex, cats) == CHIP_NO_ERROR)
+    {
+        if (cats.ContainsIdentifier(kAnchorCATIdentifier))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 void JFAManager::ReleaseSession()
 {
     auto optionalSessionHandle = mSessionHolder.Get();