Skip to content

Commit f59b118

Browse files
cjandhyalacjandhyala
committed
added code to read vendor_name, product_name, hardware_version_string and software_version_string to read from config in reference linux and darwin platform
1 parent 5570be9 commit f59b118

11 files changed

+193
-12
lines changed

‎examples/platform/linux/CommissionableInit.cpp

+28
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
#include <lib/support/CodeUtils.h>
2121
#include <lib/support/logging/CHIPLogging.h>
2222
#include <platform/TestOnlyCommissionableDataProvider.h>
23+
#include <stdio.h>
2324

2425
#include "CommissionableInit.h"
2526

@@ -99,6 +100,33 @@ CHIP_ERROR InitConfigurationManager(ConfigurationManagerImpl & configManager, Li
99100
configManager.StoreProductId(options.payload.productID);
100101
}
101102

103+
if (options.vendorName.HasValue())
104+
{
105+
const char * vendorName = options.vendorName.Value().c_str();
106+
configManager.StoreVendorName(vendorName, strlen(vendorName));
107+
}
108+
if (options.productName.HasValue())
109+
{
110+
const char * productName = options.productName.Value().c_str();
111+
configManager.StoreProductName(productName,strlen(productName));
112+
}
113+
if (options.hardwareVersionString.HasValue())
114+
{
115+
const char * hardwareVersionString = options.hardwareVersionString.Value().c_str();
116+
configManager.StoreHardwareVersionString(hardwareVersionString,strlen(hardwareVersionString));
117+
}
118+
if (options.softwareVersionString.HasValue())
119+
{
120+
const char * softwareVersionString = options.softwareVersionString.Value().c_str();
121+
configManager.StoreSoftwareVersionString(softwareVersionString,strlen(softwareVersionString));
122+
}
123+
124+
if (options.serialNumber.HasValue())
125+
{
126+
const char * serialNumber = options.serialNumber.Value().c_str();
127+
configManager.StoreSerialNumber(serialNumber, strlen(serialNumber));
128+
}
129+
102130
return CHIP_NO_ERROR;
103131
}
104132

‎examples/platform/linux/Options.cpp

+32
Original file line numberDiff line numberDiff line change
@@ -106,6 +106,12 @@ enum
106106
#if CHIP_WITH_NLFAULTINJECTION
107107
kDeviceOption_FaultInjection = 0x1027,
108108
#endif
109+
kDeviceOption_VendorName = 0x1028,
110+
kDeviceOption_ProductName = 0x1029,
111+
kDeviceOption_HardwareVersionString = 0x102a,
112+
kDeviceOption_SoftwareVersionString = 0x102b,
113+
kDeviceOption_SerialNumber = 0x102c,
114+
109115
};
110116

111117
constexpr unsigned kAppUsageLength = 64;
@@ -124,6 +130,11 @@ OptionDef sDeviceOptionDefs[] = {
124130
{ "version", kArgumentRequired, kDeviceOption_Version },
125131
{ "vendor-id", kArgumentRequired, kDeviceOption_VendorID },
126132
{ "product-id", kArgumentRequired, kDeviceOption_ProductID },
133+
{ "vendor-name", kArgumentRequired, kDeviceOption_VendorName },
134+
{ "product-name", kArgumentRequired, kDeviceOption_ProductName },
135+
{ "harware-version-string", kArgumentRequired, kDeviceOption_HardwareVersionString },
136+
{ "software-version-string", kArgumentRequired, kDeviceOption_SoftwareVersionString },
137+
{ "serial-number", kArgumentRequired, kDeviceOption_SerialNumber },
127138
{ "custom-flow", kArgumentRequired, kDeviceOption_CustomFlow },
128139
{ "capabilities", kArgumentRequired, kDeviceOption_Capabilities },
129140
{ "discriminator", kArgumentRequired, kDeviceOption_Discriminator },
@@ -588,8 +599,29 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier,
588599
retval = false;
589600
}
590601
break;
602+
591603
}
592604
#endif
605+
case kDeviceOption_VendorName:
606+
LinuxDeviceOptions::GetInstance().vendorName.SetValue(std::string{ aValue });
607+
break;
608+
609+
case kDeviceOption_ProductName:
610+
LinuxDeviceOptions::GetInstance().productName.SetValue(std::string{ aValue });
611+
break;
612+
613+
case kDeviceOption_HardwareVersionString:
614+
LinuxDeviceOptions::GetInstance().hardwareVersionString.SetValue(std::string{ aValue });
615+
break;
616+
617+
case kDeviceOption_SoftwareVersionString:
618+
LinuxDeviceOptions::GetInstance().softwareVersionString.SetValue(std::string{ aValue });
619+
break;
620+
621+
case kDeviceOption_SerialNumber:
622+
LinuxDeviceOptions::GetInstance().serialNumber.SetValue(std::string{ aValue });
623+
break;
624+
593625
default:
594626
PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName);
595627
retval = false;

