Matter SDK Coverage Report
Current view: top level - controller - CHIPDeviceController.cpp (source / functions) Coverage Total Hit
Test: SHA:a05e91d5c1f6f1949c49ee560f231875b462695e Lines: 0.2 % 1832 3
Test Date: 2025-09-17 07:11:20 Functions: 0.5 % 197 1

            Line data    Source code
       1              : /*
       2              :  *
       3              :  *    Copyright (c) 2020-2024 Project CHIP Authors
       4              :  *    Copyright (c) 2013-2017 Nest Labs, Inc.
       5              :  *    All rights reserved.
       6              :  *
       7              :  *    Licensed under the Apache License, Version 2.0 (the "License");
       8              :  *    you may not use this file except in compliance with the License.
       9              :  *    You may obtain a copy of the License at
      10              :  *
      11              :  *        http://www.apache.org/licenses/LICENSE-2.0
      12              :  *
      13              :  *    Unless required by applicable law or agreed to in writing, software
      14              :  *    distributed under the License is distributed on an "AS IS" BASIS,
      15              :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      16              :  *    See the License for the specific language governing permissions and
      17              :  *    limitations under the License.
      18              :  */
      19              : 
      20              : /**
      21              :  *    @file
      22              :  *      Implementation of CHIP Device Controller, a common class
      23              :  *      that implements discovery, pairing and provisioning of CHIP
      24              :  *      devices.
      25              :  *
      26              :  */
      27              : 
      28              : // module header, comes first
      29              : #include <controller/CHIPDeviceController.h>
      30              : 
      31              : #include <app-common/zap-generated/ids/Attributes.h>
      32              : #include <app-common/zap-generated/ids/Clusters.h>
      33              : 
      34              : #include <app/InteractionModelEngine.h>
      35              : #include <app/OperationalSessionSetup.h>
      36              : #include <app/server/Dnssd.h>
      37              : #include <controller/CurrentFabricRemover.h>
      38              : #include <controller/InvokeInteraction.h>
      39              : #include <controller/WriteInteraction.h>
      40              : #include <credentials/CHIPCert.h>
      41              : #include <credentials/DeviceAttestationCredsProvider.h>
      42              : #include <crypto/CHIPCryptoPAL.h>
      43              : #include <lib/core/CHIPCore.h>
      44              : #include <lib/core/CHIPEncoding.h>
      45              : #include <lib/core/CHIPSafeCasts.h>
      46              : #include <lib/core/ErrorStr.h>
      47              : #include <lib/core/NodeId.h>
      48              : #include <lib/support/Base64.h>
      49              : #include <lib/support/CHIPArgParser.hpp>
      50              : #include <lib/support/CHIPMem.h>
      51              : #include <lib/support/CodeUtils.h>
      52              : #include <lib/support/PersistentStorageMacros.h>
      53              : #include <lib/support/SafeInt.h>
      54              : #include <lib/support/ScopedBuffer.h>
      55              : #include <lib/support/ThreadOperationalDataset.h>
      56              : #include <lib/support/TimeUtils.h>
      57              : #include <lib/support/logging/CHIPLogging.h>
      58              : #include <messaging/ExchangeContext.h>
      59              : #include <platform/LockTracker.h>
      60              : #include <protocols/secure_channel/MessageCounterManager.h>
      61              : #include <setup_payload/QRCodeSetupPayloadParser.h>
      62              : #include <tracing/macros.h>
      63              : #include <tracing/metric_event.h>
      64              : 
      65              : #if CONFIG_NETWORK_LAYER_BLE
      66              : #include <ble/Ble.h>
      67              : #include <transport/raw/BLE.h>
      68              : #endif
      69              : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
      70              : #include <transport/raw/WiFiPAF.h>
      71              : #endif
      72              : 
      73              : #if CHIP_DEVICE_CONFIG_ENABLE_NFC_BASED_COMMISSIONING
      74              : #include <platform/internal/NFCCommissioningManager.h>
      75              : #endif
      76              : 
      77              : #include <algorithm>
      78              : #include <array>
      79              : #include <errno.h>
      80              : #include <inttypes.h>
      81              : #include <limits>
      82              : #include <memory>
      83              : #include <stdint.h>
      84              : #include <stdlib.h>
      85              : #include <string>
      86              : #include <time.h>
      87              : 
      88              : using namespace chip::app;
      89              : using namespace chip::app::Clusters;
      90              : using namespace chip::Inet;
      91              : using namespace chip::System;
      92              : using namespace chip::Transport;
      93              : using namespace chip::Credentials;
      94              : using namespace chip::Crypto;
      95              : using namespace chip::Tracing;
      96              : 
      97              : namespace chip {
      98              : namespace Controller {
      99              : 
     100              : using namespace chip::Encoding;
     101              : #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
     102              : using namespace chip::Protocols::UserDirectedCommissioning;
     103              : #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
     104              : 
     105           88 : DeviceController::DeviceController()
     106              : {
     107            8 :     mState = State::NotInitialized;
     108            8 : }
     109              : 
     110            0 : CHIP_ERROR DeviceController::Init(ControllerInitParams params)
     111              : {
     112            0 :     assertChipStackLockedByCurrentThread();
     113              : 
     114            0 :     VerifyOrReturnError(mState == State::NotInitialized, CHIP_ERROR_INCORRECT_STATE);
     115            0 :     VerifyOrReturnError(params.systemState != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     116              : 
     117            0 :     VerifyOrReturnError(params.systemState->SystemLayer() != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     118            0 :     VerifyOrReturnError(params.systemState->UDPEndPointManager() != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     119              : 
     120              : #if CONFIG_NETWORK_LAYER_BLE
     121            0 :     VerifyOrReturnError(params.systemState->BleLayer() != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     122              : #endif
     123              : 
     124            0 :     VerifyOrReturnError(params.systemState->TransportMgr() != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     125              : 
     126            0 :     ReturnErrorOnFailure(mDNSResolver.Init(params.systemState->UDPEndPointManager()));
     127            0 :     mDNSResolver.SetDiscoveryDelegate(this);
     128            0 :     RegisterDeviceDiscoveryDelegate(params.deviceDiscoveryDelegate);
     129              : 
     130            0 :     mVendorId = params.controllerVendorId;
     131            0 :     if (params.operationalKeypair != nullptr || !params.controllerNOC.empty() || !params.controllerRCAC.empty())
     132              :     {
     133            0 :         ReturnErrorOnFailure(InitControllerNOCChain(params));
     134              :     }
     135            0 :     else if (params.fabricIndex.HasValue())
     136              :     {
     137            0 :         VerifyOrReturnError(params.systemState->Fabrics()->FabricCount() > 0, CHIP_ERROR_INVALID_ARGUMENT);
     138            0 :         if (params.systemState->Fabrics()->FindFabricWithIndex(params.fabricIndex.Value()) != nullptr)
     139              :         {
     140            0 :             mFabricIndex = params.fabricIndex.Value();
     141              :         }
     142              :         else
     143              :         {
     144            0 :             ChipLogError(Controller, "There is no fabric corresponding to the given fabricIndex");
     145            0 :             return CHIP_ERROR_INVALID_ARGUMENT;
     146              :         }
     147              :     }
     148              : 
     149            0 :     mSystemState = params.systemState->Retain();
     150            0 :     mState       = State::Initialized;
     151              : 
     152            0 :     mRemoveFromFabricTableOnShutdown = params.removeFromFabricTableOnShutdown;
     153            0 :     mDeleteFromFabricTableOnShutdown = params.deleteFromFabricTableOnShutdown;
     154              : 
     155            0 :     if (GetFabricIndex() != kUndefinedFabricIndex)
     156              :     {
     157            0 :         ChipLogProgress(Controller,
     158              :                         "Joined the fabric at index %d. Fabric ID is 0x" ChipLogFormatX64
     159              :                         " (Compressed Fabric ID: " ChipLogFormatX64 ")",
     160              :                         GetFabricIndex(), ChipLogValueX64(GetFabricId()), ChipLogValueX64(GetCompressedFabricId()));
     161              :     }
     162              : 
     163            0 :     return CHIP_NO_ERROR;
     164              : }
     165              : 
     166            0 : CHIP_ERROR DeviceController::InitControllerNOCChain(const ControllerInitParams & params)
     167              : {
     168            0 :     FabricInfo newFabric;
     169            0 :     constexpr uint32_t chipCertAllocatedLen = kMaxCHIPCertLength;
     170            0 :     chip::Platform::ScopedMemoryBuffer<uint8_t> rcacBuf;
     171            0 :     chip::Platform::ScopedMemoryBuffer<uint8_t> icacBuf;
     172            0 :     chip::Platform::ScopedMemoryBuffer<uint8_t> nocBuf;
     173            0 :     Credentials::P256PublicKeySpan rootPublicKeySpan;
     174              :     FabricId fabricId;
     175              :     NodeId nodeId;
     176            0 :     bool hasExternallyOwnedKeypair                   = false;
     177            0 :     Crypto::P256Keypair * externalOperationalKeypair = nullptr;
     178            0 :     VendorId newFabricVendorId                       = params.controllerVendorId;
     179              : 
     180              :     // There are three possibilities here in terms of what happens with our
     181              :     // operational key:
     182              :     // 1) We have an externally owned operational keypair.
     183              :     // 2) We have an operational keypair that the fabric table should clone via
     184              :     //    serialize/deserialize.
     185              :     // 3) We have no keypair at all, and the fabric table has been initialized
     186              :     //    with a key store.
     187            0 :     if (params.operationalKeypair != nullptr)
     188              :     {
     189            0 :         hasExternallyOwnedKeypair  = params.hasExternallyOwnedOperationalKeypair;
     190            0 :         externalOperationalKeypair = params.operationalKeypair;
     191              :     }
     192              : 
     193            0 :     VerifyOrReturnError(rcacBuf.Alloc(chipCertAllocatedLen), CHIP_ERROR_NO_MEMORY);
     194            0 :     VerifyOrReturnError(icacBuf.Alloc(chipCertAllocatedLen), CHIP_ERROR_NO_MEMORY);
     195            0 :     VerifyOrReturnError(nocBuf.Alloc(chipCertAllocatedLen), CHIP_ERROR_NO_MEMORY);
     196              : 
     197            0 :     MutableByteSpan rcacSpan(rcacBuf.Get(), chipCertAllocatedLen);
     198              : 
     199            0 :     ReturnErrorOnFailure(ConvertX509CertToChipCert(params.controllerRCAC, rcacSpan));
     200            0 :     ReturnErrorOnFailure(Credentials::ExtractPublicKeyFromChipCert(rcacSpan, rootPublicKeySpan));
     201            0 :     Crypto::P256PublicKey rootPublicKey{ rootPublicKeySpan };
     202              : 
     203            0 :     MutableByteSpan icacSpan;
     204            0 :     if (params.controllerICAC.empty())
     205              :     {
     206            0 :         ChipLogProgress(Controller, "Intermediate CA is not needed");
     207              :     }
     208              :     else
     209              :     {
     210            0 :         icacSpan = MutableByteSpan(icacBuf.Get(), chipCertAllocatedLen);
     211            0 :         ReturnErrorOnFailure(ConvertX509CertToChipCert(params.controllerICAC, icacSpan));
     212              :     }
     213              : 
     214            0 :     MutableByteSpan nocSpan = MutableByteSpan(nocBuf.Get(), chipCertAllocatedLen);
     215              : 
     216            0 :     ReturnErrorOnFailure(ConvertX509CertToChipCert(params.controllerNOC, nocSpan));
     217            0 :     ReturnErrorOnFailure(ExtractNodeIdFabricIdFromOpCert(nocSpan, &nodeId, &fabricId));
     218              : 
     219            0 :     auto * fabricTable            = params.systemState->Fabrics();
     220            0 :     const FabricInfo * fabricInfo = nullptr;
     221              : 
     222              :     //
     223              :     // When multiple controllers are permitted on the same fabric, we need to find fabrics with
     224              :     // nodeId as an extra discriminant since we can have multiple FabricInfo objects that all
     225              :     // collide on the same fabric. Not doing so may result in a match with an existing FabricInfo
     226              :     // instance that matches the fabric in the provided NOC but is associated with a different NodeId
     227              :     // that is already in use by another active controller instance. That will effectively cause it
     228              :     // to change its identity inadvertently, which is not acceptable.
     229              :     //
     230              :     // TODO: Figure out how to clean up unreclaimed FabricInfos restored from persistent
     231              :     //       storage that are not in use by active DeviceController instances. Also, figure out
     232              :     //       how to reclaim FabricInfo slots when a DeviceController instance is deleted.
     233              :     //
     234            0 :     if (params.permitMultiControllerFabrics)
     235              :     {
     236            0 :         fabricInfo = fabricTable->FindIdentity(rootPublicKey, fabricId, nodeId);
     237              :     }
     238              :     else
     239              :     {
     240            0 :         fabricInfo = fabricTable->FindFabric(rootPublicKey, fabricId);
     241              :     }
     242              : 
     243            0 :     bool fabricFoundInTable = (fabricInfo != nullptr);
     244              : 
     245            0 :     FabricIndex fabricIndex = fabricFoundInTable ? fabricInfo->GetFabricIndex() : kUndefinedFabricIndex;
     246              : 
     247            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
     248              : 
     249            0 :     auto advertiseOperational =
     250            0 :         params.enableServerInteractions ? FabricTable::AdvertiseIdentity::Yes : FabricTable::AdvertiseIdentity::No;
     251              : 
     252              :     //
     253              :     // We permit colliding fabrics when multiple controllers are present on the same logical fabric
     254              :     // since each controller is associated with a unique FabricInfo 'identity' object and consequently,
     255              :     // a unique FabricIndex.
     256              :     //
     257              :     // This sets a flag that will be cleared automatically when the fabric is committed/reverted later
     258              :     // in this function.
     259              :     //
     260            0 :     if (params.permitMultiControllerFabrics)
     261              :     {
     262            0 :         fabricTable->PermitCollidingFabrics();
     263              :     }
     264              : 
     265              :     // We have 4 cases to handle legacy usage of direct operational key injection
     266            0 :     if (externalOperationalKeypair)
     267              :     {
     268              :         // Cases 1 and 2: Injected operational keys
     269              : 
     270              :         // CASE 1: Fabric update with injected key
     271            0 :         if (fabricFoundInTable)
     272              :         {
     273            0 :             err = fabricTable->UpdatePendingFabricWithProvidedOpKey(fabricIndex, nocSpan, icacSpan, externalOperationalKeypair,
     274              :                                                                     hasExternallyOwnedKeypair, advertiseOperational);
     275              :         }
     276              :         else
     277              :         // CASE 2: New fabric with injected key
     278              :         {
     279            0 :             err = fabricTable->AddNewPendingTrustedRootCert(rcacSpan);
     280            0 :             if (err == CHIP_NO_ERROR)
     281              :             {
     282            0 :                 err = fabricTable->AddNewPendingFabricWithProvidedOpKey(nocSpan, icacSpan, newFabricVendorId,
     283              :                                                                         externalOperationalKeypair, hasExternallyOwnedKeypair,
     284              :                                                                         &fabricIndex, advertiseOperational);
     285              :             }
     286              :         }
     287              :     }
     288              :     else
     289              :     {
     290              :         // Cases 3 and 4: OperationalKeystore has the keys
     291              : 
     292              :         // CASE 3: Fabric update with operational keystore
     293            0 :         if (fabricFoundInTable)
     294              :         {
     295            0 :             VerifyOrReturnError(fabricTable->HasOperationalKeyForFabric(fabricIndex), CHIP_ERROR_KEY_NOT_FOUND);
     296              : 
     297            0 :             err = fabricTable->UpdatePendingFabricWithOperationalKeystore(fabricIndex, nocSpan, icacSpan, advertiseOperational);
     298              :         }
     299              :         else
     300              :         // CASE 4: New fabric with operational keystore
     301              :         {
     302            0 :             err = fabricTable->AddNewPendingTrustedRootCert(rcacSpan);
     303            0 :             if (err == CHIP_NO_ERROR)
     304              :             {
     305            0 :                 err = fabricTable->AddNewPendingFabricWithOperationalKeystore(nocSpan, icacSpan, newFabricVendorId, &fabricIndex,
     306              :                                                                               advertiseOperational);
     307              :             }
     308              : 
     309            0 :             if (err == CHIP_NO_ERROR)
     310              :             {
     311              :                 // Now that we know our planned fabric index, verify that the
     312              :                 // keystore has a key for it.
     313            0 :                 if (!fabricTable->HasOperationalKeyForFabric(fabricIndex))
     314              :                 {
     315            0 :                     err = CHIP_ERROR_KEY_NOT_FOUND;
     316              :                 }
     317              :             }
     318              :         }
     319              :     }
     320              : 
     321              :     // Commit after setup, error-out on failure.
     322            0 :     if (err == CHIP_NO_ERROR)
     323              :     {
     324              :         // No need to revert on error: CommitPendingFabricData reverts internally on *any* error.
     325            0 :         err = fabricTable->CommitPendingFabricData();
     326              :     }
     327              :     else
     328              :     {
     329            0 :         fabricTable->RevertPendingFabricData();
     330              :     }
     331              : 
     332            0 :     ReturnErrorOnFailure(err);
     333            0 :     VerifyOrReturnError(fabricIndex != kUndefinedFabricIndex, CHIP_ERROR_INTERNAL);
     334              : 
     335            0 :     mFabricIndex       = fabricIndex;
     336            0 :     mAdvertiseIdentity = advertiseOperational;
     337            0 :     return CHIP_NO_ERROR;
     338            0 : }
     339              : 
     340            0 : CHIP_ERROR DeviceController::UpdateControllerNOCChain(const ByteSpan & noc, const ByteSpan & icac,
     341              :                                                       Crypto::P256Keypair * operationalKeypair,
     342              :                                                       bool operationalKeypairExternalOwned)
     343              : {
     344            0 :     VerifyOrReturnError(mFabricIndex != kUndefinedFabricIndex, CHIP_ERROR_INTERNAL);
     345            0 :     VerifyOrReturnError(mSystemState != nullptr, CHIP_ERROR_INTERNAL);
     346            0 :     FabricTable * fabricTable = mSystemState->Fabrics();
     347            0 :     CHIP_ERROR err            = CHIP_NO_ERROR;
     348              :     FabricId fabricId;
     349              :     NodeId nodeId;
     350            0 :     CATValues oldCats;
     351            0 :     CATValues newCats;
     352            0 :     ReturnErrorOnFailure(ExtractNodeIdFabricIdFromOpCert(noc, &nodeId, &fabricId));
     353            0 :     ReturnErrorOnFailure(fabricTable->FetchCATs(mFabricIndex, oldCats));
     354            0 :     ReturnErrorOnFailure(ExtractCATsFromOpCert(noc, newCats));
     355              : 
     356            0 :     bool needCloseSession = true;
     357            0 :     if (GetFabricInfo()->GetNodeId() == nodeId && oldCats == newCats)
     358              :     {
     359            0 :         needCloseSession = false;
     360              :     }
     361              : 
     362            0 :     if (operationalKeypair != nullptr)
     363              :     {
     364            0 :         err = fabricTable->UpdatePendingFabricWithProvidedOpKey(mFabricIndex, noc, icac, operationalKeypair,
     365              :                                                                 operationalKeypairExternalOwned, mAdvertiseIdentity);
     366              :     }
     367              :     else
     368              :     {
     369            0 :         VerifyOrReturnError(fabricTable->HasOperationalKeyForFabric(mFabricIndex), CHIP_ERROR_KEY_NOT_FOUND);
     370            0 :         err = fabricTable->UpdatePendingFabricWithOperationalKeystore(mFabricIndex, noc, icac, mAdvertiseIdentity);
     371              :     }
     372              : 
     373            0 :     if (err == CHIP_NO_ERROR)
     374              :     {
     375            0 :         err = fabricTable->CommitPendingFabricData();
     376              :     }
     377              :     else
     378              :     {
     379            0 :         fabricTable->RevertPendingFabricData();
     380              :     }
     381              : 
     382            0 :     ReturnErrorOnFailure(err);
     383            0 :     if (needCloseSession)
     384              :     {
     385              :         // If the node id or CATs have changed, our existing CASE sessions are no longer valid,
     386              :         // because the other side will think anything coming over those sessions comes from our
     387              :         // old node ID, and the new CATs might not satisfy the ACL requirements of the other side.
     388            0 :         mSystemState->SessionMgr()->ExpireAllSessionsForFabric(mFabricIndex);
     389              :     }
     390            0 :     ChipLogProgress(Controller, "Controller NOC chain has updated");
     391            0 :     return CHIP_NO_ERROR;
     392              : }
     393              : 
     394            0 : void DeviceController::Shutdown()
     395              : {
     396            0 :     assertChipStackLockedByCurrentThread();
     397              : 
     398            0 :     VerifyOrReturn(mState != State::NotInitialized);
     399              : 
     400              :     // If our state is initialialized it means mSystemState is valid,
     401              :     // and we can use it below before we release our reference to it.
     402            0 :     ChipLogDetail(Controller, "Shutting down the controller");
     403            0 :     mState = State::NotInitialized;
     404              : 
     405            0 :     if (mFabricIndex != kUndefinedFabricIndex)
     406              :     {
     407              :         // Shut down any subscription clients for this fabric.
     408            0 :         app::InteractionModelEngine::GetInstance()->ShutdownSubscriptions(mFabricIndex);
     409              : 
     410              :         // Shut down any ongoing CASE session activity we have.  We're going to
     411              :         // assume that all sessions for our fabric belong to us here.
     412            0 :         mSystemState->CASESessionMgr()->ReleaseSessionsForFabric(mFabricIndex);
     413              : 
     414              :         // Shut down any bdx transfers we're acting as the server for.
     415            0 :         mSystemState->BDXTransferServer()->AbortTransfersForFabric(mFabricIndex);
     416              : 
     417              :         // TODO: The CASE session manager does not shut down existing CASE
     418              :         // sessions.  It just shuts down any ongoing CASE session establishment
     419              :         // we're in the middle of as initiator.  Maybe it should shut down
     420              :         // existing sessions too?
     421            0 :         mSystemState->SessionMgr()->ExpireAllSessionsForFabric(mFabricIndex);
     422              : 
     423            0 :         if (mDeleteFromFabricTableOnShutdown)
     424              :         {
     425            0 :             mSystemState->Fabrics()->Delete(mFabricIndex);
     426              :         }
     427            0 :         else if (mRemoveFromFabricTableOnShutdown)
     428              :         {
     429            0 :             mSystemState->Fabrics()->Forget(mFabricIndex);
     430              :         }
     431              :     }
     432              : 
     433            0 :     mSystemState->Release();
     434            0 :     mSystemState = nullptr;
     435              : 
     436            0 :     mDNSResolver.Shutdown();
     437            0 :     mDeviceDiscoveryDelegate = nullptr;
     438              : }
     439              : 
     440            0 : CHIP_ERROR DeviceController::GetPeerAddressAndPort(NodeId peerId, Inet::IPAddress & addr, uint16_t & port)
     441              : {
     442            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
     443            0 :     Transport::PeerAddress peerAddr;
     444            0 :     ReturnErrorOnFailure(mSystemState->CASESessionMgr()->GetPeerAddress(GetPeerScopedId(peerId), peerAddr));
     445            0 :     addr = peerAddr.GetIPAddress();
     446            0 :     port = peerAddr.GetPort();
     447            0 :     return CHIP_NO_ERROR;
     448              : }
     449              : 
     450            0 : CHIP_ERROR DeviceController::GetPeerAddress(NodeId nodeId, Transport::PeerAddress & addr)
     451              : {
     452            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
     453            0 :     ReturnErrorOnFailure(mSystemState->CASESessionMgr()->GetPeerAddress(GetPeerScopedId(nodeId), addr));
     454              : 
     455            0 :     return CHIP_NO_ERROR;
     456              : }
     457              : 
     458            0 : CHIP_ERROR DeviceController::ComputePASEVerifier(uint32_t iterations, uint32_t setupPincode, const ByteSpan & salt,
     459              :                                                  Spake2pVerifier & outVerifier)
     460              : {
     461            0 :     ReturnErrorOnFailure(PASESession::GeneratePASEVerifier(outVerifier, iterations, salt, /* useRandomPIN= */ false, setupPincode));
     462              : 
     463            0 :     return CHIP_NO_ERROR;
     464              : }
     465              : 
     466            0 : ControllerDeviceInitParams DeviceController::GetControllerDeviceInitParams()
     467              : {
     468              :     return ControllerDeviceInitParams{
     469            0 :         .sessionManager = mSystemState->SessionMgr(),
     470            0 :         .exchangeMgr    = mSystemState->ExchangeMgr(),
     471            0 :     };
     472              : }
     473              : 
     474            0 : DeviceCommissioner::DeviceCommissioner() :
     475            0 :     mOnDeviceConnectedCallback(OnDeviceConnectedFn, this), mOnDeviceConnectionFailureCallback(OnDeviceConnectionFailureFn, this),
     476              : #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
     477            0 :     mOnDeviceConnectionRetryCallback(OnDeviceConnectionRetryFn, this),
     478              : #endif // CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
     479            0 :     mDeviceAttestationInformationVerificationCallback(OnDeviceAttestationInformationVerification, this),
     480            0 :     mDeviceNOCChainCallback(OnDeviceNOCChainGeneration, this), mSetUpCodePairer(this)
     481              : {
     482              : #if CHIP_DEVICE_CONFIG_ENABLE_JOINT_FABRIC
     483              :     (void) mPeerAdminJFAdminClusterEndpointId;
     484              : #endif // CHIP_DEVICE_CONFIG_ENABLE_JOINT_FABRIC
     485            0 : }
     486              : 
     487            0 : CHIP_ERROR DeviceCommissioner::Init(CommissionerInitParams params)
     488              : {
     489            0 :     VerifyOrReturnError(params.operationalCredentialsDelegate != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     490            0 :     mOperationalCredentialsDelegate = params.operationalCredentialsDelegate;
     491            0 :     ReturnErrorOnFailure(DeviceController::Init(params));
     492              : 
     493            0 :     mPairingDelegate = params.pairingDelegate;
     494              : 
     495              :     // Configure device attestation validation
     496            0 :     mDeviceAttestationVerifier = params.deviceAttestationVerifier;
     497            0 :     if (mDeviceAttestationVerifier == nullptr)
     498              :     {
     499            0 :         mDeviceAttestationVerifier = Credentials::GetDeviceAttestationVerifier();
     500            0 :         if (mDeviceAttestationVerifier == nullptr)
     501              :         {
     502            0 :             ChipLogError(Controller,
     503              :                          "Missing DeviceAttestationVerifier configuration at DeviceCommissioner init and none set with "
     504              :                          "Credentials::SetDeviceAttestationVerifier()!");
     505            0 :             return CHIP_ERROR_INVALID_ARGUMENT;
     506              :         }
     507              : 
     508              :         // We fell back on a default from singleton accessor.
     509            0 :         ChipLogProgress(Controller,
     510              :                         "*** Missing DeviceAttestationVerifier configuration at DeviceCommissioner init: using global default, "
     511              :                         "consider passing one in CommissionerInitParams.");
     512              :     }
     513              : 
     514            0 :     if (params.defaultCommissioner != nullptr)
     515              :     {
     516            0 :         mDefaultCommissioner = params.defaultCommissioner;
     517              :     }
     518              :     else
     519              :     {
     520            0 :         mDefaultCommissioner = &mAutoCommissioner;
     521              :     }
     522              : 
     523              : #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY // make this commissioner discoverable
     524              :     mUdcTransportMgr = chip::Platform::New<UdcTransportMgr>();
     525              :     ReturnErrorOnFailure(mUdcTransportMgr->Init(Transport::UdpListenParameters(mSystemState->UDPEndPointManager())
     526              :                                                     .SetAddressType(Inet::IPAddressType::kIPv6)
     527              :                                                     .SetListenPort(static_cast<uint16_t>(mUdcListenPort))
     528              : #if INET_CONFIG_ENABLE_IPV4
     529              :                                                     ,
     530              :                                                 Transport::UdpListenParameters(mSystemState->UDPEndPointManager())
     531              :                                                     .SetAddressType(Inet::IPAddressType::kIPv4)
     532              :                                                     .SetListenPort(static_cast<uint16_t>(mUdcListenPort))
     533              : #endif // INET_CONFIG_ENABLE_IPV4
     534              :                                                     ));
     535              : 
     536              :     mUdcServer = chip::Platform::New<UserDirectedCommissioningServer>();
     537              :     mUdcTransportMgr->SetSessionManager(mUdcServer);
     538              :     mUdcServer->SetTransportManager(mUdcTransportMgr);
     539              : 
     540              :     mUdcServer->SetInstanceNameResolver(this);
     541              : #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
     542              : 
     543            0 :     mSetUpCodePairer.SetSystemLayer(mSystemState->SystemLayer());
     544              : #if CONFIG_NETWORK_LAYER_BLE
     545            0 :     mSetUpCodePairer.SetBleLayer(mSystemState->BleLayer());
     546              : #endif // CONFIG_NETWORK_LAYER_BLE
     547              : 
     548            0 :     return CHIP_NO_ERROR;
     549              : }
     550              : 
     551            0 : void DeviceCommissioner::Shutdown()
     552              : {
     553            0 :     VerifyOrReturn(mState != State::NotInitialized);
     554              : 
     555            0 :     ChipLogDetail(Controller, "Shutting down the commissioner");
     556              : 
     557            0 :     mSetUpCodePairer.StopPairing();
     558              : 
     559              :     // Check to see if pairing in progress before shutting down
     560            0 :     CommissioneeDeviceProxy * device = mDeviceInPASEEstablishment;
     561            0 :     if (device != nullptr && device->IsSessionSetupInProgress())
     562              :     {
     563            0 :         ChipLogDetail(Controller, "Setup in progress, stopping setup before shutting down");
     564            0 :         OnSessionEstablishmentError(CHIP_ERROR_CONNECTION_ABORTED);
     565              :     }
     566              : 
     567            0 :     CancelCommissioningInteractions();
     568              : 
     569              : #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY // make this commissioner discoverable
     570              :     if (mUdcTransportMgr != nullptr)
     571              :     {
     572              :         chip::Platform::Delete(mUdcTransportMgr);
     573              :         mUdcTransportMgr = nullptr;
     574              :     }
     575              :     if (mUdcServer != nullptr)
     576              :     {
     577              :         mUdcServer->SetInstanceNameResolver(nullptr);
     578              :         chip::Platform::Delete(mUdcServer);
     579              :         mUdcServer = nullptr;
     580              :     }
     581              : #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
     582              : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     583            0 :     WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer().Shutdown(
     584            0 :         [](uint32_t id, WiFiPAF::WiFiPafRole role) { DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(id, role); });
     585              : #endif
     586              : 
     587              :     // Release everything from the commissionee device pool here.
     588              :     // Make sure to use ReleaseCommissioneeDevice so we don't keep dangling
     589              :     // pointers to the device objects.
     590            0 :     mCommissioneeDevicePool.ForEachActiveObject([this](auto * commissioneeDevice) {
     591            0 :         ReleaseCommissioneeDevice(commissioneeDevice);
     592            0 :         return Loop::Continue;
     593              :     });
     594              : 
     595            0 :     DeviceController::Shutdown();
     596              : }
     597              : 
     598            0 : CommissioneeDeviceProxy * DeviceCommissioner::FindCommissioneeDevice(NodeId id)
     599              : {
     600              :     MATTER_TRACE_SCOPE("FindCommissioneeDevice", "DeviceCommissioner");
     601            0 :     CommissioneeDeviceProxy * foundDevice = nullptr;
     602            0 :     mCommissioneeDevicePool.ForEachActiveObject([&](auto * deviceProxy) {
     603            0 :         if (deviceProxy->GetDeviceId() == id || deviceProxy->GetTemporaryCommissioningId() == id)
     604              :         {
     605            0 :             foundDevice = deviceProxy;
     606            0 :             return Loop::Break;
     607              :         }
     608            0 :         return Loop::Continue;
     609              :     });
     610              : 
     611            0 :     return foundDevice;
     612              : }
     613              : 
     614            0 : CommissioneeDeviceProxy * DeviceCommissioner::FindCommissioneeDevice(const Transport::PeerAddress & peerAddress)
     615              : {
     616            0 :     CommissioneeDeviceProxy * foundDevice = nullptr;
     617            0 :     mCommissioneeDevicePool.ForEachActiveObject([&](auto * deviceProxy) {
     618            0 :         if (deviceProxy->GetPeerAddress() == peerAddress)
     619              :         {
     620            0 :             foundDevice = deviceProxy;
     621            0 :             return Loop::Break;
     622              :         }
     623            0 :         return Loop::Continue;
     624              :     });
     625              : 
     626            0 :     return foundDevice;
     627              : }
     628              : 
     629            0 : void DeviceCommissioner::ReleaseCommissioneeDevice(CommissioneeDeviceProxy * device)
     630              : {
     631              : #if CONFIG_NETWORK_LAYER_BLE
     632            0 :     if (mSystemState->BleLayer() != nullptr && device->GetDeviceTransportType() == Transport::Type::kBle)
     633              :     {
     634              :         // We only support one BLE connection, so if this is BLE, close it
     635            0 :         ChipLogProgress(Discovery, "Closing all BLE connections");
     636            0 :         mSystemState->BleLayer()->CloseAllBleConnections();
     637              :     }
     638              : #endif
     639              : 
     640              : #if CHIP_DEVICE_CONFIG_ENABLE_NFC_BASED_COMMISSIONING
     641              :     Nfc::NFCReaderTransport * readerTransport = DeviceLayer::Internal::NFCCommissioningMgr().GetNFCReaderTransport();
     642              :     if (readerTransport)
     643              :     {
     644              :         ChipLogProgress(Controller, "Stopping discovery of all NFC tags");
     645              :         readerTransport->StopDiscoveringTags();
     646              :     }
     647              : #endif
     648              : 
     649              :     // Make sure that there will be no dangling pointer
     650            0 :     if (mDeviceInPASEEstablishment == device)
     651              :     {
     652            0 :         mDeviceInPASEEstablishment = nullptr;
     653              :     }
     654            0 :     if (mDeviceBeingCommissioned == device)
     655              :     {
     656            0 :         mDeviceBeingCommissioned = nullptr;
     657              :     }
     658              : 
     659              :     // Release the commissionee device after we have nulled out our pointers,
     660              :     // because that can call back in to us with error notifications as the
     661              :     // session is released.
     662            0 :     mCommissioneeDevicePool.ReleaseObject(device);
     663            0 : }
     664              : 
     665            0 : CHIP_ERROR DeviceCommissioner::GetDeviceBeingCommissioned(NodeId deviceId, CommissioneeDeviceProxy ** out_device)
     666              : {
     667            0 :     VerifyOrReturnError(out_device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     668            0 :     CommissioneeDeviceProxy * device = FindCommissioneeDevice(deviceId);
     669              : 
     670            0 :     VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     671              : 
     672            0 :     *out_device = device;
     673              : 
     674            0 :     return CHIP_NO_ERROR;
     675              : }
     676              : 
     677            0 : CHIP_ERROR DeviceCommissioner::PairDevice(NodeId remoteDeviceId, const char * setUpCode, const CommissioningParameters & params,
     678              :                                           DiscoveryType discoveryType, Optional<Dnssd::CommonResolutionData> resolutionData)
     679              : {
     680              :     MATTER_TRACE_SCOPE("PairDevice", "DeviceCommissioner");
     681              : 
     682            0 :     if (mDefaultCommissioner == nullptr)
     683              :     {
     684            0 :         ChipLogError(Controller, "No default commissioner is specified");
     685            0 :         return CHIP_ERROR_INCORRECT_STATE;
     686              :     }
     687            0 :     ReturnErrorOnFailure(mDefaultCommissioner->SetCommissioningParameters(params));
     688              : 
     689            0 :     return mSetUpCodePairer.PairDevice(remoteDeviceId, setUpCode, SetupCodePairerBehaviour::kCommission, discoveryType,
     690            0 :                                        resolutionData);
     691              : }
     692              : 
     693            0 : CHIP_ERROR DeviceCommissioner::PairDevice(NodeId remoteDeviceId, const char * setUpCode, DiscoveryType discoveryType,
     694              :                                           Optional<Dnssd::CommonResolutionData> resolutionData)
     695              : {
     696              :     MATTER_TRACE_SCOPE("PairDevice", "DeviceCommissioner");
     697            0 :     return mSetUpCodePairer.PairDevice(remoteDeviceId, setUpCode, SetupCodePairerBehaviour::kCommission, discoveryType,
     698            0 :                                        resolutionData);
     699              : }
     700              : 
     701            0 : CHIP_ERROR DeviceCommissioner::PairDevice(NodeId remoteDeviceId, RendezvousParameters & params)
     702              : {
     703              :     MATTER_TRACE_SCOPE("PairDevice", "DeviceCommissioner");
     704            0 :     ReturnErrorOnFailureWithMetric(kMetricDeviceCommissionerCommission, EstablishPASEConnection(remoteDeviceId, params));
     705            0 :     auto errorCode = Commission(remoteDeviceId);
     706            0 :     VerifyOrDoWithMetric(kMetricDeviceCommissionerCommission, CHIP_NO_ERROR == errorCode, errorCode);
     707            0 :     return errorCode;
     708              : }
     709              : 
     710            0 : CHIP_ERROR DeviceCommissioner::PairDevice(NodeId remoteDeviceId, RendezvousParameters & rendezvousParams,
     711              :                                           CommissioningParameters & commissioningParams)
     712              : {
     713              :     MATTER_TRACE_SCOPE("PairDevice", "DeviceCommissioner");
     714            0 :     ReturnErrorOnFailureWithMetric(kMetricDeviceCommissionerCommission, EstablishPASEConnection(remoteDeviceId, rendezvousParams));
     715            0 :     auto errorCode = Commission(remoteDeviceId, commissioningParams);
     716            0 :     VerifyOrDoWithMetric(kMetricDeviceCommissionerCommission, CHIP_NO_ERROR == errorCode, errorCode);
     717            0 :     return errorCode;
     718              : }
     719              : 
     720            0 : CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, const char * setUpCode, DiscoveryType discoveryType,
     721              :                                                        Optional<Dnssd::CommonResolutionData> resolutionData)
     722              : {
     723              :     MATTER_TRACE_SCOPE("EstablishPASEConnection", "DeviceCommissioner");
     724            0 :     return mSetUpCodePairer.PairDevice(remoteDeviceId, setUpCode, SetupCodePairerBehaviour::kPaseOnly, discoveryType,
     725            0 :                                        resolutionData);
     726              : }
     727              : 
     728            0 : CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, RendezvousParameters & params)
     729              : {
     730              :     MATTER_TRACE_SCOPE("EstablishPASEConnection", "DeviceCommissioner");
     731              :     MATTER_LOG_METRIC_BEGIN(kMetricDeviceCommissionerPASESession);
     732              : 
     733            0 :     CHIP_ERROR err                     = CHIP_NO_ERROR;
     734            0 :     CommissioneeDeviceProxy * device   = nullptr;
     735            0 :     CommissioneeDeviceProxy * current  = nullptr;
     736            0 :     Transport::PeerAddress peerAddress = Transport::PeerAddress::UDP(Inet::IPAddress::Any);
     737              : 
     738            0 :     Messaging::ExchangeContext * exchangeCtxt = nullptr;
     739            0 :     Optional<SessionHandle> session;
     740              : 
     741            0 :     VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
     742            0 :     VerifyOrExit(mDeviceInPASEEstablishment == nullptr, err = CHIP_ERROR_INCORRECT_STATE);
     743              : 
     744              :     // TODO(#13940): We need to specify the peer address for BLE transport in bindings.
     745            0 :     if (params.GetPeerAddress().GetTransportType() == Transport::Type::kBle ||
     746            0 :         params.GetPeerAddress().GetTransportType() == Transport::Type::kUndefined)
     747              :     {
     748              : #if CONFIG_NETWORK_LAYER_BLE
     749              : #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE
     750              :         ConnectBleTransportToSelf();
     751              : #endif // CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE
     752            0 :         if (!params.HasBleLayer())
     753              :         {
     754            0 :             params.SetPeerAddress(Transport::PeerAddress::BLE());
     755              :         }
     756            0 :         peerAddress = Transport::PeerAddress::BLE();
     757              : #endif // CONFIG_NETWORK_LAYER_BLE
     758              :     }
     759            0 :     else if (params.GetPeerAddress().GetTransportType() == Transport::Type::kTcp ||
     760            0 :              params.GetPeerAddress().GetTransportType() == Transport::Type::kUdp)
     761              :     {
     762            0 :         peerAddress = Transport::PeerAddress::UDP(params.GetPeerAddress().GetIPAddress(), params.GetPeerAddress().GetPort(),
     763            0 :                                                   params.GetPeerAddress().GetInterface());
     764              :     }
     765              : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     766            0 :     else if (params.GetPeerAddress().GetTransportType() == Transport::Type::kWiFiPAF)
     767              :     {
     768            0 :         peerAddress = Transport::PeerAddress::WiFiPAF(remoteDeviceId);
     769              :     }
     770              : #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     771              : 
     772            0 :     current = FindCommissioneeDevice(peerAddress);
     773            0 :     if (current != nullptr)
     774              :     {
     775            0 :         if (current->GetDeviceId() == remoteDeviceId)
     776              :         {
     777              :             // We might be able to just reuse its connection if it has one or is
     778              :             // working on one.
     779            0 :             if (current->IsSecureConnected())
     780              :             {
     781            0 :                 if (mPairingDelegate)
     782              :                 {
     783              :                     // We already have an open secure session to this device, call the callback immediately and early return.
     784              :                     // We don't know what the right RendezvousParameters are here.
     785            0 :                     mPairingDelegate->OnPairingComplete(CHIP_NO_ERROR, std::nullopt);
     786              :                 }
     787              :                 MATTER_LOG_METRIC_END(kMetricDeviceCommissionerPASESession, CHIP_NO_ERROR);
     788            0 :                 return CHIP_NO_ERROR;
     789              :             }
     790            0 :             if (current->IsSessionSetupInProgress())
     791              :             {
     792              :                 // We're not connected yet, but we're in the process of connecting. Pairing delegate will get a callback when
     793              :                 // connection completes
     794            0 :                 return CHIP_NO_ERROR;
     795              :             }
     796              :         }
     797              : 
     798              :         // Either the consumer wants to assign a different device id to this
     799              :         // peer address now (so we can't reuse the commissionee device we have
     800              :         // already) or something has gone strange. Delete the old device, try
     801              :         // again.
     802            0 :         ChipLogError(Controller, "Found unconnected device, removing");
     803            0 :         ReleaseCommissioneeDevice(current);
     804              :     }
     805              : 
     806            0 :     device = mCommissioneeDevicePool.CreateObject();
     807            0 :     VerifyOrExit(device != nullptr, err = CHIP_ERROR_NO_MEMORY);
     808              : 
     809            0 :     mDeviceInPASEEstablishment = device;
     810            0 :     device->Init(GetControllerDeviceInitParams(), remoteDeviceId, peerAddress);
     811            0 :     device->UpdateDeviceData(params.GetPeerAddress(), params.GetMRPConfig());
     812              : 
     813              : #if CONFIG_NETWORK_LAYER_BLE
     814            0 :     if (params.GetPeerAddress().GetTransportType() == Transport::Type::kBle)
     815              :     {
     816            0 :         if (params.HasConnectionObject())
     817              :         {
     818            0 :             SuccessOrExit(err = mSystemState->BleLayer()->NewBleConnectionByObject(params.GetConnectionObject()));
     819              :         }
     820            0 :         else if (params.HasDiscoveredObject())
     821              :         {
     822              :             // The RendezvousParameters argument needs to be recovered if the search succeed, so save them
     823              :             // for later.
     824            0 :             mRendezvousParametersForDeviceDiscoveredOverBle = params;
     825            0 :             SuccessOrExit(err = mSystemState->BleLayer()->NewBleConnectionByObject(params.GetDiscoveredObject(), this,
     826              :                                                                                    OnDiscoveredDeviceOverBleSuccess,
     827              :                                                                                    OnDiscoveredDeviceOverBleError));
     828            0 :             ExitNow(CHIP_NO_ERROR);
     829              :         }
     830            0 :         else if (params.HasDiscriminator())
     831              :         {
     832              :             // The RendezvousParameters argument needs to be recovered if the search succeed, so save them
     833              :             // for later.
     834            0 :             mRendezvousParametersForDeviceDiscoveredOverBle = params;
     835              : 
     836            0 :             SuccessOrExit(err = mSystemState->BleLayer()->NewBleConnectionByDiscriminator(params.GetSetupDiscriminator().value(),
     837              :                                                                                           this, OnDiscoveredDeviceOverBleSuccess,
     838              :                                                                                           OnDiscoveredDeviceOverBleError));
     839            0 :             ExitNow(CHIP_NO_ERROR);
     840              :         }
     841              :         else
     842              :         {
     843            0 :             ExitNow(err = CHIP_ERROR_INVALID_ARGUMENT);
     844              :         }
     845              :     }
     846              : #endif
     847              : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     848            0 :     if (params.GetPeerAddress().GetTransportType() == Transport::Type::kWiFiPAF)
     849              :     {
     850            0 :         if (DeviceLayer::ConnectivityMgr().GetWiFiPAF()->GetWiFiPAFState() != WiFiPAF::State::kConnected)
     851              :         {
     852            0 :             ChipLogProgress(Controller, "WiFi-PAF: Subscribing to the NAN-USD devices, nodeId: %lu",
     853              :                             params.GetPeerAddress().GetRemoteId());
     854            0 :             mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params;
     855            0 :             auto nodeId                                         = params.GetPeerAddress().GetRemoteId();
     856            0 :             const SetupDiscriminator connDiscriminator(params.GetSetupDiscriminator().value());
     857            0 :             VerifyOrReturnValue(!connDiscriminator.IsShortDiscriminator(), CHIP_ERROR_INVALID_ARGUMENT,
     858              :                                 ChipLogError(Controller, "Error, Long discriminator is required"));
     859            0 :             uint16_t discriminator              = connDiscriminator.GetLongValue();
     860            0 :             WiFiPAF::WiFiPAFSession sessionInfo = { .role          = WiFiPAF::WiFiPafRole::kWiFiPafRole_Subscriber,
     861              :                                                     .nodeId        = nodeId,
     862            0 :                                                     .discriminator = discriminator };
     863            0 :             ReturnErrorOnFailure(
     864              :                 DeviceLayer::ConnectivityMgr().GetWiFiPAF()->AddPafSession(WiFiPAF::PafInfoAccess::kAccNodeInfo, sessionInfo));
     865            0 :             DeviceLayer::ConnectivityMgr().WiFiPAFSubscribe(discriminator, reinterpret_cast<void *>(this),
     866              :                                                             OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError);
     867            0 :             ExitNow(CHIP_NO_ERROR);
     868              :         }
     869              :     }
     870              : #endif
     871            0 :     session = mSystemState->SessionMgr()->CreateUnauthenticatedSession(params.GetPeerAddress(), params.GetMRPConfig());
     872            0 :     VerifyOrExit(session.HasValue(), err = CHIP_ERROR_NO_MEMORY);
     873              : 
     874              :     // Allocate the exchange immediately before calling PASESession::Pair.
     875              :     //
     876              :     // PASESession::Pair takes ownership of the exchange and will free it on
     877              :     // error, but can only do this if it is actually called.  Allocating the
     878              :     // exchange context right before calling Pair ensures that if allocation
     879              :     // succeeds, PASESession has taken ownership.
     880            0 :     exchangeCtxt = mSystemState->ExchangeMgr()->NewContext(session.Value(), &device->GetPairing());
     881            0 :     VerifyOrExit(exchangeCtxt != nullptr, err = CHIP_ERROR_INTERNAL);
     882              : 
     883            0 :     err = device->GetPairing().Pair(*mSystemState->SessionMgr(), params.GetSetupPINCode(), GetLocalMRPConfig(), exchangeCtxt, this);
     884            0 :     SuccessOrExit(err);
     885              : 
     886            0 :     mRendezvousParametersForPASEEstablishment = params;
     887              : 
     888            0 : exit:
     889            0 :     if (err != CHIP_NO_ERROR)
     890              :     {
     891            0 :         if (device != nullptr)
     892              :         {
     893            0 :             ReleaseCommissioneeDevice(device);
     894              :         }
     895              :         MATTER_LOG_METRIC_END(kMetricDeviceCommissionerPASESession, err);
     896              :     }
     897              : 
     898            0 :     return err;
     899            0 : }
     900              : 
     901              : #if CONFIG_NETWORK_LAYER_BLE
     902            0 : void DeviceCommissioner::OnDiscoveredDeviceOverBleSuccess(void * appState, BLE_CONNECTION_OBJECT connObj)
     903              : {
     904            0 :     auto self   = static_cast<DeviceCommissioner *>(appState);
     905            0 :     auto device = self->mDeviceInPASEEstablishment;
     906              : 
     907            0 :     if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kBle)
     908              :     {
     909            0 :         auto remoteId = device->GetDeviceId();
     910              : 
     911            0 :         auto params = self->mRendezvousParametersForDeviceDiscoveredOverBle;
     912            0 :         params.SetConnectionObject(connObj);
     913            0 :         self->mRendezvousParametersForDeviceDiscoveredOverBle = RendezvousParameters();
     914              : 
     915            0 :         self->ReleaseCommissioneeDevice(device);
     916            0 :         LogErrorOnFailure(self->EstablishPASEConnection(remoteId, params));
     917              :     }
     918            0 : }
     919              : 
     920            0 : void DeviceCommissioner::OnDiscoveredDeviceOverBleError(void * appState, CHIP_ERROR err)
     921              : {
     922            0 :     auto self   = static_cast<DeviceCommissioner *>(appState);
     923            0 :     auto device = self->mDeviceInPASEEstablishment;
     924              : 
     925            0 :     if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kBle)
     926              :     {
     927            0 :         self->ReleaseCommissioneeDevice(device);
     928            0 :         self->mRendezvousParametersForDeviceDiscoveredOverBle = RendezvousParameters();
     929              : 
     930              :         // Callback is required when BLE discovery fails, otherwise the caller will always be in a suspended state
     931              :         // A better way to handle it should define a new error code
     932            0 :         if (self->mPairingDelegate != nullptr)
     933              :         {
     934            0 :             self->mPairingDelegate->OnPairingComplete(err, std::nullopt);
     935              :         }
     936              :     }
     937            0 : }
     938              : #endif // CONFIG_NETWORK_LAYER_BLE
     939              : 
     940              : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     941            0 : void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState)
     942              : {
     943            0 :     auto self   = reinterpret_cast<DeviceCommissioner *>(appState);
     944            0 :     auto device = self->mDeviceInPASEEstablishment;
     945              : 
     946            0 :     if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF)
     947              :     {
     948            0 :         ChipLogProgress(Controller, "WiFi-PAF: Subscription Completed, dev_id = %lu", device->GetDeviceId());
     949            0 :         auto remoteId = device->GetDeviceId();
     950            0 :         auto params   = self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF;
     951              : 
     952            0 :         self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = RendezvousParameters();
     953            0 :         self->ReleaseCommissioneeDevice(device);
     954            0 :         LogErrorOnFailure(self->EstablishPASEConnection(remoteId, params));
     955              :     }
     956            0 : }
     957              : 
     958            0 : void DeviceCommissioner::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err)
     959              : {
     960            0 :     auto self   = (DeviceCommissioner *) appState;
     961            0 :     auto device = self->mDeviceInPASEEstablishment;
     962              : 
     963            0 :     if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF)
     964              :     {
     965            0 :         ChipLogError(Controller, "WiFi-PAF: Subscription Error, id = %lu, err = %" CHIP_ERROR_FORMAT, device->GetDeviceId(),
     966              :                      err.Format());
     967            0 :         self->ReleaseCommissioneeDevice(device);
     968            0 :         self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = RendezvousParameters();
     969            0 :         if (self->mPairingDelegate != nullptr)
     970              :         {
     971            0 :             self->mPairingDelegate->OnPairingComplete(err, std::nullopt);
     972              :         }
     973              :     }
     974            0 : }
     975              : #endif
     976              : 
     977            0 : CHIP_ERROR DeviceCommissioner::Commission(NodeId remoteDeviceId, CommissioningParameters & params)
     978              : {
     979            0 :     if (mDefaultCommissioner == nullptr)
     980              :     {
     981            0 :         ChipLogError(Controller, "No default commissioner is specified");
     982            0 :         return CHIP_ERROR_INCORRECT_STATE;
     983              :     }
     984            0 :     ReturnErrorOnFailureWithMetric(kMetricDeviceCommissionerCommission, mDefaultCommissioner->SetCommissioningParameters(params));
     985            0 :     auto errorCode = Commission(remoteDeviceId);
     986            0 :     VerifyOrDoWithMetric(kMetricDeviceCommissionerCommission, CHIP_NO_ERROR == errorCode, errorCode);
     987            0 :     return errorCode;
     988              : }
     989              : 
     990            0 : CHIP_ERROR DeviceCommissioner::Commission(NodeId remoteDeviceId)
     991              : {
     992              :     MATTER_TRACE_SCOPE("Commission", "DeviceCommissioner");
     993              : 
     994            0 :     if (mDefaultCommissioner == nullptr)
     995              :     {
     996            0 :         ChipLogError(Controller, "No default commissioner is specified");
     997            0 :         return CHIP_ERROR_INCORRECT_STATE;
     998              :     }
     999              : 
    1000            0 :     CommissioneeDeviceProxy * device = FindCommissioneeDevice(remoteDeviceId);
    1001            0 :     if (device == nullptr || (!device->IsSecureConnected() && !device->IsSessionSetupInProgress()))
    1002              :     {
    1003            0 :         ChipLogError(Controller, "Invalid device for commissioning " ChipLogFormatX64, ChipLogValueX64(remoteDeviceId));
    1004            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1005              :     }
    1006            0 :     if (!device->IsSecureConnected() && device != mDeviceInPASEEstablishment)
    1007              :     {
    1008              :         // We should not end up in this state because we won't attempt to establish more than one connection at a time.
    1009            0 :         ChipLogError(Controller, "Device is not connected and not being paired " ChipLogFormatX64, ChipLogValueX64(remoteDeviceId));
    1010            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1011              :     }
    1012              : 
    1013            0 :     if (mCommissioningStage != CommissioningStage::kSecurePairing)
    1014              :     {
    1015            0 :         ChipLogError(Controller, "Commissioning already in progress (stage '%s') - not restarting",
    1016              :                      StageToString(mCommissioningStage));
    1017            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1018              :     }
    1019              : 
    1020            0 :     ChipLogProgress(Controller, "Commission called for node ID 0x" ChipLogFormatX64, ChipLogValueX64(remoteDeviceId));
    1021              : 
    1022            0 :     mDefaultCommissioner->SetOperationalCredentialsDelegate(mOperationalCredentialsDelegate);
    1023            0 :     if (device->IsSecureConnected())
    1024              :     {
    1025              :         MATTER_LOG_METRIC_BEGIN(kMetricDeviceCommissionerCommission);
    1026            0 :         mDefaultCommissioner->StartCommissioning(this, device);
    1027              :     }
    1028              :     else
    1029              :     {
    1030            0 :         mRunCommissioningAfterConnection = true;
    1031              :     }
    1032            0 :     return CHIP_NO_ERROR;
    1033              : }
    1034              : 
    1035              : CHIP_ERROR
    1036            0 : DeviceCommissioner::ContinueCommissioningAfterDeviceAttestation(DeviceProxy * device,
    1037              :                                                                 Credentials::AttestationVerificationResult attestationResult)
    1038              : {
    1039              :     MATTER_TRACE_SCOPE("continueCommissioningDevice", "DeviceCommissioner");
    1040              : 
    1041            0 :     if (mDefaultCommissioner == nullptr)
    1042              :     {
    1043            0 :         ChipLogError(Controller, "No default commissioner is specified");
    1044            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1045              :     }
    1046              : 
    1047            0 :     if (device == nullptr || device != mDeviceBeingCommissioned)
    1048              :     {
    1049            0 :         ChipLogError(Controller, "Invalid device for commissioning %p", device);
    1050            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1051              :     }
    1052            0 :     CommissioneeDeviceProxy * commissioneeDevice = FindCommissioneeDevice(device->GetDeviceId());
    1053            0 :     if (commissioneeDevice == nullptr)
    1054              :     {
    1055            0 :         ChipLogError(Controller, "Couldn't find commissionee device");
    1056            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1057              :     }
    1058            0 :     if (!commissioneeDevice->IsSecureConnected() || commissioneeDevice != mDeviceBeingCommissioned)
    1059              :     {
    1060            0 :         ChipLogError(Controller, "Invalid device for commissioning after attestation failure: 0x" ChipLogFormatX64,
    1061              :                      ChipLogValueX64(commissioneeDevice->GetDeviceId()));
    1062            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1063              :     }
    1064              : 
    1065            0 :     if (mCommissioningStage != CommissioningStage::kAttestationRevocationCheck)
    1066              :     {
    1067            0 :         ChipLogError(Controller, "Commissioning is not attestation verification phase");
    1068            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1069              :     }
    1070              : 
    1071            0 :     ChipLogProgress(Controller, "Continuing commissioning after attestation failure for device ID 0x" ChipLogFormatX64,
    1072              :                     ChipLogValueX64(commissioneeDevice->GetDeviceId()));
    1073              : 
    1074            0 :     if (attestationResult != AttestationVerificationResult::kSuccess)
    1075              :     {
    1076            0 :         ChipLogError(Controller, "Client selected error: %u for failed 'Attestation Information' for device",
    1077              :                      to_underlying(attestationResult));
    1078              : 
    1079            0 :         CommissioningDelegate::CommissioningReport report;
    1080            0 :         report.Set<AttestationErrorInfo>(attestationResult);
    1081            0 :         CommissioningStageComplete(CHIP_ERROR_INTERNAL, report);
    1082            0 :     }
    1083              :     else
    1084              :     {
    1085            0 :         ChipLogProgress(Controller, "Overriding attestation failure per client and continuing commissioning");
    1086            0 :         CommissioningStageComplete(CHIP_NO_ERROR);
    1087              :     }
    1088            0 :     return CHIP_NO_ERROR;
    1089              : }
    1090              : 
    1091              : #if CHIP_DEVICE_CONFIG_ENABLE_NFC_BASED_COMMISSIONING
    1092              : CHIP_ERROR DeviceCommissioner::ContinueCommissioningAfterConnectNetworkRequest(NodeId remoteDeviceId)
    1093              : {
    1094              :     MATTER_TRACE_SCOPE("continueCommissioningAfterConnectNetworkRequest", "DeviceCommissioner");
    1095              : 
    1096              :     if (mDefaultCommissioner == nullptr)
    1097              :     {
    1098              :         ChipLogError(Controller, "No default commissioner is specified");
    1099              :         return CHIP_ERROR_INCORRECT_STATE;
    1100              :     }
    1101              : 
    1102              :     // Move to kEvictPreviousCaseSessions stage since the next stage will be to find the device
    1103              :     // on the operational network
    1104              :     mCommissioningStage = CommissioningStage::kEvictPreviousCaseSessions;
    1105              : 
    1106              :     // Setup device being commissioned
    1107              :     CommissioneeDeviceProxy * device = nullptr;
    1108              :     if (!mDeviceBeingCommissioned)
    1109              :     {
    1110              :         device = mCommissioneeDevicePool.CreateObject();
    1111              :         if (!device)
    1112              :             return CHIP_ERROR_NO_MEMORY;
    1113              : 
    1114              :         Transport::PeerAddress peerAddress = Transport::PeerAddress::UDP(Inet::IPAddress::Any);
    1115              :         device->Init(GetControllerDeviceInitParams(), remoteDeviceId, peerAddress);
    1116              :         mDeviceBeingCommissioned = device;
    1117              :     }
    1118              : 
    1119              :     mDefaultCommissioner->SetOperationalCredentialsDelegate(mOperationalCredentialsDelegate);
    1120              : 
    1121              :     ChipLogProgress(Controller, "Continuing commissioning after connect to network complete for device ID 0x" ChipLogFormatX64,
    1122              :                     ChipLogValueX64(remoteDeviceId));
    1123              : 
    1124              :     MATTER_LOG_METRIC_BEGIN(kMetricDeviceCommissioningOperationalSetup);
    1125              :     CHIP_ERROR err = mDefaultCommissioner->StartCommissioning(this, device);
    1126              :     if (err != CHIP_NO_ERROR)
    1127              :     {
    1128              :         MATTER_LOG_METRIC_END(kMetricDeviceCommissioningOperationalSetup, err);
    1129              :     }
    1130              :     return err;
    1131              : }
    1132              : #endif
    1133              : 
    1134            0 : CHIP_ERROR DeviceCommissioner::StopPairing(NodeId remoteDeviceId)
    1135              : {
    1136            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
    1137            0 :     VerifyOrReturnError(remoteDeviceId != kUndefinedNodeId, CHIP_ERROR_INVALID_ARGUMENT);
    1138              : 
    1139            0 :     ChipLogProgress(Controller, "StopPairing called for node ID 0x" ChipLogFormatX64, ChipLogValueX64(remoteDeviceId));
    1140              : 
    1141              :     // If we're still in the process of discovering the device, just stop the SetUpCodePairer
    1142            0 :     if (mSetUpCodePairer.StopPairing(remoteDeviceId))
    1143              :     {
    1144            0 :         mRunCommissioningAfterConnection = false;
    1145            0 :         OnSessionEstablishmentError(CHIP_ERROR_CANCELLED);
    1146            0 :         return CHIP_NO_ERROR;
    1147              :     }
    1148              : 
    1149              :     // Otherwise we might be pairing and / or commissioning it.
    1150            0 :     CommissioneeDeviceProxy * device = FindCommissioneeDevice(remoteDeviceId);
    1151            0 :     VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR);
    1152              : 
    1153            0 :     if (mDeviceBeingCommissioned == device)
    1154              :     {
    1155            0 :         CancelCommissioningInteractions();
    1156            0 :         CommissioningStageComplete(CHIP_ERROR_CANCELLED);
    1157              :     }
    1158              :     else
    1159              :     {
    1160            0 :         ReleaseCommissioneeDevice(device);
    1161              :     }
    1162            0 :     return CHIP_NO_ERROR;
    1163              : }
    1164              : 
    1165            0 : void DeviceCommissioner::CancelCommissioningInteractions()
    1166              : {
    1167            0 :     if (mReadClient)
    1168              :     {
    1169            0 :         ChipLogDetail(Controller, "Cancelling read request for step '%s'", StageToString(mCommissioningStage));
    1170            0 :         mReadClient.reset(); // destructor cancels
    1171            0 :         mAttributeCache.reset();
    1172              :     }
    1173            0 :     if (mInvokeCancelFn)
    1174              :     {
    1175            0 :         ChipLogDetail(Controller, "Cancelling command invocation for step '%s'", StageToString(mCommissioningStage));
    1176            0 :         mInvokeCancelFn();
    1177            0 :         mInvokeCancelFn = nullptr;
    1178              :     }
    1179            0 :     if (mWriteCancelFn)
    1180              :     {
    1181            0 :         ChipLogDetail(Controller, "Cancelling write request for step '%s'", StageToString(mCommissioningStage));
    1182            0 :         mWriteCancelFn();
    1183            0 :         mWriteCancelFn = nullptr;
    1184              :     }
    1185            0 :     if (mOnDeviceConnectedCallback.IsRegistered())
    1186              :     {
    1187            0 :         ChipLogDetail(Controller, "Cancelling CASE setup for step '%s'", StageToString(mCommissioningStage));
    1188            0 :         CancelCASECallbacks();
    1189              :     }
    1190            0 : }
    1191              : 
    1192            0 : void DeviceCommissioner::CancelCASECallbacks()
    1193              : {
    1194            0 :     mOnDeviceConnectedCallback.Cancel();
    1195            0 :     mOnDeviceConnectionFailureCallback.Cancel();
    1196              : #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
    1197            0 :     mOnDeviceConnectionRetryCallback.Cancel();
    1198              : #endif
    1199            0 : }
    1200              : 
    1201            0 : CHIP_ERROR DeviceCommissioner::UnpairDevice(NodeId remoteDeviceId)
    1202              : {
    1203              :     MATTER_TRACE_SCOPE("UnpairDevice", "DeviceCommissioner");
    1204            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
    1205              : 
    1206            0 :     return AutoCurrentFabricRemover::RemoveCurrentFabric(this, remoteDeviceId);
    1207              : }
    1208              : 
    1209            0 : void DeviceCommissioner::RendezvousCleanup(CHIP_ERROR status)
    1210              : {
    1211            0 :     if (mDeviceInPASEEstablishment != nullptr)
    1212              :     {
    1213              :         // Release the commissionee device. For BLE, this is stored,
    1214              :         // for IP commissioning, we have taken a reference to the
    1215              :         // operational node to send the completion command.
    1216            0 :         ReleaseCommissioneeDevice(mDeviceInPASEEstablishment);
    1217              : 
    1218            0 :         if (mPairingDelegate != nullptr)
    1219              :         {
    1220            0 :             mPairingDelegate->OnPairingComplete(status, std::nullopt);
    1221              :         }
    1222              :     }
    1223            0 : }
    1224              : 
    1225            0 : void DeviceCommissioner::OnSessionEstablishmentError(CHIP_ERROR err)
    1226              : {
    1227              :     MATTER_LOG_METRIC_END(kMetricDeviceCommissionerPASESession, err);
    1228              : 
    1229            0 :     mRendezvousParametersForPASEEstablishment.reset();
    1230              : 
    1231            0 :     if (mPairingDelegate != nullptr)
    1232              :     {
    1233            0 :         mPairingDelegate->OnStatusUpdate(DevicePairingDelegate::SecurePairingFailed);
    1234              :     }
    1235              : 
    1236            0 :     RendezvousCleanup(err);
    1237            0 : }
    1238              : 
    1239            0 : void DeviceCommissioner::OnSessionEstablished(const SessionHandle & session)
    1240              : {
    1241              :     // PASE session established.
    1242            0 :     CommissioneeDeviceProxy * device = mDeviceInPASEEstablishment;
    1243              : 
    1244              :     // We are in the callback for this pairing. Reset so we can pair another device.
    1245            0 :     mDeviceInPASEEstablishment = nullptr;
    1246              : 
    1247              :     // Make sure to clear out mRendezvousParametersForPASEEstablishment no
    1248              :     // matter what.
    1249            0 :     std::optional<RendezvousParameters> paseParameters;
    1250            0 :     paseParameters.swap(mRendezvousParametersForPASEEstablishment);
    1251              : 
    1252            0 :     VerifyOrReturn(device != nullptr, OnSessionEstablishmentError(CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR));
    1253              : 
    1254            0 :     CHIP_ERROR err = device->SetConnected(session);
    1255            0 :     if (err != CHIP_NO_ERROR)
    1256              :     {
    1257            0 :         ChipLogError(Controller, "Failed in setting up secure channel: %" CHIP_ERROR_FORMAT, err.Format());
    1258            0 :         OnSessionEstablishmentError(err);
    1259            0 :         return;
    1260              :     }
    1261              : 
    1262            0 :     ChipLogDetail(Controller, "Remote device completed SPAKE2+ handshake");
    1263              : 
    1264              :     MATTER_LOG_METRIC_END(kMetricDeviceCommissionerPASESession, CHIP_NO_ERROR);
    1265            0 :     if (mPairingDelegate != nullptr)
    1266              :     {
    1267            0 :         mPairingDelegate->OnPairingComplete(CHIP_NO_ERROR, paseParameters);
    1268              :     }
    1269              : 
    1270            0 :     if (mRunCommissioningAfterConnection)
    1271              :     {
    1272            0 :         mRunCommissioningAfterConnection = false;
    1273              :         MATTER_LOG_METRIC_BEGIN(kMetricDeviceCommissionerCommission);
    1274            0 :         mDefaultCommissioner->StartCommissioning(this, device);
    1275              :     }
    1276              : }
    1277              : 
    1278            0 : CHIP_ERROR DeviceCommissioner::SendCertificateChainRequestCommand(DeviceProxy * device,
    1279              :                                                                   Credentials::CertificateType certificateType,
    1280              :                                                                   Optional<System::Clock::Timeout> timeout)
    1281              : {
    1282              :     MATTER_TRACE_SCOPE("SendCertificateChainRequestCommand", "DeviceCommissioner");
    1283            0 :     ChipLogDetail(Controller, "Sending Certificate Chain request to %p device", device);
    1284            0 :     VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
    1285              : 
    1286            0 :     OperationalCredentials::Commands::CertificateChainRequest::Type request;
    1287            0 :     request.certificateType = static_cast<OperationalCredentials::CertificateChainTypeEnum>(certificateType);
    1288            0 :     return SendCommissioningCommand(device, request, OnCertificateChainResponse, OnCertificateChainFailureResponse, kRootEndpointId,
    1289            0 :                                     timeout);
    1290              : }
    1291              : 
    1292            0 : void DeviceCommissioner::OnCertificateChainFailureResponse(void * context, CHIP_ERROR error)
    1293              : {
    1294              :     MATTER_TRACE_SCOPE("OnCertificateChainFailureResponse", "DeviceCommissioner");
    1295            0 :     ChipLogProgress(Controller, "Device failed to receive the Certificate Chain request Response: %" CHIP_ERROR_FORMAT,
    1296              :                     error.Format());
    1297            0 :     DeviceCommissioner * commissioner = reinterpret_cast<DeviceCommissioner *>(context);
    1298            0 :     commissioner->CommissioningStageComplete(error);
    1299            0 : }
    1300              : 
    1301            0 : void DeviceCommissioner::OnCertificateChainResponse(
    1302              :     void * context, const chip::app::Clusters::OperationalCredentials::Commands::CertificateChainResponse::DecodableType & response)
    1303              : {
    1304              :     MATTER_TRACE_SCOPE("OnCertificateChainResponse", "DeviceCommissioner");
    1305            0 :     ChipLogProgress(Controller, "Received certificate chain from the device");
    1306            0 :     DeviceCommissioner * commissioner = reinterpret_cast<DeviceCommissioner *>(context);
    1307              : 
    1308            0 :     CommissioningDelegate::CommissioningReport report;
    1309            0 :     report.Set<RequestedCertificate>(RequestedCertificate(response.certificate));
    1310              : 
    1311            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
    1312            0 : }
    1313              : 
    1314            0 : CHIP_ERROR DeviceCommissioner::SendAttestationRequestCommand(DeviceProxy * device, const ByteSpan & attestationNonce,
    1315              :                                                              Optional<System::Clock::Timeout> timeout)
    1316              : {
    1317              :     MATTER_TRACE_SCOPE("SendAttestationRequestCommand", "DeviceCommissioner");
    1318            0 :     ChipLogDetail(Controller, "Sending Attestation request to %p device", device);
    1319            0 :     VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
    1320              : 
    1321            0 :     OperationalCredentials::Commands::AttestationRequest::Type request;
    1322            0 :     request.attestationNonce = attestationNonce;
    1323              : 
    1324            0 :     ReturnErrorOnFailure(
    1325              :         SendCommissioningCommand(device, request, OnAttestationResponse, OnAttestationFailureResponse, kRootEndpointId, timeout));
    1326            0 :     ChipLogDetail(Controller, "Sent Attestation request, waiting for the Attestation Information");
    1327            0 :     return CHIP_NO_ERROR;
    1328              : }
    1329              : 
    1330            0 : void DeviceCommissioner::OnAttestationFailureResponse(void * context, CHIP_ERROR error)
    1331              : {
    1332              :     MATTER_TRACE_SCOPE("OnAttestationFailureResponse", "DeviceCommissioner");
    1333            0 :     ChipLogProgress(Controller, "Device failed to receive the Attestation Information Response: %" CHIP_ERROR_FORMAT,
    1334              :                     error.Format());
    1335            0 :     DeviceCommissioner * commissioner = reinterpret_cast<DeviceCommissioner *>(context);
    1336            0 :     commissioner->CommissioningStageComplete(error);
    1337            0 : }
    1338              : 
    1339            0 : void DeviceCommissioner::OnAttestationResponse(void * context,
    1340              :                                                const OperationalCredentials::Commands::AttestationResponse::DecodableType & data)
    1341              : {
    1342              :     MATTER_TRACE_SCOPE("OnAttestationResponse", "DeviceCommissioner");
    1343            0 :     ChipLogProgress(Controller, "Received Attestation Information from the device");
    1344            0 :     DeviceCommissioner * commissioner = reinterpret_cast<DeviceCommissioner *>(context);
    1345              : 
    1346            0 :     CommissioningDelegate::CommissioningReport report;
    1347            0 :     report.Set<AttestationResponse>(AttestationResponse(data.attestationElements, data.attestationSignature));
    1348            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
    1349            0 : }
    1350              : 
    1351            0 : void DeviceCommissioner::OnDeviceAttestationInformationVerification(
    1352              :     void * context, const Credentials::DeviceAttestationVerifier::AttestationInfo & info, AttestationVerificationResult result)
    1353              : {
    1354              :     MATTER_TRACE_SCOPE("OnDeviceAttestationInformationVerification", "DeviceCommissioner");
    1355            0 :     DeviceCommissioner * commissioner = reinterpret_cast<DeviceCommissioner *>(context);
    1356              : 
    1357            0 :     if (commissioner->mCommissioningStage == CommissioningStage::kAttestationVerification)
    1358              :     {
    1359              :         // Check for revoked DAC Chain before calling delegate. Enter next stage.
    1360              : 
    1361            0 :         CommissioningDelegate::CommissioningReport report;
    1362            0 :         report.Set<AttestationErrorInfo>(result);
    1363              : 
    1364            0 :         return commissioner->CommissioningStageComplete(
    1365            0 :             result == AttestationVerificationResult::kSuccess ? CHIP_NO_ERROR : CHIP_ERROR_FAILED_DEVICE_ATTESTATION, report);
    1366            0 :     }
    1367              : 
    1368            0 :     if (!commissioner->mDeviceBeingCommissioned)
    1369              :     {
    1370            0 :         ChipLogError(Controller, "Device attestation verification result received when we're not commissioning a device");
    1371            0 :         return;
    1372              :     }
    1373              : 
    1374            0 :     auto & params = commissioner->mDefaultCommissioner->GetCommissioningParameters();
    1375            0 :     Credentials::DeviceAttestationDelegate * deviceAttestationDelegate = params.GetDeviceAttestationDelegate();
    1376              : 
    1377            0 :     if (params.GetCompletionStatus().attestationResult.HasValue())
    1378              :     {
    1379            0 :         auto previousResult = params.GetCompletionStatus().attestationResult.Value();
    1380            0 :         if (previousResult != AttestationVerificationResult::kSuccess)
    1381              :         {
    1382            0 :             result = previousResult;
    1383              :         }
    1384              :     }
    1385              : 
    1386            0 :     if (result != AttestationVerificationResult::kSuccess)
    1387              :     {
    1388            0 :         CommissioningDelegate::CommissioningReport report;
    1389            0 :         report.Set<AttestationErrorInfo>(result);
    1390            0 :         if (result == AttestationVerificationResult::kNotImplemented)
    1391              :         {
    1392            0 :             ChipLogError(Controller,
    1393              :                          "Failed in verifying 'Attestation Information' command received from the device due to default "
    1394              :                          "DeviceAttestationVerifier Class not being overridden by a real implementation.");
    1395            0 :             commissioner->CommissioningStageComplete(CHIP_ERROR_NOT_IMPLEMENTED, report);
    1396            0 :             return;
    1397              :         }
    1398              : 
    1399            0 :         ChipLogError(Controller, "Failed in verifying 'Attestation Information' command received from the device: err %hu (%s)",
    1400              :                      static_cast<uint16_t>(result), GetAttestationResultDescription(result));
    1401              :         // Go look at AttestationVerificationResult enum in src/credentials/attestation_verifier/DeviceAttestationVerifier.h to
    1402              :         // understand the errors.
    1403              : 
    1404              :         // If a device attestation status delegate is installed, delegate handling of failure to the client and let them
    1405              :         // decide on whether to proceed further or not.
    1406            0 :         if (deviceAttestationDelegate)
    1407              :         {
    1408            0 :             commissioner->ExtendArmFailSafeForDeviceAttestation(info, result);
    1409              :         }
    1410              :         else
    1411              :         {
    1412            0 :             commissioner->CommissioningStageComplete(CHIP_ERROR_FAILED_DEVICE_ATTESTATION, report);
    1413              :         }
    1414            0 :     }
    1415              :     else
    1416              :     {
    1417            0 :         if (deviceAttestationDelegate && deviceAttestationDelegate->ShouldWaitAfterDeviceAttestation())
    1418              :         {
    1419            0 :             commissioner->ExtendArmFailSafeForDeviceAttestation(info, result);
    1420              :         }
    1421              :         else
    1422              :         {
    1423            0 :             ChipLogProgress(Controller, "Successfully validated 'Attestation Information' command received from the device.");
    1424            0 :             commissioner->CommissioningStageComplete(CHIP_NO_ERROR);
    1425              :         }
    1426              :     }
    1427              : }
    1428              : 
    1429            0 : void DeviceCommissioner::OnArmFailSafeExtendedForDeviceAttestation(
    1430              :     void * context, const GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType &)
    1431              : {
    1432            0 :     ChipLogProgress(Controller, "Successfully extended fail-safe timer to handle DA failure");
    1433            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1434              : 
    1435              :     // We have completed our command invoke, but we're not going to finish the
    1436              :     // commissioning step until our client examines the attestation
    1437              :     // information.  Clear out mInvokeCancelFn (which points at the
    1438              :     // CommandSender we just finished using) now, so it's not dangling.
    1439            0 :     commissioner->mInvokeCancelFn = nullptr;
    1440              : 
    1441            0 :     commissioner->HandleDeviceAttestationCompleted();
    1442            0 : }
    1443              : 
    1444            0 : void DeviceCommissioner::HandleDeviceAttestationCompleted()
    1445              : {
    1446            0 :     if (!mDeviceBeingCommissioned)
    1447              :     {
    1448            0 :         return;
    1449              :     }
    1450              : 
    1451            0 :     auto & params                                                      = mDefaultCommissioner->GetCommissioningParameters();
    1452            0 :     Credentials::DeviceAttestationDelegate * deviceAttestationDelegate = params.GetDeviceAttestationDelegate();
    1453            0 :     if (deviceAttestationDelegate)
    1454              :     {
    1455            0 :         ChipLogProgress(Controller, "Device attestation completed, delegating continuation to client");
    1456            0 :         deviceAttestationDelegate->OnDeviceAttestationCompleted(this, mDeviceBeingCommissioned, *mAttestationDeviceInfo,
    1457              :                                                                 mAttestationResult);
    1458              :     }
    1459              :     else
    1460              :     {
    1461            0 :         ChipLogError(Controller, "Need to wait for device attestation delegate, but no delegate available. Failing commissioning");
    1462            0 :         CommissioningDelegate::CommissioningReport report;
    1463            0 :         report.Set<AttestationErrorInfo>(mAttestationResult);
    1464            0 :         CommissioningStageComplete(CHIP_ERROR_INTERNAL, report);
    1465            0 :     }
    1466              : }
    1467              : 
    1468            0 : void DeviceCommissioner::OnFailedToExtendedArmFailSafeDeviceAttestation(void * context, CHIP_ERROR error)
    1469              : {
    1470            0 :     ChipLogProgress(Controller, "Failed to extend fail-safe timer to handle attestation failure: %" CHIP_ERROR_FORMAT,
    1471              :                     error.Format());
    1472            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1473              : 
    1474            0 :     CommissioningDelegate::CommissioningReport report;
    1475            0 :     report.Set<AttestationErrorInfo>(commissioner->mAttestationResult);
    1476            0 :     commissioner->CommissioningStageComplete(CHIP_ERROR_INTERNAL, report);
    1477            0 : }
    1478              : 
    1479            0 : void DeviceCommissioner::OnICDManagementRegisterClientResponse(
    1480              :     void * context, const app::Clusters::IcdManagement::Commands::RegisterClientResponse::DecodableType & data)
    1481              : {
    1482            0 :     CHIP_ERROR err                    = CHIP_NO_ERROR;
    1483            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1484            0 :     VerifyOrExit(commissioner != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
    1485            0 :     VerifyOrExit(commissioner->mCommissioningStage == CommissioningStage::kICDRegistration, err = CHIP_ERROR_INCORRECT_STATE);
    1486            0 :     VerifyOrExit(commissioner->mDeviceBeingCommissioned != nullptr, err = CHIP_ERROR_INCORRECT_STATE);
    1487              : 
    1488            0 :     if (commissioner->mPairingDelegate != nullptr)
    1489              :     {
    1490            0 :         commissioner->mPairingDelegate->OnICDRegistrationComplete(
    1491            0 :             ScopedNodeId(commissioner->mDeviceBeingCommissioned->GetDeviceId(), commissioner->GetFabricIndex()), data.ICDCounter);
    1492              :     }
    1493              : 
    1494            0 : exit:
    1495            0 :     CommissioningDelegate::CommissioningReport report;
    1496            0 :     commissioner->CommissioningStageComplete(err, report);
    1497            0 : }
    1498              : 
    1499            0 : void DeviceCommissioner::OnICDManagementStayActiveResponse(
    1500              :     void * context, const app::Clusters::IcdManagement::Commands::StayActiveResponse::DecodableType & data)
    1501              : {
    1502            0 :     CHIP_ERROR err                    = CHIP_NO_ERROR;
    1503            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1504            0 :     VerifyOrExit(commissioner != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
    1505            0 :     VerifyOrExit(commissioner->mCommissioningStage == CommissioningStage::kICDSendStayActive, err = CHIP_ERROR_INCORRECT_STATE);
    1506            0 :     VerifyOrExit(commissioner->mDeviceBeingCommissioned != nullptr, err = CHIP_ERROR_INCORRECT_STATE);
    1507              : 
    1508            0 :     if (commissioner->mPairingDelegate != nullptr)
    1509              :     {
    1510            0 :         commissioner->mPairingDelegate->OnICDStayActiveComplete(
    1511              : 
    1512            0 :             ScopedNodeId(commissioner->mDeviceBeingCommissioned->GetDeviceId(), commissioner->GetFabricIndex()),
    1513            0 :             data.promisedActiveDuration);
    1514              :     }
    1515              : 
    1516            0 : exit:
    1517            0 :     CommissioningDelegate::CommissioningReport report;
    1518            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
    1519            0 : }
    1520              : 
    1521            0 : bool DeviceCommissioner::ExtendArmFailSafeInternal(DeviceProxy * proxy, CommissioningStage step, uint16_t armFailSafeTimeout,
    1522              :                                                    Optional<System::Clock::Timeout> commandTimeout,
    1523              :                                                    OnExtendFailsafeSuccess onSuccess, OnExtendFailsafeFailure onFailure,
    1524              :                                                    bool fireAndForget)
    1525              : {
    1526              :     using namespace System;
    1527              :     using namespace System::Clock;
    1528            0 :     auto now                = SystemClock().GetMonotonicTimestamp();
    1529            0 :     auto newFailSafeTimeout = now + Seconds16(armFailSafeTimeout);
    1530            0 :     if (newFailSafeTimeout < proxy->GetFailSafeExpirationTimestamp())
    1531              :     {
    1532            0 :         ChipLogProgress(
    1533              :             Controller, "Skipping arming failsafe: new time (%u seconds from now) before old time (%u seconds from now)",
    1534              :             armFailSafeTimeout, std::chrono::duration_cast<Seconds16>(proxy->GetFailSafeExpirationTimestamp() - now).count());
    1535            0 :         return false;
    1536              :     }
    1537              : 
    1538            0 :     uint64_t breadcrumb = static_cast<uint64_t>(step);
    1539            0 :     GeneralCommissioning::Commands::ArmFailSafe::Type request;
    1540            0 :     request.expiryLengthSeconds = armFailSafeTimeout;
    1541            0 :     request.breadcrumb          = breadcrumb;
    1542            0 :     ChipLogProgress(Controller, "Arming failsafe (%u seconds)", request.expiryLengthSeconds);
    1543            0 :     CHIP_ERROR err = SendCommissioningCommand(proxy, request, onSuccess, onFailure, kRootEndpointId, commandTimeout, fireAndForget);
    1544            0 :     if (err != CHIP_NO_ERROR)
    1545              :     {
    1546            0 :         onFailure((!fireAndForget) ? this : nullptr, err);
    1547            0 :         return true; // we have called onFailure already
    1548              :     }
    1549              : 
    1550              :     // Note: The stored timestamp may become invalid if we fail asynchronously
    1551            0 :     proxy->SetFailSafeExpirationTimestamp(newFailSafeTimeout);
    1552            0 :     return true;
    1553              : }
    1554              : 
    1555            0 : void DeviceCommissioner::ExtendArmFailSafeForDeviceAttestation(const Credentials::DeviceAttestationVerifier::AttestationInfo & info,
    1556              :                                                                Credentials::AttestationVerificationResult result)
    1557              : {
    1558            0 :     mAttestationResult = result;
    1559              : 
    1560            0 :     auto & params                                                      = mDefaultCommissioner->GetCommissioningParameters();
    1561            0 :     Credentials::DeviceAttestationDelegate * deviceAttestationDelegate = params.GetDeviceAttestationDelegate();
    1562              : 
    1563            0 :     mAttestationDeviceInfo = Platform::MakeUnique<Credentials::DeviceAttestationVerifier::AttestationDeviceInfo>(info);
    1564              : 
    1565            0 :     auto expiryLengthSeconds      = deviceAttestationDelegate->FailSafeExpiryTimeoutSecs();
    1566            0 :     bool waitForFailsafeExtension = expiryLengthSeconds.HasValue();
    1567            0 :     if (waitForFailsafeExtension)
    1568              :     {
    1569            0 :         ChipLogProgress(Controller, "Changing fail-safe timer to %u seconds to handle DA failure", expiryLengthSeconds.Value());
    1570              :         // Per spec, anything we do with the fail-safe armed must not time out
    1571              :         // in less than kMinimumCommissioningStepTimeout.
    1572              :         waitForFailsafeExtension =
    1573            0 :             ExtendArmFailSafeInternal(mDeviceBeingCommissioned, mCommissioningStage, expiryLengthSeconds.Value(),
    1574            0 :                                       MakeOptional(kMinimumCommissioningStepTimeout), OnArmFailSafeExtendedForDeviceAttestation,
    1575              :                                       OnFailedToExtendedArmFailSafeDeviceAttestation, /* fireAndForget = */ false);
    1576              :     }
    1577              :     else
    1578              :     {
    1579            0 :         ChipLogProgress(Controller, "Proceeding without changing fail-safe timer value as delegate has not set it");
    1580              :     }
    1581              : 
    1582            0 :     if (!waitForFailsafeExtension)
    1583              :     {
    1584            0 :         HandleDeviceAttestationCompleted();
    1585              :     }
    1586            0 : }
    1587              : 
    1588            0 : CHIP_ERROR DeviceCommissioner::ValidateAttestationInfo(const Credentials::DeviceAttestationVerifier::AttestationInfo & info)
    1589              : {
    1590              :     MATTER_TRACE_SCOPE("ValidateAttestationInfo", "DeviceCommissioner");
    1591            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
    1592            0 :     VerifyOrReturnError(mDeviceAttestationVerifier != nullptr, CHIP_ERROR_INCORRECT_STATE);
    1593              : 
    1594            0 :     mDeviceAttestationVerifier->VerifyAttestationInformation(info, &mDeviceAttestationInformationVerificationCallback);
    1595              : 
    1596              :     // TODO: Validate Firmware Information
    1597              : 
    1598            0 :     return CHIP_NO_ERROR;
    1599              : }
    1600              : 
    1601              : CHIP_ERROR
    1602            0 : DeviceCommissioner::CheckForRevokedDACChain(const Credentials::DeviceAttestationVerifier::AttestationInfo & info)
    1603              : {
    1604              :     MATTER_TRACE_SCOPE("CheckForRevokedDACChain", "DeviceCommissioner");
    1605            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
    1606            0 :     VerifyOrReturnError(mDeviceAttestationVerifier != nullptr, CHIP_ERROR_INCORRECT_STATE);
    1607              : 
    1608            0 :     mDeviceAttestationVerifier->CheckForRevokedDACChain(info, &mDeviceAttestationInformationVerificationCallback);
    1609              : 
    1610            0 :     return CHIP_NO_ERROR;
    1611              : }
    1612              : 
    1613            0 : CHIP_ERROR DeviceCommissioner::ValidateCSR(DeviceProxy * proxy, const ByteSpan & NOCSRElements,
    1614              :                                            const ByteSpan & AttestationSignature, const ByteSpan & dac, const ByteSpan & csrNonce)
    1615              : {
    1616              :     MATTER_TRACE_SCOPE("ValidateCSR", "DeviceCommissioner");
    1617            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
    1618            0 :     VerifyOrReturnError(mDeviceAttestationVerifier != nullptr, CHIP_ERROR_INCORRECT_STATE);
    1619              : 
    1620            0 :     P256PublicKey dacPubkey;
    1621            0 :     ReturnErrorOnFailure(ExtractPubkeyFromX509Cert(dac, dacPubkey));
    1622              : 
    1623              :     // Retrieve attestation challenge
    1624              :     ByteSpan attestationChallenge =
    1625            0 :         proxy->GetSecureSession().Value()->AsSecureSession()->GetCryptoContext().GetAttestationChallenge();
    1626              : 
    1627              :     // The operational CA should also verify this on its end during NOC generation, if end-to-end attestation is desired.
    1628            0 :     return mDeviceAttestationVerifier->VerifyNodeOperationalCSRInformation(NOCSRElements, attestationChallenge,
    1629            0 :                                                                            AttestationSignature, dacPubkey, csrNonce);
    1630            0 : }
    1631              : 
    1632            0 : CHIP_ERROR DeviceCommissioner::SendOperationalCertificateSigningRequestCommand(DeviceProxy * device, const ByteSpan & csrNonce,
    1633              :                                                                                Optional<System::Clock::Timeout> timeout)
    1634              : {
    1635              :     MATTER_TRACE_SCOPE("SendOperationalCertificateSigningRequestCommand", "DeviceCommissioner");
    1636            0 :     ChipLogDetail(Controller, "Sending CSR request to %p device", device);
    1637            0 :     VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
    1638              : 
    1639            0 :     OperationalCredentials::Commands::CSRRequest::Type request;
    1640            0 :     request.CSRNonce = csrNonce;
    1641              : 
    1642            0 :     ReturnErrorOnFailure(SendCommissioningCommand(device, request, OnOperationalCertificateSigningRequest, OnCSRFailureResponse,
    1643              :                                                   kRootEndpointId, timeout));
    1644            0 :     ChipLogDetail(Controller, "Sent CSR request, waiting for the CSR");
    1645            0 :     return CHIP_NO_ERROR;
    1646              : }
    1647              : 
    1648            0 : void DeviceCommissioner::OnCSRFailureResponse(void * context, CHIP_ERROR error)
    1649              : {
    1650              :     MATTER_TRACE_SCOPE("OnCSRFailureResponse", "DeviceCommissioner");
    1651            0 :     ChipLogProgress(Controller, "Device failed to receive the CSR request Response: %" CHIP_ERROR_FORMAT, error.Format());
    1652            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1653            0 :     commissioner->CommissioningStageComplete(error);
    1654            0 : }
    1655              : 
    1656            0 : void DeviceCommissioner::OnOperationalCertificateSigningRequest(
    1657              :     void * context, const OperationalCredentials::Commands::CSRResponse::DecodableType & data)
    1658              : {
    1659              :     MATTER_TRACE_SCOPE("OnOperationalCertificateSigningRequest", "DeviceCommissioner");
    1660            0 :     ChipLogProgress(Controller, "Received certificate signing request from the device");
    1661            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1662              : 
    1663            0 :     CommissioningDelegate::CommissioningReport report;
    1664            0 :     report.Set<CSRResponse>(CSRResponse(data.NOCSRElements, data.attestationSignature));
    1665            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
    1666            0 : }
    1667              : 
    1668            0 : void DeviceCommissioner::OnDeviceNOCChainGeneration(void * context, CHIP_ERROR status, const ByteSpan & noc, const ByteSpan & icac,
    1669              :                                                     const ByteSpan & rcac, Optional<IdentityProtectionKeySpan> ipk,
    1670              :                                                     Optional<NodeId> adminSubject)
    1671              : {
    1672              :     MATTER_TRACE_SCOPE("OnDeviceNOCChainGeneration", "DeviceCommissioner");
    1673            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1674              : 
    1675              :     // The placeholder IPK is not satisfactory, but is there to fill the NocChain struct on error. It will still fail.
    1676            0 :     const uint8_t placeHolderIpk[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    1677              :                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
    1678            0 :     if (status == CHIP_NO_ERROR && !ipk.HasValue())
    1679              :     {
    1680            0 :         ChipLogError(Controller, "Did not have an IPK from the OperationalCredentialsIssuer! Cannot commission.");
    1681            0 :         status = CHIP_ERROR_INVALID_ARGUMENT;
    1682              :     }
    1683              : 
    1684            0 :     ChipLogProgress(Controller, "Received callback from the CA for NOC Chain generation. Status: %" CHIP_ERROR_FORMAT,
    1685              :                     status.Format());
    1686            0 :     if (status == CHIP_NO_ERROR && commissioner->mState != State::Initialized)
    1687              :     {
    1688            0 :         status = CHIP_ERROR_INCORRECT_STATE;
    1689              :     }
    1690            0 :     if (status != CHIP_NO_ERROR)
    1691              :     {
    1692            0 :         ChipLogError(Controller, "Failed in generating device's operational credentials. Error: %" CHIP_ERROR_FORMAT,
    1693              :                      status.Format());
    1694              :     }
    1695              : 
    1696              :     // TODO - Verify that the generated root cert matches with commissioner's root cert
    1697            0 :     CommissioningDelegate::CommissioningReport report;
    1698            0 :     report.Set<NocChain>(NocChain(noc, icac, rcac, ipk.HasValue() ? ipk.Value() : IdentityProtectionKeySpan(placeHolderIpk),
    1699            0 :                                   adminSubject.HasValue() ? adminSubject.Value() : commissioner->GetNodeId()));
    1700            0 :     commissioner->CommissioningStageComplete(status, report);
    1701            0 : }
    1702              : 
    1703            0 : CHIP_ERROR DeviceCommissioner::IssueNOCChain(const ByteSpan & NOCSRElements, NodeId nodeId,
    1704              :                                              chip::Callback::Callback<OnNOCChainGeneration> * callback)
    1705              : {
    1706              :     MATTER_TRACE_SCOPE("IssueNOCChain", "DeviceCommissioner");
    1707            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
    1708              : 
    1709            0 :     ChipLogProgress(Controller, "Getting certificate chain for the device on fabric idx %u", static_cast<unsigned>(mFabricIndex));
    1710              : 
    1711            0 :     mOperationalCredentialsDelegate->SetNodeIdForNextNOCRequest(nodeId);
    1712              : 
    1713            0 :     if (mFabricIndex != kUndefinedFabricIndex)
    1714              :     {
    1715            0 :         mOperationalCredentialsDelegate->SetFabricIdForNextNOCRequest(GetFabricId());
    1716              :     }
    1717              : 
    1718              :     // Note: we don't have attestationSignature, attestationChallenge, DAC, PAI so we are just providing an empty ByteSpan
    1719              :     // for those arguments.
    1720            0 :     return mOperationalCredentialsDelegate->GenerateNOCChain(NOCSRElements, ByteSpan(), ByteSpan(), ByteSpan(), ByteSpan(),
    1721            0 :                                                              ByteSpan(), callback);
    1722              : }
    1723              : 
    1724            0 : CHIP_ERROR DeviceCommissioner::ProcessCSR(DeviceProxy * proxy, const ByteSpan & NOCSRElements,
    1725              :                                           const ByteSpan & AttestationSignature, const ByteSpan & dac, const ByteSpan & pai,
    1726              :                                           const ByteSpan & csrNonce)
    1727              : {
    1728              :     MATTER_TRACE_SCOPE("ProcessOpCSR", "DeviceCommissioner");
    1729            0 :     VerifyOrReturnError(mState == State::Initialized, CHIP_ERROR_INCORRECT_STATE);
    1730              : 
    1731            0 :     ChipLogProgress(Controller, "Getting certificate chain for the device from the issuer");
    1732              : 
    1733            0 :     P256PublicKey dacPubkey;
    1734            0 :     ReturnErrorOnFailure(ExtractPubkeyFromX509Cert(dac, dacPubkey));
    1735              : 
    1736              :     // Retrieve attestation challenge
    1737              :     ByteSpan attestationChallenge =
    1738            0 :         proxy->GetSecureSession().Value()->AsSecureSession()->GetCryptoContext().GetAttestationChallenge();
    1739              : 
    1740            0 :     mOperationalCredentialsDelegate->SetNodeIdForNextNOCRequest(proxy->GetDeviceId());
    1741              : 
    1742            0 :     if (mFabricIndex != kUndefinedFabricIndex)
    1743              :     {
    1744            0 :         mOperationalCredentialsDelegate->SetFabricIdForNextNOCRequest(GetFabricId());
    1745              :     }
    1746              : 
    1747            0 :     return mOperationalCredentialsDelegate->GenerateNOCChain(NOCSRElements, csrNonce, AttestationSignature, attestationChallenge,
    1748            0 :                                                              dac, pai, &mDeviceNOCChainCallback);
    1749            0 : }
    1750              : 
    1751            0 : CHIP_ERROR DeviceCommissioner::SendOperationalCertificate(DeviceProxy * device, const ByteSpan & nocCertBuf,
    1752              :                                                           const Optional<ByteSpan> & icaCertBuf,
    1753              :                                                           const IdentityProtectionKeySpan ipk, const NodeId adminSubject,
    1754              :                                                           Optional<System::Clock::Timeout> timeout)
    1755              : {
    1756              :     MATTER_TRACE_SCOPE("SendOperationalCertificate", "DeviceCommissioner");
    1757              : 
    1758            0 :     VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
    1759              : 
    1760            0 :     OperationalCredentials::Commands::AddNOC::Type request;
    1761            0 :     request.NOCValue         = nocCertBuf;
    1762            0 :     request.ICACValue        = icaCertBuf;
    1763            0 :     request.IPKValue         = ipk;
    1764            0 :     request.caseAdminSubject = adminSubject;
    1765            0 :     request.adminVendorId    = mVendorId;
    1766              : 
    1767            0 :     ReturnErrorOnFailure(SendCommissioningCommand(device, request, OnOperationalCertificateAddResponse, OnAddNOCFailureResponse,
    1768              :                                                   kRootEndpointId, timeout));
    1769              : 
    1770            0 :     ChipLogProgress(Controller, "Sent operational certificate to the device");
    1771              : 
    1772            0 :     return CHIP_NO_ERROR;
    1773              : }
    1774              : 
    1775            0 : CHIP_ERROR DeviceCommissioner::ConvertFromOperationalCertStatus(OperationalCredentials::NodeOperationalCertStatusEnum err)
    1776              : {
    1777              :     using OperationalCredentials::NodeOperationalCertStatusEnum;
    1778            0 :     switch (err)
    1779              :     {
    1780            0 :     case NodeOperationalCertStatusEnum::kOk:
    1781            0 :         return CHIP_NO_ERROR;
    1782            0 :     case NodeOperationalCertStatusEnum::kInvalidPublicKey:
    1783            0 :         return CHIP_ERROR_INVALID_PUBLIC_KEY;
    1784            0 :     case NodeOperationalCertStatusEnum::kInvalidNodeOpId:
    1785            0 :         return CHIP_ERROR_WRONG_NODE_ID;
    1786            0 :     case NodeOperationalCertStatusEnum::kInvalidNOC:
    1787            0 :         return CHIP_ERROR_UNSUPPORTED_CERT_FORMAT;
    1788            0 :     case NodeOperationalCertStatusEnum::kMissingCsr:
    1789            0 :         return CHIP_ERROR_INCORRECT_STATE;
    1790            0 :     case NodeOperationalCertStatusEnum::kTableFull:
    1791            0 :         return CHIP_ERROR_NO_MEMORY;
    1792            0 :     case NodeOperationalCertStatusEnum::kInvalidAdminSubject:
    1793            0 :         return CHIP_ERROR_INVALID_ADMIN_SUBJECT;
    1794            0 :     case NodeOperationalCertStatusEnum::kFabricConflict:
    1795            0 :         return CHIP_ERROR_FABRIC_EXISTS;
    1796            0 :     case NodeOperationalCertStatusEnum::kLabelConflict:
    1797            0 :         return CHIP_ERROR_INVALID_ARGUMENT;
    1798            0 :     case NodeOperationalCertStatusEnum::kInvalidFabricIndex:
    1799            0 :         return CHIP_ERROR_INVALID_FABRIC_INDEX;
    1800            0 :     case NodeOperationalCertStatusEnum::kUnknownEnumValue:
    1801              :         // Is this a reasonable value?
    1802            0 :         return CHIP_ERROR_CERT_LOAD_FAILED;
    1803              :     }
    1804              : 
    1805            0 :     return CHIP_ERROR_CERT_LOAD_FAILED;
    1806              : }
    1807              : 
    1808            0 : void DeviceCommissioner::OnAddNOCFailureResponse(void * context, CHIP_ERROR error)
    1809              : {
    1810              :     MATTER_TRACE_SCOPE("OnAddNOCFailureResponse", "DeviceCommissioner");
    1811            0 :     ChipLogProgress(Controller, "Device failed to receive the operational certificate Response: %" CHIP_ERROR_FORMAT,
    1812              :                     error.Format());
    1813            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1814            0 :     commissioner->CommissioningStageComplete(error);
    1815            0 : }
    1816              : 
    1817            0 : void DeviceCommissioner::OnOperationalCertificateAddResponse(
    1818              :     void * context, const OperationalCredentials::Commands::NOCResponse::DecodableType & data)
    1819              : {
    1820              :     MATTER_TRACE_SCOPE("OnOperationalCertificateAddResponse", "DeviceCommissioner");
    1821            0 :     ChipLogProgress(Controller, "Device returned status %d on receiving the NOC", to_underlying(data.statusCode));
    1822            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1823              : 
    1824            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
    1825              : 
    1826            0 :     VerifyOrExit(commissioner->mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE);
    1827              : 
    1828            0 :     VerifyOrExit(commissioner->mDeviceBeingCommissioned != nullptr, err = CHIP_ERROR_INCORRECT_STATE);
    1829              : 
    1830            0 :     err = ConvertFromOperationalCertStatus(data.statusCode);
    1831            0 :     SuccessOrExit(err);
    1832              : 
    1833            0 :     err = commissioner->OnOperationalCredentialsProvisioningCompletion(commissioner->mDeviceBeingCommissioned);
    1834              : 
    1835            0 : exit:
    1836            0 :     if (err != CHIP_NO_ERROR)
    1837              :     {
    1838            0 :         ChipLogProgress(Controller, "Add NOC failed with error: %" CHIP_ERROR_FORMAT, err.Format());
    1839            0 :         commissioner->CommissioningStageComplete(err);
    1840              :     }
    1841            0 : }
    1842              : 
    1843            0 : CHIP_ERROR DeviceCommissioner::SendTrustedRootCertificate(DeviceProxy * device, const ByteSpan & rcac,
    1844              :                                                           Optional<System::Clock::Timeout> timeout)
    1845              : {
    1846              :     MATTER_TRACE_SCOPE("SendTrustedRootCertificate", "DeviceCommissioner");
    1847            0 :     VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
    1848              : 
    1849            0 :     ChipLogProgress(Controller, "Sending root certificate to the device");
    1850              : 
    1851            0 :     OperationalCredentials::Commands::AddTrustedRootCertificate::Type request;
    1852            0 :     request.rootCACertificate = rcac;
    1853            0 :     ReturnErrorOnFailure(
    1854              :         SendCommissioningCommand(device, request, OnRootCertSuccessResponse, OnRootCertFailureResponse, kRootEndpointId, timeout));
    1855              : 
    1856            0 :     ChipLogProgress(Controller, "Sent root certificate to the device");
    1857              : 
    1858            0 :     return CHIP_NO_ERROR;
    1859              : }
    1860              : 
    1861            0 : void DeviceCommissioner::OnRootCertSuccessResponse(void * context, const chip::app::DataModel::NullObjectType &)
    1862              : {
    1863              :     MATTER_TRACE_SCOPE("OnRootCertSuccessResponse", "DeviceCommissioner");
    1864            0 :     ChipLogProgress(Controller, "Device confirmed that it has received the root certificate");
    1865            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1866            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR);
    1867            0 : }
    1868              : 
    1869            0 : void DeviceCommissioner::OnRootCertFailureResponse(void * context, CHIP_ERROR error)
    1870              : {
    1871              :     MATTER_TRACE_SCOPE("OnRootCertFailureResponse", "DeviceCommissioner");
    1872            0 :     ChipLogProgress(Controller, "Device failed to receive the root certificate Response: %" CHIP_ERROR_FORMAT, error.Format());
    1873            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1874            0 :     commissioner->CommissioningStageComplete(error);
    1875            0 : }
    1876              : 
    1877            0 : CHIP_ERROR DeviceCommissioner::OnOperationalCredentialsProvisioningCompletion(DeviceProxy * device)
    1878              : {
    1879              :     MATTER_TRACE_SCOPE("OnOperationalCredentialsProvisioningCompletion", "DeviceCommissioner");
    1880            0 :     ChipLogProgress(Controller, "Operational credentials provisioned on device %p", device);
    1881            0 :     VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
    1882              : 
    1883            0 :     if (mPairingDelegate != nullptr)
    1884              :     {
    1885            0 :         mPairingDelegate->OnStatusUpdate(DevicePairingDelegate::SecurePairingSuccess);
    1886              :     }
    1887            0 :     CommissioningStageComplete(CHIP_NO_ERROR);
    1888              : 
    1889            0 :     return CHIP_NO_ERROR;
    1890              : }
    1891              : 
    1892              : #if CONFIG_NETWORK_LAYER_BLE
    1893              : #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE
    1894              : void DeviceCommissioner::ConnectBleTransportToSelf()
    1895              : {
    1896              :     Transport::BLEBase & transport = std::get<Transport::BLE<1>>(mSystemState->TransportMgr()->GetTransport().GetTransports());
    1897              :     if (!transport.IsBleLayerTransportSetToSelf())
    1898              :     {
    1899              :         transport.SetBleLayerTransportToSelf();
    1900              :     }
    1901              : }
    1902              : #endif // CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE
    1903              : 
    1904            0 : void DeviceCommissioner::CloseBleConnection()
    1905              : {
    1906              :     // It is fine since we can only commission one device at the same time.
    1907              :     // We should be able to distinguish different BLE connections if we want
    1908              :     // to commission multiple devices at the same time over BLE.
    1909            0 :     mSystemState->BleLayer()->CloseAllBleConnections();
    1910            0 : }
    1911              : #endif
    1912              : 
    1913            0 : CHIP_ERROR DeviceCommissioner::DiscoverCommissionableNodes(Dnssd::DiscoveryFilter filter)
    1914              : {
    1915            0 :     ReturnErrorOnFailure(SetUpNodeDiscovery());
    1916            0 :     return mDNSResolver.DiscoverCommissionableNodes(filter);
    1917              : }
    1918              : 
    1919            0 : CHIP_ERROR DeviceCommissioner::StopCommissionableDiscovery()
    1920              : {
    1921            0 :     return mDNSResolver.StopDiscovery();
    1922              : }
    1923              : 
    1924            0 : const Dnssd::CommissionNodeData * DeviceCommissioner::GetDiscoveredDevice(int idx)
    1925              : {
    1926            0 :     return GetDiscoveredNode(idx);
    1927              : }
    1928              : 
    1929              : #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY // make this commissioner discoverable
    1930              : 
    1931              : CHIP_ERROR DeviceCommissioner::SetUdcListenPort(uint16_t listenPort)
    1932              : {
    1933              :     if (mState == State::Initialized)
    1934              :     {
    1935              :         return CHIP_ERROR_INCORRECT_STATE;
    1936              :     }
    1937              : 
    1938              :     mUdcListenPort = listenPort;
    1939              :     return CHIP_NO_ERROR;
    1940              : }
    1941              : 
    1942              : void DeviceCommissioner::FindCommissionableNode(char * instanceName)
    1943              : {
    1944              :     Dnssd::DiscoveryFilter filter(Dnssd::DiscoveryFilterType::kInstanceName, instanceName);
    1945              :     DiscoverCommissionableNodes(filter);
    1946              : }
    1947              : 
    1948              : #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
    1949              : 
    1950            0 : void DeviceCommissioner::OnNodeDiscovered(const chip::Dnssd::DiscoveredNodeData & nodeData)
    1951              : {
    1952              : #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
    1953              :     if (mUdcServer != nullptr)
    1954              :     {
    1955              :         mUdcServer->OnCommissionableNodeFound(nodeData);
    1956              :     }
    1957              : #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
    1958            0 :     AbstractDnssdDiscoveryController::OnNodeDiscovered(nodeData);
    1959            0 :     mSetUpCodePairer.NotifyCommissionableDeviceDiscovered(nodeData);
    1960            0 : }
    1961              : 
    1962            0 : void DeviceCommissioner::OnBasicSuccess(void * context, const chip::app::DataModel::NullObjectType &)
    1963              : {
    1964            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1965            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR);
    1966            0 : }
    1967              : 
    1968            0 : void DeviceCommissioner::OnBasicFailure(void * context, CHIP_ERROR error)
    1969              : {
    1970            0 :     ChipLogProgress(Controller, "Received failure response: %" CHIP_ERROR_FORMAT, error.Format());
    1971            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    1972            0 :     commissioner->CommissioningStageComplete(error);
    1973            0 : }
    1974              : 
    1975            0 : static GeneralCommissioning::Commands::ArmFailSafe::Type DisarmFailsafeRequest()
    1976              : {
    1977            0 :     GeneralCommissioning::Commands::ArmFailSafe::Type request;
    1978            0 :     request.expiryLengthSeconds = 0; // Expire immediately.
    1979            0 :     request.breadcrumb          = 0;
    1980            0 :     return request;
    1981              : }
    1982              : 
    1983            0 : static void MarkForEviction(const Optional<SessionHandle> & session)
    1984              : {
    1985            0 :     if (session.HasValue())
    1986              :     {
    1987            0 :         session.Value()->AsSecureSession()->MarkForEviction();
    1988              :     }
    1989            0 : }
    1990              : 
    1991            0 : void DeviceCommissioner::CleanupCommissioning(DeviceProxy * proxy, NodeId nodeId, const CompletionStatus & completionStatus)
    1992              : {
    1993              :     // At this point, proxy == mDeviceBeingCommissioned, nodeId == mDeviceBeingCommissioned->GetDeviceId()
    1994              : 
    1995            0 :     mCommissioningCompletionStatus = completionStatus;
    1996              : 
    1997            0 :     if (completionStatus.err == CHIP_NO_ERROR)
    1998              :     {
    1999              :         // CommissioningStageComplete uses mDeviceBeingCommissioned, which can
    2000              :         // be commissionee if we are cleaning up before we've gone operational.  Normally
    2001              :         // that would not happen in this non-error case, _except_ if we were told to skip sending
    2002              :         // CommissioningComplete: in that case we do not have an operational DeviceProxy, so
    2003              :         // we're using our CommissioneeDeviceProxy to do a successful cleanup.
    2004              :         //
    2005              :         // This means we have to call CommissioningStageComplete() before we destroy commissionee.
    2006              :         //
    2007              :         // This should be safe, because CommissioningStageComplete() does not call CleanupCommissioning
    2008              :         // when called in the cleanup stage (which is where we are), and StopPairing does not directly release
    2009              :         // mDeviceBeingCommissioned.
    2010            0 :         CommissioningStageComplete(CHIP_NO_ERROR);
    2011              : 
    2012            0 :         CommissioneeDeviceProxy * commissionee = FindCommissioneeDevice(nodeId);
    2013            0 :         if (commissionee != nullptr)
    2014              :         {
    2015            0 :             ReleaseCommissioneeDevice(commissionee);
    2016              :         }
    2017              :         // Send the callbacks, we're done.
    2018            0 :         SendCommissioningCompleteCallbacks(nodeId, mCommissioningCompletionStatus);
    2019              :     }
    2020            0 :     else if (completionStatus.err == CHIP_ERROR_CANCELLED)
    2021              :     {
    2022              :         // If we're cleaning up because cancellation has been requested via StopPairing(), expire the failsafe
    2023              :         // in the background and reset our state synchronously, so a new commissioning attempt can be started.
    2024            0 :         CommissioneeDeviceProxy * commissionee = FindCommissioneeDevice(nodeId);
    2025            0 :         SessionHolder session((commissionee == proxy) ? commissionee->DetachSecureSession().Value()
    2026            0 :                                                       : proxy->GetSecureSession().Value());
    2027              : 
    2028            0 :         auto request     = DisarmFailsafeRequest();
    2029            0 :         auto onSuccessCb = [session](const app::ConcreteCommandPath & aPath, const app::StatusIB & aStatus,
    2030              :                                      const decltype(request)::ResponseType & responseData) {
    2031            0 :             ChipLogProgress(Controller, "Failsafe disarmed");
    2032            0 :             MarkForEviction(session.Get());
    2033            0 :         };
    2034            0 :         auto onFailureCb = [session](CHIP_ERROR aError) {
    2035            0 :             ChipLogProgress(Controller, "Ignoring failure to disarm failsafe: %" CHIP_ERROR_FORMAT, aError.Format());
    2036            0 :             MarkForEviction(session.Get());
    2037            0 :         };
    2038              : 
    2039            0 :         ChipLogProgress(Controller, "Disarming failsafe on device %p in background", proxy);
    2040            0 :         CHIP_ERROR err = InvokeCommandRequest(proxy->GetExchangeManager(), session.Get().Value(), kRootEndpointId, request,
    2041              :                                               onSuccessCb, onFailureCb);
    2042            0 :         if (err != CHIP_NO_ERROR)
    2043              :         {
    2044            0 :             ChipLogError(Controller, "Failed to send command to disarm fail-safe: %" CHIP_ERROR_FORMAT, err.Format());
    2045              :         }
    2046              : 
    2047            0 :         CleanupDoneAfterError();
    2048            0 :     }
    2049            0 :     else if (completionStatus.failedStage.HasValue() && completionStatus.failedStage.Value() >= kWiFiNetworkSetup)
    2050              :     {
    2051              :         // If we were already doing network setup, we need to retain the pase session and start again from network setup stage.
    2052              :         // We do not need to reset the failsafe here because we want to keep everything on the device up to this point, so just
    2053              :         // send the completion callbacks (see "Commissioning Flows Error Handling" in the spec).
    2054            0 :         CommissioningStageComplete(CHIP_NO_ERROR);
    2055            0 :         SendCommissioningCompleteCallbacks(nodeId, mCommissioningCompletionStatus);
    2056              :     }
    2057              :     else
    2058              :     {
    2059              :         // If we've failed somewhere in the early stages (or we don't have a failedStage specified), we need to start from the
    2060              :         // beginning. However, because some of the commands can only be sent once per arm-failsafe, we also need to force a reset on
    2061              :         // the failsafe so we can start fresh on the next attempt.
    2062            0 :         ChipLogProgress(Controller, "Disarming failsafe on device %p", proxy);
    2063            0 :         auto request   = DisarmFailsafeRequest();
    2064            0 :         CHIP_ERROR err = SendCommissioningCommand(proxy, request, OnDisarmFailsafe, OnDisarmFailsafeFailure, kRootEndpointId);
    2065            0 :         if (err != CHIP_NO_ERROR)
    2066              :         {
    2067              :             // We won't get any async callbacks here, so just pretend like the command errored out async.
    2068            0 :             ChipLogError(Controller, "Failed to send command to disarm fail-safe: %" CHIP_ERROR_FORMAT, err.Format());
    2069            0 :             CleanupDoneAfterError();
    2070              :         }
    2071              :     }
    2072            0 : }
    2073              : 
    2074            0 : void DeviceCommissioner::OnDisarmFailsafe(void * context,
    2075              :                                           const GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType & data)
    2076              : {
    2077            0 :     ChipLogProgress(Controller, "Failsafe disarmed");
    2078            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2079            0 :     commissioner->CleanupDoneAfterError();
    2080            0 : }
    2081              : 
    2082            0 : void DeviceCommissioner::OnDisarmFailsafeFailure(void * context, CHIP_ERROR error)
    2083              : {
    2084            0 :     ChipLogProgress(Controller, "Ignoring failure to disarm failsafe: %" CHIP_ERROR_FORMAT, error.Format());
    2085            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2086            0 :     commissioner->CleanupDoneAfterError();
    2087            0 : }
    2088              : 
    2089            0 : void DeviceCommissioner::CleanupDoneAfterError()
    2090              : {
    2091              :     // If someone nulled out our mDeviceBeingCommissioned, there's nothing else
    2092              :     // to do here.
    2093            0 :     VerifyOrReturn(mDeviceBeingCommissioned != nullptr);
    2094              : 
    2095            0 :     NodeId nodeId = mDeviceBeingCommissioned->GetDeviceId();
    2096              : 
    2097              :     // Signal completion - this will reset mDeviceBeingCommissioned.
    2098            0 :     CommissioningStageComplete(CHIP_NO_ERROR);
    2099              : 
    2100              :     // At this point, we also want to close off the pase session so we need to re-establish
    2101            0 :     CommissioneeDeviceProxy * commissionee = FindCommissioneeDevice(nodeId);
    2102              : 
    2103              :     // If we've disarmed the failsafe, it's because we're starting again, so kill the pase connection.
    2104            0 :     if (commissionee != nullptr)
    2105              :     {
    2106            0 :         ReleaseCommissioneeDevice(commissionee);
    2107              :     }
    2108              : 
    2109              :     // Invoke callbacks last, after we have cleared up all state.
    2110            0 :     SendCommissioningCompleteCallbacks(nodeId, mCommissioningCompletionStatus);
    2111              : }
    2112              : 
    2113            0 : void DeviceCommissioner::SendCommissioningCompleteCallbacks(NodeId nodeId, const CompletionStatus & completionStatus)
    2114              : {
    2115              :     MATTER_LOG_METRIC_END(kMetricDeviceCommissionerCommission, completionStatus.err);
    2116              : 
    2117            0 :     ChipLogProgress(Controller, "Commissioning complete for node ID 0x" ChipLogFormatX64 ": %s", ChipLogValueX64(nodeId),
    2118              :                     (completionStatus.err == CHIP_NO_ERROR ? "success" : completionStatus.err.AsString()));
    2119            0 :     mCommissioningStage = CommissioningStage::kSecurePairing;
    2120              : 
    2121            0 :     if (mPairingDelegate == nullptr)
    2122              :     {
    2123            0 :         return;
    2124              :     }
    2125              : 
    2126            0 :     mPairingDelegate->OnCommissioningComplete(nodeId, completionStatus.err);
    2127              : 
    2128            0 :     PeerId peerId(GetCompressedFabricId(), nodeId);
    2129            0 :     if (completionStatus.err == CHIP_NO_ERROR)
    2130              :     {
    2131            0 :         mPairingDelegate->OnCommissioningSuccess(peerId);
    2132              :     }
    2133              :     else
    2134              :     {
    2135              :         // TODO: We should propogate detailed error information (commissioningError, networkCommissioningStatus) from
    2136              :         // completionStatus.
    2137            0 :         mPairingDelegate->OnCommissioningFailure(peerId, completionStatus.err, completionStatus.failedStage.ValueOr(kError),
    2138            0 :                                                  completionStatus.attestationResult);
    2139              :     }
    2140              : }
    2141              : 
    2142            0 : void DeviceCommissioner::CommissioningStageComplete(CHIP_ERROR err, CommissioningDelegate::CommissioningReport report)
    2143              : {
    2144              :     // Once this stage is complete, reset mDeviceBeingCommissioned - this will be reset when the delegate calls the next step.
    2145              :     MATTER_TRACE_SCOPE("CommissioningStageComplete", "DeviceCommissioner");
    2146              :     MATTER_LOG_METRIC_END(MetricKeyForCommissioningStage(mCommissioningStage), err);
    2147            0 :     VerifyOrDie(mDeviceBeingCommissioned);
    2148              : 
    2149            0 :     NodeId nodeId            = mDeviceBeingCommissioned->GetDeviceId();
    2150            0 :     DeviceProxy * proxy      = mDeviceBeingCommissioned;
    2151            0 :     mDeviceBeingCommissioned = nullptr;
    2152            0 :     mInvokeCancelFn          = nullptr;
    2153            0 :     mWriteCancelFn           = nullptr;
    2154              : 
    2155            0 :     if (mPairingDelegate != nullptr)
    2156              :     {
    2157            0 :         mPairingDelegate->OnCommissioningStatusUpdate(PeerId(GetCompressedFabricId(), nodeId), mCommissioningStage, err);
    2158              :     }
    2159              : 
    2160            0 :     if (mCommissioningDelegate == nullptr)
    2161              :     {
    2162            0 :         return;
    2163              :     }
    2164            0 :     report.stageCompleted = mCommissioningStage;
    2165            0 :     CHIP_ERROR status     = mCommissioningDelegate->CommissioningStepFinished(err, report);
    2166            0 :     if (status != CHIP_NO_ERROR && mCommissioningStage != CommissioningStage::kCleanup)
    2167              :     {
    2168              :         // Commissioning delegate will only return error if it failed to perform the appropriate commissioning step.
    2169              :         // In this case, we should complete the commissioning for it.
    2170            0 :         CompletionStatus completionStatus;
    2171            0 :         completionStatus.err         = status;
    2172            0 :         completionStatus.failedStage = MakeOptional(report.stageCompleted);
    2173            0 :         mCommissioningStage          = CommissioningStage::kCleanup;
    2174            0 :         mDeviceBeingCommissioned     = proxy;
    2175            0 :         CleanupCommissioning(proxy, nodeId, completionStatus);
    2176              :     }
    2177              : }
    2178              : 
    2179            0 : void DeviceCommissioner::OnDeviceConnectedFn(void * context, Messaging::ExchangeManager & exchangeMgr,
    2180              :                                              const SessionHandle & sessionHandle)
    2181              : {
    2182              :     // CASE session established.
    2183              :     MATTER_LOG_METRIC_END(kMetricDeviceCommissioningOperationalSetup, CHIP_NO_ERROR);
    2184            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2185            0 :     VerifyOrDie(commissioner->mCommissioningStage == CommissioningStage::kFindOperationalForStayActive ||
    2186              :                 commissioner->mCommissioningStage == CommissioningStage::kFindOperationalForCommissioningComplete);
    2187            0 :     VerifyOrDie(commissioner->mDeviceBeingCommissioned->GetDeviceId() == sessionHandle->GetPeer().GetNodeId());
    2188            0 :     commissioner->CancelCASECallbacks(); // ensure all CASE callbacks are unregistered
    2189              : 
    2190            0 :     CommissioningDelegate::CommissioningReport report;
    2191            0 :     report.Set<OperationalNodeFoundData>(OperationalNodeFoundData(OperationalDeviceProxy(&exchangeMgr, sessionHandle)));
    2192            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
    2193            0 : }
    2194              : 
    2195            0 : void DeviceCommissioner::OnDeviceConnectionFailureFn(void * context, const ScopedNodeId & peerId, CHIP_ERROR error)
    2196              : {
    2197              :     // CASE session establishment failed.
    2198              :     MATTER_LOG_METRIC_END(kMetricDeviceCommissioningOperationalSetup, error);
    2199            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2200            0 :     VerifyOrDie(commissioner->mCommissioningStage == CommissioningStage::kFindOperationalForStayActive ||
    2201              :                 commissioner->mCommissioningStage == CommissioningStage::kFindOperationalForCommissioningComplete);
    2202            0 :     VerifyOrDie(commissioner->mDeviceBeingCommissioned->GetDeviceId() == peerId.GetNodeId());
    2203            0 :     commissioner->CancelCASECallbacks(); // ensure all CASE callbacks are unregistered
    2204              : 
    2205            0 :     if (error != CHIP_NO_ERROR)
    2206              :     {
    2207            0 :         ChipLogProgress(Controller, "Device connection failed. Error %" CHIP_ERROR_FORMAT, error.Format());
    2208              :     }
    2209              :     else
    2210              :     {
    2211              :         // Ensure that commissioning stage advancement is done based on seeing an error.
    2212            0 :         ChipLogError(Controller, "Device connection failed without a valid error code.");
    2213            0 :         error = CHIP_ERROR_INTERNAL;
    2214              :     }
    2215            0 :     commissioner->CommissioningStageComplete(error);
    2216            0 : }
    2217              : 
    2218              : #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
    2219              : // No specific action to take on either success or failure here; we're just
    2220              : // trying to bump the fail-safe, and if that fails it's not clear there's much
    2221              : // we can to with that.
    2222            0 : static void OnExtendFailsafeForCASERetryFailure(void * context, CHIP_ERROR error)
    2223              : {
    2224            0 :     ChipLogError(Controller, "Failed to extend fail-safe for CASE retry: %" CHIP_ERROR_FORMAT, error.Format());
    2225            0 : }
    2226              : static void
    2227            0 : OnExtendFailsafeForCASERetrySuccess(void * context,
    2228              :                                     const app::Clusters::GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType & data)
    2229              : {
    2230            0 :     ChipLogProgress(Controller, "Status of extending fail-safe for CASE retry: %u", to_underlying(data.errorCode));
    2231            0 : }
    2232              : 
    2233            0 : void DeviceCommissioner::OnDeviceConnectionRetryFn(void * context, const ScopedNodeId & peerId, CHIP_ERROR error,
    2234              :                                                    System::Clock::Seconds16 retryTimeout)
    2235              : {
    2236            0 :     ChipLogError(Controller,
    2237              :                  "Session establishment failed for " ChipLogFormatScopedNodeId ", error: %" CHIP_ERROR_FORMAT
    2238              :                  ".  Next retry expected to get a response to Sigma1 or fail within %d seconds",
    2239              :                  ChipLogValueScopedNodeId(peerId), error.Format(), retryTimeout.count());
    2240              : 
    2241            0 :     auto self = static_cast<DeviceCommissioner *>(context);
    2242            0 :     VerifyOrDie(self->GetCommissioningStage() == CommissioningStage::kFindOperationalForStayActive ||
    2243              :                 self->GetCommissioningStage() == CommissioningStage::kFindOperationalForCommissioningComplete);
    2244            0 :     VerifyOrDie(self->mDeviceBeingCommissioned->GetDeviceId() == peerId.GetNodeId());
    2245              : 
    2246              :     // We need to do the fail-safe arming over the PASE session.
    2247            0 :     auto * commissioneeDevice = self->FindCommissioneeDevice(peerId.GetNodeId());
    2248            0 :     if (!commissioneeDevice)
    2249              :     {
    2250              :         // Commissioning canceled, presumably.  Just ignore the notification,
    2251              :         // not much we can do here.
    2252            0 :         return;
    2253              :     }
    2254              : 
    2255              :     // Extend by the default failsafe timeout plus our retry timeout, so we can
    2256              :     // be sure the fail-safe will not expire before we try the next time, if
    2257              :     // there will be a next time.
    2258              :     //
    2259              :     // TODO: Make it possible for our clients to control the exact timeout here?
    2260              :     uint16_t failsafeTimeout;
    2261            0 :     if (UINT16_MAX - retryTimeout.count() < kDefaultFailsafeTimeout)
    2262              :     {
    2263            0 :         failsafeTimeout = UINT16_MAX;
    2264              :     }
    2265              :     else
    2266              :     {
    2267            0 :         failsafeTimeout = static_cast<uint16_t>(retryTimeout.count() + kDefaultFailsafeTimeout);
    2268              :     }
    2269              : 
    2270              :     // A false return is fine; we don't want to make the fail-safe shorter here.
    2271            0 :     self->ExtendArmFailSafeInternal(commissioneeDevice, self->GetCommissioningStage(), failsafeTimeout,
    2272            0 :                                     MakeOptional(kMinimumCommissioningStepTimeout), OnExtendFailsafeForCASERetrySuccess,
    2273              :                                     OnExtendFailsafeForCASERetryFailure, /* fireAndForget = */ true);
    2274              : }
    2275              : #endif // CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
    2276              : 
    2277              : // ClusterStateCache::Callback / ReadClient::Callback
    2278            0 : void DeviceCommissioner::OnDone(app::ReadClient * readClient)
    2279              : {
    2280            0 :     VerifyOrDie(readClient != nullptr && readClient == mReadClient.get());
    2281            0 :     mReadClient.reset();
    2282            0 :     switch (mCommissioningStage)
    2283              :     {
    2284            0 :     case CommissioningStage::kReadCommissioningInfo:
    2285            0 :         ContinueReadingCommissioningInfo(mCommissioningDelegate->GetCommissioningParameters());
    2286            0 :         break;
    2287            0 :     default:
    2288            0 :         VerifyOrDie(false);
    2289              :         break;
    2290              :     }
    2291            0 : }
    2292              : 
    2293              : namespace {
    2294              : // Helper for grouping attribute paths into read interactions in ContinueReadingCommissioningInfo()
    2295              : // below. The logic generates a sequence of calls to AddAttributePath(), stopping when the capacity
    2296              : // of the builder is exceeded. When creating subsequent read requests, the same sequence of calls
    2297              : // is generated again, but the builder will skip however many attributes were already read in
    2298              : // previous requests. This makes it easy to have logic that conditionally reads attributes, without
    2299              : // needing to write manual code to work out where subsequent reads need to resume -- the logic that
    2300              : // decides which attributes to read simply needs to be repeatable / deterministic.
    2301              : class ReadInteractionBuilder
    2302              : {
    2303              :     static constexpr auto kCapacity = InteractionModelEngine::kMinSupportedPathsPerReadRequest;
    2304              : 
    2305              :     size_t mSkip  = 0;
    2306              :     size_t mCount = 0;
    2307              :     app::AttributePathParams mPaths[kCapacity];
    2308              : 
    2309              : public:
    2310            0 :     ReadInteractionBuilder(size_t skip = 0) : mSkip(skip) {}
    2311              : 
    2312            0 :     size_t size() { return std::min(mCount, kCapacity); }
    2313            0 :     bool exceeded() { return mCount > kCapacity; }
    2314            0 :     app::AttributePathParams * paths() { return mPaths; }
    2315              : 
    2316              :     // Adds an attribute path if within the current window.
    2317              :     // Returns false if the available space has been exceeded.
    2318              :     template <typename... Ts>
    2319            0 :     bool AddAttributePath(Ts &&... args)
    2320              :     {
    2321            0 :         if (mSkip > 0)
    2322              :         {
    2323            0 :             mSkip--;
    2324            0 :             return true;
    2325              :         }
    2326            0 :         if (mCount >= kCapacity)
    2327              :         {
    2328              :             // capacity exceeded
    2329            0 :             mCount = kCapacity + 1;
    2330            0 :             return false;
    2331              :         }
    2332            0 :         mPaths[mCount++] = app::AttributePathParams(std::forward<Ts>(args)...);
    2333            0 :         return true;
    2334              :     }
    2335              : };
    2336              : } // namespace
    2337              : 
    2338            0 : void DeviceCommissioner::ContinueReadingCommissioningInfo(const CommissioningParameters & params)
    2339              : {
    2340            0 :     VerifyOrDie(mCommissioningStage == CommissioningStage::kReadCommissioningInfo);
    2341              : 
    2342              :     // mReadCommissioningInfoProgress starts at 0 and counts the number of paths we have read.
    2343              :     // A marker value is used to indicate that there are no further attributes to read.
    2344              :     static constexpr auto kReadProgressNoFurtherAttributes = std::numeric_limits<decltype(mReadCommissioningInfoProgress)>::max();
    2345            0 :     if (mReadCommissioningInfoProgress == kReadProgressNoFurtherAttributes)
    2346              :     {
    2347            0 :         FinishReadingCommissioningInfo(params);
    2348            0 :         return;
    2349              :     }
    2350              : 
    2351              :     // We can ony read 9 paths per Read Interaction, since that is the minimum a server has to
    2352              :     // support per spec (see "Interaction Model Limits"), so we generally need to perform more
    2353              :     // that one interaction. To build the list of attributes for each interaction, we use a
    2354              :     // builder that skips adding paths that we already handled in a previous interaction, and
    2355              :     // returns false if the current request is exhausted. This construction avoids allocating
    2356              :     // memory to hold the complete list of attributes to read up front; however the logic to
    2357              :     // determine the attributes to include must be deterministic since it runs multiple times.
    2358              :     // The use of an immediately-invoked lambda is convenient for control flow.
    2359            0 :     ReadInteractionBuilder builder(mReadCommissioningInfoProgress);
    2360            0 :     [&]() -> void {
    2361              :         // General Commissioning
    2362            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::GeneralCommissioning::Id,
    2363              :                                                 Clusters::GeneralCommissioning::Attributes::SupportsConcurrentConnection::Id));
    2364            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::GeneralCommissioning::Id,
    2365              :                                                 Clusters::GeneralCommissioning::Attributes::Breadcrumb::Id));
    2366            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::GeneralCommissioning::Id,
    2367              :                                                 Clusters::GeneralCommissioning::Attributes::BasicCommissioningInfo::Id));
    2368            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::GeneralCommissioning::Id,
    2369              :                                                 Clusters::GeneralCommissioning::Attributes::RegulatoryConfig::Id));
    2370            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::GeneralCommissioning::Id,
    2371              :                                                 Clusters::GeneralCommissioning::Attributes::LocationCapability::Id));
    2372            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::GeneralCommissioning::Id,
    2373              :                                                 Clusters::GeneralCommissioning::Attributes::IsCommissioningWithoutPower::Id));
    2374              : 
    2375              :         // Basic Information: VID and PID for device attestation purposes
    2376            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::BasicInformation::Id,
    2377              :                                                 Clusters::BasicInformation::Attributes::VendorID::Id));
    2378            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::BasicInformation::Id,
    2379              :                                                 Clusters::BasicInformation::Attributes::ProductID::Id));
    2380              : 
    2381              :         // Time Synchronization: all attributes
    2382            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::TimeSynchronization::Id));
    2383              : 
    2384              :         // Network Commissioning (all endpoints): Read the feature map and connect time
    2385              :         // TODO: Expose a flag that disables network setup so we don't need to read this
    2386            0 :         VerifyOrReturn(builder.AddAttributePath(Clusters::NetworkCommissioning::Id,
    2387              :                                                 Clusters::NetworkCommissioning::Attributes::FeatureMap::Id));
    2388            0 :         VerifyOrReturn(builder.AddAttributePath(Clusters::NetworkCommissioning::Id,
    2389              :                                                 Clusters::NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::Id));
    2390              : 
    2391              :         // If we were asked to do network scans, also read ScanMaxTimeSeconds,
    2392              :         // so we know how long to wait for those.
    2393            0 :         if (params.GetAttemptWiFiNetworkScan().ValueOr(false) || params.GetAttemptThreadNetworkScan().ValueOr(false))
    2394              :         {
    2395            0 :             VerifyOrReturn(builder.AddAttributePath(Clusters::NetworkCommissioning::Id,
    2396              :                                                     Clusters::NetworkCommissioning::Attributes::ScanMaxTimeSeconds::Id));
    2397              :         }
    2398              : 
    2399              :         // OperationalCredentials: existing fabrics, if necessary
    2400            0 :         if (params.GetCheckForMatchingFabric())
    2401              :         {
    2402            0 :             VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::OperationalCredentials::Id,
    2403              :                                                     Clusters::OperationalCredentials::Attributes::Fabrics::Id));
    2404              :         }
    2405              : 
    2406              :         // ICD Management
    2407            0 :         if (params.GetICDRegistrationStrategy() != ICDRegistrationStrategy::kIgnore)
    2408              :         {
    2409            0 :             VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::IcdManagement::Id,
    2410              :                                                     Clusters::IcdManagement::Attributes::FeatureMap::Id));
    2411              :         }
    2412            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::IcdManagement::Id,
    2413              :                                                 Clusters::IcdManagement::Attributes::UserActiveModeTriggerHint::Id));
    2414            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::IcdManagement::Id,
    2415              :                                                 Clusters::IcdManagement::Attributes::UserActiveModeTriggerInstruction::Id));
    2416            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::IcdManagement::Id,
    2417              :                                                 Clusters::IcdManagement::Attributes::IdleModeDuration::Id));
    2418            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::IcdManagement::Id,
    2419              :                                                 Clusters::IcdManagement::Attributes::ActiveModeDuration::Id));
    2420            0 :         VerifyOrReturn(builder.AddAttributePath(kRootEndpointId, Clusters::IcdManagement::Id,
    2421              :                                                 Clusters::IcdManagement::Attributes::ActiveModeThreshold::Id));
    2422              : 
    2423              :         // Extra paths requested via CommissioningParameters
    2424            0 :         for (auto const & path : params.GetExtraReadPaths())
    2425              :         {
    2426            0 :             VerifyOrReturn(builder.AddAttributePath(path));
    2427              :         }
    2428            0 :     }();
    2429              : 
    2430            0 :     VerifyOrDie(builder.size() > 0); // our logic is broken if there is nothing to read
    2431            0 :     if (builder.exceeded())
    2432              :     {
    2433              :         // Keep track of the number of attributes we have read already so we can resume from there.
    2434            0 :         auto progress = mReadCommissioningInfoProgress + builder.size();
    2435            0 :         VerifyOrDie(progress < kReadProgressNoFurtherAttributes);
    2436            0 :         mReadCommissioningInfoProgress = static_cast<decltype(mReadCommissioningInfoProgress)>(progress);
    2437              :     }
    2438              :     else
    2439              :     {
    2440            0 :         mReadCommissioningInfoProgress = kReadProgressNoFurtherAttributes;
    2441              :     }
    2442              : 
    2443            0 :     SendCommissioningReadRequest(mDeviceBeingCommissioned, mCommissioningStepTimeout, builder.paths(), builder.size());
    2444              : }
    2445              : 
    2446              : namespace {
    2447            0 : void AccumulateErrors(CHIP_ERROR & acc, CHIP_ERROR err)
    2448              : {
    2449            0 :     if (acc == CHIP_NO_ERROR && err != CHIP_NO_ERROR)
    2450              :     {
    2451            0 :         acc = err;
    2452              :     }
    2453            0 : }
    2454              : } // namespace
    2455              : 
    2456            0 : void DeviceCommissioner::FinishReadingCommissioningInfo(const CommissioningParameters & params)
    2457              : {
    2458              :     // We want to parse as much information as possible, even if we eventually end
    2459              :     // up returning an error (e.g. because some mandatory information was missing).
    2460            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
    2461            0 :     ReadCommissioningInfo info;
    2462            0 :     info.attributes = mAttributeCache.get();
    2463            0 :     AccumulateErrors(err, ParseGeneralCommissioningInfo(info));
    2464            0 :     AccumulateErrors(err, ParseBasicInformation(info));
    2465            0 :     AccumulateErrors(err, ParseNetworkCommissioningInfo(info));
    2466            0 :     AccumulateErrors(err, ParseTimeSyncInfo(info));
    2467            0 :     AccumulateErrors(err, ParseFabrics(info));
    2468            0 :     AccumulateErrors(err, ParseICDInfo(info));
    2469            0 :     AccumulateErrors(err, ParseExtraCommissioningInfo(info, params));
    2470              : 
    2471            0 :     if (mPairingDelegate != nullptr && err == CHIP_NO_ERROR)
    2472              :     {
    2473            0 :         mPairingDelegate->OnReadCommissioningInfo(info);
    2474              :     }
    2475              : 
    2476            0 :     CommissioningDelegate::CommissioningReport report;
    2477            0 :     report.Set<ReadCommissioningInfo>(info);
    2478            0 :     CommissioningStageComplete(err, report);
    2479              : 
    2480              :     // Only release the attribute cache once `info` is no longer needed.
    2481            0 :     mAttributeCache.reset();
    2482            0 : }
    2483              : 
    2484            0 : CHIP_ERROR DeviceCommissioner::ParseGeneralCommissioningInfo(ReadCommissioningInfo & info)
    2485              : {
    2486              :     using namespace GeneralCommissioning::Attributes;
    2487            0 :     CHIP_ERROR return_err = CHIP_NO_ERROR;
    2488              :     CHIP_ERROR err;
    2489              : 
    2490            0 :     BasicCommissioningInfo::TypeInfo::DecodableType basicInfo;
    2491            0 :     err = mAttributeCache->Get<BasicCommissioningInfo::TypeInfo>(kRootEndpointId, basicInfo);
    2492            0 :     if (err == CHIP_NO_ERROR)
    2493              :     {
    2494            0 :         info.general.recommendedFailsafe = basicInfo.failSafeExpiryLengthSeconds;
    2495              :     }
    2496              :     else
    2497              :     {
    2498            0 :         ChipLogError(Controller, "Failed to read BasicCommissioningInfo: %" CHIP_ERROR_FORMAT, err.Format());
    2499            0 :         return_err = err;
    2500              :     }
    2501              : 
    2502            0 :     err = mAttributeCache->Get<RegulatoryConfig::TypeInfo>(kRootEndpointId, info.general.currentRegulatoryLocation);
    2503            0 :     if (err != CHIP_NO_ERROR)
    2504              :     {
    2505            0 :         ChipLogError(Controller, "Failed to read RegulatoryConfig: %" CHIP_ERROR_FORMAT, err.Format());
    2506            0 :         return_err = err;
    2507              :     }
    2508              : 
    2509            0 :     err = mAttributeCache->Get<LocationCapability::TypeInfo>(kRootEndpointId, info.general.locationCapability);
    2510            0 :     if (err != CHIP_NO_ERROR)
    2511              :     {
    2512            0 :         ChipLogError(Controller, "Failed to read LocationCapability: %" CHIP_ERROR_FORMAT, err.Format());
    2513            0 :         return_err = err;
    2514              :     }
    2515              : 
    2516            0 :     err = mAttributeCache->Get<Breadcrumb::TypeInfo>(kRootEndpointId, info.general.breadcrumb);
    2517            0 :     if (err != CHIP_NO_ERROR)
    2518              :     {
    2519            0 :         ChipLogError(Controller, "Failed to read Breadcrumb: %" CHIP_ERROR_FORMAT, err.Format());
    2520            0 :         return_err = err;
    2521              :     }
    2522              : 
    2523            0 :     err = mAttributeCache->Get<SupportsConcurrentConnection::TypeInfo>(kRootEndpointId, info.supportsConcurrentConnection);
    2524            0 :     if (err != CHIP_NO_ERROR)
    2525              :     {
    2526            0 :         ChipLogError(Controller, "Ignoring failure to read SupportsConcurrentConnection: %" CHIP_ERROR_FORMAT, err.Format());
    2527            0 :         info.supportsConcurrentConnection = true; // default to true (concurrent), not a fatal error
    2528              :     }
    2529              : 
    2530            0 :     err = mAttributeCache->Get<IsCommissioningWithoutPower::TypeInfo>(kRootEndpointId, info.general.isCommissioningWithoutPower);
    2531            0 :     if (err != CHIP_NO_ERROR)
    2532              :     {
    2533            0 :         ChipLogError(Controller, "Ignoring failure to read IsCommissioningWithoutPower: %" CHIP_ERROR_FORMAT, err.Format());
    2534            0 :         info.general.isCommissioningWithoutPower = false; // default to false, not a fatal error
    2535              :     }
    2536              : 
    2537            0 :     return return_err;
    2538              : }
    2539              : 
    2540            0 : CHIP_ERROR DeviceCommissioner::ParseBasicInformation(ReadCommissioningInfo & info)
    2541              : {
    2542              :     using namespace BasicInformation::Attributes;
    2543            0 :     CHIP_ERROR return_err = CHIP_NO_ERROR;
    2544              :     CHIP_ERROR err;
    2545              : 
    2546            0 :     err = mAttributeCache->Get<VendorID::TypeInfo>(kRootEndpointId, info.basic.vendorId);
    2547            0 :     if (err != CHIP_NO_ERROR)
    2548              :     {
    2549            0 :         ChipLogError(Controller, "Failed to read VendorID: %" CHIP_ERROR_FORMAT, err.Format());
    2550            0 :         return_err = err;
    2551              :     }
    2552              : 
    2553            0 :     err = mAttributeCache->Get<ProductID::TypeInfo>(kRootEndpointId, info.basic.productId);
    2554            0 :     if (err != CHIP_NO_ERROR)
    2555              :     {
    2556            0 :         ChipLogError(Controller, "Failed to read ProductID: %" CHIP_ERROR_FORMAT, err.Format());
    2557            0 :         return_err = err;
    2558              :     }
    2559              : 
    2560            0 :     return return_err;
    2561              : }
    2562              : 
    2563            0 : CHIP_ERROR DeviceCommissioner::ParseNetworkCommissioningInfo(ReadCommissioningInfo & info)
    2564              : {
    2565              :     using namespace NetworkCommissioning::Attributes;
    2566            0 :     CHIP_ERROR return_err = CHIP_NO_ERROR;
    2567              :     CHIP_ERROR err;
    2568              : 
    2569              :     // Set the network cluster endpoints first so we can match up the connection
    2570              :     // times. Note that here we don't know what endpoints the network
    2571              :     // commissioning clusters might be on.
    2572            0 :     err = mAttributeCache->ForEachAttribute(NetworkCommissioning::Id, [this, &info](const ConcreteAttributePath & path) {
    2573            0 :         VerifyOrReturnError(path.mAttributeId == FeatureMap::Id, CHIP_NO_ERROR);
    2574            0 :         BitFlags<NetworkCommissioning::Feature> features;
    2575            0 :         if (mAttributeCache->Get<FeatureMap::TypeInfo>(path, *features.RawStorage()) == CHIP_NO_ERROR)
    2576              :         {
    2577            0 :             if (features.Has(NetworkCommissioning::Feature::kWiFiNetworkInterface))
    2578              :             {
    2579            0 :                 ChipLogProgress(Controller, "NetworkCommissioning Features: has WiFi. endpointid = %u", path.mEndpointId);
    2580            0 :                 info.network.wifi.endpoint = path.mEndpointId;
    2581              :             }
    2582            0 :             else if (features.Has(NetworkCommissioning::Feature::kThreadNetworkInterface))
    2583              :             {
    2584            0 :                 ChipLogProgress(Controller, "NetworkCommissioning Features: has Thread. endpointid = %u", path.mEndpointId);
    2585            0 :                 info.network.thread.endpoint = path.mEndpointId;
    2586              :             }
    2587            0 :             else if (features.Has(NetworkCommissioning::Feature::kEthernetNetworkInterface))
    2588              :             {
    2589            0 :                 ChipLogProgress(Controller, "NetworkCommissioning Features: has Ethernet. endpointid = %u", path.mEndpointId);
    2590            0 :                 info.network.eth.endpoint = path.mEndpointId;
    2591              :             }
    2592              :         }
    2593            0 :         return CHIP_NO_ERROR;
    2594              :     });
    2595            0 :     AccumulateErrors(return_err, err);
    2596              : 
    2597            0 :     if (info.network.thread.endpoint != kInvalidEndpointId)
    2598              :     {
    2599            0 :         err = ParseNetworkCommissioningTimeouts(info.network.thread, "Thread");
    2600            0 :         AccumulateErrors(return_err, err);
    2601              :     }
    2602              : 
    2603            0 :     if (info.network.wifi.endpoint != kInvalidEndpointId)
    2604              :     {
    2605            0 :         err = ParseNetworkCommissioningTimeouts(info.network.wifi, "Wi-Fi");
    2606            0 :         AccumulateErrors(return_err, err);
    2607              :     }
    2608              : 
    2609            0 :     if (return_err != CHIP_NO_ERROR)
    2610              :     {
    2611            0 :         ChipLogError(Controller, "Failed to parse Network Commissioning information: %" CHIP_ERROR_FORMAT, return_err.Format());
    2612              :     }
    2613            0 :     return return_err;
    2614              : }
    2615              : 
    2616            0 : CHIP_ERROR DeviceCommissioner::ParseNetworkCommissioningTimeouts(NetworkClusterInfo & networkInfo, const char * networkType)
    2617              : {
    2618              :     using namespace NetworkCommissioning::Attributes;
    2619              : 
    2620            0 :     CHIP_ERROR err = mAttributeCache->Get<ConnectMaxTimeSeconds::TypeInfo>(networkInfo.endpoint, networkInfo.minConnectionTime);
    2621            0 :     if (err != CHIP_NO_ERROR)
    2622              :     {
    2623            0 :         ChipLogError(Controller, "Failed to read %s ConnectMaxTimeSeconds (endpoint %u): %" CHIP_ERROR_FORMAT, networkType,
    2624              :                      networkInfo.endpoint, err.Format());
    2625            0 :         return err;
    2626              :     }
    2627              : 
    2628            0 :     err = mAttributeCache->Get<ScanMaxTimeSeconds::TypeInfo>(networkInfo.endpoint, networkInfo.maxScanTime);
    2629            0 :     if (err != CHIP_NO_ERROR)
    2630              :     {
    2631              :         // We don't always read this attribute, and we read it as a wildcard, so
    2632              :         // don't treat it as an error simply because it's missing.
    2633            0 :         if (err != CHIP_ERROR_KEY_NOT_FOUND)
    2634              :         {
    2635            0 :             ChipLogError(Controller, "Failed to read %s ScanMaxTimeSeconds (endpoint: %u): %" CHIP_ERROR_FORMAT, networkType,
    2636              :                          networkInfo.endpoint, err.Format());
    2637            0 :             return err;
    2638              :         }
    2639              : 
    2640              :         // Just flag as "we don't know".
    2641            0 :         networkInfo.maxScanTime = 0;
    2642              :     }
    2643              : 
    2644            0 :     return CHIP_NO_ERROR;
    2645              : }
    2646              : 
    2647            0 : CHIP_ERROR DeviceCommissioner::ParseTimeSyncInfo(ReadCommissioningInfo & info)
    2648              : {
    2649              :     using namespace TimeSynchronization::Attributes;
    2650              :     CHIP_ERROR err;
    2651              : 
    2652              :     // If we fail to get the feature map, there's no viable time cluster, don't set anything.
    2653            0 :     BitFlags<TimeSynchronization::Feature> featureMap;
    2654            0 :     err = mAttributeCache->Get<FeatureMap::TypeInfo>(kRootEndpointId, *featureMap.RawStorage());
    2655            0 :     if (err != CHIP_NO_ERROR)
    2656              :     {
    2657            0 :         info.requiresUTC               = false;
    2658            0 :         info.requiresTimeZone          = false;
    2659            0 :         info.requiresDefaultNTP        = false;
    2660            0 :         info.requiresTrustedTimeSource = false;
    2661            0 :         return CHIP_NO_ERROR;
    2662              :     }
    2663            0 :     info.requiresUTC               = true;
    2664            0 :     info.requiresTimeZone          = featureMap.Has(TimeSynchronization::Feature::kTimeZone);
    2665            0 :     info.requiresDefaultNTP        = featureMap.Has(TimeSynchronization::Feature::kNTPClient);
    2666            0 :     info.requiresTrustedTimeSource = featureMap.Has(TimeSynchronization::Feature::kTimeSyncClient);
    2667              : 
    2668            0 :     if (info.requiresTimeZone)
    2669              :     {
    2670            0 :         err = mAttributeCache->Get<TimeZoneListMaxSize::TypeInfo>(kRootEndpointId, info.maxTimeZoneSize);
    2671            0 :         if (err != CHIP_NO_ERROR)
    2672              :         {
    2673              :             // This information should be available, let's do our best with what we have, but we can't set
    2674              :             // the time zone without this information
    2675            0 :             info.requiresTimeZone = false;
    2676              :         }
    2677            0 :         err = mAttributeCache->Get<DSTOffsetListMaxSize::TypeInfo>(kRootEndpointId, info.maxDSTSize);
    2678            0 :         if (err != CHIP_NO_ERROR)
    2679              :         {
    2680            0 :             info.requiresTimeZone = false;
    2681              :         }
    2682              :     }
    2683            0 :     if (info.requiresDefaultNTP)
    2684              :     {
    2685            0 :         DefaultNTP::TypeInfo::DecodableType defaultNTP;
    2686            0 :         err = mAttributeCache->Get<DefaultNTP::TypeInfo>(kRootEndpointId, defaultNTP);
    2687            0 :         if (err == CHIP_NO_ERROR && (!defaultNTP.IsNull()) && (defaultNTP.Value().size() != 0))
    2688              :         {
    2689            0 :             info.requiresDefaultNTP = false;
    2690              :         }
    2691              :     }
    2692            0 :     if (info.requiresTrustedTimeSource)
    2693              :     {
    2694            0 :         TrustedTimeSource::TypeInfo::DecodableType trustedTimeSource;
    2695            0 :         err = mAttributeCache->Get<TrustedTimeSource::TypeInfo>(kRootEndpointId, trustedTimeSource);
    2696            0 :         if (err == CHIP_NO_ERROR && !trustedTimeSource.IsNull())
    2697              :         {
    2698            0 :             info.requiresTrustedTimeSource = false;
    2699              :         }
    2700              :     }
    2701              : 
    2702            0 :     return CHIP_NO_ERROR;
    2703              : }
    2704              : 
    2705            0 : CHIP_ERROR DeviceCommissioner::ParseFabrics(ReadCommissioningInfo & info)
    2706              : {
    2707              :     using namespace OperationalCredentials::Attributes;
    2708              :     CHIP_ERROR err;
    2709            0 :     CHIP_ERROR return_err = CHIP_NO_ERROR;
    2710              : 
    2711              :     // We might not have requested a Fabrics attribute at all, so not having a
    2712              :     // value for it is not an error.
    2713            0 :     err = mAttributeCache->ForEachAttribute(OperationalCredentials::Id, [this, &info](const ConcreteAttributePath & path) {
    2714              :         using namespace chip::app::Clusters::OperationalCredentials::Attributes;
    2715              :         // this code is checking if the device is already on the commissioner's fabric.
    2716              :         // if a matching fabric is found, then remember the nodeId so that the commissioner
    2717              :         // can, if it decides to, cancel commissioning (before it fails in AddNoc) and know
    2718              :         // the device's nodeId on its fabric.
    2719            0 :         switch (path.mAttributeId)
    2720              :         {
    2721            0 :         case Fabrics::Id: {
    2722            0 :             Fabrics::TypeInfo::DecodableType fabrics;
    2723            0 :             ReturnErrorOnFailure(this->mAttributeCache->Get<Fabrics::TypeInfo>(path, fabrics));
    2724              :             // this is a best effort attempt to find a matching fabric, so no error checking on iter
    2725            0 :             auto iter = fabrics.begin();
    2726            0 :             while (iter.Next())
    2727              :             {
    2728            0 :                 auto & fabricDescriptor = iter.GetValue();
    2729            0 :                 ChipLogProgress(Controller,
    2730              :                                 "DeviceCommissioner::OnDone - fabric.vendorId=0x%04X fabric.fabricId=0x" ChipLogFormatX64
    2731              :                                 " fabric.nodeId=0x" ChipLogFormatX64,
    2732              :                                 fabricDescriptor.vendorID, ChipLogValueX64(fabricDescriptor.fabricID),
    2733              :                                 ChipLogValueX64(fabricDescriptor.nodeID));
    2734            0 :                 if (GetFabricId() == fabricDescriptor.fabricID)
    2735              :                 {
    2736            0 :                     ChipLogProgress(Controller, "DeviceCommissioner::OnDone - found a matching fabric id");
    2737            0 :                     chip::ByteSpan rootKeySpan = fabricDescriptor.rootPublicKey;
    2738            0 :                     if (rootKeySpan.size() != Crypto::kP256_PublicKey_Length)
    2739              :                     {
    2740            0 :                         ChipLogError(Controller, "DeviceCommissioner::OnDone - fabric root key size mismatch %u != %u",
    2741              :                                      static_cast<unsigned>(rootKeySpan.size()),
    2742              :                                      static_cast<unsigned>(Crypto::kP256_PublicKey_Length));
    2743            0 :                         continue;
    2744              :                     }
    2745            0 :                     P256PublicKeySpan rootPubKeySpan(rootKeySpan.data());
    2746            0 :                     Crypto::P256PublicKey deviceRootPublicKey(rootPubKeySpan);
    2747              : 
    2748            0 :                     Crypto::P256PublicKey commissionerRootPublicKey;
    2749            0 :                     if (CHIP_NO_ERROR != GetRootPublicKey(commissionerRootPublicKey))
    2750              :                     {
    2751            0 :                         ChipLogError(Controller, "DeviceCommissioner::OnDone - error reading commissioner root public key");
    2752              :                     }
    2753            0 :                     else if (commissionerRootPublicKey.Matches(deviceRootPublicKey))
    2754              :                     {
    2755            0 :                         ChipLogProgress(Controller, "DeviceCommissioner::OnDone - fabric root keys match");
    2756            0 :                         info.remoteNodeId = fabricDescriptor.nodeID;
    2757              :                     }
    2758            0 :                 }
    2759              :             }
    2760              : 
    2761            0 :             return CHIP_NO_ERROR;
    2762              :         }
    2763            0 :         default:
    2764            0 :             return CHIP_NO_ERROR;
    2765              :         }
    2766              :     });
    2767              : 
    2768            0 :     if (mPairingDelegate != nullptr)
    2769              :     {
    2770            0 :         mPairingDelegate->OnFabricCheck(info.remoteNodeId);
    2771              :     }
    2772              : 
    2773            0 :     return return_err;
    2774              : }
    2775              : 
    2776            0 : CHIP_ERROR DeviceCommissioner::ParseICDInfo(ReadCommissioningInfo & info)
    2777              : {
    2778              :     using namespace IcdManagement::Attributes;
    2779              :     CHIP_ERROR err;
    2780              : 
    2781            0 :     bool hasUserActiveModeTrigger = false;
    2782            0 :     bool isICD                    = false;
    2783              : 
    2784            0 :     BitFlags<IcdManagement::Feature> featureMap;
    2785            0 :     err = mAttributeCache->Get<FeatureMap::TypeInfo>(kRootEndpointId, *featureMap.RawStorage());
    2786            0 :     if (err == CHIP_NO_ERROR)
    2787              :     {
    2788            0 :         info.icd.isLIT                  = featureMap.Has(IcdManagement::Feature::kLongIdleTimeSupport);
    2789            0 :         info.icd.checkInProtocolSupport = featureMap.Has(IcdManagement::Feature::kCheckInProtocolSupport);
    2790            0 :         hasUserActiveModeTrigger        = featureMap.Has(IcdManagement::Feature::kUserActiveModeTrigger);
    2791            0 :         isICD                           = true;
    2792              :     }
    2793            0 :     else if (err == CHIP_ERROR_KEY_NOT_FOUND)
    2794              :     {
    2795              :         // This key is optional so not an error
    2796            0 :         info.icd.isLIT = false;
    2797            0 :         err            = CHIP_NO_ERROR;
    2798              :     }
    2799            0 :     else if (err == CHIP_ERROR_IM_STATUS_CODE_RECEIVED)
    2800              :     {
    2801            0 :         app::StatusIB statusIB;
    2802            0 :         err = mAttributeCache->GetStatus(app::ConcreteAttributePath(kRootEndpointId, IcdManagement::Id, FeatureMap::Id), statusIB);
    2803            0 :         if (err == CHIP_NO_ERROR)
    2804              :         {
    2805            0 :             if (statusIB.mStatus == Protocols::InteractionModel::Status::UnsupportedCluster)
    2806              :             {
    2807            0 :                 info.icd.isLIT = false;
    2808              :             }
    2809              :             else
    2810              :             {
    2811            0 :                 err = statusIB.ToChipError();
    2812              :             }
    2813              :         }
    2814              :     }
    2815              : 
    2816            0 :     ReturnErrorOnFailure(err);
    2817              : 
    2818            0 :     info.icd.userActiveModeTriggerHint.ClearAll();
    2819            0 :     info.icd.userActiveModeTriggerInstruction = CharSpan();
    2820              : 
    2821            0 :     if (hasUserActiveModeTrigger)
    2822              :     {
    2823              :         // Intentionally ignore errors since they are not mandatory.
    2824            0 :         bool activeModeTriggerInstructionRequired = false;
    2825              : 
    2826            0 :         err = mAttributeCache->Get<UserActiveModeTriggerHint::TypeInfo>(kRootEndpointId, info.icd.userActiveModeTriggerHint);
    2827            0 :         if (err != CHIP_NO_ERROR)
    2828              :         {
    2829            0 :             ChipLogError(Controller, "IcdManagement.UserActiveModeTriggerHint expected, but failed to read.");
    2830            0 :             return err;
    2831              :         }
    2832              : 
    2833              :         using IcdManagement::UserActiveModeTriggerBitmap;
    2834            0 :         activeModeTriggerInstructionRequired = info.icd.userActiveModeTriggerHint.HasAny(
    2835            0 :             UserActiveModeTriggerBitmap::kCustomInstruction, UserActiveModeTriggerBitmap::kActuateSensorSeconds,
    2836            0 :             UserActiveModeTriggerBitmap::kActuateSensorTimes, UserActiveModeTriggerBitmap::kActuateSensorLightsBlink,
    2837            0 :             UserActiveModeTriggerBitmap::kResetButtonLightsBlink, UserActiveModeTriggerBitmap::kResetButtonSeconds,
    2838            0 :             UserActiveModeTriggerBitmap::kResetButtonTimes, UserActiveModeTriggerBitmap::kSetupButtonSeconds,
    2839            0 :             UserActiveModeTriggerBitmap::kSetupButtonTimes, UserActiveModeTriggerBitmap::kSetupButtonTimes,
    2840            0 :             UserActiveModeTriggerBitmap::kAppDefinedButton);
    2841              : 
    2842            0 :         if (activeModeTriggerInstructionRequired)
    2843              :         {
    2844            0 :             err = mAttributeCache->Get<UserActiveModeTriggerInstruction::TypeInfo>(kRootEndpointId,
    2845            0 :                                                                                    info.icd.userActiveModeTriggerInstruction);
    2846            0 :             if (err != CHIP_NO_ERROR)
    2847              :             {
    2848            0 :                 ChipLogError(Controller,
    2849              :                              "IcdManagement.UserActiveModeTriggerInstruction expected for given active mode trigger hint, but "
    2850              :                              "failed to read.");
    2851            0 :                 return err;
    2852              :             }
    2853              :         }
    2854              :     }
    2855              : 
    2856            0 :     if (!isICD)
    2857              :     {
    2858            0 :         info.icd.idleModeDuration    = 0;
    2859            0 :         info.icd.activeModeDuration  = 0;
    2860            0 :         info.icd.activeModeThreshold = 0;
    2861            0 :         return CHIP_NO_ERROR;
    2862              :     }
    2863              : 
    2864            0 :     err = mAttributeCache->Get<IdleModeDuration::TypeInfo>(kRootEndpointId, info.icd.idleModeDuration);
    2865            0 :     if (err != CHIP_NO_ERROR)
    2866              :     {
    2867            0 :         ChipLogError(Controller, "IcdManagement.IdleModeDuration expected, but failed to read: %" CHIP_ERROR_FORMAT, err.Format());
    2868            0 :         return err;
    2869              :     }
    2870              : 
    2871            0 :     err = mAttributeCache->Get<ActiveModeDuration::TypeInfo>(kRootEndpointId, info.icd.activeModeDuration);
    2872            0 :     if (err != CHIP_NO_ERROR)
    2873              :     {
    2874            0 :         ChipLogError(Controller, "IcdManagement.ActiveModeDuration expected, but failed to read: %" CHIP_ERROR_FORMAT,
    2875              :                      err.Format());
    2876            0 :         return err;
    2877              :     }
    2878              : 
    2879            0 :     err = mAttributeCache->Get<ActiveModeThreshold::TypeInfo>(kRootEndpointId, info.icd.activeModeThreshold);
    2880            0 :     if (err != CHIP_NO_ERROR)
    2881              :     {
    2882            0 :         ChipLogError(Controller, "IcdManagement.ActiveModeThreshold expected, but failed to read: %" CHIP_ERROR_FORMAT,
    2883              :                      err.Format());
    2884              :     }
    2885              : 
    2886            0 :     return err;
    2887              : }
    2888              : 
    2889            0 : void DeviceCommissioner::OnArmFailSafe(void * context,
    2890              :                                        const GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType & data)
    2891              : {
    2892            0 :     CommissioningDelegate::CommissioningReport report;
    2893            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
    2894              : 
    2895            0 :     ChipLogProgress(Controller, "Received ArmFailSafe response errorCode=%u", to_underlying(data.errorCode));
    2896            0 :     if (data.errorCode != GeneralCommissioning::CommissioningErrorEnum::kOk)
    2897              :     {
    2898            0 :         err = CHIP_ERROR_INTERNAL;
    2899            0 :         report.Set<CommissioningErrorInfo>(data.errorCode);
    2900              :     }
    2901              : 
    2902            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2903            0 :     commissioner->CommissioningStageComplete(err, report);
    2904            0 : }
    2905              : 
    2906            0 : void DeviceCommissioner::OnSetRegulatoryConfigResponse(
    2907              :     void * context, const GeneralCommissioning::Commands::SetRegulatoryConfigResponse::DecodableType & data)
    2908              : {
    2909            0 :     CommissioningDelegate::CommissioningReport report;
    2910            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
    2911              : 
    2912            0 :     ChipLogProgress(Controller, "Received SetRegulatoryConfig response errorCode=%u", to_underlying(data.errorCode));
    2913            0 :     if (data.errorCode != GeneralCommissioning::CommissioningErrorEnum::kOk)
    2914              :     {
    2915            0 :         err = CHIP_ERROR_INTERNAL;
    2916            0 :         report.Set<CommissioningErrorInfo>(data.errorCode);
    2917              :     }
    2918            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2919            0 :     commissioner->CommissioningStageComplete(err, report);
    2920            0 : }
    2921              : 
    2922            0 : void DeviceCommissioner::OnSetTCAcknowledgementsResponse(
    2923              :     void * context, const GeneralCommissioning::Commands::SetTCAcknowledgementsResponse::DecodableType & data)
    2924              : {
    2925            0 :     CommissioningDelegate::CommissioningReport report;
    2926            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
    2927              : 
    2928            0 :     ChipLogProgress(Controller, "Received SetTCAcknowledgements response errorCode=%u", to_underlying(data.errorCode));
    2929            0 :     if (data.errorCode != GeneralCommissioning::CommissioningErrorEnum::kOk)
    2930              :     {
    2931            0 :         err = CHIP_ERROR_INTERNAL;
    2932            0 :         report.Set<CommissioningErrorInfo>(data.errorCode);
    2933              :     }
    2934            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2935            0 :     commissioner->CommissioningStageComplete(err, report);
    2936            0 : }
    2937              : 
    2938            0 : void DeviceCommissioner::OnSetTimeZoneResponse(void * context,
    2939              :                                                const TimeSynchronization::Commands::SetTimeZoneResponse::DecodableType & data)
    2940              : {
    2941            0 :     CommissioningDelegate::CommissioningReport report;
    2942            0 :     CHIP_ERROR err                    = CHIP_NO_ERROR;
    2943            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2944              :     TimeZoneResponseInfo info;
    2945            0 :     info.requiresDSTOffsets = data.DSTOffsetRequired;
    2946            0 :     report.Set<TimeZoneResponseInfo>(info);
    2947            0 :     commissioner->CommissioningStageComplete(err, report);
    2948            0 : }
    2949              : 
    2950            0 : void DeviceCommissioner::OnSetUTCError(void * context, CHIP_ERROR error)
    2951              : {
    2952              :     // For SetUTCTime, we don't actually care if the commissionee didn't want out time, that's its choice
    2953            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2954            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR);
    2955            0 : }
    2956              : 
    2957            0 : void DeviceCommissioner::OnScanNetworksFailure(void * context, CHIP_ERROR error)
    2958              : {
    2959            0 :     ChipLogProgress(Controller, "Received ScanNetworks failure response %" CHIP_ERROR_FORMAT, error.Format());
    2960              : 
    2961            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2962              : 
    2963              :     // advance to the kNeedsNetworkCreds waiting step
    2964              :     // clear error so that we don't abort the commissioning when ScanNetworks fails
    2965            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR);
    2966              : 
    2967            0 :     if (commissioner->GetPairingDelegate() != nullptr)
    2968              :     {
    2969            0 :         commissioner->GetPairingDelegate()->OnScanNetworksFailure(error);
    2970              :     }
    2971            0 : }
    2972              : 
    2973            0 : void DeviceCommissioner::OnScanNetworksResponse(void * context,
    2974              :                                                 const NetworkCommissioning::Commands::ScanNetworksResponse::DecodableType & data)
    2975              : {
    2976            0 :     CommissioningDelegate::CommissioningReport report;
    2977              : 
    2978            0 :     ChipLogProgress(Controller, "Received ScanNetwork response, networkingStatus=%u debugText=%s",
    2979              :                     to_underlying(data.networkingStatus),
    2980              :                     (data.debugText.HasValue() ? std::string(data.debugText.Value().data(), data.debugText.Value().size()).c_str()
    2981              :                                                : "none provided"));
    2982            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    2983              : 
    2984              :     // advance to the kNeedsNetworkCreds waiting step
    2985            0 :     commissioner->CommissioningStageComplete(CHIP_NO_ERROR);
    2986              : 
    2987            0 :     if (commissioner->GetPairingDelegate() != nullptr)
    2988              :     {
    2989            0 :         commissioner->GetPairingDelegate()->OnScanNetworksSuccess(data);
    2990              :     }
    2991            0 : }
    2992              : 
    2993            0 : CHIP_ERROR DeviceCommissioner::NetworkCredentialsReady()
    2994              : {
    2995            0 :     VerifyOrReturnError(mCommissioningStage == CommissioningStage::kNeedsNetworkCreds, CHIP_ERROR_INCORRECT_STATE);
    2996              : 
    2997              :     // need to advance to next step
    2998            0 :     CommissioningStageComplete(CHIP_NO_ERROR);
    2999              : 
    3000            0 :     return CHIP_NO_ERROR;
    3001              : }
    3002              : 
    3003            0 : CHIP_ERROR DeviceCommissioner::ICDRegistrationInfoReady()
    3004              : {
    3005            0 :     VerifyOrReturnError(mCommissioningStage == CommissioningStage::kICDGetRegistrationInfo, CHIP_ERROR_INCORRECT_STATE);
    3006              : 
    3007              :     // need to advance to next step
    3008            0 :     CommissioningStageComplete(CHIP_NO_ERROR);
    3009              : 
    3010            0 :     return CHIP_NO_ERROR;
    3011              : }
    3012              : 
    3013            0 : void DeviceCommissioner::OnNetworkConfigResponse(void * context,
    3014              :                                                  const NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType & data)
    3015              : {
    3016            0 :     CommissioningDelegate::CommissioningReport report;
    3017            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
    3018              : 
    3019            0 :     ChipLogProgress(Controller, "Received NetworkConfig response, networkingStatus=%u", to_underlying(data.networkingStatus));
    3020            0 :     if (data.networkingStatus != NetworkCommissioning::NetworkCommissioningStatusEnum::kSuccess)
    3021              :     {
    3022            0 :         err = CHIP_ERROR_INTERNAL;
    3023            0 :         report.Set<NetworkCommissioningStatusInfo>(data.networkingStatus);
    3024              :     }
    3025            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    3026            0 :     commissioner->CommissioningStageComplete(err, report);
    3027            0 : }
    3028              : 
    3029            0 : void DeviceCommissioner::OnConnectNetworkResponse(
    3030              :     void * context, const NetworkCommissioning::Commands::ConnectNetworkResponse::DecodableType & data)
    3031              : {
    3032            0 :     CommissioningDelegate::CommissioningReport report;
    3033            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
    3034              : 
    3035            0 :     ChipLogProgress(Controller, "Received ConnectNetwork response, networkingStatus=%u", to_underlying(data.networkingStatus));
    3036            0 :     if (data.networkingStatus != NetworkCommissioning::NetworkCommissioningStatusEnum::kSuccess)
    3037              :     {
    3038            0 :         err = CHIP_ERROR_INTERNAL;
    3039            0 :         report.Set<NetworkCommissioningStatusInfo>(data.networkingStatus);
    3040              :     }
    3041            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    3042            0 :     commissioner->CommissioningStageComplete(err, report);
    3043            0 : }
    3044              : 
    3045            0 : void DeviceCommissioner::OnCommissioningCompleteResponse(
    3046              :     void * context, const GeneralCommissioning::Commands::CommissioningCompleteResponse::DecodableType & data)
    3047              : {
    3048            0 :     CommissioningDelegate::CommissioningReport report;
    3049            0 :     CHIP_ERROR err = CHIP_NO_ERROR;
    3050              : 
    3051            0 :     ChipLogProgress(Controller, "Received CommissioningComplete response, errorCode=%u", to_underlying(data.errorCode));
    3052            0 :     if (data.errorCode != GeneralCommissioning::CommissioningErrorEnum::kOk)
    3053              :     {
    3054            0 :         err = CHIP_ERROR_INTERNAL;
    3055            0 :         report.Set<CommissioningErrorInfo>(data.errorCode);
    3056              :     }
    3057            0 :     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
    3058            0 :     commissioner->CommissioningStageComplete(err, report);
    3059            0 : }
    3060              : 
    3061              : template <typename RequestObjectT>
    3062              : CHIP_ERROR
    3063            0 : DeviceCommissioner::SendCommissioningCommand(DeviceProxy * device, const RequestObjectT & request,
    3064              :                                              CommandResponseSuccessCallback<typename RequestObjectT::ResponseType> successCb,
    3065              :                                              CommandResponseFailureCallback failureCb, EndpointId endpoint,
    3066              :                                              Optional<System::Clock::Timeout> timeout, bool fireAndForget)
    3067              : 
    3068              : {
    3069              :     // Default behavior is to make sequential, cancellable calls tracked via mInvokeCancelFn.
    3070              :     // Fire-and-forget calls are not cancellable and don't receive `this` as context in callbacks.
    3071            0 :     VerifyOrDie(fireAndForget || !mInvokeCancelFn); // we don't make parallel (cancellable) calls
    3072              : 
    3073            0 :     void * context   = (!fireAndForget) ? this : nullptr;
    3074            0 :     auto onSuccessCb = [context, successCb](const app::ConcreteCommandPath & aPath, const app::StatusIB & aStatus,
    3075              :                                             const typename RequestObjectT::ResponseType & responseData) {
    3076            0 :         successCb(context, responseData);
    3077              :     };
    3078            0 :     auto onFailureCb = [context, failureCb](CHIP_ERROR aError) { failureCb(context, aError); };
    3079              : 
    3080            0 :     return InvokeCommandRequest(device->GetExchangeManager(), device->GetSecureSession().Value(), endpoint, request, onSuccessCb,
    3081            0 :                                 onFailureCb, NullOptional, timeout, (!fireAndForget) ? &mInvokeCancelFn : nullptr);
    3082              : }
    3083              : 
    3084              : template <typename AttrType>
    3085              : CHIP_ERROR DeviceCommissioner::SendCommissioningWriteRequest(DeviceProxy * device, EndpointId endpoint, ClusterId cluster,
    3086              :                                                              AttributeId attribute, const AttrType & requestData,
    3087              :                                                              WriteResponseSuccessCallback successCb,
    3088              :                                                              WriteResponseFailureCallback failureCb)
    3089              : {
    3090              :     VerifyOrDie(!mWriteCancelFn); // we don't make parallel (cancellable) calls
    3091              :     auto onSuccessCb = [this, successCb](const app::ConcreteAttributePath & aPath) { successCb(this); };
    3092              :     auto onFailureCb = [this, failureCb](const app::ConcreteAttributePath * aPath, CHIP_ERROR aError) { failureCb(this, aError); };
    3093              :     return WriteAttribute(device->GetSecureSession().Value(), endpoint, cluster, attribute, requestData, onSuccessCb, onFailureCb,
    3094              :                           /* aTimedWriteTimeoutMs = */ NullOptional, /* onDoneCb = */ nullptr, /* aDataVersion = */ NullOptional,
    3095              :                           /* outCancelFn = */ &mWriteCancelFn);
    3096              : }
    3097              : 
    3098            0 : void DeviceCommissioner::SendCommissioningReadRequest(DeviceProxy * proxy, Optional<System::Clock::Timeout> timeout,
    3099              :                                                       app::AttributePathParams * readPaths, size_t readPathsSize)
    3100              : {
    3101            0 :     VerifyOrDie(!mReadClient); // we don't perform parallel reads
    3102              : 
    3103            0 :     app::InteractionModelEngine * engine = app::InteractionModelEngine::GetInstance();
    3104            0 :     app::ReadPrepareParams readParams(proxy->GetSecureSession().Value());
    3105            0 :     readParams.mIsFabricFiltered = false;
    3106            0 :     if (timeout.HasValue())
    3107              :     {
    3108            0 :         readParams.mTimeout = timeout.Value();
    3109              :     }
    3110            0 :     readParams.mpAttributePathParamsList    = readPaths;
    3111            0 :     readParams.mAttributePathParamsListSize = readPathsSize;
    3112              : 
    3113              :     // Take ownership of the attribute cache, so it can be released if SendRequest fails.
    3114            0 :     auto attributeCache = std::move(mAttributeCache);
    3115              :     auto readClient     = chip::Platform::MakeUnique<app::ReadClient>(
    3116            0 :         engine, proxy->GetExchangeManager(), attributeCache->GetBufferedCallback(), app::ReadClient::InteractionType::Read);
    3117            0 :     CHIP_ERROR err = readClient->SendRequest(readParams);
    3118            0 :     if (err != CHIP_NO_ERROR)
    3119              :     {
    3120            0 :         ChipLogError(Controller, "Failed to send read request: %" CHIP_ERROR_FORMAT, err.Format());
    3121            0 :         CommissioningStageComplete(err);
    3122            0 :         return;
    3123              :     }
    3124            0 :     mAttributeCache = std::move(attributeCache);
    3125            0 :     mReadClient     = std::move(readClient);
    3126            0 : }
    3127              : 
    3128            0 : void DeviceCommissioner::PerformCommissioningStep(DeviceProxy * proxy, CommissioningStage step, CommissioningParameters & params,
    3129              :                                                   CommissioningDelegate * delegate, EndpointId endpoint,
    3130              :                                                   Optional<System::Clock::Timeout> timeout)
    3131              : 
    3132              : {
    3133              :     MATTER_LOG_METRIC(kMetricDeviceCommissionerCommissionStage, step);
    3134              :     MATTER_LOG_METRIC_BEGIN(MetricKeyForCommissioningStage(step));
    3135              : 
    3136            0 :     if (params.GetCompletionStatus().err == CHIP_NO_ERROR)
    3137              :     {
    3138            0 :         ChipLogProgress(Controller, "Performing next commissioning step '%s'", StageToString(step));
    3139              :     }
    3140              :     else
    3141              :     {
    3142            0 :         ChipLogProgress(Controller, "Performing next commissioning step '%s' with completion status = '%s'", StageToString(step),
    3143              :                         params.GetCompletionStatus().err.AsString());
    3144              :     }
    3145              : 
    3146            0 :     if (mPairingDelegate)
    3147              :     {
    3148            0 :         mPairingDelegate->OnCommissioningStageStart(PeerId(GetCompressedFabricId(), proxy->GetDeviceId()), step);
    3149              :     }
    3150              : 
    3151            0 :     mCommissioningStepTimeout = timeout;
    3152            0 :     mCommissioningStage       = step;
    3153            0 :     mCommissioningDelegate    = delegate;
    3154            0 :     mDeviceBeingCommissioned  = proxy;
    3155              : 
    3156              :     // TODO: Extend timeouts to the DAC and Opcert requests.
    3157              :     // TODO(cecille): We probably want something better than this for breadcrumbs.
    3158            0 :     uint64_t breadcrumb = static_cast<uint64_t>(step);
    3159              : 
    3160            0 :     switch (step)
    3161              :     {
    3162            0 :     case CommissioningStage::kArmFailsafe: {
    3163            0 :         VerifyOrDie(endpoint == kRootEndpointId);
    3164              :         // Make sure the fail-safe value we set here actually ends up being used
    3165              :         // no matter what.
    3166            0 :         proxy->SetFailSafeExpirationTimestamp(System::Clock::kZero);
    3167            0 :         VerifyOrDie(ExtendArmFailSafeInternal(proxy, step, params.GetFailsafeTimerSeconds().ValueOr(kDefaultFailsafeTimeout),
    3168              :                                               timeout, OnArmFailSafe, OnBasicFailure, /* fireAndForget = */ false));
    3169              :     }
    3170            0 :     break;
    3171            0 :     case CommissioningStage::kReadCommissioningInfo: {
    3172            0 :         VerifyOrDie(endpoint == kRootEndpointId);
    3173            0 :         ChipLogProgress(Controller, "Sending read requests for commissioning information");
    3174              : 
    3175              :         // Allocate a ClusterStateCache to collect the data from our read requests.
    3176              :         // The cache will be released in:
    3177              :         // - SendCommissioningReadRequest when failing to send a read request.
    3178              :         // - FinishReadingCommissioningInfo when the ReadCommissioningInfo stage is completed.
    3179              :         // - CancelCommissioningInteractions
    3180            0 :         mAttributeCache = Platform::MakeUnique<app::ClusterStateCache>(*this);
    3181              : 
    3182              :         // Generally we need to make more than one read request, because as per spec a server only
    3183              :         // supports a limited number of paths per Read Interaction. Because the actual number of
    3184              :         // interactions we end up performing is dynamic, we track all of them within a single
    3185              :         // commissioning stage.
    3186            0 :         mReadCommissioningInfoProgress = 0;
    3187            0 :         ContinueReadingCommissioningInfo(params); // Note: assume params == delegate.GetCommissioningParameters()
    3188            0 :         break;
    3189              :     }
    3190            0 :     case CommissioningStage::kConfigureUTCTime: {
    3191            0 :         TimeSynchronization::Commands::SetUTCTime::Type request;
    3192            0 :         uint64_t kChipEpochUsSinceUnixEpoch = static_cast<uint64_t>(kChipEpochSecondsSinceUnixEpoch) * chip::kMicrosecondsPerSecond;
    3193              :         System::Clock::Microseconds64 utcTime;
    3194            0 :         if (System::SystemClock().GetClock_RealTime(utcTime) != CHIP_NO_ERROR || utcTime.count() <= kChipEpochUsSinceUnixEpoch)
    3195              :         {
    3196              :             // We have no time to give, but that's OK, just complete this stage
    3197            0 :             CommissioningStageComplete(CHIP_NO_ERROR);
    3198            0 :             return;
    3199              :         }
    3200              : 
    3201            0 :         request.UTCTime = utcTime.count() - kChipEpochUsSinceUnixEpoch;
    3202              :         // For now, we assume a seconds granularity
    3203            0 :         request.granularity = TimeSynchronization::GranularityEnum::kSecondsGranularity;
    3204            0 :         CHIP_ERROR err      = SendCommissioningCommand(proxy, request, OnBasicSuccess, OnSetUTCError, endpoint, timeout);
    3205            0 :         if (err != CHIP_NO_ERROR)
    3206              :         {
    3207              :             // We won't get any async callbacks here, so just complete our stage.
    3208            0 :             ChipLogError(Controller, "Failed to send SetUTCTime command: %" CHIP_ERROR_FORMAT, err.Format());
    3209            0 :             CommissioningStageComplete(err);
    3210            0 :             return;
    3211              :         }
    3212            0 :         break;
    3213              :     }
    3214            0 :     case CommissioningStage::kConfigureTimeZone: {
    3215            0 :         if (!params.GetTimeZone().HasValue())
    3216              :         {
    3217            0 :             ChipLogError(Controller, "ConfigureTimeZone stage called with no time zone data");
    3218            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3219            0 :             return;
    3220              :         }
    3221            0 :         TimeSynchronization::Commands::SetTimeZone::Type request;
    3222            0 :         request.timeZone = params.GetTimeZone().Value();
    3223            0 :         CHIP_ERROR err   = SendCommissioningCommand(proxy, request, OnSetTimeZoneResponse, OnBasicFailure, endpoint, timeout);
    3224            0 :         if (err != CHIP_NO_ERROR)
    3225              :         {
    3226              :             // We won't get any async callbacks here, so just complete our stage.
    3227            0 :             ChipLogError(Controller, "Failed to send SetTimeZone command: %" CHIP_ERROR_FORMAT, err.Format());
    3228            0 :             CommissioningStageComplete(err);
    3229            0 :             return;
    3230              :         }
    3231            0 :         break;
    3232              :     }
    3233            0 :     case CommissioningStage::kConfigureDSTOffset: {
    3234            0 :         if (!params.GetDSTOffsets().HasValue())
    3235              :         {
    3236            0 :             ChipLogError(Controller, "ConfigureDSTOffset stage called with no DST data");
    3237            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3238            0 :             return;
    3239              :         }
    3240            0 :         TimeSynchronization::Commands::SetDSTOffset::Type request;
    3241            0 :         request.DSTOffset = params.GetDSTOffsets().Value();
    3242            0 :         CHIP_ERROR err    = SendCommissioningCommand(proxy, request, OnBasicSuccess, OnBasicFailure, endpoint, timeout);
    3243            0 :         if (err != CHIP_NO_ERROR)
    3244              :         {
    3245              :             // We won't get any async callbacks here, so just complete our stage.
    3246            0 :             ChipLogError(Controller, "Failed to send SetDSTOffset command: %" CHIP_ERROR_FORMAT, err.Format());
    3247            0 :             CommissioningStageComplete(err);
    3248            0 :             return;
    3249              :         }
    3250            0 :         break;
    3251              :     }
    3252            0 :     case CommissioningStage::kConfigureDefaultNTP: {
    3253            0 :         if (!params.GetDefaultNTP().HasValue())
    3254              :         {
    3255            0 :             ChipLogError(Controller, "ConfigureDefaultNTP stage called with no default NTP data");
    3256            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3257            0 :             return;
    3258              :         }
    3259            0 :         TimeSynchronization::Commands::SetDefaultNTP::Type request;
    3260            0 :         request.defaultNTP = params.GetDefaultNTP().Value();
    3261            0 :         CHIP_ERROR err     = SendCommissioningCommand(proxy, request, OnBasicSuccess, OnBasicFailure, endpoint, timeout);
    3262            0 :         if (err != CHIP_NO_ERROR)
    3263              :         {
    3264              :             // We won't get any async callbacks here, so just complete our stage.
    3265            0 :             ChipLogError(Controller, "Failed to send SetDefaultNTP command: %" CHIP_ERROR_FORMAT, err.Format());
    3266            0 :             CommissioningStageComplete(err);
    3267            0 :             return;
    3268              :         }
    3269            0 :         break;
    3270              :     }
    3271            0 :     case CommissioningStage::kScanNetworks: {
    3272            0 :         NetworkCommissioning::Commands::ScanNetworks::Type request;
    3273            0 :         if (params.GetWiFiCredentials().HasValue())
    3274              :         {
    3275            0 :             request.ssid.Emplace(params.GetWiFiCredentials().Value().ssid);
    3276              :         }
    3277            0 :         request.breadcrumb.Emplace(breadcrumb);
    3278            0 :         CHIP_ERROR err = SendCommissioningCommand(proxy, request, OnScanNetworksResponse, OnScanNetworksFailure, endpoint, timeout);
    3279            0 :         if (err != CHIP_NO_ERROR)
    3280              :         {
    3281              :             // We won't get any async callbacks here, so just complete our stage.
    3282            0 :             ChipLogError(Controller, "Failed to send ScanNetworks command: %" CHIP_ERROR_FORMAT, err.Format());
    3283            0 :             CommissioningStageComplete(err);
    3284            0 :             return;
    3285              :         }
    3286            0 :         break;
    3287              :     }
    3288            0 :     case CommissioningStage::kNeedsNetworkCreds: {
    3289              :         // nothing to do, the OnScanNetworksSuccess and OnScanNetworksFailure callbacks provide indication to the
    3290              :         // DevicePairingDelegate that network credentials are needed.
    3291            0 :         break;
    3292              :     }
    3293            0 :     case CommissioningStage::kConfigRegulatory: {
    3294              :         // TODO(cecille): Worthwhile to keep this around as part of the class?
    3295              :         // TODO(cecille): Where is the country config actually set?
    3296            0 :         ChipLogProgress(Controller, "Setting Regulatory Config");
    3297              :         auto capability =
    3298            0 :             params.GetLocationCapability().ValueOr(app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum::kOutdoor);
    3299              :         app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum regulatoryConfig;
    3300              :         // Value is only switchable on the devices with indoor/outdoor capability
    3301            0 :         if (capability == app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum::kIndoorOutdoor)
    3302              :         {
    3303              :             // If the device supports indoor and outdoor configs, use the setting from the commissioner, otherwise fall back to
    3304              :             // the current device setting then to outdoor (most restrictive)
    3305            0 :             if (params.GetDeviceRegulatoryLocation().HasValue())
    3306              :             {
    3307            0 :                 regulatoryConfig = params.GetDeviceRegulatoryLocation().Value();
    3308            0 :                 ChipLogProgress(Controller, "Setting regulatory config to %u from commissioner override",
    3309              :                                 static_cast<uint8_t>(regulatoryConfig));
    3310              :             }
    3311            0 :             else if (params.GetDefaultRegulatoryLocation().HasValue())
    3312              :             {
    3313            0 :                 regulatoryConfig = params.GetDefaultRegulatoryLocation().Value();
    3314            0 :                 ChipLogProgress(Controller, "No regulatory config supplied by controller, leaving as device default (%u)",
    3315              :                                 static_cast<uint8_t>(regulatoryConfig));
    3316              :             }
    3317              :             else
    3318              :             {
    3319            0 :                 regulatoryConfig = app::Clusters::GeneralCommissioning::RegulatoryLocationTypeEnum::kOutdoor;
    3320            0 :                 ChipLogProgress(Controller, "No overrride or device regulatory config supplied, setting to outdoor");
    3321              :             }
    3322              :         }
    3323              :         else
    3324              :         {
    3325            0 :             ChipLogProgress(Controller, "Device does not support configurable regulatory location");
    3326            0 :             regulatoryConfig = capability;
    3327              :         }
    3328              : 
    3329            0 :         CharSpan countryCode;
    3330            0 :         const auto & providedCountryCode = params.GetCountryCode();
    3331            0 :         if (providedCountryCode.HasValue())
    3332              :         {
    3333            0 :             countryCode = providedCountryCode.Value();
    3334              :         }
    3335              :         else
    3336              :         {
    3337              :             // Default to "XX", for lack of anything better.
    3338            0 :             countryCode = "XX"_span;
    3339              :         }
    3340              : 
    3341            0 :         GeneralCommissioning::Commands::SetRegulatoryConfig::Type request;
    3342            0 :         request.newRegulatoryConfig = regulatoryConfig;
    3343            0 :         request.countryCode         = countryCode;
    3344            0 :         request.breadcrumb          = breadcrumb;
    3345            0 :         CHIP_ERROR err = SendCommissioningCommand(proxy, request, OnSetRegulatoryConfigResponse, OnBasicFailure, endpoint, timeout);
    3346            0 :         if (err != CHIP_NO_ERROR)
    3347              :         {
    3348              :             // We won't get any async callbacks here, so just complete our stage.
    3349            0 :             ChipLogError(Controller, "Failed to send SetRegulatoryConfig command: %" CHIP_ERROR_FORMAT, err.Format());
    3350            0 :             CommissioningStageComplete(err);
    3351            0 :             return;
    3352              :         }
    3353              :     }
    3354            0 :     break;
    3355            0 :     case CommissioningStage::kConfigureTCAcknowledgments: {
    3356            0 :         ChipLogProgress(Controller, "Setting Terms and Conditions");
    3357              : 
    3358            0 :         if (!params.GetTermsAndConditionsAcknowledgement().HasValue())
    3359              :         {
    3360            0 :             ChipLogProgress(Controller, "Setting Terms and Conditions: Skipped");
    3361            0 :             CommissioningStageComplete(CHIP_NO_ERROR);
    3362            0 :             return;
    3363              :         }
    3364              : 
    3365            0 :         GeneralCommissioning::Commands::SetTCAcknowledgements::Type request;
    3366            0 :         TermsAndConditionsAcknowledgement termsAndConditionsAcknowledgement = params.GetTermsAndConditionsAcknowledgement().Value();
    3367            0 :         request.TCUserResponse = termsAndConditionsAcknowledgement.acceptedTermsAndConditions;
    3368            0 :         request.TCVersion      = termsAndConditionsAcknowledgement.acceptedTermsAndConditionsVersion;
    3369              : 
    3370            0 :         ChipLogProgress(Controller, "Setting Terms and Conditions: %hu, %hu", request.TCUserResponse, request.TCVersion);
    3371              :         CHIP_ERROR err =
    3372            0 :             SendCommissioningCommand(proxy, request, OnSetTCAcknowledgementsResponse, OnBasicFailure, endpoint, timeout);
    3373            0 :         if (err != CHIP_NO_ERROR)
    3374              :         {
    3375            0 :             ChipLogError(Controller, "Failed to send SetTCAcknowledgements command: %" CHIP_ERROR_FORMAT, err.Format());
    3376            0 :             CommissioningStageComplete(err);
    3377            0 :             return;
    3378              :         }
    3379            0 :         break;
    3380              :     }
    3381            0 :     case CommissioningStage::kSendPAICertificateRequest: {
    3382            0 :         ChipLogProgress(Controller, "Sending request for PAI certificate");
    3383            0 :         CHIP_ERROR err = SendCertificateChainRequestCommand(proxy, CertificateType::kPAI, timeout);
    3384            0 :         if (err != CHIP_NO_ERROR)
    3385              :         {
    3386              :             // We won't get any async callbacks here, so just complete our stage.
    3387            0 :             ChipLogError(Controller, "Failed to send CertificateChainRequest command to get PAI: %" CHIP_ERROR_FORMAT,
    3388              :                          err.Format());
    3389            0 :             CommissioningStageComplete(err);
    3390            0 :             return;
    3391              :         }
    3392            0 :         break;
    3393              :     }
    3394            0 :     case CommissioningStage::kSendDACCertificateRequest: {
    3395            0 :         ChipLogProgress(Controller, "Sending request for DAC certificate");
    3396            0 :         CHIP_ERROR err = SendCertificateChainRequestCommand(proxy, CertificateType::kDAC, timeout);
    3397            0 :         if (err != CHIP_NO_ERROR)
    3398              :         {
    3399              :             // We won't get any async callbacks here, so just complete our stage.
    3400            0 :             ChipLogError(Controller, "Failed to send CertificateChainRequest command to get DAC: %" CHIP_ERROR_FORMAT,
    3401              :                          err.Format());
    3402            0 :             CommissioningStageComplete(err);
    3403            0 :             return;
    3404              :         }
    3405            0 :         break;
    3406              :     }
    3407            0 :     case CommissioningStage::kSendAttestationRequest: {
    3408            0 :         ChipLogProgress(Controller, "Sending Attestation Request to the device.");
    3409            0 :         if (!params.GetAttestationNonce().HasValue())
    3410              :         {
    3411            0 :             ChipLogError(Controller, "No attestation nonce found");
    3412            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3413            0 :             return;
    3414              :         }
    3415            0 :         CHIP_ERROR err = SendAttestationRequestCommand(proxy, params.GetAttestationNonce().Value(), timeout);
    3416            0 :         if (err != CHIP_NO_ERROR)
    3417              :         {
    3418              :             // We won't get any async callbacks here, so just complete our stage.
    3419            0 :             ChipLogError(Controller, "Failed to send AttestationRequest command: %" CHIP_ERROR_FORMAT, err.Format());
    3420            0 :             CommissioningStageComplete(err);
    3421            0 :             return;
    3422              :         }
    3423            0 :         break;
    3424              :     }
    3425            0 :     case CommissioningStage::kAttestationVerification: {
    3426            0 :         ChipLogProgress(Controller, "Verifying Device Attestation information received from the device");
    3427            0 :         if (IsAttestationInformationMissing(params))
    3428              :         {
    3429            0 :             ChipLogError(Controller, "Missing attestation information");
    3430            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3431            0 :             return;
    3432              :         }
    3433              : 
    3434              :         DeviceAttestationVerifier::AttestationInfo info(
    3435            0 :             params.GetAttestationElements().Value(),
    3436            0 :             proxy->GetSecureSession().Value()->AsSecureSession()->GetCryptoContext().GetAttestationChallenge(),
    3437            0 :             params.GetAttestationSignature().Value(), params.GetPAI().Value(), params.GetDAC().Value(),
    3438            0 :             params.GetAttestationNonce().Value(), params.GetRemoteVendorId().Value(), params.GetRemoteProductId().Value());
    3439              : 
    3440            0 :         CHIP_ERROR err = ValidateAttestationInfo(info);
    3441            0 :         if (err != CHIP_NO_ERROR)
    3442              :         {
    3443            0 :             ChipLogError(Controller, "Error validating attestation information: %" CHIP_ERROR_FORMAT, err.Format());
    3444            0 :             CommissioningStageComplete(CHIP_ERROR_FAILED_DEVICE_ATTESTATION);
    3445            0 :             return;
    3446              :         }
    3447              :     }
    3448            0 :     break;
    3449            0 :     case CommissioningStage::kAttestationRevocationCheck: {
    3450            0 :         ChipLogProgress(Controller, "Verifying the device's DAC chain revocation status");
    3451            0 :         if (IsAttestationInformationMissing(params))
    3452              :         {
    3453            0 :             ChipLogError(Controller, "Missing attestation information");
    3454            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3455            0 :             return;
    3456              :         }
    3457              : 
    3458              :         DeviceAttestationVerifier::AttestationInfo info(
    3459            0 :             params.GetAttestationElements().Value(),
    3460            0 :             proxy->GetSecureSession().Value()->AsSecureSession()->GetCryptoContext().GetAttestationChallenge(),
    3461            0 :             params.GetAttestationSignature().Value(), params.GetPAI().Value(), params.GetDAC().Value(),
    3462            0 :             params.GetAttestationNonce().Value(), params.GetRemoteVendorId().Value(), params.GetRemoteProductId().Value());
    3463              : 
    3464            0 :         CHIP_ERROR err = CheckForRevokedDACChain(info);
    3465              : 
    3466            0 :         if (err != CHIP_NO_ERROR)
    3467              :         {
    3468            0 :             ChipLogError(Controller, "Error validating device's DAC chain revocation status: %" CHIP_ERROR_FORMAT, err.Format());
    3469            0 :             CommissioningStageComplete(CHIP_ERROR_FAILED_DEVICE_ATTESTATION);
    3470            0 :             return;
    3471              :         }
    3472              :     }
    3473            0 :     break;
    3474            0 :     case CommissioningStage::kJCMTrustVerification: {
    3475            0 :         CHIP_ERROR err = StartJCMTrustVerification();
    3476            0 :         if (err != CHIP_NO_ERROR)
    3477              :         {
    3478            0 :             ChipLogError(Controller, "Failed to start JCM Trust Verification: %" CHIP_ERROR_FORMAT, err.Format());
    3479            0 :             CommissioningStageComplete(err);
    3480            0 :             return;
    3481              :         }
    3482            0 :         break;
    3483              :     }
    3484              : 
    3485            0 :     case CommissioningStage::kSendOpCertSigningRequest: {
    3486            0 :         if (!params.GetCSRNonce().HasValue())
    3487              :         {
    3488            0 :             ChipLogError(Controller, "No CSR nonce found");
    3489            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3490            0 :             return;
    3491              :         }
    3492            0 :         CHIP_ERROR err = SendOperationalCertificateSigningRequestCommand(proxy, params.GetCSRNonce().Value(), timeout);
    3493            0 :         if (err != CHIP_NO_ERROR)
    3494              :         {
    3495              :             // We won't get any async callbacks here, so just complete our stage.
    3496            0 :             ChipLogError(Controller, "Failed to send CSR request: %" CHIP_ERROR_FORMAT, err.Format());
    3497            0 :             CommissioningStageComplete(err);
    3498            0 :             return;
    3499              :         }
    3500            0 :         break;
    3501              :     }
    3502            0 :     case CommissioningStage::kValidateCSR: {
    3503            0 :         if (!params.GetNOCChainGenerationParameters().HasValue() || !params.GetDAC().HasValue() || !params.GetCSRNonce().HasValue())
    3504              :         {
    3505            0 :             ChipLogError(Controller, "Unable to validate CSR");
    3506            0 :             return CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3507              :         }
    3508              :         // This is non-blocking, so send the callback immediately.
    3509            0 :         CHIP_ERROR err = ValidateCSR(proxy, params.GetNOCChainGenerationParameters().Value().nocsrElements,
    3510            0 :                                      params.GetNOCChainGenerationParameters().Value().signature, params.GetDAC().Value(),
    3511            0 :                                      params.GetCSRNonce().Value());
    3512            0 :         if (err != CHIP_NO_ERROR)
    3513              :         {
    3514            0 :             ChipLogError(Controller, "Failed to validate CSR: %" CHIP_ERROR_FORMAT, err.Format());
    3515              :         }
    3516            0 :         CommissioningStageComplete(err);
    3517            0 :         return;
    3518              :     }
    3519              :     break;
    3520            0 :     case CommissioningStage::kGenerateNOCChain: {
    3521            0 :         if (!params.GetNOCChainGenerationParameters().HasValue() || !params.GetDAC().HasValue() || !params.GetPAI().HasValue() ||
    3522            0 :             !params.GetCSRNonce().HasValue())
    3523              :         {
    3524            0 :             ChipLogError(Controller, "Unable to generate NOC chain parameters");
    3525            0 :             return CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3526              :         }
    3527            0 :         CHIP_ERROR err = ProcessCSR(proxy, params.GetNOCChainGenerationParameters().Value().nocsrElements,
    3528            0 :                                     params.GetNOCChainGenerationParameters().Value().signature, params.GetDAC().Value(),
    3529            0 :                                     params.GetPAI().Value(), params.GetCSRNonce().Value());
    3530            0 :         if (err != CHIP_NO_ERROR)
    3531              :         {
    3532            0 :             ChipLogError(Controller, "Failed to process Operational Certificate Signing Request (CSR): %" CHIP_ERROR_FORMAT,
    3533              :                          err.Format());
    3534            0 :             CommissioningStageComplete(err);
    3535            0 :             return;
    3536              :         }
    3537              :     }
    3538            0 :     break;
    3539            0 :     case CommissioningStage::kSendTrustedRootCert: {
    3540            0 :         if (!params.GetRootCert().HasValue() || !params.GetNoc().HasValue())
    3541              :         {
    3542            0 :             ChipLogError(Controller, "No trusted root cert or NOC specified");
    3543            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3544            0 :             return;
    3545              :         }
    3546            0 :         CHIP_ERROR err = SendTrustedRootCertificate(proxy, params.GetRootCert().Value(), timeout);
    3547            0 :         if (err != CHIP_NO_ERROR)
    3548              :         {
    3549            0 :             ChipLogError(Controller, "Error sending trusted root certificate: %" CHIP_ERROR_FORMAT, err.Format());
    3550            0 :             CommissioningStageComplete(err);
    3551            0 :             return;
    3552              :         }
    3553              : 
    3554            0 :         err = proxy->SetPeerId(params.GetRootCert().Value(), params.GetNoc().Value());
    3555            0 :         if (err != CHIP_NO_ERROR)
    3556              :         {
    3557            0 :             ChipLogError(Controller, "Error setting peer id: %" CHIP_ERROR_FORMAT, err.Format());
    3558            0 :             CommissioningStageComplete(err);
    3559            0 :             return;
    3560              :         }
    3561            0 :         if (!IsOperationalNodeId(proxy->GetDeviceId()))
    3562              :         {
    3563            0 :             ChipLogError(Controller, "Given node ID is not an operational node ID");
    3564            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3565            0 :             return;
    3566              :         }
    3567              :     }
    3568            0 :     break;
    3569            0 :     case CommissioningStage::kSendNOC: {
    3570            0 :         if (!params.GetNoc().HasValue() || !params.GetIpk().HasValue() || !params.GetAdminSubject().HasValue())
    3571              :         {
    3572            0 :             ChipLogError(Controller, "AddNOC contents not specified");
    3573            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3574            0 :             return;
    3575              :         }
    3576            0 :         CHIP_ERROR err = SendOperationalCertificate(proxy, params.GetNoc().Value(), params.GetIcac(), params.GetIpk().Value(),
    3577            0 :                                                     params.GetAdminSubject().Value(), timeout);
    3578            0 :         if (err != CHIP_NO_ERROR)
    3579              :         {
    3580              :             // We won't get any async callbacks here, so just complete our stage.
    3581            0 :             ChipLogError(Controller, "Error installing operational certificate with AddNOC: %" CHIP_ERROR_FORMAT, err.Format());
    3582            0 :             CommissioningStageComplete(err);
    3583            0 :             return;
    3584              :         }
    3585            0 :         break;
    3586              :     }
    3587            0 :     case CommissioningStage::kConfigureTrustedTimeSource: {
    3588            0 :         if (!params.GetTrustedTimeSource().HasValue())
    3589              :         {
    3590            0 :             ChipLogError(Controller, "ConfigureTrustedTimeSource stage called with no trusted time source data!");
    3591            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3592            0 :             return;
    3593              :         }
    3594            0 :         TimeSynchronization::Commands::SetTrustedTimeSource::Type request;
    3595            0 :         request.trustedTimeSource = params.GetTrustedTimeSource().Value();
    3596            0 :         CHIP_ERROR err            = SendCommissioningCommand(proxy, request, OnBasicSuccess, OnBasicFailure, endpoint, timeout);
    3597            0 :         if (err != CHIP_NO_ERROR)
    3598              :         {
    3599              :             // We won't get any async callbacks here, so just complete our stage.
    3600            0 :             ChipLogError(Controller, "Failed to send SendTrustedTimeSource command: %" CHIP_ERROR_FORMAT, err.Format());
    3601            0 :             CommissioningStageComplete(err);
    3602            0 :             return;
    3603              :         }
    3604            0 :         break;
    3605              :     }
    3606            0 :     case CommissioningStage::kWiFiNetworkSetup: {
    3607            0 :         if (!params.GetWiFiCredentials().HasValue())
    3608              :         {
    3609            0 :             ChipLogError(Controller, "No wifi credentials specified");
    3610            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3611            0 :             return;
    3612              :         }
    3613              : 
    3614            0 :         NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type request;
    3615            0 :         request.ssid        = params.GetWiFiCredentials().Value().ssid;
    3616            0 :         request.credentials = params.GetWiFiCredentials().Value().credentials;
    3617            0 :         request.breadcrumb.Emplace(breadcrumb);
    3618            0 :         CHIP_ERROR err = SendCommissioningCommand(proxy, request, OnNetworkConfigResponse, OnBasicFailure, endpoint, timeout);
    3619            0 :         if (err != CHIP_NO_ERROR)
    3620              :         {
    3621              :             // We won't get any async callbacks here, so just complete our stage.
    3622            0 :             ChipLogError(Controller, "Failed to send AddOrUpdateWiFiNetwork command: %" CHIP_ERROR_FORMAT, err.Format());
    3623            0 :             CommissioningStageComplete(err);
    3624            0 :             return;
    3625              :         }
    3626              :     }
    3627            0 :     break;
    3628            0 :     case CommissioningStage::kThreadNetworkSetup: {
    3629            0 :         if (!params.GetThreadOperationalDataset().HasValue())
    3630              :         {
    3631            0 :             ChipLogError(Controller, "No thread credentials specified");
    3632            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3633            0 :             return;
    3634              :         }
    3635            0 :         NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type request;
    3636            0 :         request.operationalDataset = params.GetThreadOperationalDataset().Value();
    3637            0 :         request.breadcrumb.Emplace(breadcrumb);
    3638            0 :         CHIP_ERROR err = SendCommissioningCommand(proxy, request, OnNetworkConfigResponse, OnBasicFailure, endpoint, timeout);
    3639            0 :         if (err != CHIP_NO_ERROR)
    3640              :         {
    3641              :             // We won't get any async callbacks here, so just complete our stage.
    3642            0 :             ChipLogError(Controller, "Failed to send AddOrUpdateThreadNetwork command: %" CHIP_ERROR_FORMAT, err.Format());
    3643            0 :             CommissioningStageComplete(err);
    3644            0 :             return;
    3645              :         }
    3646              :     }
    3647            0 :     break;
    3648            0 :     case CommissioningStage::kFailsafeBeforeWiFiEnable:
    3649              :         FALLTHROUGH;
    3650              :     case CommissioningStage::kFailsafeBeforeThreadEnable:
    3651              :         // Before we try to do network enablement, make sure that our fail-safe
    3652              :         // is set far enough out that we can later try to do operational
    3653              :         // discovery without it timing out.
    3654            0 :         ExtendFailsafeBeforeNetworkEnable(proxy, params, step);
    3655            0 :         break;
    3656            0 :     case CommissioningStage::kWiFiNetworkEnable: {
    3657            0 :         if (!params.GetWiFiCredentials().HasValue())
    3658              :         {
    3659            0 :             ChipLogError(Controller, "No wifi credentials specified");
    3660            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3661            0 :             return;
    3662              :         }
    3663            0 :         NetworkCommissioning::Commands::ConnectNetwork::Type request;
    3664            0 :         request.networkID = params.GetWiFiCredentials().Value().ssid;
    3665            0 :         request.breadcrumb.Emplace(breadcrumb);
    3666              : 
    3667            0 :         CHIP_ERROR err = CHIP_NO_ERROR;
    3668            0 :         ChipLogProgress(Controller, "SendCommand kWiFiNetworkEnable, supportsConcurrentConnection=%s",
    3669              :                         params.GetSupportsConcurrentConnection().HasValue()
    3670              :                             ? (params.GetSupportsConcurrentConnection().Value() ? "true" : "false")
    3671              :                             : "missing");
    3672            0 :         err = SendCommissioningCommand(proxy, request, OnConnectNetworkResponse, OnBasicFailure, endpoint, timeout);
    3673              : 
    3674            0 :         if (err != CHIP_NO_ERROR)
    3675              :         {
    3676              :             // We won't get any async callbacks here, so just complete our stage.
    3677            0 :             ChipLogError(Controller, "Failed to send WiFi ConnectNetwork command: %" CHIP_ERROR_FORMAT, err.Format());
    3678            0 :             CommissioningStageComplete(err);
    3679            0 :             return;
    3680              :         }
    3681              :     }
    3682            0 :     break;
    3683            0 :     case CommissioningStage::kThreadNetworkEnable: {
    3684            0 :         ByteSpan extendedPanId;
    3685            0 :         chip::Thread::OperationalDataset operationalDataset;
    3686            0 :         if (!params.GetThreadOperationalDataset().HasValue() ||
    3687            0 :             operationalDataset.Init(params.GetThreadOperationalDataset().Value()) != CHIP_NO_ERROR ||
    3688            0 :             operationalDataset.GetExtendedPanIdAsByteSpan(extendedPanId) != CHIP_NO_ERROR)
    3689              :         {
    3690            0 :             ChipLogError(Controller, "Invalid Thread operational dataset configured at commissioner!");
    3691            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3692            0 :             return;
    3693              :         }
    3694            0 :         NetworkCommissioning::Commands::ConnectNetwork::Type request;
    3695            0 :         request.networkID = extendedPanId;
    3696            0 :         request.breadcrumb.Emplace(breadcrumb);
    3697            0 :         CHIP_ERROR err = SendCommissioningCommand(proxy, request, OnConnectNetworkResponse, OnBasicFailure, endpoint, timeout);
    3698            0 :         if (err != CHIP_NO_ERROR)
    3699              :         {
    3700              :             // We won't get any async callbacks here, so just complete our stage.
    3701            0 :             ChipLogError(Controller, "Failed to send Thread ConnectNetwork command: %" CHIP_ERROR_FORMAT, err.Format());
    3702            0 :             CommissioningStageComplete(err);
    3703            0 :             return;
    3704              :         }
    3705              :     }
    3706            0 :     break;
    3707            0 :     case CommissioningStage::kICDGetRegistrationInfo: {
    3708            0 :         GetPairingDelegate()->OnICDRegistrationInfoRequired();
    3709            0 :         return;
    3710              :     }
    3711              :     break;
    3712            0 :     case CommissioningStage::kICDRegistration: {
    3713            0 :         IcdManagement::Commands::RegisterClient::Type request;
    3714              : 
    3715            0 :         if (!(params.GetICDCheckInNodeId().HasValue() && params.GetICDMonitoredSubject().HasValue() &&
    3716            0 :               params.GetICDSymmetricKey().HasValue()))
    3717              :         {
    3718            0 :             ChipLogError(Controller, "No ICD Registration information provided!");
    3719            0 :             CommissioningStageComplete(CHIP_ERROR_INCORRECT_STATE);
    3720            0 :             return;
    3721              :         }
    3722              : 
    3723            0 :         request.checkInNodeID    = params.GetICDCheckInNodeId().Value();
    3724            0 :         request.monitoredSubject = params.GetICDMonitoredSubject().Value();
    3725            0 :         request.key              = params.GetICDSymmetricKey().Value();
    3726              : 
    3727              :         CHIP_ERROR err =
    3728            0 :             SendCommissioningCommand(proxy, request, OnICDManagementRegisterClientResponse, OnBasicFailure, endpoint, timeout);
    3729            0 :         if (err != CHIP_NO_ERROR)
    3730              :         {
    3731              :             // We won't get any async callbacks here, so just complete our stage.
    3732            0 :             ChipLogError(Controller, "Failed to send IcdManagement.RegisterClient command: %" CHIP_ERROR_FORMAT, err.Format());
    3733            0 :             CommissioningStageComplete(err);
    3734            0 :             return;
    3735              :         }
    3736              :     }
    3737            0 :     break;
    3738            0 :     case CommissioningStage::kEvictPreviousCaseSessions: {
    3739            0 :         auto scopedPeerId = GetPeerScopedId(proxy->GetDeviceId());
    3740              : 
    3741              :         // If we ever had a commissioned device with this node ID before, we may
    3742              :         // have stale sessions to it.  Make sure we don't re-use any of those,
    3743              :         // because clearly they are not related to this new device we are
    3744              :         // commissioning.  We only care about sessions we might reuse, so just
    3745              :         // clearing the ones associated with our fabric index is good enough and
    3746              :         // we don't need to worry about ExpireAllSessionsOnLogicalFabric.
    3747            0 :         mSystemState->SessionMgr()->ExpireAllSessions(scopedPeerId);
    3748            0 :         CommissioningStageComplete(CHIP_NO_ERROR);
    3749            0 :         return;
    3750              :     }
    3751            0 :     case CommissioningStage::kFindOperationalForStayActive:
    3752              :     case CommissioningStage::kFindOperationalForCommissioningComplete: {
    3753              :         // If there is an error, CommissioningStageComplete will be called from OnDeviceConnectionFailureFn.
    3754            0 :         auto scopedPeerId = GetPeerScopedId(proxy->GetDeviceId());
    3755              :         MATTER_LOG_METRIC_BEGIN(kMetricDeviceCommissioningOperationalSetup);
    3756            0 :         mSystemState->CASESessionMgr()->FindOrEstablishSession(scopedPeerId, &mOnDeviceConnectedCallback,
    3757              :                                                                &mOnDeviceConnectionFailureCallback
    3758              : #if CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
    3759              :                                                                ,
    3760              :                                                                /* attemptCount = */ 3, &mOnDeviceConnectionRetryCallback
    3761              : #endif // CHIP_DEVICE_CONFIG_ENABLE_AUTOMATIC_CASE_RETRIES
    3762              :         );
    3763              :     }
    3764            0 :     break;
    3765            0 :     case CommissioningStage::kPrimaryOperationalNetworkFailed: {
    3766              :         // nothing to do. This stage indicates that the primary operational network failed and the network config should be
    3767              :         // removed later.
    3768            0 :         break;
    3769              :     }
    3770            0 :     case CommissioningStage::kRemoveWiFiNetworkConfig: {
    3771            0 :         NetworkCommissioning::Commands::RemoveNetwork::Type request;
    3772            0 :         request.networkID = params.GetWiFiCredentials().Value().ssid;
    3773            0 :         request.breadcrumb.Emplace(breadcrumb);
    3774            0 :         CHIP_ERROR err = SendCommissioningCommand(proxy, request, OnNetworkConfigResponse, OnBasicFailure, endpoint, timeout);
    3775            0 :         if (err != CHIP_NO_ERROR)
    3776              :         {
    3777              :             // We won't get any async callbacks here, so just complete our stage.
    3778            0 :             ChipLogError(Controller, "Failed to send RemoveNetwork command: %" CHIP_ERROR_FORMAT, err.Format());
    3779            0 :             CommissioningStageComplete(err);
    3780            0 :             return;
    3781              :         }
    3782            0 :         break;
    3783              :     }
    3784            0 :     case CommissioningStage::kRemoveThreadNetworkConfig: {
    3785            0 :         ByteSpan extendedPanId;
    3786            0 :         chip::Thread::OperationalDataset operationalDataset;
    3787            0 :         if (!params.GetThreadOperationalDataset().HasValue() ||
    3788            0 :             operationalDataset.Init(params.GetThreadOperationalDataset().Value()) != CHIP_NO_ERROR ||
    3789            0 :             operationalDataset.GetExtendedPanIdAsByteSpan(extendedPanId) != CHIP_NO_ERROR)
    3790              :         {
    3791            0 :             ChipLogError(Controller, "Invalid Thread operational dataset configured at commissioner!");
    3792            0 :             CommissioningStageComplete(CHIP_ERROR_INVALID_ARGUMENT);
    3793            0 :             return;
    3794              :         }
    3795            0 :         NetworkCommissioning::Commands::RemoveNetwork::Type request;
    3796            0 :         request.networkID = extendedPanId;
    3797            0 :         request.breadcrumb.Emplace(breadcrumb);
    3798            0 :         CHIP_ERROR err = SendCommissioningCommand(proxy, request, OnNetworkConfigResponse, OnBasicFailure, endpoint, timeout);
    3799            0 :         if (err != CHIP_NO_ERROR)
    3800              :         {
    3801              :             // We won't get any async callbacks here, so just complete our stage.
    3802            0 :             ChipLogError(Controller, "Failed to send RemoveNetwork command: %" CHIP_ERROR_FORMAT, err.Format());
    3803            0 :             CommissioningStageComplete(err);
    3804            0 :             return;
    3805              :         }
    3806            0 :         break;
    3807              :     }
    3808            0 :     case CommissioningStage::kICDSendStayActive: {
    3809            0 :         if (!(params.GetICDStayActiveDurationMsec().HasValue()))
    3810              :         {
    3811            0 :             ChipLogProgress(Controller, "Skipping kICDSendStayActive");
    3812            0 :             CommissioningStageComplete(CHIP_NO_ERROR);
    3813            0 :             return;
    3814              :         }
    3815              : 
    3816              :         // StayActive Command happens over CASE Connection
    3817            0 :         IcdManagement::Commands::StayActiveRequest::Type request;
    3818            0 :         request.stayActiveDuration = params.GetICDStayActiveDurationMsec().Value();
    3819            0 :         ChipLogError(Controller, "Send ICD StayActive with Duration %u", request.stayActiveDuration);
    3820              :         CHIP_ERROR err =
    3821            0 :             SendCommissioningCommand(proxy, request, OnICDManagementStayActiveResponse, OnBasicFailure, endpoint, timeout);
    3822            0 :         if (err != CHIP_NO_ERROR)
    3823              :         {
    3824              :             // We won't get any async callbacks here, so just complete our stage.
    3825            0 :             ChipLogError(Controller, "Failed to send IcdManagement.StayActive command: %" CHIP_ERROR_FORMAT, err.Format());
    3826            0 :             CommissioningStageComplete(err);
    3827            0 :             return;
    3828              :         }
    3829              :     }
    3830            0 :     break;
    3831            0 :     case CommissioningStage::kSendComplete: {
    3832              :         // CommissioningComplete command happens over the CASE connection.
    3833              :         GeneralCommissioning::Commands::CommissioningComplete::Type request;
    3834              :         CHIP_ERROR err =
    3835            0 :             SendCommissioningCommand(proxy, request, OnCommissioningCompleteResponse, OnBasicFailure, endpoint, timeout);
    3836            0 :         if (err != CHIP_NO_ERROR)
    3837              :         {
    3838              :             // We won't get any async callbacks here, so just complete our stage.
    3839            0 :             ChipLogError(Controller, "Failed to send CommissioningComplete command: %" CHIP_ERROR_FORMAT, err.Format());
    3840            0 :             CommissioningStageComplete(err);
    3841            0 :             return;
    3842              :         }
    3843              :     }
    3844            0 :     break;
    3845              : #if CHIP_DEVICE_CONFIG_ENABLE_NFC_BASED_COMMISSIONING
    3846              :     case CommissioningStage::kUnpoweredPhaseComplete:
    3847              :         ChipLogProgress(Controller, "Completed unpowered commissioning phase, marking commissioning as complete");
    3848              :         CommissioningStageComplete(CHIP_NO_ERROR);
    3849              :         break;
    3850              : #endif
    3851            0 :     case CommissioningStage::kCleanup:
    3852            0 :         CleanupCommissioning(proxy, proxy->GetDeviceId(), params.GetCompletionStatus());
    3853            0 :         break;
    3854            0 :     case CommissioningStage::kError:
    3855            0 :         mCommissioningStage = CommissioningStage::kSecurePairing;
    3856            0 :         break;
    3857            0 :     case CommissioningStage::kSecurePairing:
    3858            0 :         break;
    3859              :     }
    3860              : }
    3861              : 
    3862            0 : void DeviceCommissioner::ExtendFailsafeBeforeNetworkEnable(DeviceProxy * device, CommissioningParameters & params,
    3863              :                                                            CommissioningStage step)
    3864              : {
    3865            0 :     auto * commissioneeDevice = FindCommissioneeDevice(device->GetDeviceId());
    3866            0 :     if (device != commissioneeDevice)
    3867              :     {
    3868              :         // Not a commissionee device; just return.
    3869            0 :         ChipLogError(Controller, "Trying to extend fail-safe for an unknown commissionee with device id " ChipLogFormatX64,
    3870              :                      ChipLogValueX64(device->GetDeviceId()));
    3871            0 :         CommissioningStageComplete(CHIP_ERROR_INCORRECT_STATE, CommissioningDelegate::CommissioningReport());
    3872            0 :         return;
    3873              :     }
    3874              : 
    3875              :     // Try to make sure we have at least enough time for our expected
    3876              :     // commissioning bits plus the MRP retries for a Sigma1.
    3877            0 :     uint16_t failSafeTimeoutSecs = params.GetFailsafeTimerSeconds().ValueOr(kDefaultFailsafeTimeout);
    3878            0 :     auto sigma1Timeout           = CASESession::ComputeSigma1ResponseTimeout(commissioneeDevice->GetPairing().GetRemoteMRPConfig());
    3879            0 :     uint16_t sigma1TimeoutSecs   = std::chrono::duration_cast<System::Clock::Seconds16>(sigma1Timeout).count();
    3880            0 :     if (UINT16_MAX - failSafeTimeoutSecs < sigma1TimeoutSecs)
    3881              :     {
    3882            0 :         failSafeTimeoutSecs = UINT16_MAX;
    3883              :     }
    3884              :     else
    3885              :     {
    3886            0 :         failSafeTimeoutSecs = static_cast<uint16_t>(failSafeTimeoutSecs + sigma1TimeoutSecs);
    3887              :     }
    3888              : 
    3889            0 :     if (!ExtendArmFailSafeInternal(commissioneeDevice, step, failSafeTimeoutSecs, MakeOptional(kMinimumCommissioningStepTimeout),
    3890              :                                    OnArmFailSafe, OnBasicFailure, /* fireAndForget = */ false))
    3891              :     {
    3892              :         // A false return is fine; we don't want to make the fail-safe shorter here.
    3893            0 :         CommissioningStageComplete(CHIP_NO_ERROR, CommissioningDelegate::CommissioningReport());
    3894              :     }
    3895              : }
    3896              : 
    3897            0 : bool DeviceCommissioner::IsAttestationInformationMissing(const CommissioningParameters & params)
    3898              : {
    3899            0 :     if (!params.GetAttestationElements().HasValue() || !params.GetAttestationSignature().HasValue() ||
    3900            0 :         !params.GetAttestationNonce().HasValue() || !params.GetDAC().HasValue() || !params.GetPAI().HasValue() ||
    3901            0 :         !params.GetRemoteVendorId().HasValue() || !params.GetRemoteProductId().HasValue())
    3902              :     {
    3903            0 :         return true;
    3904              :     }
    3905              : 
    3906            0 :     return false;
    3907              : }
    3908              : 
    3909            0 : CHIP_ERROR DeviceController::GetCompressedFabricIdBytes(MutableByteSpan & outBytes) const
    3910              : {
    3911            0 :     const auto * fabricInfo = GetFabricInfo();
    3912            0 :     VerifyOrReturnError(fabricInfo != nullptr, CHIP_ERROR_INVALID_FABRIC_INDEX);
    3913            0 :     return fabricInfo->GetCompressedFabricIdBytes(outBytes);
    3914              : }
    3915              : 
    3916            0 : CHIP_ERROR DeviceController::GetRootPublicKey(Crypto::P256PublicKey & outRootPublicKey) const
    3917              : {
    3918            0 :     const auto * fabricTable = GetFabricTable();
    3919            0 :     VerifyOrReturnError(fabricTable != nullptr, CHIP_ERROR_INCORRECT_STATE);
    3920            0 :     return fabricTable->FetchRootPubkey(mFabricIndex, outRootPublicKey);
    3921              : }
    3922              : 
    3923            0 : bool DeviceCommissioner::HasValidCommissioningMode(const Dnssd::CommissionNodeData & nodeData)
    3924              : {
    3925            0 :     if (nodeData.commissioningMode == to_underlying(Dnssd::CommissioningMode::kDisabled))
    3926              :     {
    3927            0 :         ChipLogProgress(Controller, "Discovered device does not have an open commissioning window.");
    3928            0 :         return false;
    3929              :     }
    3930            0 :     return true;
    3931              : }
    3932              : 
    3933              : } // namespace Controller
    3934              : } // namespace chip
        

Generated by: LCOV version 2.0-1