| /* | |
| * Copyright (c) 2021-2022 Project CHIP Authors | |
| * All rights reserved. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * | |
| */ | |
| #include "CHIPCommand.h" | |
| #include <commands/icd/ICDCommand.h> | |
| #include <controller/CHIPDeviceControllerFactory.h> | |
| #include <credentials/attestation_verifier/FileAttestationTrustStore.h> | |
| #include <credentials/attestation_verifier/TestDACRevocationDelegateImpl.h> | |
| #include <data-model-providers/codegen/Instance.h> | |
| #include <lib/core/CHIPConfig.h> | |
| #include <lib/core/CHIPVendorIdentifiers.hpp> | |
| #include <lib/support/CodeUtils.h> | |
| #include <lib/support/ScopedMemoryBuffer.h> | |
| #include <lib/support/TestGroupData.h> | |
| #include <platform/LockTracker.h> | |
| #include <string> | |
| #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED | |
| #include "TraceDecoder.h" | |
| #include "TraceHandlers.h" | |
| #endif // CHIP_CONFIG_TRANSPORT_TRACE_ENABLED | |
| std::map<CHIPCommand::CommissionerIdentity, std::unique_ptr<chip::Controller::DeviceCommissioner>> CHIPCommand::mCommissioners; | |
| std::set<CHIPCommand *> CHIPCommand::sDeferredCleanups; | |
| using DeviceControllerFactory = chip::Controller::DeviceControllerFactory; | |
| constexpr chip::FabricId kIdentityNullFabricId = chip::kUndefinedFabricId; | |
| constexpr chip::FabricId kIdentityAlphaFabricId = 1; | |
| constexpr chip::FabricId kIdentityBetaFabricId = 2; | |
| constexpr chip::FabricId kIdentityGammaFabricId = 3; | |
| constexpr chip::FabricId kIdentityOtherFabricId = 4; | |
| constexpr char kPAATrustStorePathVariable[] = "CHIPTOOL_PAA_TRUST_STORE_PATH"; | |
| constexpr char kCDTrustStorePathVariable[] = "CHIPTOOL_CD_TRUST_STORE_PATH"; | |
| const chip::Credentials::AttestationTrustStore * CHIPCommand::sTrustStore = nullptr; | |
| chip::Credentials::DeviceAttestationRevocationDelegate * CHIPCommand::sRevocationDelegate = nullptr; | |
| chip::Credentials::GroupDataProviderImpl CHIPCommand::sGroupDataProvider{ kMaxGroupsPerFabric, kMaxGroupKeysPerFabric }; | |
| // All fabrics share the same ICD client storage. | |
| chip::app::DefaultICDClientStorage CHIPCommand::sICDClientStorage; | |
| chip::Crypto::RawKeySessionKeystore CHIPCommand::sSessionKeystore; | |
| chip::app::CheckInHandler CHIPCommand::sCheckInHandler; | |
| namespace { | |
| CHIP_ERROR GetAttestationTrustStore(const char * paaTrustStorePath, const chip::Credentials::AttestationTrustStore ** trustStore) | |
| { | |
| if (paaTrustStorePath == nullptr) | |
| { | |
| paaTrustStorePath = getenv(kPAATrustStorePathVariable); | |
| } | |
| if (paaTrustStorePath == nullptr) | |
| { | |
| *trustStore = chip::Credentials::GetTestAttestationTrustStore(); | |
| return CHIP_NO_ERROR; | |
| } | |
| static chip::Credentials::FileAttestationTrustStore attestationTrustStore{ paaTrustStorePath }; | |
| if (paaTrustStorePath != nullptr && attestationTrustStore.paaCount() == 0) | |
| { | |
| ChipLogError(chipTool, "No PAAs found in path: %s", paaTrustStorePath); | |
| ChipLogError(chipTool, | |
| "Please specify a valid path containing trusted PAA certificates using " | |
| "the argument [--paa-trust-store-path paa/file/path] " | |
| "or environment variable [%s=paa/file/path]", | |
| kPAATrustStorePathVariable); | |
| return CHIP_ERROR_INVALID_ARGUMENT; | |
| } | |
| *trustStore = &attestationTrustStore; | |
| return CHIP_NO_ERROR; | |
| } | |
| CHIP_ERROR GetAttestationRevocationDelegate(const char * revocationSetPath, | |
| chip::Credentials::DeviceAttestationRevocationDelegate ** revocationDelegate) | |
| { | |
| if (revocationSetPath == nullptr) | |
| { | |
| return CHIP_NO_ERROR; | |
| } | |
| static chip::Credentials::TestDACRevocationDelegateImpl testDacRevocationDelegate; | |
| ReturnErrorOnFailure(testDacRevocationDelegate.SetDeviceAttestationRevocationSetPath(revocationSetPath)); | |
| *revocationDelegate = &testDacRevocationDelegate; | |
| return CHIP_NO_ERROR; | |
| } | |
| } // namespace | |
| CHIP_ERROR CHIPCommand::MaybeSetUpStack() | |
| { | |
| if (IsInteractive()) | |
| { | |
| return CHIP_NO_ERROR; | |
| } | |
| StartTracing(); | |
| #if (CHIP_DEVICE_LAYER_TARGET_LINUX || CHIP_DEVICE_LAYER_TARGET_TIZEN) && CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE | |
| // By default, Linux device is configured as a BLE peripheral while the controller needs a BLE central. | |
| ReturnLogErrorOnFailure(chip::DeviceLayer::Internal::BLEMgrImpl().ConfigureBle(mBleAdapterId.ValueOr(0), true)); | |
| #endif | |
| ReturnLogErrorOnFailure(mDefaultStorage.Init(nullptr, GetStorageDirectory().ValueOr(nullptr))); | |
| ReturnLogErrorOnFailure(mOperationalKeystore.Init(&mDefaultStorage)); | |
| ReturnLogErrorOnFailure(mOpCertStore.Init(&mDefaultStorage)); | |
| // chip-tool uses a non-persistent keystore. | |
| // ICD storage lifetime is currently tied to the chip-tool's lifetime. Since chip-tool interactive mode is currently used for | |
| // ICD commissioning and check-in validation, this temporary storage meets the test requirements. | |
| // TODO: Implement persistent ICD storage for the chip-tool. | |
| ReturnLogErrorOnFailure(sICDClientStorage.Init(&mDefaultStorage, &sSessionKeystore)); | |
| chip::Controller::FactoryInitParams factoryInitParams; | |
| factoryInitParams.fabricIndependentStorage = &mDefaultStorage; | |
| factoryInitParams.operationalKeystore = &mOperationalKeystore; | |
| factoryInitParams.opCertStore = &mOpCertStore; | |
| factoryInitParams.enableServerInteractions = NeedsOperationalAdvertising(); | |
| factoryInitParams.sessionKeystore = &sSessionKeystore; | |
| factoryInitParams.dataModelProvider = chip::app::CodegenDataModelProviderInstance(&mDefaultStorage); | |
| // Init group data provider that will be used for all group keys and IPKs for the | |
| // chip-tool-configured fabrics. This is OK to do once since the fabric tables | |
| // and the DeviceControllerFactory all "share" in the same underlying data. | |
| // Different commissioner implementations may want to use alternate implementations | |
| // of GroupDataProvider for injection through factoryInitParams. | |
| sGroupDataProvider.SetStorageDelegate(&mDefaultStorage); | |
| sGroupDataProvider.SetSessionKeystore(factoryInitParams.sessionKeystore); | |
| ReturnLogErrorOnFailure(sGroupDataProvider.Init()); | |
| chip::Credentials::SetGroupDataProvider(&sGroupDataProvider); | |
| factoryInitParams.groupDataProvider = &sGroupDataProvider; | |
| uint16_t port = mDefaultStorage.GetListenPort(); | |
| if (port != 0) | |
| { | |
| // Make sure different commissioners run on different ports. | |
| port = static_cast<uint16_t>(port + CurrentCommissionerId()); | |
| } | |
| factoryInitParams.listenPort = port; | |
| if (mInterfaceId.HasValue()) | |
| { | |
| factoryInitParams.interfaceId = | |
| chip::Inet::InterfaceId(static_cast<chip::Inet::InterfaceId::PlatformType>(mInterfaceId.Value())); | |
| } | |
| ReturnLogErrorOnFailure(DeviceControllerFactory::GetInstance().Init(factoryInitParams)); | |
| auto systemState = chip::Controller::DeviceControllerFactory::GetInstance().GetSystemState(); | |
| VerifyOrReturnError(nullptr != systemState, CHIP_ERROR_INCORRECT_STATE); | |
| auto server = systemState->BDXTransferServer(); | |
| VerifyOrReturnError(nullptr != server, CHIP_ERROR_INCORRECT_STATE); | |
| server->SetDelegate(&BDXDiagnosticLogsServerDelegate::GetInstance()); | |
| ReturnErrorOnFailure(GetAttestationTrustStore(mPaaTrustStorePath.ValueOr(nullptr), &sTrustStore)); | |
| ReturnLogErrorOnFailure(GetAttestationRevocationDelegate(mDacRevocationSetPath.ValueOr(nullptr), &sRevocationDelegate)); | |
| auto engine = chip::app::InteractionModelEngine::GetInstance(); | |
| VerifyOrReturnError(engine != nullptr, CHIP_ERROR_INCORRECT_STATE); | |
| ReturnLogErrorOnFailure(ChipToolCheckInDelegate()->Init(&sICDClientStorage, engine)); | |
| ReturnLogErrorOnFailure(sCheckInHandler.Init(DeviceControllerFactory::GetInstance().GetSystemState()->ExchangeMgr(), | |
| &sICDClientStorage, ChipToolCheckInDelegate(), engine)); | |
| CommissionerIdentity nullIdentity{ kIdentityNull, chip::kUndefinedNodeId }; | |
| ReturnLogErrorOnFailure(InitializeCommissioner(nullIdentity, kIdentityNullFabricId)); | |
| // After initializing first commissioner, add the additional CD certs once | |
| { | |
| const char * cdTrustStorePath = mCDTrustStorePath.ValueOr(nullptr); | |
| if (cdTrustStorePath == nullptr) | |
| { | |
| cdTrustStorePath = getenv(kCDTrustStorePathVariable); | |
| } | |
| auto additionalCdCerts = | |
| chip::Credentials::LoadAllX509DerCerts(cdTrustStorePath, chip::Credentials::CertificateValidationMode::kPublicKeyOnly); | |
| if (cdTrustStorePath != nullptr && additionalCdCerts.size() == 0) | |
| { | |
| ChipLogError(chipTool, "Warning: no CD signing certs found in path: %s, only defaults will be used", cdTrustStorePath); | |
| ChipLogError(chipTool, | |
| "Please specify a path containing trusted CD verifying key certificates using " | |
| "the argument [--cd-trust-store-path cd/file/path] " | |
| "or environment variable [%s=cd/file/path]", | |
| kCDTrustStorePathVariable); | |
| } | |
| ReturnErrorOnFailure(mCredIssuerCmds->AddAdditionalCDVerifyingCerts(additionalCdCerts)); | |
| } | |
| bool allowTestCdSigningKey = !mOnlyAllowTrustedCdKeys.ValueOr(false); | |
| mCredIssuerCmds->SetCredentialIssuerOption(CredentialIssuerCommands::CredentialIssuerOptions::kAllowTestCdSigningKey, | |
| allowTestCdSigningKey); | |
| return CHIP_NO_ERROR; | |
| } | |
| void CHIPCommand::MaybeTearDownStack() | |
| { | |
| if (IsInteractive()) | |
| { | |
| return; | |
| } | |
| // | |
| // We can call DeviceController::Shutdown() safely without grabbing the stack lock | |
| // since the CHIP thread and event queue have been stopped, preventing any thread | |
| // races. | |
| // | |
| for (auto & commissioner : mCommissioners) | |
| { | |
| ShutdownCommissioner(commissioner.first); | |
| } | |
| StopTracing(); | |
| } | |
| CHIP_ERROR CHIPCommand::EnsureCommissionerForIdentity(std::string identity) | |
| { | |
| chip::NodeId nodeId; | |
| ReturnErrorOnFailure(GetIdentityNodeId(identity, &nodeId)); | |
| CommissionerIdentity lookupKey{ identity, nodeId }; | |
| if (mCommissioners.find(lookupKey) != mCommissioners.end()) | |
| { | |
| return CHIP_NO_ERROR; | |
| } | |
| // Need to initialize the commissioner. | |
| chip::FabricId fabricId; | |
| if (identity == kIdentityAlpha) | |
| { | |
| fabricId = kIdentityAlphaFabricId; | |
| } | |
| else if (identity == kIdentityBeta) | |
| { | |
| fabricId = kIdentityBetaFabricId; | |
| } | |
| else if (identity == kIdentityGamma) | |
| { | |
| fabricId = kIdentityGammaFabricId; | |
| } | |
| else | |
| { | |
| fabricId = strtoull(identity.c_str(), nullptr, 0); | |
| if (fabricId < kIdentityOtherFabricId) | |
| { | |
| ChipLogError(chipTool, "Invalid identity: %s", identity.c_str()); | |
| return CHIP_ERROR_INVALID_ARGUMENT; | |
| } | |
| } | |
| return InitializeCommissioner(lookupKey, fabricId); | |
| } | |
| CHIP_ERROR CHIPCommand::Run() | |
| { | |
| ReturnErrorOnFailure(MaybeSetUpStack()); | |
| CHIP_ERROR err = StartWaiting(GetWaitDuration()); | |
| if (IsInteractive()) | |
| { | |
| bool timedOut; | |
| // Give it 2 hours to run our cleanup; that should never get hit in practice. | |
| CHIP_ERROR cleanupErr = RunOnMatterQueue(RunCommandCleanup, chip::System::Clock::Seconds16(7200), &timedOut); | |
| VerifyOrDie(cleanupErr == CHIP_NO_ERROR); | |
| VerifyOrDie(!timedOut); | |
| } | |
| else | |
| { | |
| CleanupAfterRun(); | |
| } | |
| MaybeTearDownStack(); | |
| return err; | |
| } | |
| void CHIPCommand::StartTracing() | |
| { | |
| if (mTraceTo.HasValue()) | |
| { | |
| for (const auto & destination : mTraceTo.Value()) | |
| { | |
| mTracingSetup.EnableTracingFor(destination.c_str()); | |
| } | |
| } | |
| #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED | |
| chip::trace::InitTrace(); | |
| if (mTraceFile.HasValue()) | |
| { | |
| chip::trace::AddTraceStream(new chip::trace::TraceStreamFile(mTraceFile.Value())); | |
| } | |
| else if (mTraceLog.HasValue() && mTraceLog.Value()) | |
| { | |
| chip::trace::AddTraceStream(new chip::trace::TraceStreamLog()); | |
| } | |
| if (mTraceDecode.HasValue() && mTraceDecode.Value()) | |
| { | |
| chip::trace::TraceDecoderOptions options; | |
| // The interaction model protocol is already logged, so just disable logging those. | |
| options.mEnableProtocolInteractionModelResponse = false; | |
| chip::trace::TraceDecoder * decoder = new chip::trace::TraceDecoder(); | |
| decoder->SetOptions(options); | |
| chip::trace::AddTraceStream(decoder); | |
| } | |
| #endif // CHIP_CONFIG_TRANSPORT_TRACE_ENABLED | |
| } | |
| void CHIPCommand::StopTracing() | |
| { | |
| mTracingSetup.StopTracing(); | |
| #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED | |
| chip::trace::DeInitTrace(); | |
| #endif // CHIP_CONFIG_TRANSPORT_TRACE_ENABLED | |
| } | |
| void CHIPCommand::SetIdentity(const char * identity) | |
| { | |
| std::string name = std::string(identity); | |
| if (name.compare(kIdentityAlpha) != 0 && name.compare(kIdentityBeta) != 0 && name.compare(kIdentityGamma) != 0 && | |
| name.compare(kIdentityNull) != 0 && strtoull(name.c_str(), nullptr, 0) < kIdentityOtherFabricId) | |
| { | |
| ChipLogError(chipTool, "Unknown commissioner name: %s. Supported names are [%s, %s, %s, 4, 5...]", name.c_str(), | |
| kIdentityAlpha, kIdentityBeta, kIdentityGamma); | |
| chipDie(); | |
| } | |
| mCommissionerName.SetValue(const_cast<char *>(identity)); | |
| } | |
| std::string CHIPCommand::GetIdentity() | |
| { | |
| std::string name = mCommissionerName.HasValue() ? mCommissionerName.Value() : kIdentityAlpha; | |
| if (name.compare(kIdentityAlpha) != 0 && name.compare(kIdentityBeta) != 0 && name.compare(kIdentityGamma) != 0 && | |
| name.compare(kIdentityNull) != 0) | |
| { | |
| chip::FabricId fabricId = strtoull(name.c_str(), nullptr, 0); | |
| if (fabricId >= kIdentityOtherFabricId) | |
| { | |
| // normalize name since it is used in persistent storage | |
| char s[24]; | |
| sprintf(s, "%" PRIu64, fabricId); | |
| name = s; | |
| } | |
| else | |
| { | |
| ChipLogError(chipTool, "Unknown commissioner name: %s. Supported names are [%s, %s, %s, 4, 5...]", name.c_str(), | |
| kIdentityAlpha, kIdentityBeta, kIdentityGamma); | |
| chipDie(); | |
| } | |
| } | |
| return name; | |
| } | |
| CHIP_ERROR CHIPCommand::GetIdentityNodeId(std::string identity, chip::NodeId * nodeId) | |
| { | |
| if (mCommissionerNodeId.HasValue()) | |
| { | |
| *nodeId = mCommissionerNodeId.Value(); | |
| return CHIP_NO_ERROR; | |
| } | |
| if (identity == kIdentityNull) | |
| { | |
| *nodeId = chip::kUndefinedNodeId; | |
| return CHIP_NO_ERROR; | |
| } | |
| ReturnLogErrorOnFailure(mCommissionerStorage.Init(identity.c_str(), GetStorageDirectory().ValueOr(nullptr))); | |
| *nodeId = mCommissionerStorage.GetLocalNodeId(); | |
| return CHIP_NO_ERROR; | |
| } | |
| CHIP_ERROR CHIPCommand::GetIdentityRootCertificate(std::string identity, chip::ByteSpan & span) | |
| { | |
| if (identity == kIdentityNull) | |
| { | |
| return CHIP_ERROR_NOT_FOUND; | |
| } | |
| chip::NodeId nodeId; | |
| VerifyOrDie(GetIdentityNodeId(identity, &nodeId) == CHIP_NO_ERROR); | |
| CommissionerIdentity lookupKey{ identity, nodeId }; | |
| auto item = mCommissioners.find(lookupKey); | |
| span = chip::ByteSpan(item->first.mRCAC, item->first.mRCACLen); | |
| return CHIP_NO_ERROR; | |
| } | |
| chip::FabricId CHIPCommand::CurrentCommissionerId() | |
| { | |
| chip::FabricId id; | |
| std::string name = GetIdentity(); | |
| if (name.compare(kIdentityAlpha) == 0) | |
| { | |
| id = kIdentityAlphaFabricId; | |
| } | |
| else if (name.compare(kIdentityBeta) == 0) | |
| { | |
| id = kIdentityBetaFabricId; | |
| } | |
| else if (name.compare(kIdentityGamma) == 0) | |
| { | |
| id = kIdentityGammaFabricId; | |
| } | |
| else if (name.compare(kIdentityNull) == 0) | |
| { | |
| id = kIdentityNullFabricId; | |
| } | |
| else if ((id = strtoull(name.c_str(), nullptr, 0)) < kIdentityOtherFabricId) | |
| { | |
| VerifyOrDieWithMsg(false, chipTool, "Unknown commissioner name: %s. Supported names are [%s, %s, %s, 4, 5...]", | |
| name.c_str(), kIdentityAlpha, kIdentityBeta, kIdentityGamma); | |
| } | |
| return id; | |
| } | |
| chip::Controller::DeviceCommissioner & CHIPCommand::CurrentCommissioner() | |
| { | |
| return GetCommissioner(GetIdentity()); | |
| } | |
| chip::Controller::DeviceCommissioner & CHIPCommand::GetCommissioner(std::string identity) | |
| { | |
| // We don't have a great way to handle commissioner setup failures here. | |
| // This only matters for commands (like TestCommand) that involve multiple | |
| // identities. | |
| VerifyOrDie(EnsureCommissionerForIdentity(identity) == CHIP_NO_ERROR); | |
| chip::NodeId nodeId; | |
| VerifyOrDie(GetIdentityNodeId(identity, &nodeId) == CHIP_NO_ERROR); | |
| CommissionerIdentity lookupKey{ identity, nodeId }; | |
| auto item = mCommissioners.find(lookupKey); | |
| VerifyOrDie(item != mCommissioners.end()); | |
| return *item->second; | |
| } | |
| void CHIPCommand::ShutdownCommissioner(const CommissionerIdentity & key) | |
| { | |
| mCommissioners[key].get()->Shutdown(); | |
| } | |
| CHIP_ERROR CHIPCommand::InitializeCommissioner(CommissionerIdentity & identity, chip::FabricId fabricId) | |
| { | |
| std::unique_ptr<ChipDeviceCommissioner> commissioner = std::make_unique<ChipDeviceCommissioner>(); | |
| #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY | |
| VerifyOrReturnError(chip::CanCastTo<uint16_t>(CHIP_UDC_PORT + fabricId), CHIP_ERROR_INVALID_ARGUMENT); | |
| uint16_t udcListenPort = static_cast<uint16_t>(CHIP_UDC_PORT + fabricId); | |
| ReturnErrorOnFailure(commissioner->SetUdcListenPort(udcListenPort)); | |
| #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY | |
| chip::Controller::SetupParams commissionerParams; | |
| ReturnLogErrorOnFailure(mCredIssuerCmds->SetupDeviceAttestation(commissionerParams, sTrustStore, sRevocationDelegate)); | |
| chip::Crypto::P256Keypair ephemeralKey; | |
| if (fabricId != chip::kUndefinedFabricId) | |
| { | |
| // TODO - OpCreds should only be generated for pairing command | |
| // store the credentials in persistent storage, and | |
| // generate when not available in the storage. | |
| ReturnLogErrorOnFailure(mCommissionerStorage.Init(identity.mName.c_str(), GetStorageDirectory().ValueOr(nullptr))); | |
| if (mUseMaxSizedCerts.HasValue()) | |
| { | |
| auto option = CredentialIssuerCommands::CredentialIssuerOptions::kMaximizeCertificateSizes; | |
| mCredIssuerCmds->SetCredentialIssuerOption(option, mUseMaxSizedCerts.Value()); | |
| } | |
| ReturnLogErrorOnFailure(mCredIssuerCmds->InitializeCredentialsIssuer(mCommissionerStorage)); | |
| chip::MutableByteSpan nocSpan(identity.mNOC); | |
| chip::MutableByteSpan icacSpan(identity.mICAC); | |
| chip::MutableByteSpan rcacSpan(identity.mRCAC); | |
| ReturnLogErrorOnFailure(ephemeralKey.Initialize(chip::Crypto::ECPKeyTarget::ECDSA)); | |
| ReturnLogErrorOnFailure(mCredIssuerCmds->GenerateControllerNOCChain(identity.mLocalNodeId, fabricId, | |
| mCommissionerStorage.GetCommissionerCATs(), | |
| ephemeralKey, rcacSpan, icacSpan, nocSpan)); | |
| identity.mRCACLen = rcacSpan.size(); | |
| identity.mICACLen = icacSpan.size(); | |
| identity.mNOCLen = nocSpan.size(); | |
| commissionerParams.operationalKeypair = &ephemeralKey; | |
| commissionerParams.controllerRCAC = rcacSpan; | |
| commissionerParams.controllerICAC = icacSpan; | |
| commissionerParams.controllerNOC = nocSpan; | |
| commissionerParams.permitMultiControllerFabrics = true; | |
| commissionerParams.enableServerInteractions = NeedsOperationalAdvertising(); | |
| } | |
| // TODO: Initialize IPK epoch key in ExampleOperationalCredentials issuer rather than relying on DefaultIpkValue | |
| commissionerParams.operationalCredentialsDelegate = mCredIssuerCmds->GetCredentialIssuer(); | |
| commissionerParams.controllerVendorId = mCommissionerVendorId.ValueOr(chip::VendorId::TestVendor1); | |
| ReturnLogErrorOnFailure(DeviceControllerFactory::GetInstance().SetupCommissioner(commissionerParams, *(commissioner.get()))); | |
| if (identity.mName != kIdentityNull) | |
| { | |
| // Initialize Group Data, including IPK | |
| chip::FabricIndex fabricIndex = commissioner->GetFabricIndex(); | |
| uint8_t compressed_fabric_id[sizeof(uint64_t)]; | |
| chip::MutableByteSpan compressed_fabric_id_span(compressed_fabric_id); | |
| ReturnLogErrorOnFailure(commissioner->GetCompressedFabricIdBytes(compressed_fabric_id_span)); | |
| ReturnLogErrorOnFailure(chip::GroupTesting::InitData(&sGroupDataProvider, fabricIndex, compressed_fabric_id_span)); | |
| // Configure the default IPK for all fabrics used by CHIP-tool. The epoch | |
| // key is the same, but the derived keys will be different for each fabric. | |
| chip::ByteSpan defaultIpk = chip::GroupTesting::DefaultIpkValue::GetDefaultIpk(); | |
| ReturnLogErrorOnFailure( | |
| chip::Credentials::SetSingleIpkEpochKey(&sGroupDataProvider, fabricIndex, defaultIpk, compressed_fabric_id_span)); | |
| } | |
| ReturnErrorOnFailure(CHIPCommand::sICDClientStorage.UpdateFabricList(commissioner->GetFabricIndex())); | |
| mCommissioners[identity] = std::move(commissioner); | |
| return CHIP_NO_ERROR; | |
| } | |
| void CHIPCommand::RunQueuedCommand(intptr_t commandArg) | |
| { | |
| auto * command = reinterpret_cast<CHIPCommand *>(commandArg); | |
| CHIP_ERROR err = command->EnsureCommissionerForIdentity(command->GetIdentity()); | |
| if (err == CHIP_NO_ERROR) | |
| { | |
| err = command->RunCommand(); | |
| } | |
| if (err != CHIP_NO_ERROR) | |
| { | |
| command->SetCommandExitStatus(err); | |
| } | |
| } | |
| void CHIPCommand::RunCommandCleanup(intptr_t commandArg) | |
| { | |
| auto * command = reinterpret_cast<CHIPCommand *>(commandArg); | |
| command->CleanupAfterRun(); | |
| command->StopWaiting(); | |
| } | |
| void CHIPCommand::CleanupAfterRun() | |
| { | |
| assertChipStackLockedByCurrentThread(); | |
| bool deferCleanup = (IsInteractive() && DeferInteractiveCleanup()); | |
| Shutdown(); | |
| if (deferCleanup) | |
| { | |
| sDeferredCleanups.insert(this); | |
| } | |
| else | |
| { | |
| Cleanup(); | |
| } | |
| } | |
| CHIP_ERROR CHIPCommand::RunOnMatterQueue(MatterWorkCallback callback, chip::System::Clock::Timeout timeout, bool * timedOut) | |
| { | |
| { | |
| std::lock_guard<std::mutex> lk(cvWaitingForResponseMutex); | |
| mWaitingForResponse = true; | |
| } | |
| auto err = chip::DeviceLayer::PlatformMgr().ScheduleWork(callback, reinterpret_cast<intptr_t>(this)); | |
| if (CHIP_NO_ERROR != err) | |
| { | |
| { | |
| std::lock_guard<std::mutex> lk(cvWaitingForResponseMutex); | |
| mWaitingForResponse = false; | |
| } | |
| return err; | |
| } | |
| auto waitingUntil = std::chrono::system_clock::now() + std::chrono::duration_cast<std::chrono::seconds>(timeout); | |
| { | |
| std::unique_lock<std::mutex> lk(cvWaitingForResponseMutex); | |
| *timedOut = !cvWaitingForResponse.wait_until(lk, waitingUntil, [this]() { return !this->mWaitingForResponse; }); | |
| } | |
| return CHIP_NO_ERROR; | |
| } | |
| #if !CONFIG_USE_SEPARATE_EVENTLOOP | |
| static void OnResponseTimeout(chip::System::Layer *, void * appState) | |
| { | |
| (reinterpret_cast<CHIPCommand *>(appState))->SetCommandExitStatus(CHIP_ERROR_TIMEOUT); | |
| } | |
| #endif // !CONFIG_USE_SEPARATE_EVENTLOOP | |
| CHIP_ERROR CHIPCommand::StartWaiting(chip::System::Clock::Timeout duration) | |
| { | |
| #if CONFIG_USE_SEPARATE_EVENTLOOP | |
| // ServiceEvents() calls StartEventLoopTask(), which is paired with the StopEventLoopTask() below. | |
| if (!IsInteractive()) | |
| { | |
| ReturnLogErrorOnFailure(DeviceControllerFactory::GetInstance().ServiceEvents()); | |
| } | |
| if (duration.count() == 0) | |
| { | |
| mCommandExitStatus = RunCommand(); | |
| } | |
| else | |
| { | |
| bool timedOut; | |
| CHIP_ERROR err = RunOnMatterQueue(RunQueuedCommand, duration, &timedOut); | |
| if (CHIP_NO_ERROR != err) | |
| { | |
| return err; | |
| } | |
| if (timedOut) | |
| { | |
| mCommandExitStatus = CHIP_ERROR_TIMEOUT; | |
| } | |
| } | |
| if (!IsInteractive()) | |
| { | |
| LogErrorOnFailure(chip::DeviceLayer::PlatformMgr().StopEventLoopTask()); | |
| } | |
| #else | |
| chip::DeviceLayer::PlatformMgr().ScheduleWork(RunQueuedCommand, reinterpret_cast<intptr_t>(this)); | |
| ReturnLogErrorOnFailure(chip::DeviceLayer::SystemLayer().StartTimer(duration, OnResponseTimeout, this)); | |
| chip::DeviceLayer::PlatformMgr().RunEventLoop(); | |
| #endif // CONFIG_USE_SEPARATE_EVENTLOOP | |
| return mCommandExitStatus; | |
| } | |
| void CHIPCommand::StopWaiting() | |
| { | |
| #if CONFIG_USE_SEPARATE_EVENTLOOP | |
| { | |
| std::lock_guard<std::mutex> lk(cvWaitingForResponseMutex); | |
| mWaitingForResponse = false; | |
| } | |
| cvWaitingForResponse.notify_all(); | |
| #else // CONFIG_USE_SEPARATE_EVENTLOOP | |
| LogErrorOnFailure(chip::DeviceLayer::PlatformMgr().StopEventLoopTask()); | |
| #endif // CONFIG_USE_SEPARATE_EVENTLOOP | |
| } | |
| void CHIPCommand::ExecuteDeferredCleanups(intptr_t ignored) | |
| { | |
| for (auto * cmd : sDeferredCleanups) | |
| { | |
| cmd->Cleanup(); | |
| } | |
| sDeferredCleanups.clear(); | |
| } |