‎examples/platform/linux/Options.h

+5
Original file line numberDiff line numberDiff line change
@@ -76,6 +76,11 @@ struct LinuxDeviceOptions
7676
int32_t subscriptionCapacity = CHIP_IM_MAX_NUM_SUBSCRIPTIONS;
7777
int32_t subscriptionResumptionRetryIntervalSec = -1;
7878
#endif
79+
chip::Optional<std::string> vendorName;
80+
chip::Optional<std::string> productName;
81+
chip::Optional<std::string> hardwareVersionString;
82+
chip::Optional<std::string> softwareVersionString;
83+
chip::Optional<std::string> serialNumber;
7984
static LinuxDeviceOptions & GetInstance();
8085
};
8186

‎src/include/platform/ConfigurationManager.h

+5
Original file line numberDiff line numberDiff line change
@@ -134,6 +134,11 @@ class ConfigurationManager
134134

135135
virtual CHIP_ERROR GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo) = 0;
136136

137+
virtual CHIP_ERROR StoreVendorName(const char * vendorName, size_t vendorNameLen) = 0;
138+
virtual CHIP_ERROR StoreProductName(const char * productName, size_t productNameLen) = 0;
139+
virtual CHIP_ERROR StoreHardwareVersionString(const char * hardwareVersionString, size_t hardwareVersionStringLen) = 0;
140+
virtual CHIP_ERROR StoreSoftwareVersionString(const char * softwareVersionString, size_t softwareVersionStringLen) = 0;
141+
137142
#if CHIP_CONFIG_TEST
138143
virtual void RunUnitTests() = 0;
139144
#endif

‎src/include/platform/internal/GenericConfigurationManagerImpl.h

+5
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,11 @@ class GenericConfigurationManagerImpl : public ConfigurationManager
103103
CHIP_ERROR GetUniqueId(char * buf, size_t bufSize) override;
104104
CHIP_ERROR StoreUniqueId(const char * uniqueId, size_t uniqueIdLen) override;
105105
CHIP_ERROR GenerateUniqueId(char * buf, size_t bufSize) override;
106+
107+
CHIP_ERROR StoreVendorName(const char * vendorName, size_t vendorNameLen) override;
108+
CHIP_ERROR StoreProductName(const char * productName, size_t productNameLen) override;
109+
CHIP_ERROR StoreHardwareVersionString(const char * hardwareVersionString, size_t hardwareVersionStringLen) override;
110+
CHIP_ERROR StoreSoftwareVersionString(const char * softwareVersionString, size_t softwareVersionStringLen) override;
106111
#if CHIP_CONFIG_TEST
107112
void RunUnitTests() override;
108113
#endif

‎src/include/platform/internal/GenericConfigurationManagerImpl.ipp

