src/include/platform/ConfigurationManager.h

   1 /*
   2  *
   3  *    Copyright (c) 2020 Project CHIP Authors
   4  *    Copyright (c) 2019-2020 Google LLC.
   5  *    Copyright (c) 2018 Nest Labs, Inc.
   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  *          Defines the public interface for the Device Layer ConfigurationManager object.
  23  */
  24
  25 #pragma once
  26
  27 #include <cstdint>
  28
  29 #include <platform/PersistedStorage.h>
  30
  31 namespace chip {
  32 namespace Ble {
  33 struct ChipBLEDeviceIdentificationInfo;
  34 }
  35 } // namespace chip
  36
  37 namespace chip {
  38 namespace DeviceLayer {
  39
  40 class PlatformManagerImpl;
  41 class ConfigurationManagerImpl;
  42 namespace Internal {
  43 template <class>
  44 class GenericPlatformManagerImpl;
  45 template <class>
  46 class GenericPlatformManagerImpl_POSIX;
  47 } // namespace Internal
  48
  49 /**
  50  * Provides access to runtime and build-time configuration information for a chip device.
  51  */
  52 class ConfigurationManager
  53 {
  54 public:
  55     // ===== Members that define the public interface of the ConfigurationManager
  56
  57     enum
  58     {
  59         kMaxPairingCodeLength      = 16,
  60         kMaxSerialNumberLength     = 32,
  61         kMaxFirmwareRevisionLength = 32,
  62     };
  63
  64     CHIP_ERROR GetVendorId(uint16_t & vendorId);
  65     CHIP_ERROR GetProductId(uint16_t & productId);
  66     CHIP_ERROR GetProductRevision(uint16_t & productRev);
  67     CHIP_ERROR GetSerialNumber(char * buf, size_t bufSize, size_t & serialNumLen);
  68     CHIP_ERROR GetPrimaryWiFiMACAddress(uint8_t * buf);
  69     CHIP_ERROR GetPrimary802154MACAddress(uint8_t * buf);
  70     CHIP_ERROR GetManufacturingDate(uint16_t & year, uint8_t & month, uint8_t & dayOfMonth);
  71     CHIP_ERROR GetFirmwareRevision(char * buf, size_t bufSize, size_t & outLen);
  72     CHIP_ERROR GetFirmwareBuildTime(uint16_t & year, uint8_t & month, uint8_t & dayOfMonth, uint8_t & hour, uint8_t & minute,
  73                                     uint8_t & second);
  74     CHIP_ERROR GetDeviceId(uint64_t & deviceId);
  75     CHIP_ERROR GetDeviceCertificate(uint8_t * buf, size_t bufSize, size_t & certLen);
  76     CHIP_ERROR GetDeviceIntermediateCACerts(uint8_t * buf, size_t bufSize, size_t & certsLen);
  77     CHIP_ERROR GetDevicePrivateKey(uint8_t * buf, size_t bufSize, size_t & keyLen);
  78     CHIP_ERROR GetManufacturerDeviceId(uint64_t & deviceId);
  79     CHIP_ERROR GetManufacturerDeviceCertificate(uint8_t * buf, size_t bufSize, size_t & certLen);
  80     CHIP_ERROR GetManufacturerDeviceIntermediateCACerts(uint8_t * buf, size_t bufSize, size_t & certsLen);
  81     CHIP_ERROR GetManufacturerDevicePrivateKey(uint8_t * buf, size_t bufSize, size_t & keyLen);
  82     CHIP_ERROR GetSetupPinCode(uint32_t & setupPinCode);
  83     CHIP_ERROR GetSetupDiscriminator(uint16_t & setupDiscriminator);
  84     CHIP_ERROR GetServiceId(uint64_t & serviceId);
  85     CHIP_ERROR GetFabricId(uint64_t & fabricId);
  86     CHIP_ERROR GetServiceConfig(uint8_t * buf, size_t bufSize, size_t & serviceConfigLen);
  87     CHIP_ERROR GetPairedAccountId(char * buf, size_t bufSize, size_t & accountIdLen);
  88 #if CHIP_ENABLE_ROTATING_DEVICE_ID
  89     // Lifetime counter is monotonic counter that is incremented only in the case of a factory reset
  90     CHIP_ERROR GetLifetimeCounter(uint16_t & lifetimeCounter);
  91 #endif
  92     CHIP_ERROR StoreSerialNumber(const char * serialNum, size_t serialNumLen);
  93     CHIP_ERROR StorePrimaryWiFiMACAddress(const uint8_t * buf);
  94     CHIP_ERROR StorePrimary802154MACAddress(const uint8_t * buf);
  95     CHIP_ERROR StoreManufacturingDate(const char * mfgDate, size_t mfgDateLen);
  96     CHIP_ERROR StoreProductRevision(uint16_t productRev);
  97     CHIP_ERROR StoreFabricId(uint64_t fabricId);
  98 #if CHIP_DEVICE_CONFIG_ENABLE_JUST_IN_TIME_PROVISIONING
  99     CHIP_ERROR StoreDeviceId(uint64_t deviceId);
 100     CHIP_ERROR StoreDeviceCertificate(const uint8_t * cert, size_t certLen);
 101     CHIP_ERROR StoreDeviceIntermediateCACerts(const uint8_t * certs, size_t certsLen);
 102     CHIP_ERROR StoreDevicePrivateKey(const uint8_t * key, size_t keyLen);
 103 #endif
 104     CHIP_ERROR StoreManufacturerDeviceId(uint64_t deviceId);
 105     CHIP_ERROR StoreManufacturerDeviceCertificate(const uint8_t * cert, size_t certLen);
 106     CHIP_ERROR StoreManufacturerDeviceIntermediateCACerts(const uint8_t * certs, size_t certsLen);
 107     CHIP_ERROR StoreManufacturerDevicePrivateKey(const uint8_t * key, size_t keyLen);
 108     CHIP_ERROR StoreSetupPinCode(uint32_t setupPinCode);
 109     CHIP_ERROR StoreSetupDiscriminator(uint16_t setupDiscriminator);
 110     CHIP_ERROR StoreServiceProvisioningData(uint64_t serviceId, const uint8_t * serviceConfig, size_t serviceConfigLen,
 111                                             const char * accountId, size_t accountIdLen);
 112     CHIP_ERROR ClearServiceProvisioningData();
 113     CHIP_ERROR StoreServiceConfig(const uint8_t * serviceConfig, size_t serviceConfigLen);
 114     CHIP_ERROR StorePairedAccountId(const char * accountId, size_t accountIdLen);
 115
 116     CHIP_ERROR GetQRCodeString(char * buf, size_t bufSize);
 117
 118     CHIP_ERROR GetWiFiAPSSID(char * buf, size_t bufSize);
 119
 120     CHIP_ERROR GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo);
 121
 122 #if !defined(NDEBUG)
 123     CHIP_ERROR RunUnitTests();
 124 #endif
 125
 126     bool IsServiceProvisioned();
 127     bool IsPairedToAccount();
 128     bool IsMemberOfFabric();
 129     bool IsFullyProvisioned();
 130 #if CHIP_DEVICE_CONFIG_ENABLE_JUST_IN_TIME_PROVISIONING
 131     bool OperationalDeviceCredentialsProvisioned();
 132 #endif
 133
 134     void InitiateFactoryReset();
 135
 136     CHIP_ERROR ComputeProvisioningHash(uint8_t * hashBuf, size_t hashBufSize);
 137
 138     void LogDeviceConfig();
 139
 140 private:
 141     // ===== Members for internal use by the following friends.
 142
 143     friend class ::chip::DeviceLayer::PlatformManagerImpl;
 144     template <class>
 145     friend class ::chip::DeviceLayer::Internal::GenericPlatformManagerImpl;
 146     template <class>
 147     friend class ::chip::DeviceLayer::Internal::GenericPlatformManagerImpl_POSIX;
 148     // Parentheses used to fix clang parsing issue with these declarations
 149     friend CHIP_ERROR(::chip::Platform::PersistedStorage::Read)(::chip::Platform::PersistedStorage::Key key, uint32_t & value);
 150     friend CHIP_ERROR(::chip::Platform::PersistedStorage::Write)(::chip::Platform::PersistedStorage::Key key, uint32_t value);
 151
 152     using ImplClass = ::chip::DeviceLayer::ConfigurationManagerImpl;
 153
 154     CHIP_ERROR Init();
 155     CHIP_ERROR ConfigureChipStack();
 156     bool CanFactoryReset();
 157     CHIP_ERROR GetFailSafeArmed(bool & val);
 158     CHIP_ERROR SetFailSafeArmed(bool val);
 159     CHIP_ERROR ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t & value);
 160     CHIP_ERROR WritePersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t value);
 161 #if CHIP_DEVICE_CONFIG_ENABLE_JUST_IN_TIME_PROVISIONING
 162     CHIP_ERROR ClearOperationalDeviceCredentials(void);
 163     void UseManufacturerCredentialsAsOperational(bool val);
 164 #endif
 165
 166 protected:
 167     // Construction/destruction limited to subclasses.
 168     ConfigurationManager()  = default;
 169     ~ConfigurationManager() = default;
 170
 171     // No copy, move or assignment.
 172     ConfigurationManager(const ConfigurationManager &)  = delete;
 173     ConfigurationManager(const ConfigurationManager &&) = delete;
 174     ConfigurationManager & operator=(const ConfigurationManager &) = delete;
 175 };
 176
 177 /**
 178  * Returns a reference to the public interface of the ConfigurationManager singleton object.
 179  *
 180  * chip application should use this to access features of the ConfigurationManager object
 181  * that are common to all platforms.
 182  */
 183 extern ConfigurationManager & ConfigurationMgr();
 184
 185 /**
 186  * Returns the platform-specific implementation of the ConfigurationManager singleton object.
 187  *
 188  * chip applications can use this to gain access to features of the ConfigurationManager
 189  * that are specific to the selected platform.
 190  */
 191 extern ConfigurationManagerImpl & ConfigurationMgrImpl();
 192
 193 } // namespace DeviceLayer
 194 } // namespace chip
 195
 196 /* Include a header file containing the implementation of the ConfigurationManager
 197  * object for the selected platform.
 198  */
 199 #ifdef EXTERNAL_CONFIGURATIONMANAGERIMPL_HEADER
 200 #include EXTERNAL_CONFIGURATIONMANAGERIMPL_HEADER
 201 #elif defined(CHIP_DEVICE_LAYER_TARGET)
 202 #define CONFIGURATIONMANAGERIMPL_HEADER <platform/CHIP_DEVICE_LAYER_TARGET/ConfigurationManagerImpl.h>
 203 #include CONFIGURATIONMANAGERIMPL_HEADER
 204 #endif // defined(CHIP_DEVICE_LAYER_TARGET)
 205
 206 namespace chip {
 207 namespace DeviceLayer {
 208
 209 /**
 210  * Id of the vendor that produced the device.
 211  */
 212 inline CHIP_ERROR ConfigurationManager::GetVendorId(uint16_t & vendorId)
 213 {
 214     return static_cast<ImplClass *>(this)->_GetVendorId(vendorId);
 215 }
 216
 217 /**
 218  * Device product id assigned by the vendor.
 219  */
 220 inline CHIP_ERROR ConfigurationManager::GetProductId(uint16_t & productId)
 221 {
 222     return static_cast<ImplClass *>(this)->_GetProductId(productId);
 223 }
 224
 225 /**
 226  * Product revision number assigned by the vendor.
 227  */
 228 inline CHIP_ERROR ConfigurationManager::GetProductRevision(uint16_t & productRev)
 229 {
 230     return static_cast<ImplClass *>(this)->_GetProductRevision(productRev);
 231 }
 232
 233 inline CHIP_ERROR ConfigurationManager::GetSerialNumber(char * buf, size_t bufSize, size_t & serialNumLen)
 234 {
 235     return static_cast<ImplClass *>(this)->_GetSerialNumber(buf, bufSize, serialNumLen);
 236 }
 237
 238 inline CHIP_ERROR ConfigurationManager::GetPrimaryWiFiMACAddress(uint8_t * buf)
 239 {
 240     return static_cast<ImplClass *>(this)->_GetPrimaryWiFiMACAddress(buf);
 241 }
 242
 243 inline CHIP_ERROR ConfigurationManager::GetPrimary802154MACAddress(uint8_t * buf)
 244 {
 245     return static_cast<ImplClass *>(this)->_GetPrimary802154MACAddress(buf);
 246 }
 247
 248 inline CHIP_ERROR ConfigurationManager::GetManufacturingDate(uint16_t & year, uint8_t & month, uint8_t & dayOfMonth)
 249 {
 250     return static_cast<ImplClass *>(this)->_GetManufacturingDate(year, month, dayOfMonth);
 251 }
 252
 253 inline CHIP_ERROR ConfigurationManager::GetFirmwareRevision(char * buf, size_t bufSize, size_t & outLen)
 254 {
 255     return static_cast<ImplClass *>(this)->_GetFirmwareRevision(buf, bufSize, outLen);
 256 }
 257
 258 inline CHIP_ERROR ConfigurationManager::GetFirmwareBuildTime(uint16_t & year, uint8_t & month, uint8_t & dayOfMonth, uint8_t & hour,
 259                                                              uint8_t & minute, uint8_t & second)
 260 {
 261     return static_cast<ImplClass *>(this)->_GetFirmwareBuildTime(year, month, dayOfMonth, hour, minute, second);
 262 }
 263
 264 inline CHIP_ERROR ConfigurationManager::GetDeviceId(uint64_t & deviceId)
 265 {
 266     return static_cast<ImplClass *>(this)->_GetDeviceId(deviceId);
 267 }
 268
 269 inline CHIP_ERROR ConfigurationManager::GetDeviceCertificate(uint8_t * buf, size_t bufSize, size_t & certLen)
 270 {
 271     return static_cast<ImplClass *>(this)->_GetDeviceCertificate(buf, bufSize, certLen);
 272 }
 273
 274 inline CHIP_ERROR ConfigurationManager::GetDeviceIntermediateCACerts(uint8_t * buf, size_t bufSize, size_t & certsLen)
 275 {
 276     return static_cast<ImplClass *>(this)->_GetDeviceIntermediateCACerts(buf, bufSize, certsLen);
 277 }
 278
 279 inline CHIP_ERROR ConfigurationManager::GetDevicePrivateKey(uint8_t * buf, size_t bufSize, size_t & keyLen)
 280 {
 281     return static_cast<ImplClass *>(this)->_GetDevicePrivateKey(buf, bufSize, keyLen);
 282 }
 283
 284 inline CHIP_ERROR ConfigurationManager::GetManufacturerDeviceId(uint64_t & deviceId)
 285 {
 286     return static_cast<ImplClass *>(this)->_GetManufacturerDeviceId(deviceId);
 287 }
 288
 289 inline CHIP_ERROR ConfigurationManager::GetManufacturerDeviceCertificate(uint8_t * buf, size_t bufSize, size_t & certLen)
 290 {
 291     return static_cast<ImplClass *>(this)->_GetManufacturerDeviceCertificate(buf, bufSize, certLen);
 292 }
 293
 294 inline CHIP_ERROR ConfigurationManager::GetManufacturerDeviceIntermediateCACerts(uint8_t * buf, size_t bufSize, size_t & certsLen)
 295 {
 296     return static_cast<ImplClass *>(this)->_GetManufacturerDeviceIntermediateCACerts(buf, bufSize, certsLen);
 297 }
 298
 299 inline CHIP_ERROR ConfigurationManager::GetManufacturerDevicePrivateKey(uint8_t * buf, size_t bufSize, size_t & keyLen)
 300 {
 301     return static_cast<ImplClass *>(this)->_GetManufacturerDevicePrivateKey(buf, bufSize, keyLen);
 302 }
 303
 304 inline CHIP_ERROR ConfigurationManager::GetSetupPinCode(uint32_t & setupPinCode)
 305 {
 306     return static_cast<ImplClass *>(this)->_GetSetupPinCode(setupPinCode);
 307 }
 308
 309 inline CHIP_ERROR ConfigurationManager::GetSetupDiscriminator(uint16_t & setupDiscriminator)
 310 {
 311     return static_cast<ImplClass *>(this)->_GetSetupDiscriminator(setupDiscriminator);
 312 }
 313
 314 inline CHIP_ERROR ConfigurationManager::GetServiceId(uint64_t & serviceId)
 315 {
 316     return static_cast<ImplClass *>(this)->_GetServiceId(serviceId);
 317 }
 318
 319 inline CHIP_ERROR ConfigurationManager::GetFabricId(uint64_t & fabricId)
 320 {
 321     return static_cast<ImplClass *>(this)->_GetFabricId(fabricId);
 322 }
 323
 324 inline CHIP_ERROR ConfigurationManager::GetServiceConfig(uint8_t * buf, size_t bufSize, size_t & serviceConfigLen)
 325 {
 326     return static_cast<ImplClass *>(this)->_GetServiceConfig(buf, bufSize, serviceConfigLen);
 327 }
 328
 329 inline CHIP_ERROR ConfigurationManager::GetPairedAccountId(char * buf, size_t bufSize, size_t & accountIdLen)
 330 {
 331     return static_cast<ImplClass *>(this)->_GetPairedAccountId(buf, bufSize, accountIdLen);
 332 }
 333
 334 #if CHIP_ENABLE_ROTATING_DEVICE_ID
 335 inline CHIP_ERROR ConfigurationManager::GetLifetimeCounter(uint16_t & lifetimeCounter)
 336 {
 337     return static_cast<ImplClass *>(this)->_GetLifetimeCounter(lifetimeCounter);
 338 }
 339 #endif
 340
 341 inline CHIP_ERROR ConfigurationManager::StoreSerialNumber(const char * serialNum, size_t serialNumLen)
 342 {
 343     return static_cast<ImplClass *>(this)->_StoreSerialNumber(serialNum, serialNumLen);
 344 }
 345
 346 inline CHIP_ERROR ConfigurationManager::StorePrimaryWiFiMACAddress(const uint8_t * buf)
 347 {
 348     return static_cast<ImplClass *>(this)->_StorePrimaryWiFiMACAddress(buf);
 349 }
 350
 351 inline CHIP_ERROR ConfigurationManager::StorePrimary802154MACAddress(const uint8_t * buf)
 352 {
 353     return static_cast<ImplClass *>(this)->_StorePrimary802154MACAddress(buf);
 354 }
 355
 356 inline CHIP_ERROR ConfigurationManager::StoreManufacturingDate(const char * mfgDate, size_t mfgDateLen)
 357 {
 358     return static_cast<ImplClass *>(this)->_StoreManufacturingDate(mfgDate, mfgDateLen);
 359 }
 360
 361 inline CHIP_ERROR ConfigurationManager::StoreProductRevision(uint16_t productRev)
 362 {
 363     return static_cast<ImplClass *>(this)->_StoreProductRevision(productRev);
 364 }
 365
 366 inline CHIP_ERROR ConfigurationManager::StoreFabricId(uint64_t fabricId)
 367 {
 368     return static_cast<ImplClass *>(this)->_StoreFabricId(fabricId);
 369 }
 370
 371 #if CHIP_DEVICE_CONFIG_ENABLE_JUST_IN_TIME_PROVISIONING
 372
 373 inline CHIP_ERROR ConfigurationManager::StoreDeviceId(uint64_t deviceId)
 374 {
 375     return static_cast<ImplClass *>(this)->_StoreDeviceId(deviceId);
 376 }
 377
 378 inline CHIP_ERROR ConfigurationManager::StoreDeviceCertificate(const uint8_t * cert, size_t certLen)
 379 {
 380     return static_cast<ImplClass *>(this)->_StoreDeviceCertificate(cert, certLen);
 381 }
 382
 383 inline CHIP_ERROR ConfigurationManager::StoreDeviceIntermediateCACerts(const uint8_t * certs, size_t certsLen)
 384 {
 385     return static_cast<ImplClass *>(this)->_StoreDeviceIntermediateCACerts(certs, certsLen);
 386 }
 387
 388 inline CHIP_ERROR ConfigurationManager::StoreDevicePrivateKey(const uint8_t * key, size_t keyLen)
 389 {
 390     return static_cast<ImplClass *>(this)->_StoreDevicePrivateKey(key, keyLen);
 391 }
 392
 393 #endif // CHIP_DEVICE_CONFIG_ENABLE_JUST_IN_TIME_PROVISIONING
 394
 395 inline CHIP_ERROR ConfigurationManager::StoreManufacturerDeviceId(uint64_t deviceId)
 396 {
 397     return static_cast<ImplClass *>(this)->_StoreManufacturerDeviceId(deviceId);
 398 }
 399
 400 inline CHIP_ERROR ConfigurationManager::StoreManufacturerDeviceCertificate(const uint8_t * cert, size_t certLen)
 401 {
 402     return static_cast<ImplClass *>(this)->_StoreManufacturerDeviceCertificate(cert, certLen);
 403 }
 404
 405 inline CHIP_ERROR ConfigurationManager::StoreManufacturerDeviceIntermediateCACerts(const uint8_t * certs, size_t certsLen)
 406 {
 407     return static_cast<ImplClass *>(this)->_StoreManufacturerDeviceIntermediateCACerts(certs, certsLen);
 408 }
 409
 410 inline CHIP_ERROR ConfigurationManager::StoreManufacturerDevicePrivateKey(const uint8_t * key, size_t keyLen)
 411 {
 412     return static_cast<ImplClass *>(this)->_StoreManufacturerDevicePrivateKey(key, keyLen);
 413 }
 414
 415 inline CHIP_ERROR ConfigurationManager::StoreSetupPinCode(uint32_t setupPinCode)
 416 {
 417     return static_cast<ImplClass *>(this)->_StoreSetupPinCode(setupPinCode);
 418 }
 419
 420 inline CHIP_ERROR ConfigurationManager::StoreSetupDiscriminator(uint16_t setupDiscriminator)
 421 {
 422     return static_cast<ImplClass *>(this)->_StoreSetupDiscriminator(setupDiscriminator);
 423 }
 424
 425 inline CHIP_ERROR ConfigurationManager::StoreServiceProvisioningData(uint64_t serviceId, const uint8_t * serviceConfig,
 426                                                                      size_t serviceConfigLen, const char * accountId,
 427                                                                      size_t accountIdLen)
 428 {
 429     return static_cast<ImplClass *>(this)->_StoreServiceProvisioningData(serviceId, serviceConfig, serviceConfigLen, accountId,
 430                                                                          accountIdLen);
 431 }
 432
 433 inline CHIP_ERROR ConfigurationManager::ClearServiceProvisioningData()
 434 {
 435     return static_cast<ImplClass *>(this)->_ClearServiceProvisioningData();
 436 }
 437
 438 inline CHIP_ERROR ConfigurationManager::StoreServiceConfig(const uint8_t * serviceConfig, size_t serviceConfigLen)
 439 {
 440     return static_cast<ImplClass *>(this)->_StoreServiceConfig(serviceConfig, serviceConfigLen);
 441 }
 442
 443 inline CHIP_ERROR ConfigurationManager::StorePairedAccountId(const char * accountId, size_t accountIdLen)
 444 {
 445     return static_cast<ImplClass *>(this)->_StorePairedAccountId(accountId, accountIdLen);
 446 }
 447
 448 inline CHIP_ERROR ConfigurationManager::ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t & value)
 449 {
 450     return static_cast<ImplClass *>(this)->_ReadPersistedStorageValue(key, value);
 451 }
 452
 453 inline CHIP_ERROR ConfigurationManager::WritePersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t value)
 454 {
 455     return static_cast<ImplClass *>(this)->_WritePersistedStorageValue(key, value);
 456 }
 457
 458 inline CHIP_ERROR ConfigurationManager::GetQRCodeString(char * buf, size_t bufSize)
 459 {
 460     return static_cast<ImplClass *>(this)->_GetQRCodeString(buf, bufSize);
 461 }
 462
 463 inline CHIP_ERROR ConfigurationManager::GetWiFiAPSSID(char * buf, size_t bufSize)
 464 {
 465     return static_cast<ImplClass *>(this)->_GetWiFiAPSSID(buf, bufSize);
 466 }
 467
 468 inline CHIP_ERROR ConfigurationManager::GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo)
 469 {
 470     return static_cast<ImplClass *>(this)->_GetBLEDeviceIdentificationInfo(deviceIdInfo);
 471 }
 472
 473 inline bool ConfigurationManager::IsServiceProvisioned()
 474 {
 475     return static_cast<ImplClass *>(this)->_IsServiceProvisioned();
 476 }
 477
 478 inline bool ConfigurationManager::IsPairedToAccount()
 479 {
 480     return static_cast<ImplClass *>(this)->_IsPairedToAccount();
 481 }
 482
 483 inline bool ConfigurationManager::IsMemberOfFabric()
 484 {
 485     return static_cast<ImplClass *>(this)->_IsMemberOfFabric();
 486 }
 487
 488 inline bool ConfigurationManager::IsFullyProvisioned()
 489 {
 490     return static_cast<ImplClass *>(this)->_IsFullyProvisioned();
 491 }
 492
 493 inline void ConfigurationManager::InitiateFactoryReset()
 494 {
 495 #if CHIP_ENABLE_ROTATING_DEVICE_ID
 496     static_cast<ImplClass *>(this)->_IncrementLifetimeCounter();
 497 #endif
 498     static_cast<ImplClass *>(this)->_InitiateFactoryReset();
 499 }
 500
 501 #if !defined(NDEBUG)
 502 inline CHIP_ERROR ConfigurationManager::RunUnitTests()
 503 {
 504     return static_cast<ImplClass *>(this)->_RunUnitTests();
 505 }
 506 #endif
 507
 508 inline CHIP_ERROR ConfigurationManager::ComputeProvisioningHash(uint8_t * hashBuf, size_t hashBufSize)
 509 {
 510     return static_cast<ImplClass *>(this)->_ComputeProvisioningHash(hashBuf, hashBufSize);
 511 }
 512
 513 inline CHIP_ERROR ConfigurationManager::Init()
 514 {
 515     return static_cast<ImplClass *>(this)->_Init();
 516 }
 517
 518 inline CHIP_ERROR ConfigurationManager::ConfigureChipStack()
 519 {
 520     return static_cast<ImplClass *>(this)->_ConfigureChipStack();
 521 }
 522
 523 inline bool ConfigurationManager::CanFactoryReset()
 524 {
 525     return static_cast<ImplClass *>(this)->_CanFactoryReset();
 526 }
 527
 528 inline CHIP_ERROR ConfigurationManager::GetFailSafeArmed(bool & val)
 529 {
 530     return static_cast<ImplClass *>(this)->_GetFailSafeArmed(val);
 531 }
 532
 533 inline CHIP_ERROR ConfigurationManager::SetFailSafeArmed(bool val)
 534 {
 535     return static_cast<ImplClass *>(this)->_SetFailSafeArmed(val);
 536 }
 537
 538 #if CHIP_DEVICE_CONFIG_ENABLE_JUST_IN_TIME_PROVISIONING
 539
 540 inline bool ConfigurationManager::OperationalDeviceCredentialsProvisioned()
 541 {
 542     return static_cast<ImplClass *>(this)->_OperationalDeviceCredentialsProvisioned();
 543 }
 544
 545 inline CHIP_ERROR ConfigurationManager::ClearOperationalDeviceCredentials(void)
 546 {
 547     return static_cast<ImplClass *>(this)->_ClearOperationalDeviceCredentials();
 548 }
 549
 550 inline void ConfigurationManager::UseManufacturerCredentialsAsOperational(bool val)
 551 {
 552     static_cast<ImplClass *>(this)->_UseManufacturerCredentialsAsOperational(val);
 553 }
 554
 555 #endif // CHIP_DEVICE_CONFIG_ENABLE_JUST_IN_TIME_PROVISIONING
 556
 557 inline void ConfigurationManager::LogDeviceConfig()
 558 {
 559     static_cast<ImplClass *>(this)->_LogDeviceConfig();
 560 }
 561
 562 } // namespace DeviceLayer
 563 } // namespace chip