Line data Source code
1 : /*
2 : *
3 : * Copyright (c) 2020-2022 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 : * Contains non-inline method definitions for the
23 : * GenericConfigurationManagerImpl<> template.
24 : */
25 :
26 : #ifndef GENERIC_CONFIGURATION_MANAGER_IMPL_CPP
27 : #define GENERIC_CONFIGURATION_MANAGER_IMPL_CPP
28 :
29 : #include <FirmwareBuildTime.h>
30 : #include <ble/Ble.h>
31 : #include <crypto/CHIPCryptoPAL.h>
32 : #include <crypto/RandUtils.h>
33 : #include <inttypes.h>
34 : #include <lib/core/CHIPConfig.h>
35 : #include <lib/support/Base64.h>
36 : #include <lib/support/BytesToHex.h>
37 : #include <lib/support/CHIPMem.h>
38 : #include <lib/support/CodeUtils.h>
39 : #include <lib/support/SafeInt.h>
40 : #include <lib/support/ScopedBuffer.h>
41 : #include <platform/BuildTime.h>
42 : #include <platform/CommissionableDataProvider.h>
43 : #include <platform/DeviceControlServer.h>
44 : #include <platform/internal/CHIPDeviceLayerInternal.h>
45 : #include <platform/internal/GenericConfigurationManagerImpl.h>
46 : #include <platform/internal/GenericDeviceInstanceInfoProvider.ipp>
47 :
48 : #if CHIP_DEVICE_CONFIG_ENABLE_THREAD
49 : #include <platform/ThreadStackManager.h>
50 : #endif
51 :
52 : #include <optional>
53 :
54 : // TODO : may be we can make it configurable
55 : #define BLE_ADVERTISEMENT_VERSION 0
56 :
57 : namespace chip {
58 : namespace DeviceLayer {
59 : namespace Internal {
60 :
61 : namespace {
62 : std::optional<System::Clock::Seconds32> gFirmwareBuildChipEpochTime;
63 : }
64 :
65 : #if CHIP_USE_TRANSITIONAL_COMMISSIONABLE_DATA_PROVIDER
66 :
67 : // Legacy version of CommissionableDataProvider used for a grace period
68 : // to a transition where all ConfigurationManager customers move to
69 : // provide their own impl of CommissionableDataProvider interface.
70 :
71 : template <class ConfigClass>
72 : class LegacyTemporaryCommissionableDataProvider : public CommissionableDataProvider
73 : {
74 : public:
75 : // GenericConfigurationManagerImpl will own a LegacyTemporaryCommissionableDataProvider which
76 : // *refers back to that GenericConfigurationManagerImpl*, due to how CRTP-based
77 : // storage APIs are defined. This is a bit unclean, but only applicable to the
78 : // transition path when `CHIP_USE_TRANSITIONAL_COMMISSIONABLE_DATA_PROVIDER` is true.
79 : // This circular dependency is NOT needed by CommissionableDataProvider, but required
80 : // to keep legacy code running.
81 : LegacyTemporaryCommissionableDataProvider(GenericConfigurationManagerImpl<ConfigClass> & configManager) :
82 : mGenericConfigManager(configManager)
83 : {}
84 :
85 : CHIP_ERROR GetSetupDiscriminator(uint16_t & setupDiscriminator) override;
86 : CHIP_ERROR SetSetupDiscriminator(uint16_t setupDiscriminator) override;
87 : CHIP_ERROR GetSpake2pIterationCount(uint32_t & iterationCount) override;
88 : CHIP_ERROR GetSpake2pSalt(MutableByteSpan & saltBuf) override;
89 : CHIP_ERROR GetSpake2pVerifier(MutableByteSpan & verifierBuf, size_t & outVerifierLen) override;
90 : CHIP_ERROR GetSetupPasscode(uint32_t & setupPasscode) override;
91 : CHIP_ERROR SetSetupPasscode(uint32_t setupPasscode) override;
92 :
93 : private:
94 : GenericConfigurationManagerImpl<ConfigClass> & mGenericConfigManager;
95 : };
96 :
97 : template <class ConfigClass>
98 : CHIP_ERROR LegacyTemporaryCommissionableDataProvider<ConfigClass>::GetSetupPasscode(uint32_t & setupPasscode)
99 : {
100 : CHIP_ERROR err;
101 :
102 : err = mGenericConfigManager.ReadConfigValue(ConfigClass::kConfigKey_SetupPinCode, setupPasscode);
103 : #if defined(CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE) && CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE
104 : if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
105 : {
106 : setupPasscode = CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE;
107 : err = CHIP_NO_ERROR;
108 : }
109 : #endif // defined(CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE) && CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE
110 : SuccessOrExit(err);
111 :
112 : exit:
113 : return err;
114 : }
115 :
116 : template <class ConfigClass>
117 : CHIP_ERROR LegacyTemporaryCommissionableDataProvider<ConfigClass>::SetSetupPasscode(uint32_t setupPasscode)
118 : {
119 : return mGenericConfigManager.WriteConfigValue(ConfigClass::kConfigKey_SetupPinCode, setupPasscode);
120 : }
121 :
122 : template <class ConfigClass>
123 : CHIP_ERROR LegacyTemporaryCommissionableDataProvider<ConfigClass>::GetSetupDiscriminator(uint16_t & setupDiscriminator)
124 : {
125 : CHIP_ERROR err;
126 : uint32_t val;
127 :
128 : err = mGenericConfigManager.ReadConfigValue(ConfigClass::kConfigKey_SetupDiscriminator, val);
129 : #if defined(CHIP_DEVICE_CONFIG_USE_TEST_SETUP_DISCRIMINATOR) && CHIP_DEVICE_CONFIG_USE_TEST_SETUP_DISCRIMINATOR
130 : if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
131 : {
132 : val = CHIP_DEVICE_CONFIG_USE_TEST_SETUP_DISCRIMINATOR;
133 : err = CHIP_NO_ERROR;
134 : }
135 : #endif // defined(CHIP_DEVICE_CONFIG_USE_TEST_SETUP_DISCRIMINATOR) && CHIP_DEVICE_CONFIG_USE_TEST_SETUP_DISCRIMINATOR
136 : SuccessOrExit(err);
137 :
138 : setupDiscriminator = static_cast<uint16_t>(val);
139 :
140 : exit:
141 : return err;
142 : }
143 :
144 : template <class ConfigClass>
145 : CHIP_ERROR LegacyTemporaryCommissionableDataProvider<ConfigClass>::SetSetupDiscriminator(uint16_t setupDiscriminator)
146 : {
147 : return mGenericConfigManager.WriteConfigValue(ConfigClass::kConfigKey_SetupDiscriminator,
148 : static_cast<uint32_t>(setupDiscriminator));
149 : }
150 :
151 : template <class ConfigClass>
152 : CHIP_ERROR LegacyTemporaryCommissionableDataProvider<ConfigClass>::GetSpake2pIterationCount(uint32_t & iterationCount)
153 : {
154 : CHIP_ERROR err = mGenericConfigManager.ReadConfigValue(ConfigClass::kConfigKey_Spake2pIterationCount, iterationCount);
155 :
156 : #if defined(CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_ITERATION_COUNT) && CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_ITERATION_COUNT
157 : if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
158 : {
159 : iterationCount = CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_ITERATION_COUNT;
160 : err = CHIP_NO_ERROR;
161 : }
162 : #endif // defined(CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_ITERATION_COUNT) && CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_ITERATION_COUNT
163 : SuccessOrExit(err);
164 :
165 : exit:
166 : return err;
167 : }
168 :
169 : template <class ConfigClass>
170 : CHIP_ERROR LegacyTemporaryCommissionableDataProvider<ConfigClass>::GetSpake2pSalt(MutableByteSpan & saltBuf)
171 : {
172 : static constexpr size_t kSpake2pSalt_MaxBase64Len = BASE64_ENCODED_LEN(chip::Crypto::kSpake2p_Max_PBKDF_Salt_Length) + 1;
173 :
174 : CHIP_ERROR err = CHIP_NO_ERROR;
175 : char saltB64[kSpake2pSalt_MaxBase64Len] = { 0 };
176 : size_t saltB64Len = 0;
177 :
178 : err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_Spake2pSalt, saltB64, sizeof(saltB64), saltB64Len);
179 :
180 : #if defined(CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_SALT)
181 : if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
182 : {
183 : saltB64Len = strlen(CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_SALT);
184 : VerifyOrReturnError(saltB64Len <= sizeof(saltB64), CHIP_ERROR_BUFFER_TOO_SMALL);
185 : memcpy(saltB64, CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_SALT, saltB64Len);
186 : err = CHIP_NO_ERROR;
187 : }
188 : #endif // defined(CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_SALT)
189 :
190 : ReturnErrorOnFailure(err);
191 :
192 : VerifyOrReturnError(chip::CanCastTo<uint32_t>(saltB64Len), CHIP_ERROR_INTERNAL);
193 :
194 : size_t saltLen = chip::Base64Decode32(saltB64, static_cast<uint32_t>(saltB64Len), reinterpret_cast<uint8_t *>(saltB64));
195 :
196 : VerifyOrReturnError(saltLen <= saltBuf.size(), CHIP_ERROR_BUFFER_TOO_SMALL);
197 : memcpy(saltBuf.data(), saltB64, saltLen);
198 : saltBuf.reduce_size(saltLen);
199 :
200 : return CHIP_NO_ERROR;
201 : }
202 :
203 : template <class ConfigClass>
204 : CHIP_ERROR LegacyTemporaryCommissionableDataProvider<ConfigClass>::GetSpake2pVerifier(MutableByteSpan & verifierBuf,
205 : size_t & verifierLen)
206 : {
207 : static constexpr size_t kSpake2pSerializedVerifier_MaxBase64Len =
208 : BASE64_ENCODED_LEN(chip::Crypto::kSpake2p_VerifierSerialized_Length) + 1;
209 :
210 : CHIP_ERROR err = CHIP_NO_ERROR;
211 : char verifierB64[kSpake2pSerializedVerifier_MaxBase64Len] = { 0 };
212 : size_t verifierB64Len = 0;
213 :
214 : err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_Spake2pVerifier, verifierB64, sizeof(verifierB64),
215 : verifierB64Len);
216 :
217 : #if defined(CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_VERIFIER)
218 : if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
219 : {
220 : verifierB64Len = strlen(CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_VERIFIER);
221 : VerifyOrReturnError(verifierB64Len <= sizeof(verifierB64), CHIP_ERROR_BUFFER_TOO_SMALL);
222 : memcpy(verifierB64, CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_VERIFIER, verifierB64Len);
223 : err = CHIP_NO_ERROR;
224 : }
225 : #endif // defined(CHIP_DEVICE_CONFIG_USE_TEST_SPAKE2P_VERIFIER)
226 :
227 : ReturnErrorOnFailure(err);
228 :
229 : VerifyOrReturnError(chip::CanCastTo<uint32_t>(verifierB64Len), CHIP_ERROR_INTERNAL);
230 : verifierLen =
231 : chip::Base64Decode32(verifierB64, static_cast<uint32_t>(verifierB64Len), reinterpret_cast<uint8_t *>(verifierB64));
232 :
233 : VerifyOrReturnError(verifierLen <= verifierBuf.size(), CHIP_ERROR_BUFFER_TOO_SMALL);
234 : memcpy(verifierBuf.data(), verifierB64, verifierLen);
235 : verifierBuf.reduce_size(verifierLen);
236 :
237 : return err;
238 : }
239 :
240 : #endif // CHIP_USE_TRANSITIONAL_COMMISSIONABLE_DATA_PROVIDER
241 :
242 : template <class ConfigClass>
243 48 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::Init()
244 : {
245 48 : CHIP_ERROR err = CHIP_NO_ERROR;
246 :
247 : #if CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID)
248 : mLifetimePersistedCounter.Init(CHIP_CONFIG_LIFETIIME_PERSISTED_COUNTER_KEY);
249 : #endif
250 :
251 : #if CHIP_USE_TRANSITIONAL_DEVICE_INSTANCE_INFO_PROVIDER
252 48 : static GenericDeviceInstanceInfoProvider<ConfigClass> sGenericDeviceInstanceInfoProvider(*this);
253 :
254 48 : SetDeviceInstanceInfoProvider(&sGenericDeviceInstanceInfoProvider);
255 : #endif
256 :
257 : #if CHIP_USE_TRANSITIONAL_COMMISSIONABLE_DATA_PROVIDER
258 : // Using a temporary singleton here because the overall GenericConfigurationManagerImpl is
259 : // a singleton. This is TEMPORARY code to set the table for clients to set their own
260 : // implementation properly, without loss of functionality for legacy in the meantime.
261 : static LegacyTemporaryCommissionableDataProvider<ConfigClass> sLegacyTemporaryCommissionableDataProvider(*this);
262 :
263 : SetCommissionableDataProvider(&sLegacyTemporaryCommissionableDataProvider);
264 : #endif
265 :
266 : char uniqueId[kMaxUniqueIDLength + 1];
267 :
268 : // Generate Unique ID only if it is not present in the storage.
269 48 : if (GetUniqueId(uniqueId, sizeof(uniqueId)) != CHIP_NO_ERROR)
270 : {
271 2 : ReturnErrorOnFailure(GenerateUniqueId(uniqueId, sizeof(uniqueId)));
272 2 : ReturnErrorOnFailure(StoreUniqueId(uniqueId, strlen(uniqueId)));
273 : }
274 :
275 48 : return err;
276 : }
277 :
278 : template <class ConfigClass>
279 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSoftwareVersion(uint32_t & softwareVer)
280 : {
281 0 : softwareVer = static_cast<uint32_t>(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION);
282 0 : return CHIP_NO_ERROR;
283 : }
284 :
285 : template <class ConfigClass>
286 0 : inline CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSoftwareVersion(uint32_t softwareVer)
287 : {
288 0 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
289 : }
290 :
291 : template <class ConfigClass>
292 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetConfigurationVersion(uint32_t & configurationVer)
293 : {
294 0 : configurationVer = static_cast<uint32_t>(CHIP_DEVICE_CONFIG_DEVICE_CONFIGURATION_VERSION);
295 0 : return CHIP_NO_ERROR;
296 : }
297 :
298 : template <class ConfigClass>
299 0 : inline CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreConfigurationVersion(uint32_t configurationVer)
300 : {
301 0 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
302 : }
303 :
304 : template <class ConfigClass>
305 464 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetFirmwareBuildChipEpochTime(System::Clock::Seconds32 & chipEpochTime)
306 : {
307 : // If the setter was called and we have a value in memory, return this.
308 464 : if (gFirmwareBuildChipEpochTime.has_value())
309 : {
310 62 : chipEpochTime = gFirmwareBuildChipEpochTime.value();
311 62 : return CHIP_NO_ERROR;
312 : }
313 : #ifdef CHIP_DEVICE_CONFIG_FIRMWARE_BUILD_TIME_MATTER_EPOCH_S
314 : {
315 402 : chipEpochTime = chip::System::Clock::Seconds32(CHIP_DEVICE_CONFIG_FIRMWARE_BUILD_TIME_MATTER_EPOCH_S);
316 402 : return CHIP_NO_ERROR;
317 : }
318 : #endif
319 : // Else, attempt to read the hard-coded values.
320 : VerifyOrReturnError(!BUILD_DATE_IS_BAD(CHIP_DEVICE_CONFIG_FIRMWARE_BUILD_DATE), CHIP_ERROR_INTERNAL);
321 : VerifyOrReturnError(!BUILD_TIME_IS_BAD(CHIP_DEVICE_CONFIG_FIRMWARE_BUILD_TIME), CHIP_ERROR_INTERNAL);
322 : const char * date = CHIP_DEVICE_CONFIG_FIRMWARE_BUILD_DATE;
323 : const char * time = CHIP_DEVICE_CONFIG_FIRMWARE_BUILD_TIME;
324 : uint32_t seconds;
325 : auto good = CalendarToChipEpochTime(COMPUTE_BUILD_YEAR(date), COMPUTE_BUILD_MONTH(date), COMPUTE_BUILD_DAY(date),
326 : COMPUTE_BUILD_HOUR(time), COMPUTE_BUILD_MIN(time), COMPUTE_BUILD_SEC(time), seconds);
327 : if (good)
328 : {
329 : chipEpochTime = chip::System::Clock::Seconds32(seconds);
330 : }
331 : return good ? CHIP_NO_ERROR : CHIP_ERROR_INVALID_ARGUMENT;
332 : }
333 :
334 : template <class ConfigClass>
335 10 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::SetFirmwareBuildChipEpochTime(System::Clock::Seconds32 chipEpochTime)
336 : {
337 : // The setter is sticky in that once the hard-coded time is overriden, it
338 : // will be for the lifetime of the configuration manager singleton.
339 : // However, this is not persistent across boots.
340 : //
341 : // Implementations that can't use the hard-coded time for whatever reason
342 : // should set this at each init.
343 10 : gFirmwareBuildChipEpochTime = chipEpochTime;
344 10 : return CHIP_NO_ERROR;
345 : }
346 :
347 : template <class ConfigClass>
348 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetDeviceTypeId(uint32_t & deviceType)
349 : {
350 0 : deviceType = static_cast<uint32_t>(CHIP_DEVICE_CONFIG_DEVICE_TYPE);
351 0 : return CHIP_NO_ERROR;
352 : }
353 :
354 : template <class ConfigClass>
355 7 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetInitialPairingHint(uint16_t & pairingHint)
356 : {
357 7 : pairingHint = static_cast<uint16_t>(CHIP_DEVICE_CONFIG_PAIRING_INITIAL_HINT);
358 7 : return CHIP_NO_ERROR;
359 : }
360 :
361 : template <class ConfigClass>
362 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSecondaryPairingHint(uint16_t & pairingHint)
363 : {
364 0 : pairingHint = static_cast<uint16_t>(CHIP_DEVICE_CONFIG_PAIRING_SECONDARY_HINT);
365 0 : return CHIP_NO_ERROR;
366 : }
367 :
368 : template <class ConfigClass>
369 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSoftwareVersionString(char * buf, size_t bufSize)
370 : {
371 0 : VerifyOrReturnError(bufSize >= sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
372 0 : strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING);
373 0 : return CHIP_NO_ERROR;
374 : }
375 :
376 : template <class ConfigClass>
377 2 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSerialNumber(const char * serialNum, size_t serialNumLen)
378 : {
379 2 : return WriteConfigValueStr(ConfigClass::kConfigKey_SerialNum, serialNum, serialNumLen);
380 : }
381 :
382 : template <class ConfigClass>
383 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetPrimaryWiFiMACAddress(uint8_t * buf)
384 : {
385 0 : return CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND;
386 : }
387 :
388 : template <class ConfigClass>
389 9 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetPrimaryMACAddress(MutableByteSpan & buf)
390 : {
391 9 : if (buf.size() != ConfigurationManager::kPrimaryMACAddressLength)
392 1 : return CHIP_ERROR_INVALID_ARGUMENT;
393 :
394 8 : memset(buf.data(), 0, buf.size()); // zero the whole buffer, in case the caller ignores buf.size()
395 :
396 : #if CHIP_DEVICE_CONFIG_ENABLE_THREAD
397 8 : if (chip::DeviceLayer::ThreadStackMgr().GetPrimary802154MACAddress(buf.data()) == CHIP_NO_ERROR)
398 : {
399 0 : ChipLogDetail(DeviceLayer, "Using Thread extended MAC for hostname.");
400 0 : buf.reduce_size(kThreadMACAddressLength);
401 0 : return CHIP_NO_ERROR;
402 : }
403 : #endif
404 :
405 8 : if (chip::DeviceLayer::ConfigurationMgr().GetPrimaryWiFiMACAddress(buf.data()) == CHIP_NO_ERROR)
406 : {
407 8 : ChipLogDetail(DeviceLayer, "Using WiFi MAC for hostname");
408 8 : buf.reduce_size(kEthernetMACAddressLength);
409 8 : return CHIP_NO_ERROR;
410 : }
411 :
412 0 : return CHIP_ERROR_NOT_FOUND;
413 : }
414 :
415 : template <class ConfigClass>
416 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetPrimary802154MACAddress(uint8_t * buf)
417 : {
418 : #if CHIP_DEVICE_CONFIG_ENABLE_THREAD
419 0 : return ThreadStackMgr().GetPrimary802154MACAddress(buf);
420 : #else
421 : return CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND;
422 : #endif // CHIP_DEVICE_CONFIG_ENABLE_THREAD
423 : }
424 :
425 : template <class ConfigClass>
426 1 : inline CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreHardwareVersion(uint16_t hardwareVer)
427 : {
428 1 : return WriteConfigValue(ConfigClass::kConfigKey_HardwareVersion, static_cast<uint32_t>(hardwareVer));
429 : }
430 :
431 : template <class ConfigClass>
432 1 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreManufacturingDate(const char * mfgDate, size_t mfgDateLen)
433 : {
434 1 : return WriteConfigValueStr(ConfigClass::kConfigKey_ManufacturingDate, mfgDate, mfgDateLen);
435 : }
436 :
437 : template <class ConfigClass>
438 0 : void GenericConfigurationManagerImpl<ConfigClass>::InitiateFactoryReset()
439 0 : {}
440 :
441 : template <class ImplClass>
442 : void GenericConfigurationManagerImpl<ImplClass>::NotifyOfAdvertisementStart()
443 : {
444 : #if CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID)
445 : // Increment life time counter to protect against long-term tracking of rotating device ID.
446 : IncrementLifetimeCounter();
447 : // Inheriting classes should call this method so the lifetime counter is updated if necessary.
448 : #endif
449 : }
450 :
451 : template <class ConfigClass>
452 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetRegulatoryLocation(uint8_t & location)
453 : {
454 : uint32_t value;
455 0 : if (CHIP_NO_ERROR != ReadConfigValue(ConfigClass::kConfigKey_RegulatoryLocation, value))
456 : {
457 0 : ReturnErrorOnFailure(GetLocationCapability(location));
458 :
459 0 : if (CHIP_NO_ERROR != StoreRegulatoryLocation(location))
460 : {
461 0 : ChipLogError(DeviceLayer, "Failed to store RegulatoryLocation");
462 : }
463 : }
464 : else
465 : {
466 0 : location = static_cast<uint8_t>(value);
467 : }
468 :
469 0 : return CHIP_NO_ERROR;
470 : }
471 :
472 : template <class ConfigClass>
473 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreRegulatoryLocation(uint8_t location)
474 : {
475 0 : uint32_t value = location;
476 0 : return WriteConfigValue(ConfigClass::kConfigKey_RegulatoryLocation, value);
477 : }
478 :
479 : template <class ConfigClass>
480 1 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetCountryCode(char * buf, size_t bufSize, size_t & codeLen)
481 : {
482 1 : return ReadConfigValueStr(ConfigClass::kConfigKey_CountryCode, buf, bufSize, codeLen);
483 : }
484 :
485 : template <class ConfigClass>
486 1 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreCountryCode(const char * code, size_t codeLen)
487 : {
488 1 : return WriteConfigValueStr(ConfigClass::kConfigKey_CountryCode, code, codeLen);
489 : }
490 :
491 : template <class ImplClass>
492 0 : CHIP_ERROR GenericConfigurationManagerImpl<ImplClass>::GetRebootCount(uint32_t & rebootCount)
493 : {
494 0 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
495 : }
496 :
497 : template <class ImplClass>
498 0 : CHIP_ERROR GenericConfigurationManagerImpl<ImplClass>::StoreRebootCount(uint32_t rebootCount)
499 : {
500 0 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
501 : }
502 :
503 : template <class ImplClass>
504 0 : CHIP_ERROR GenericConfigurationManagerImpl<ImplClass>::GetTotalOperationalHours(uint32_t & totalOperationalHours)
505 : {
506 0 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
507 : }
508 :
509 : template <class ImplClass>
510 0 : CHIP_ERROR GenericConfigurationManagerImpl<ImplClass>::StoreTotalOperationalHours(uint32_t totalOperationalHours)
511 : {
512 0 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
513 : }
514 :
515 : template <class ImplClass>
516 0 : CHIP_ERROR GenericConfigurationManagerImpl<ImplClass>::GetBootReason(uint32_t & bootReason)
517 : {
518 0 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
519 : }
520 :
521 : template <class ImplClass>
522 0 : CHIP_ERROR GenericConfigurationManagerImpl<ImplClass>::StoreBootReason(uint32_t bootReason)
523 : {
524 0 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
525 : }
526 :
527 : template <class ConfigClass>
528 50 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetUniqueId(char * buf, size_t bufSize)
529 : {
530 : CHIP_ERROR err;
531 50 : size_t uniqueIdLen = 0; // without counting null-terminator
532 50 : err = ReadConfigValueStr(ConfigClass::kConfigKey_UniqueId, buf, bufSize, uniqueIdLen);
533 :
534 50 : ReturnErrorOnFailure(err);
535 48 : VerifyOrReturnError(uniqueIdLen < bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
536 :
537 : // ensure null termination if the string read is not null terminting (e.g. posix config on darwin
538 : // returns data without null terminators as it reads data as binary.)
539 48 : buf[uniqueIdLen] = 0;
540 :
541 48 : return err;
542 : }
543 :
544 : template <class ConfigClass>
545 4 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreUniqueId(const char * uniqueId, size_t uniqueIdLen)
546 : {
547 4 : return WriteConfigValueStr(ConfigClass::kConfigKey_UniqueId, uniqueId, uniqueIdLen);
548 : }
549 :
550 : template <class ConfigClass>
551 2 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GenerateUniqueId(char * buf, size_t bufSize)
552 : {
553 2 : uint64_t randomUniqueId = Crypto::GetRandU64();
554 2 : return Encoding::BytesToUppercaseHexString(reinterpret_cast<uint8_t *>(&randomUniqueId), sizeof(uint64_t), buf, bufSize);
555 : }
556 :
557 : #if CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID)
558 : template <class ConfigClass>
559 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetLifetimeCounter(uint16_t & lifetimeCounter)
560 : {
561 : lifetimeCounter = static_cast<uint16_t>(mLifetimePersistedCounter.GetValue());
562 : return CHIP_NO_ERROR;
563 : }
564 :
565 : template <class ConfigClass>
566 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::IncrementLifetimeCounter()
567 : {
568 : return mLifetimePersistedCounter.Advance();
569 : }
570 :
571 : template <class ConfigClass>
572 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::SetRotatingDeviceIdUniqueId(const ByteSpan & uniqueIdSpan)
573 : {
574 : VerifyOrReturnError(uniqueIdSpan.size() >= kMinRotatingDeviceIDUniqueIDLength, CHIP_ERROR_INVALID_ARGUMENT);
575 : VerifyOrReturnError(uniqueIdSpan.size() <= CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID_LENGTH, CHIP_ERROR_BUFFER_TOO_SMALL);
576 : memcpy(mRotatingDeviceIdUniqueId, uniqueIdSpan.data(), uniqueIdSpan.size());
577 : mRotatingDeviceIdUniqueIdLength = uniqueIdSpan.size();
578 : return CHIP_NO_ERROR;
579 : }
580 :
581 : template <class ConfigClass>
582 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetRotatingDeviceIdUniqueId(MutableByteSpan & uniqueIdSpan)
583 : {
584 : VerifyOrReturnError(mRotatingDeviceIdUniqueIdLength <= uniqueIdSpan.size(), CHIP_ERROR_BUFFER_TOO_SMALL);
585 : memcpy(uniqueIdSpan.data(), mRotatingDeviceIdUniqueId, mRotatingDeviceIdUniqueIdLength);
586 : uniqueIdSpan.reduce_size(mRotatingDeviceIdUniqueIdLength);
587 : return CHIP_NO_ERROR;
588 : }
589 :
590 : #endif // CHIP_ENABLE_ROTATING_DEVICE_ID
591 :
592 : template <class ConfigClass>
593 1 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetFailSafeArmed(bool & val)
594 : {
595 1 : return ReadConfigValue(ConfigClass::kConfigKey_FailSafeArmed, val);
596 : }
597 :
598 : template <class ConfigClass>
599 2 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::SetFailSafeArmed(bool val)
600 : {
601 2 : return WriteConfigValue(ConfigClass::kConfigKey_FailSafeArmed, val);
602 : }
603 :
604 : template <class ConfigClass>
605 : CHIP_ERROR
606 0 : GenericConfigurationManagerImpl<ConfigClass>::GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo)
607 : {
608 : CHIP_ERROR err;
609 : uint16_t id;
610 : uint16_t discriminator;
611 :
612 0 : deviceIdInfo.Init();
613 :
614 0 : err = GetDeviceInstanceInfoProvider()->GetVendorId(id);
615 0 : SuccessOrExit(err);
616 0 : deviceIdInfo.SetVendorId(id);
617 :
618 0 : err = GetDeviceInstanceInfoProvider()->GetProductId(id);
619 0 : SuccessOrExit(err);
620 0 : deviceIdInfo.SetProductId(id);
621 :
622 0 : err = GetCommissionableDataProvider()->GetSetupDiscriminator(discriminator);
623 0 : SuccessOrExit(err);
624 0 : deviceIdInfo.SetDeviceDiscriminator(discriminator);
625 :
626 0 : deviceIdInfo.SetAdvertisementVersion(BLE_ADVERTISEMENT_VERSION);
627 :
628 : #if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
629 : deviceIdInfo.SetAdditionalDataFlag(true);
630 : #endif
631 :
632 0 : exit:
633 0 : return err;
634 : }
635 :
636 : template <class ConfigClass>
637 0 : bool GenericConfigurationManagerImpl<ConfigClass>::IsFullyProvisioned()
638 : {
639 : return
640 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION
641 0 : ConnectivityMgr().IsWiFiStationProvisioned() &&
642 : #endif
643 : #if CHIP_DEVICE_CONFIG_ENABLE_THREAD
644 0 : ConnectivityMgr().IsThreadProvisioned() &&
645 : #endif
646 0 : true;
647 : }
648 :
649 : template <class ConfigClass>
650 7 : bool GenericConfigurationManagerImpl<ConfigClass>::IsCommissionableDeviceTypeEnabled()
651 : {
652 : #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONABLE_DEVICE_TYPE
653 : return true;
654 : #else
655 7 : return false;
656 : #endif
657 : }
658 :
659 : template <class ConfigClass>
660 7 : bool GenericConfigurationManagerImpl<ConfigClass>::IsCommissionableDeviceNameEnabled()
661 : {
662 7 : return CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONABLE_DEVICE_NAME == 1;
663 : }
664 :
665 : template <class ConfigClass>
666 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetCommissionableDeviceName(char * buf, size_t bufSize)
667 : {
668 0 : VerifyOrReturnError(bufSize >= sizeof(CHIP_DEVICE_CONFIG_DEVICE_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
669 0 : strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_NAME);
670 0 : return CHIP_NO_ERROR;
671 : }
672 :
673 : template <class ConfigClass>
674 7 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetInitialPairingInstruction(char * buf, size_t bufSize)
675 : {
676 7 : VerifyOrReturnError(bufSize >= sizeof(CHIP_DEVICE_CONFIG_PAIRING_INITIAL_INSTRUCTION), CHIP_ERROR_BUFFER_TOO_SMALL);
677 7 : strcpy(buf, CHIP_DEVICE_CONFIG_PAIRING_INITIAL_INSTRUCTION);
678 7 : return CHIP_NO_ERROR;
679 : }
680 :
681 : template <class ConfigClass>
682 0 : CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSecondaryPairingInstruction(char * buf, size_t bufSize)
683 : {
684 0 : VerifyOrReturnError(bufSize >= sizeof(CHIP_DEVICE_CONFIG_PAIRING_SECONDARY_INSTRUCTION), CHIP_ERROR_BUFFER_TOO_SMALL);
685 0 : strcpy(buf, CHIP_DEVICE_CONFIG_PAIRING_SECONDARY_INSTRUCTION);
686 0 : return CHIP_NO_ERROR;
687 : }
688 :
689 : #if CHIP_CONFIG_TEST
690 : template <class ConfigClass>
691 1 : void GenericConfigurationManagerImpl<ConfigClass>::RunUnitTests()
692 : {
693 1 : ChipLogProgress(DeviceLayer, "Running configuration unit test");
694 1 : RunConfigUnitTest();
695 1 : }
696 : #endif
697 :
698 : template <class ConfigClass>
699 0 : void GenericConfigurationManagerImpl<ConfigClass>::LogDeviceConfig()
700 : {
701 : CHIP_ERROR err;
702 :
703 0 : ChipLogProgress(DeviceLayer, "Device Configuration:");
704 :
705 0 : DeviceInstanceInfoProvider * deviceInstanceInfoProvider = GetDeviceInstanceInfoProvider();
706 :
707 : {
708 : char serialNum[ConfigurationManager::kMaxSerialNumberLength + 1];
709 0 : err = deviceInstanceInfoProvider->GetSerialNumber(serialNum, sizeof(serialNum));
710 0 : ChipLogProgress(DeviceLayer, " Serial Number: %s", (err == CHIP_NO_ERROR) ? serialNum : "(not set)");
711 : }
712 :
713 : {
714 : uint16_t vendorId;
715 0 : if (deviceInstanceInfoProvider->GetVendorId(vendorId) != CHIP_NO_ERROR)
716 : {
717 0 : vendorId = 0;
718 : }
719 0 : ChipLogProgress(DeviceLayer, " Vendor Id: %u (0x%X)", vendorId, vendorId);
720 : }
721 :
722 : {
723 : uint16_t productId;
724 0 : if (deviceInstanceInfoProvider->GetProductId(productId) != CHIP_NO_ERROR)
725 : {
726 0 : productId = 0;
727 : }
728 0 : ChipLogProgress(DeviceLayer, " Product Id: %u (0x%X)", productId, productId);
729 : }
730 :
731 : {
732 : char productName[ConfigurationManager::kMaxProductNameLength + 1];
733 0 : err = deviceInstanceInfoProvider->GetProductName(productName, sizeof(productName));
734 0 : if (CHIP_NO_ERROR == err)
735 : {
736 0 : ChipLogProgress(DeviceLayer, " Product Name: %s", productName);
737 : }
738 : else
739 : {
740 0 : ChipLogError(DeviceLayer, " Product Name: n/a (%" CHIP_ERROR_FORMAT ")", err.Format());
741 : }
742 : }
743 :
744 : {
745 : uint16_t hardwareVer;
746 0 : if (deviceInstanceInfoProvider->GetHardwareVersion(hardwareVer) != CHIP_NO_ERROR)
747 : {
748 0 : hardwareVer = 0;
749 : }
750 0 : ChipLogProgress(DeviceLayer, " Hardware Version: %u", hardwareVer);
751 : }
752 :
753 0 : CommissionableDataProvider * cdp = GetCommissionableDataProvider();
754 :
755 : {
756 : uint32_t setupPasscode;
757 0 : if ((cdp == nullptr) || (cdp->GetSetupPasscode(setupPasscode) != CHIP_NO_ERROR))
758 : {
759 0 : setupPasscode = 0;
760 : }
761 0 : ChipLogProgress(DeviceLayer, " Setup Pin Code (0 for UNKNOWN/ERROR): %" PRIu32 "", setupPasscode);
762 : }
763 :
764 : {
765 : uint16_t setupDiscriminator;
766 0 : if ((cdp == nullptr) || (cdp->GetSetupDiscriminator(setupDiscriminator) != CHIP_NO_ERROR))
767 : {
768 0 : setupDiscriminator = 0xFFFF;
769 : }
770 0 : ChipLogProgress(DeviceLayer, " Setup Discriminator (0xFFFF for UNKNOWN/ERROR): %u (0x%X)", setupDiscriminator,
771 : setupDiscriminator);
772 : }
773 :
774 : {
775 : uint16_t year;
776 : uint8_t month, dayOfMonth;
777 0 : err = deviceInstanceInfoProvider->GetManufacturingDate(year, month, dayOfMonth);
778 0 : if (err == CHIP_NO_ERROR)
779 : {
780 0 : ChipLogProgress(DeviceLayer, " Manufacturing Date: %04u-%02u-%02u", year, month, dayOfMonth);
781 : }
782 : else
783 : {
784 0 : ChipLogProgress(DeviceLayer, " Manufacturing Date: (not set)");
785 : }
786 : }
787 :
788 : {
789 : uint32_t deviceType;
790 0 : if (GetDeviceTypeId(deviceType) != CHIP_NO_ERROR)
791 : {
792 0 : deviceType = 0;
793 : }
794 0 : ChipLogProgress(DeviceLayer, " Device Type: %" PRIu32 " (0x%" PRIX32 ")", deviceType, deviceType);
795 : }
796 0 : }
797 :
798 : } // namespace Internal
799 : } // namespace DeviceLayer
800 : } // namespace chip
801 :
802 : #endif // GENERIC_CONFIGURATION_MANAGER_IMPL_CPP
|