+39-3
Original file line numberDiff line numberDiff line change
@@ -351,16 +351,52 @@ CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSecondaryPairingHint
351351
template <class ConfigClass>
352352
CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSoftwareVersionString(char * buf, size_t bufSize)
353353
{
354-
ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
355-
strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING);
356-
return CHIP_NO_ERROR;
354+
ChipError err = CHIP_NO_ERROR;
355+
size_t softwareVersionStringLen = 0; // without counting null-terminator
356+
357+
err = ReadConfigValueStr(ConfigClass::kConfigKey_SoftwareVersionString, buf, bufSize, softwareVersionStringLen);
358+
#ifdef CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING
359+
if (CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
360+
{
361+
ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
362+
memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING, sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING));
363+
softwareVersionStringLen = sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING) - 1;
364+
err = CHIP_NO_ERROR;
365+
}
366+
#endif
367+
ReturnErrorOnFailure(err);
368+
369+
ReturnErrorCodeIf(softwareVersionStringLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
370+
ReturnErrorCodeIf(buf[softwareVersionStringLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
371+
372+
return err;
357373
}
358374

359375
template <class ConfigClass>
360376
CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSerialNumber(const char * serialNum, size_t serialNumLen)
361377
{
362378
return WriteConfigValueStr(ConfigClass::kConfigKey_SerialNum, serialNum, serialNumLen);
363379
}
380+
template <class ConfigClass>
381+
CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreVendorName(const char * vendorName, size_t vendorNameLen)
382+
{
383+
return WriteConfigValueStr(ConfigClass::kConfigKey_VendorName, vendorName, vendorNameLen);
384+
}
385+
template <class ConfigClass>
386+
CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreProductName(const char * productName, size_t productNameLen)
387+
{
388+
return WriteConfigValueStr(ConfigClass::kConfigKey_ProductName, productName, productNameLen);
389+
}
390+
template <class ConfigClass>
391+
CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreHardwareVersionString(const char * hardwareVersionString, size_t hardwareVersionStringLen)
392+
{
393+
return WriteConfigValueStr(ConfigClass::kConfigKey_HardwareVersionString, hardwareVersionString, hardwareVersionStringLen);
394+
}
395+
template <class ConfigClass>
396+
CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSoftwareVersionString(const char * softwareVersionString, size_t softwareVersionStringLen)
397+
{
398+
return WriteConfigValueStr(ConfigClass::kConfigKey_SoftwareVersionString, softwareVersionString, softwareVersionStringLen);
399+
}
364400

365401
template <class ConfigClass>
366402
CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetPrimaryWiFiMACAddress(uint8_t * buf)

‎src/include/platform/internal/GenericDeviceInstanceInfoProvider.ipp

+58-9
Original file line numberDiff line numberDiff line change
@@ -38,18 +38,50 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetProductId(uint16_t
3838
template <class ConfigClass>
3939
CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetVendorName(char * buf, size_t bufSize)
4040
{
41-
ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
42-
strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME);
43-
return CHIP_NO_ERROR;
41+
ChipError err = CHIP_NO_ERROR;
42+
size_t vendorNameLen = 0; // without counting null-terminator
43+
44+
err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_VendorName, buf, bufSize, vendorNameLen);
45+
#ifdef CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME
46+
if (CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
47+
{
48+
ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
49+
memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME, sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME));
50+
vendorNameLen = sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME) - 1;
51+
err = CHIP_NO_ERROR;
52+
}
53+
#endif
54+
ReturnErrorOnFailure(err);
55+
56+
ReturnErrorCodeIf(vendorNameLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
57+
ReturnErrorCodeIf(buf[vendorNameLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
58+
59+
return err;
4460
}
4561

4662
template <class ConfigClass>
4763
CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetProductName(char * buf, size_t bufSize)
4864
{
49-
ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
50-
strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME);
65+
ChipError err = CHIP_NO_ERROR;
66+
size_t productNameLen = 0; // without counting null-terminator
5167

52-
return CHIP_NO_ERROR;
68+
err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_ProductName, buf, bufSize, productNameLen);
69+
70+
#ifdef CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME
71+
if (CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
72+
{
73+
ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
74+
memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME, sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME));
75+
productNameLen = sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME) - 1;
76+
err = CHIP_NO_ERROR;
77+
}
78+
#endif
79+
ReturnErrorOnFailure(err);
80+
81+
ReturnErrorCodeIf(productNameLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
82+
ReturnErrorCodeIf(buf[productNameLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
83+
84+
return err;
5385
}
5486

5587
template <class ConfigClass>
@@ -176,9 +208,26 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetHardwareVersion(ui
176208
template <class ConfigClass>
177209
CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetHardwareVersionString(char * buf, size_t bufSize)
178210
{
179-
ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
180-
strcpy(buf, CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING);
181-
return CHIP_NO_ERROR;
211+
ChipError err = CHIP_NO_ERROR;
212+
size_t hardwareVersionStringLen = 0; // without counting null-terminator
213+
214+
err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_HardwareVersionString, buf, bufSize, hardwareVersionStringLen);
215+
216+
#ifdef CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING
217+
if (CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
218+
{
219+
ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
220+
memcpy(buf, CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING, sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING));
221+
hardwareVersionStringLen = sizeof(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER) - 1;
222+
err = CHIP_NO_ERROR;
223+
}
224+
#endif
225+
ReturnErrorOnFailure(err);
226+
227+
ReturnErrorCodeIf(hardwareVersionStringLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
228+
ReturnErrorCodeIf(buf[hardwareVersionStringLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
229+
230+
return err;
182231
}
183232

184233
template <class ConfigClass>

‎src/platform/Darwin/PosixConfig.cpp

+5
Original file line numberDiff line numberDiff line change
@@ -56,6 +56,11 @@ const PosixConfig::Key PosixConfig::kConfigKey_Spake2pVerifier = { kConfig
5656
const PosixConfig::Key PosixConfig::kConfigKey_VendorId = { kConfigNamespace_ChipFactory, "vendor-id" };
5757
const PosixConfig::Key PosixConfig::kConfigKey_ProductId = { kConfigNamespace_ChipFactory, "product-id" };
5858

59+
const PosixConfig::Key PosixConfig::kConfigKey_VendorName = { kConfigNamespace_ChipFactory, "vendor-name" };
60+
const PosixConfig::Key PosixConfig::kConfigKey_ProductName = { kConfigNamespace_ChipFactory, "product-name" };
61+
const PosixConfig::Key PosixConfig::kConfigKey_HardwareVersionString = { kConfigNamespace_ChipFactory, "hardware-version-string" };
62+
const PosixConfig::Key PosixConfig::kConfigKey_SoftwareVersionString = { kConfigNamespace_ChipFactory, "software-version-string" };
63+
5964
// Keys stored in the Chip-config namespace
6065
const PosixConfig::Key PosixConfig::kConfigKey_FailSafeArmed = { kConfigNamespace_ChipConfig, "fail-safe-armed" };
6166
const PosixConfig::Key PosixConfig::kConfigKey_RegulatoryLocation = { kConfigNamespace_ChipConfig, "regulatory-location" };

‎src/platform/Darwin/PosixConfig.h

+5
Original file line numberDiff line numberDiff line change
@@ -72,6 +72,11 @@ class PosixConfig
7272
static const Key kCounterKey_RebootCount;
7373
static const Key kCounterKey_BootReason;
7474

75+
static const Key kConfigKey_VendorName;
76+
static const Key kConfigKey_ProductName;
77+
static const Key kConfigKey_HardwareVersionString;
78+
static const Key kConfigKey_SoftwareVersionString;
79+
7580
#if !CHIP_DISABLE_PLATFORM_KVS
7681
static CHIP_ERROR Init(void);
7782

‎src/platform/Linux/PosixConfig.cpp

+6
Original file line numberDiff line numberDiff line change
@@ -63,6 +63,12 @@ const PosixConfig::Key PosixConfig::kConfigKey_Spake2pVerifier = { kConfig
6363
const PosixConfig::Key PosixConfig::kConfigKey_VendorId = { kConfigNamespace_ChipFactory, "vendor-id" };
6464
const PosixConfig::Key PosixConfig::kConfigKey_ProductId = { kConfigNamespace_ChipFactory, "product-id" };
6565

66+
const PosixConfig::Key PosixConfig::kConfigKey_VendorName = { kConfigNamespace_ChipFactory, "vendor-name" };
67+
const PosixConfig::Key PosixConfig::kConfigKey_ProductName = { kConfigNamespace_ChipFactory, "product-name" };
68+
const PosixConfig::Key PosixConfig::kConfigKey_HardwareVersionString = { kConfigNamespace_ChipFactory, "hardware-version-string" };
69+
const PosixConfig::Key PosixConfig::kConfigKey_SoftwareVersionString = { kConfigNamespace_ChipFactory, "software-version-string" };
70+
71+
6672
// Keys stored in the Chip-config namespace
6773
const PosixConfig::Key PosixConfig::kConfigKey_ServiceConfig = { kConfigNamespace_ChipConfig, "service-config" };
6874
const PosixConfig::Key PosixConfig::kConfigKey_PairedAccountId = { kConfigNamespace_ChipConfig, "account-id" };

‎src/platform/Linux/PosixConfig.h

+5
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,11 @@ class PosixConfig
8383
static const Key kCounterKey_TotalOperationalHours;
8484
static const Key kCounterKey_BootReason;
8585

86+
static const Key kConfigKey_VendorName;
87+
static const Key kConfigKey_ProductName;
88+
static const Key kConfigKey_HardwareVersionString;
89+
static const Key kConfigKey_SoftwareVersionString;
90+
8691
static CHIP_ERROR Init();
8792

8893
// Config value accessors.

0 commit comments

Comments
 (0)