Matter SDK Coverage Report
Current view: top level - controller - CHIPDeviceControllerFactory.cpp (source / functions) Coverage Total Hit
Test: SHA:1560a87972ec2c7a76cec101927a563a6862bc2a Lines: 0.0 % 270 0
Test Date: 2025-03-31 07:08:14 Functions: 0.0 % 14 0

            Line data    Source code
       1              : /*
       2              :  *
       3              :  *    Copyright (c) 2021 Project CHIP Authors
       4              :  *    All rights reserved.
       5              :  *
       6              :  *    Licensed under the Apache License, Version 2.0 (the "License");
       7              :  *    you may not use this file except in compliance with the License.
       8              :  *    You may obtain a copy of the License at
       9              :  *
      10              :  *        http://www.apache.org/licenses/LICENSE-2.0
      11              :  *
      12              :  *    Unless required by applicable law or agreed to in writing, software
      13              :  *    distributed under the License is distributed on an "AS IS" BASIS,
      14              :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15              :  *    See the License for the specific language governing permissions and
      16              :  *    limitations under the License.
      17              :  */
      18              : 
      19              : /**
      20              :  *    @file
      21              :  *      Implementation of CHIP Device Controller Factory, a utility/manager class
      22              :  *      that vends Controller objects
      23              :  */
      24              : 
      25              : #include <controller/CHIPDeviceControllerFactory.h>
      26              : 
      27              : #include <app/InteractionModelEngine.h>
      28              : #include <app/OperationalSessionSetup.h>
      29              : #include <app/TimerDelegates.h>
      30              : #include <app/reporting/ReportSchedulerImpl.h>
      31              : #include <app/util/DataModelHandler.h>
      32              : #include <lib/core/ErrorStr.h>
      33              : #include <messaging/ReliableMessageProtocolConfig.h>
      34              : 
      35              : #if CONFIG_DEVICE_LAYER
      36              : #include <platform/CHIPDeviceLayer.h>
      37              : #include <platform/ConfigurationManager.h>
      38              : #endif
      39              : 
      40              : #include <app/server/Dnssd.h>
      41              : #include <protocols/secure_channel/CASEServer.h>
      42              : #include <protocols/secure_channel/SimpleSessionResumptionStorage.h>
      43              : 
      44              : using namespace chip::Inet;
      45              : using namespace chip::System;
      46              : using namespace chip::Credentials;
      47              : 
      48              : namespace chip {
      49              : namespace Controller {
      50              : 
      51            0 : CHIP_ERROR DeviceControllerFactory::Init(FactoryInitParams params)
      52              : {
      53              : 
      54              :     // SystemState is only set the first time init is called, after that it is managed
      55              :     // internally. If SystemState is set then init has already completed.
      56            0 :     if (mSystemState != nullptr)
      57              :     {
      58            0 :         ChipLogError(Controller, "Device Controller Factory already initialized...");
      59            0 :         return CHIP_NO_ERROR;
      60              :     }
      61              : 
      62              :     // Save our initialization state that we can't recover later from a
      63              :     // created-but-shut-down system state.
      64            0 :     mListenPort                = params.listenPort;
      65            0 :     mFabricIndependentStorage  = params.fabricIndependentStorage;
      66            0 :     mOperationalKeystore       = params.operationalKeystore;
      67            0 :     mOpCertStore               = params.opCertStore;
      68            0 :     mCertificateValidityPolicy = params.certificateValidityPolicy;
      69            0 :     mSessionResumptionStorage  = params.sessionResumptionStorage;
      70            0 :     mEnableServerInteractions  = params.enableServerInteractions;
      71              : 
      72              :     // Initialize the system state. Note that it is left in a somewhat
      73              :     // special state where it is initialized, but has a ref count of 0.
      74            0 :     CHIP_ERROR err = InitSystemState(params);
      75              : 
      76            0 :     return err;
      77              : }
      78              : 
      79            0 : CHIP_ERROR DeviceControllerFactory::ReinitSystemStateIfNecessary()
      80              : {
      81            0 :     VerifyOrReturnError(mSystemState != nullptr, CHIP_ERROR_INCORRECT_STATE);
      82            0 :     VerifyOrReturnError(mSystemState->IsShutDown(), CHIP_NO_ERROR);
      83              : 
      84            0 :     FactoryInitParams params;
      85            0 :     params.systemLayer        = mSystemState->SystemLayer();
      86            0 :     params.udpEndPointManager = mSystemState->UDPEndPointManager();
      87              : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
      88            0 :     params.tcpEndPointManager = mSystemState->TCPEndPointManager();
      89              : #endif
      90              : #if CONFIG_NETWORK_LAYER_BLE
      91            0 :     params.bleLayer = mSystemState->BleLayer();
      92              : #endif
      93            0 :     params.listenPort                = mListenPort;
      94            0 :     params.fabricIndependentStorage  = mFabricIndependentStorage;
      95            0 :     params.enableServerInteractions  = mEnableServerInteractions;
      96            0 :     params.groupDataProvider         = mSystemState->GetGroupDataProvider();
      97            0 :     params.sessionKeystore           = mSystemState->GetSessionKeystore();
      98            0 :     params.fabricTable               = mSystemState->Fabrics();
      99            0 :     params.operationalKeystore       = mOperationalKeystore;
     100            0 :     params.opCertStore               = mOpCertStore;
     101            0 :     params.certificateValidityPolicy = mCertificateValidityPolicy;
     102            0 :     params.sessionResumptionStorage  = mSessionResumptionStorage;
     103              : 
     104              :     // re-initialization keeps any previously initialized values. The only place where
     105              :     // a provider exists is in the InteractionModelEngine, so just say "keep it as is".
     106            0 :     params.dataModelProvider = app::InteractionModelEngine::GetInstance()->GetDataModelProvider();
     107              : 
     108            0 :     return InitSystemState(params);
     109              : }
     110              : 
     111            0 : CHIP_ERROR DeviceControllerFactory::InitSystemState(FactoryInitParams params)
     112              : {
     113            0 :     if (mSystemState != nullptr)
     114              :     {
     115            0 :         Platform::Delete(mSystemState);
     116            0 :         mSystemState = nullptr;
     117              :     }
     118              : 
     119            0 :     DeviceControllerSystemStateParams stateParams;
     120              : #if CONFIG_DEVICE_LAYER
     121            0 :     ReturnErrorOnFailure(DeviceLayer::PlatformMgr().InitChipStack());
     122              : 
     123            0 :     stateParams.systemLayer        = &DeviceLayer::SystemLayer();
     124            0 :     stateParams.udpEndPointManager = DeviceLayer::UDPEndPointManager();
     125              : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
     126            0 :     stateParams.tcpEndPointManager = DeviceLayer::TCPEndPointManager();
     127              : #endif
     128              : #else
     129              :     stateParams.systemLayer        = params.systemLayer;
     130              :     stateParams.tcpEndPointManager = params.tcpEndPointManager;
     131              :     stateParams.udpEndPointManager = params.udpEndPointManager;
     132              :     ChipLogError(Controller, "Warning: Device Controller Factory should be with a CHIP Device Layer...");
     133              : #endif // CONFIG_DEVICE_LAYER
     134              : 
     135              : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
     136            0 :     auto tcpListenParams = Transport::TcpListenParameters(stateParams.tcpEndPointManager)
     137            0 :                                .SetAddressType(IPAddressType::kIPv6)
     138            0 :                                .SetListenPort(params.listenPort)
     139            0 :                                .SetServerListenEnabled(false); // Initialize as a TCP Client
     140              : #endif
     141              : 
     142            0 :     if (params.dataModelProvider == nullptr)
     143              :     {
     144            0 :         ChipLogError(AppServer, "Device Controller Factory requires a `dataModelProvider` value.");
     145            0 :         ChipLogError(AppServer, "For backwards compatibility, you likely can use `CodegenDataModelProviderInstance(...)`");
     146              :     }
     147              : 
     148            0 :     VerifyOrReturnError(params.dataModelProvider != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     149            0 :     VerifyOrReturnError(stateParams.systemLayer != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     150            0 :     VerifyOrReturnError(stateParams.udpEndPointManager != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     151              : 
     152              :     // OperationalCertificateStore needs to be provided to init the fabric table if fabric table is
     153              :     // not provided wholesale.
     154            0 :     VerifyOrReturnError((params.fabricTable != nullptr) || (params.opCertStore != nullptr), CHIP_ERROR_INVALID_ARGUMENT);
     155            0 :     VerifyOrReturnError(params.sessionKeystore != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     156              : 
     157              : #if CONFIG_NETWORK_LAYER_BLE
     158              : #if CONFIG_DEVICE_LAYER
     159            0 :     stateParams.bleLayer = DeviceLayer::ConnectivityMgr().GetBleLayer();
     160              : #else
     161              :     stateParams.bleLayer = params.bleLayer;
     162              : #endif // CONFIG_DEVICE_LAYER
     163              : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     164              :     stateParams.wifipaf_layer = params.wifipaf_layer;
     165              : #endif
     166            0 :     VerifyOrReturnError(stateParams.bleLayer != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
     167              : #endif
     168              : 
     169            0 :     stateParams.transportMgr = chip::Platform::New<DeviceTransportMgr>();
     170              : 
     171              :     //
     172              :     // The logic below expects IPv6 to be at index 0 of this tuple. Keep that logic in sync with
     173              :     // this code.
     174              :     //
     175            0 :     ReturnErrorOnFailure(stateParams.transportMgr->Init(Transport::UdpListenParameters(stateParams.udpEndPointManager)
     176              :                                                             .SetAddressType(Inet::IPAddressType::kIPv6)
     177              :                                                             .SetListenPort(params.listenPort)
     178              : #if INET_CONFIG_ENABLE_IPV4
     179              :                                                             ,
     180              :                                                         //
     181              :                                                         // The logic below expects IPv4 to be at index 1 of this tuple,
     182              :                                                         // if it's enabled. Keep that logic in sync with this code.
     183              :                                                         //
     184              :                                                         Transport::UdpListenParameters(stateParams.udpEndPointManager)
     185              :                                                             .SetAddressType(Inet::IPAddressType::kIPv4)
     186              :                                                             .SetListenPort(params.listenPort)
     187              : #endif
     188              : #if CONFIG_NETWORK_LAYER_BLE
     189              :                                                             ,
     190              :                                                         Transport::BleListenParameters(stateParams.bleLayer)
     191              : #endif
     192              : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
     193              :                                                             ,
     194              :                                                         tcpListenParams
     195              : #endif
     196              : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     197              :                                                         ,
     198              :                                                         Transport::WiFiPAFListenParameters()
     199              : #endif
     200              :                                                             ));
     201              : 
     202              :     // TODO(#16231): All the new'ed state above/below in this method is never properly released or null-checked!
     203            0 :     stateParams.sessionMgr                = chip::Platform::New<SessionManager>();
     204            0 :     stateParams.certificateValidityPolicy = params.certificateValidityPolicy;
     205            0 :     stateParams.unsolicitedStatusHandler  = Platform::New<Protocols::SecureChannel::UnsolicitedStatusHandler>();
     206            0 :     stateParams.exchangeMgr               = chip::Platform::New<Messaging::ExchangeManager>();
     207            0 :     stateParams.messageCounterManager     = chip::Platform::New<secure_channel::MessageCounterManager>();
     208            0 :     stateParams.groupDataProvider         = params.groupDataProvider;
     209            0 :     stateParams.timerDelegate             = chip::Platform::New<chip::app::DefaultTimerDelegate>();
     210            0 :     stateParams.reportScheduler           = chip::Platform::New<app::reporting::ReportSchedulerImpl>(stateParams.timerDelegate);
     211            0 :     stateParams.sessionKeystore           = params.sessionKeystore;
     212            0 :     stateParams.bdxTransferServer         = chip::Platform::New<bdx::BDXTransferServer>();
     213              : 
     214              :     // if no fabricTable was provided, create one and track it in stateParams for cleanup
     215            0 :     stateParams.fabricTable = params.fabricTable;
     216              : 
     217            0 :     FabricTable * tempFabricTable = nullptr;
     218            0 :     if (stateParams.fabricTable == nullptr)
     219              :     {
     220              :         // TODO(#16231): Previously (and still) the objects new-ed in this entire method seem expected to last forever...
     221            0 :         auto newFabricTable = Platform::MakeUnique<FabricTable>();
     222            0 :         VerifyOrReturnError(newFabricTable, CHIP_ERROR_NO_MEMORY);
     223              : 
     224            0 :         FabricTable::InitParams fabricTableInitParams;
     225            0 :         fabricTableInitParams.storage             = params.fabricIndependentStorage;
     226            0 :         fabricTableInitParams.operationalKeystore = params.operationalKeystore;
     227            0 :         fabricTableInitParams.opCertStore         = params.opCertStore;
     228            0 :         ReturnErrorOnFailure(newFabricTable->Init(fabricTableInitParams));
     229            0 :         stateParams.fabricTable = newFabricTable.release();
     230            0 :         tempFabricTable         = stateParams.fabricTable;
     231            0 :     }
     232              : 
     233              :     SessionResumptionStorage * sessionResumptionStorage;
     234            0 :     if (params.sessionResumptionStorage == nullptr)
     235              :     {
     236            0 :         auto ownedSessionResumptionStorage = chip::Platform::MakeUnique<SimpleSessionResumptionStorage>();
     237            0 :         ReturnErrorOnFailure(ownedSessionResumptionStorage->Init(params.fabricIndependentStorage));
     238            0 :         stateParams.ownedSessionResumptionStorage    = std::move(ownedSessionResumptionStorage);
     239            0 :         stateParams.externalSessionResumptionStorage = nullptr;
     240            0 :         sessionResumptionStorage                     = stateParams.ownedSessionResumptionStorage.get();
     241            0 :     }
     242              :     else
     243              :     {
     244            0 :         stateParams.ownedSessionResumptionStorage    = nullptr;
     245            0 :         stateParams.externalSessionResumptionStorage = params.sessionResumptionStorage;
     246            0 :         sessionResumptionStorage                     = stateParams.externalSessionResumptionStorage;
     247              :     }
     248              : 
     249            0 :     auto delegate = chip::Platform::MakeUnique<ControllerFabricDelegate>();
     250            0 :     ReturnErrorOnFailure(delegate->Init(sessionResumptionStorage, stateParams.groupDataProvider));
     251            0 :     stateParams.fabricTableDelegate = delegate.get();
     252            0 :     ReturnErrorOnFailure(stateParams.fabricTable->AddFabricDelegate(stateParams.fabricTableDelegate));
     253            0 :     delegate.release();
     254              : 
     255            0 :     ReturnErrorOnFailure(stateParams.sessionMgr->Init(stateParams.systemLayer, stateParams.transportMgr,
     256              :                                                       stateParams.messageCounterManager, params.fabricIndependentStorage,
     257              :                                                       stateParams.fabricTable, *stateParams.sessionKeystore));
     258            0 :     ReturnErrorOnFailure(stateParams.exchangeMgr->Init(stateParams.sessionMgr));
     259            0 :     ReturnErrorOnFailure(stateParams.messageCounterManager->Init(stateParams.exchangeMgr));
     260            0 :     ReturnErrorOnFailure(stateParams.unsolicitedStatusHandler->Init(stateParams.exchangeMgr));
     261            0 :     ReturnErrorOnFailure(stateParams.bdxTransferServer->Init(stateParams.systemLayer, stateParams.exchangeMgr));
     262              : 
     263            0 :     chip::app::InteractionModelEngine * interactionModelEngine = chip::app::InteractionModelEngine::GetInstance();
     264              : 
     265              :     // Initialize the data model now that everything cluster implementations might
     266              :     // depend on is initalized.
     267            0 :     interactionModelEngine->SetDataModelProvider(params.dataModelProvider);
     268              : 
     269            0 :     ReturnErrorOnFailure(Dnssd::Resolver::Instance().Init(stateParams.udpEndPointManager));
     270              : 
     271            0 :     if (params.enableServerInteractions)
     272              :     {
     273            0 :         stateParams.caseServer = chip::Platform::New<CASEServer>();
     274              : 
     275              :         // Enable listening for session establishment messages.
     276            0 :         ReturnErrorOnFailure(stateParams.caseServer->ListenForSessionEstablishment(
     277              :             stateParams.exchangeMgr, stateParams.sessionMgr, stateParams.fabricTable, sessionResumptionStorage,
     278              :             stateParams.certificateValidityPolicy, stateParams.groupDataProvider));
     279              : 
     280              :         // Our IPv6 transport is at index 0.
     281            0 :         app::DnssdServer::Instance().SetSecuredIPv6Port(
     282            0 :             stateParams.transportMgr->GetTransport().GetImplAtIndex<0>().GetBoundPort());
     283              : 
     284              : #if INET_CONFIG_ENABLE_IPV4
     285              :         // If enabled, our IPv4 transport is at index 1.
     286            0 :         app::DnssdServer::Instance().SetSecuredIPv4Port(
     287            0 :             stateParams.transportMgr->GetTransport().GetImplAtIndex<1>().GetBoundPort());
     288              : #endif // INET_CONFIG_ENABLE_IPV4
     289              : 
     290              :         //
     291              :         // TODO: This is a hack to workaround the fact that we have a bi-polar stack that has controller and server modalities that
     292              :         // are mutually exclusive in terms of initialization of key stack singletons. Consequently, DnssdServer accesses
     293              :         // Server::GetInstance().GetFabricTable() to access the fabric table, but we don't want to do that when we're initializing
     294              :         // the controller logic since the factory here has its own fabric table.
     295              :         //
     296              :         // Consequently, reach in set the fabric table pointer to point to the right version.
     297              :         //
     298            0 :         app::DnssdServer::Instance().SetFabricTable(stateParams.fabricTable);
     299              : 
     300              : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
     301              :         // Disable the TCP Server based on the TCPListenParameters setting.
     302            0 :         app::DnssdServer::Instance().SetTCPServerEnabled(tcpListenParams.IsServerListenEnabled());
     303              : #endif
     304              :     }
     305              : 
     306            0 :     stateParams.sessionSetupPool = Platform::New<DeviceControllerSystemStateParams::SessionSetupPool>();
     307            0 :     stateParams.caseClientPool   = Platform::New<DeviceControllerSystemStateParams::CASEClientPool>();
     308              : 
     309              :     CASEClientInitParams sessionInitParams = {
     310            0 :         .sessionManager            = stateParams.sessionMgr,
     311              :         .sessionResumptionStorage  = sessionResumptionStorage,
     312            0 :         .certificateValidityPolicy = stateParams.certificateValidityPolicy,
     313            0 :         .exchangeMgr               = stateParams.exchangeMgr,
     314            0 :         .fabricTable               = stateParams.fabricTable,
     315            0 :         .groupDataProvider         = stateParams.groupDataProvider,
     316              :         // Don't provide an MRP local config, so each CASE initiation will use
     317              :         // the then-current value.
     318              :         .mrpLocalConfig = NullOptional,
     319            0 :     };
     320              : 
     321              :     CASESessionManagerConfig sessionManagerConfig = {
     322              :         .sessionInitParams = sessionInitParams,
     323            0 :         .clientPool        = stateParams.caseClientPool,
     324            0 :         .sessionSetupPool  = stateParams.sessionSetupPool,
     325            0 :     };
     326              : 
     327              :     // TODO: Need to be able to create a CASESessionManagerConfig here!
     328            0 :     stateParams.caseSessionManager = Platform::New<CASESessionManager>();
     329            0 :     ReturnErrorOnFailure(stateParams.caseSessionManager->Init(stateParams.systemLayer, sessionManagerConfig));
     330              : 
     331            0 :     ReturnErrorOnFailure(interactionModelEngine->Init(stateParams.exchangeMgr, stateParams.fabricTable, stateParams.reportScheduler,
     332              :                                                       stateParams.caseSessionManager));
     333              : 
     334              :     // store the system state
     335            0 :     mSystemState = chip::Platform::New<DeviceControllerSystemState>(std::move(stateParams));
     336            0 :     mSystemState->SetTempFabricTable(tempFabricTable, params.enableServerInteractions);
     337            0 :     ChipLogDetail(Controller, "System State Initialized...");
     338            0 :     return CHIP_NO_ERROR;
     339            0 : }
     340              : 
     341            0 : void DeviceControllerFactory::PopulateInitParams(ControllerInitParams & controllerParams, const SetupParams & params)
     342              : {
     343            0 :     controllerParams.operationalCredentialsDelegate       = params.operationalCredentialsDelegate;
     344            0 :     controllerParams.operationalKeypair                   = params.operationalKeypair;
     345            0 :     controllerParams.hasExternallyOwnedOperationalKeypair = params.hasExternallyOwnedOperationalKeypair;
     346            0 :     controllerParams.controllerNOC                        = params.controllerNOC;
     347            0 :     controllerParams.controllerICAC                       = params.controllerICAC;
     348            0 :     controllerParams.controllerRCAC                       = params.controllerRCAC;
     349            0 :     controllerParams.permitMultiControllerFabrics         = params.permitMultiControllerFabrics;
     350            0 :     controllerParams.removeFromFabricTableOnShutdown      = params.removeFromFabricTableOnShutdown;
     351            0 :     controllerParams.deleteFromFabricTableOnShutdown      = params.deleteFromFabricTableOnShutdown;
     352              : 
     353            0 :     controllerParams.systemState        = mSystemState;
     354            0 :     controllerParams.controllerVendorId = params.controllerVendorId;
     355              : 
     356            0 :     controllerParams.enableServerInteractions = params.enableServerInteractions;
     357            0 :     if (params.fabricIndex.HasValue())
     358              :     {
     359            0 :         controllerParams.fabricIndex.SetValue(params.fabricIndex.Value());
     360              :     }
     361            0 : }
     362              : 
     363            0 : void DeviceControllerFactory::ControllerInitialized(const DeviceController & controller)
     364              : {
     365            0 :     if (mEnableServerInteractions && controller.GetFabricIndex() != kUndefinedFabricIndex)
     366              :     {
     367              :         // Restart DNS-SD advertising, because initialization of this controller could
     368              :         // have modified whether a particular fabric identity should be
     369              :         // advertised.  Just calling AdvertiseOperational() is not good enough
     370              :         // here, since we might be removing advertising.
     371            0 :         app::DnssdServer::Instance().StartServer();
     372              :     }
     373            0 : }
     374              : 
     375            0 : CHIP_ERROR DeviceControllerFactory::SetupController(SetupParams params, DeviceController & controller)
     376              : {
     377            0 :     VerifyOrReturnError(params.controllerVendorId != VendorId::Unspecified, CHIP_ERROR_INVALID_ARGUMENT);
     378            0 :     ReturnErrorOnFailure(ReinitSystemStateIfNecessary());
     379              : 
     380            0 :     ControllerInitParams controllerParams;
     381            0 :     PopulateInitParams(controllerParams, params);
     382              : 
     383            0 :     CHIP_ERROR err = controller.Init(controllerParams);
     384              : 
     385            0 :     if (err == CHIP_NO_ERROR)
     386              :     {
     387            0 :         ControllerInitialized(controller);
     388              :     }
     389              : 
     390            0 :     return err;
     391              : }
     392              : 
     393            0 : CHIP_ERROR DeviceControllerFactory::SetupCommissioner(SetupParams params, DeviceCommissioner & commissioner)
     394              : {
     395            0 :     VerifyOrReturnError(params.controllerVendorId != VendorId::Unspecified, CHIP_ERROR_INVALID_ARGUMENT);
     396            0 :     ReturnErrorOnFailure(ReinitSystemStateIfNecessary());
     397              : 
     398            0 :     CommissionerInitParams commissionerParams;
     399              : 
     400              :     // PopulateInitParams works against ControllerInitParams base class of CommissionerInitParams only
     401            0 :     PopulateInitParams(commissionerParams, params);
     402              : 
     403              :     // Set commissioner-specific fields not in ControllerInitParams
     404            0 :     commissionerParams.pairingDelegate           = params.pairingDelegate;
     405            0 :     commissionerParams.defaultCommissioner       = params.defaultCommissioner;
     406            0 :     commissionerParams.deviceAttestationVerifier = params.deviceAttestationVerifier;
     407              : 
     408            0 :     CHIP_ERROR err = commissioner.Init(commissionerParams);
     409              : 
     410            0 :     if (err == CHIP_NO_ERROR)
     411              :     {
     412            0 :         ControllerInitialized(commissioner);
     413              :     }
     414              : 
     415            0 :     return err;
     416              : }
     417              : 
     418            0 : CHIP_ERROR DeviceControllerFactory::ServiceEvents()
     419              : {
     420            0 :     VerifyOrReturnError(mSystemState != nullptr, CHIP_ERROR_INCORRECT_STATE);
     421              : 
     422              : #if CONFIG_DEVICE_LAYER
     423            0 :     ReturnErrorOnFailure(DeviceLayer::PlatformMgr().StartEventLoopTask());
     424              : #endif // CONFIG_DEVICE_LAYER
     425              : 
     426            0 :     return CHIP_NO_ERROR;
     427              : }
     428              : 
     429            0 : void DeviceControllerFactory::RetainSystemState()
     430              : {
     431            0 :     (void) mSystemState->Retain();
     432            0 : }
     433              : 
     434            0 : bool DeviceControllerFactory::ReleaseSystemState()
     435              : {
     436            0 :     return mSystemState->Release();
     437              : }
     438              : 
     439            0 : CHIP_ERROR DeviceControllerFactory::EnsureAndRetainSystemState()
     440              : {
     441            0 :     ReturnErrorOnFailure(ReinitSystemStateIfNecessary());
     442            0 :     RetainSystemState();
     443            0 :     return CHIP_NO_ERROR;
     444              : }
     445              : 
     446            0 : DeviceControllerFactory::~DeviceControllerFactory()
     447              : {
     448            0 :     Shutdown();
     449            0 : }
     450              : 
     451            0 : void DeviceControllerFactory::Shutdown()
     452              : {
     453            0 :     if (mSystemState != nullptr)
     454              :     {
     455              :         // ~DeviceControllerSystemState will call Shutdown(),
     456              :         // which in turn ensures that the reference count is 0.
     457            0 :         Platform::Delete(mSystemState);
     458            0 :         mSystemState = nullptr;
     459              :     }
     460            0 :     mFabricIndependentStorage  = nullptr;
     461            0 :     mOperationalKeystore       = nullptr;
     462            0 :     mOpCertStore               = nullptr;
     463            0 :     mCertificateValidityPolicy = nullptr;
     464            0 :     mSessionResumptionStorage  = nullptr;
     465            0 : }
     466              : 
     467            0 : void DeviceControllerSystemState::Shutdown()
     468              : {
     469            0 :     VerifyOrDie(mRefCount == 0);
     470            0 :     if (mHaveShutDown)
     471              :     {
     472              :         // Nothing else to do here.
     473            0 :         return;
     474              :     }
     475            0 :     mHaveShutDown = true;
     476              : 
     477            0 :     ChipLogDetail(Controller, "Shutting down the System State, this will teardown the CHIP Stack");
     478              : 
     479            0 :     if (mTempFabricTable && mEnableServerInteractions)
     480              :     {
     481              :         // The DnssdServer is holding a reference to our temp fabric table,
     482              :         // which we are about to destroy.  Stop it, so that it will stop trying
     483              :         // to use it.
     484            0 :         app::DnssdServer::Instance().StopServer();
     485              :     }
     486              : 
     487            0 :     if (mFabricTableDelegate != nullptr)
     488              :     {
     489            0 :         if (mFabrics != nullptr)
     490              :         {
     491            0 :             mFabrics->RemoveFabricDelegate(mFabricTableDelegate);
     492              :         }
     493              : 
     494            0 :         chip::Platform::Delete(mFabricTableDelegate);
     495            0 :         mFabricTableDelegate = nullptr;
     496              :     }
     497              : 
     498            0 :     if (mBDXTransferServer != nullptr)
     499              :     {
     500            0 :         mBDXTransferServer->Shutdown();
     501            0 :         chip::Platform::Delete(mBDXTransferServer);
     502            0 :         mBDXTransferServer = nullptr;
     503              :     }
     504              : 
     505            0 :     if (mCASEServer != nullptr)
     506              :     {
     507            0 :         mCASEServer->Shutdown();
     508            0 :         chip::Platform::Delete(mCASEServer);
     509            0 :         mCASEServer = nullptr;
     510              :     }
     511              : 
     512            0 :     if (mCASESessionManager != nullptr)
     513              :     {
     514            0 :         mCASESessionManager->Shutdown();
     515            0 :         Platform::Delete(mCASESessionManager);
     516            0 :         mCASESessionManager = nullptr;
     517              :     }
     518              : 
     519              :     // The above took care of CASE handshakes, and shutting down all the
     520              :     // controllers should have taken care of the PASE handshakes.  Clean up any
     521              :     // outstanding secure sessions (shouldn't really be any, since controllers
     522              :     // should have handled that, but just in case).
     523            0 :     if (mSessionMgr != nullptr)
     524              :     {
     525            0 :         mSessionMgr->ExpireAllSecureSessions();
     526              :     }
     527              : 
     528              :     // mCASEClientPool and mSessionSetupPool must be deallocated
     529              :     // after mCASESessionManager, which uses them.
     530              : 
     531            0 :     if (mSessionSetupPool != nullptr)
     532              :     {
     533            0 :         Platform::Delete(mSessionSetupPool);
     534            0 :         mSessionSetupPool = nullptr;
     535              :     }
     536              : 
     537            0 :     if (mCASEClientPool != nullptr)
     538              :     {
     539            0 :         Platform::Delete(mCASEClientPool);
     540            0 :         mCASEClientPool = nullptr;
     541              :     }
     542              : 
     543            0 :     Dnssd::Resolver::Instance().Shutdown();
     544              : 
     545              :     // Shut down the interaction model
     546            0 :     app::InteractionModelEngine::GetInstance()->Shutdown();
     547              : 
     548              :     // Shut down the TransportMgr. This holds Inet::UDPEndPoints so it must be shut down
     549              :     // before PlatformMgr().Shutdown() shuts down Inet.
     550            0 :     if (mTransportMgr != nullptr)
     551              :     {
     552            0 :         mTransportMgr->Close();
     553            0 :         chip::Platform::Delete(mTransportMgr);
     554            0 :         mTransportMgr = nullptr;
     555              :     }
     556              : 
     557            0 :     if (mExchangeMgr != nullptr)
     558              :     {
     559            0 :         mExchangeMgr->Shutdown();
     560              :     }
     561            0 :     if (mSessionMgr != nullptr)
     562              :     {
     563            0 :         mSessionMgr->Shutdown();
     564              :     }
     565              : 
     566            0 :     mSystemLayer        = nullptr;
     567            0 :     mUDPEndPointManager = nullptr;
     568              : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
     569            0 :     mTCPEndPointManager = nullptr;
     570              : #endif
     571              : #if CONFIG_NETWORK_LAYER_BLE
     572            0 :     mBleLayer = nullptr;
     573              : #endif // CONFIG_NETWORK_LAYER_BLE
     574              : 
     575            0 :     if (mMessageCounterManager != nullptr)
     576              :     {
     577            0 :         chip::Platform::Delete(mMessageCounterManager);
     578            0 :         mMessageCounterManager = nullptr;
     579              :     }
     580              : 
     581            0 :     if (mExchangeMgr != nullptr)
     582              :     {
     583            0 :         chip::Platform::Delete(mExchangeMgr);
     584            0 :         mExchangeMgr = nullptr;
     585              :     }
     586              : 
     587            0 :     if (mUnsolicitedStatusHandler != nullptr)
     588              :     {
     589            0 :         Platform::Delete(mUnsolicitedStatusHandler);
     590            0 :         mUnsolicitedStatusHandler = nullptr;
     591              :     }
     592              : 
     593            0 :     if (mSessionMgr != nullptr)
     594              :     {
     595            0 :         chip::Platform::Delete(mSessionMgr);
     596            0 :         mSessionMgr = nullptr;
     597              :     }
     598              : 
     599            0 :     if (mReportScheduler != nullptr)
     600              :     {
     601            0 :         chip::Platform::Delete(mReportScheduler);
     602            0 :         mReportScheduler = nullptr;
     603              :     }
     604              : 
     605            0 :     if (mTimerDelegate != nullptr)
     606              :     {
     607            0 :         chip::Platform::Delete(mTimerDelegate);
     608            0 :         mTimerDelegate = nullptr;
     609              :     }
     610              : 
     611            0 :     if (mTempFabricTable != nullptr)
     612              :     {
     613            0 :         mTempFabricTable->Shutdown();
     614            0 :         chip::Platform::Delete(mTempFabricTable);
     615            0 :         mTempFabricTable = nullptr;
     616              :         // if we created a temp fabric table, then mFabrics points to it.
     617              :         // if we did not create a temp fabric table, then keep the reference
     618              :         // so that SetupController/Commissioner can use it
     619            0 :         mFabrics = nullptr;
     620              :     }
     621              : 
     622              : #if CONFIG_DEVICE_LAYER
     623              :     //
     624              :     // We can safely call PlatformMgr().Shutdown(), which like DeviceController::Shutdown(),
     625              :     // expects to be called with external thread synchronization and will not try to acquire the
     626              :     // stack lock.
     627              :     //
     628              :     // Actually stopping the event queue is a separable call that applications will have to sequence.
     629              :     // Consumers are expected to call PlaformMgr().StopEventLoopTask() before calling
     630              :     // DeviceController::Shutdown() in the CONFIG_DEVICE_LAYER configuration
     631              :     //
     632            0 :     DeviceLayer::PlatformMgr().Shutdown();
     633              : #endif
     634              : }
     635              : 
     636              : } // namespace Controller
     637              : } // namespace chip
        

Generated by: LCOV version 2.0-1