[OperationalCredentials]: Support read TrustedRootCertificates attribute (#10943)
* [OperationalCredentials]: Support read TrustedRootCertificates attribute
* Enable TrustedRootCertificates in controller zap
* Update gen folders
diff --git a/src/app/clusters/operational-credentials-server/operational-credentials-server.cpp b/src/app/clusters/operational-credentials-server/operational-credentials-server.cpp
index dfbbf05..1f3816a 100644
--- a/src/app/clusters/operational-credentials-server/operational-credentials-server.cpp
+++ b/src/app/clusters/operational-credentials-server/operational-credentials-server.cpp
@@ -69,6 +69,7 @@
private:
CHIP_ERROR ReadFabricsList(EndpointId endpoint, AttributeValueEncoder & aEncoder);
+ CHIP_ERROR ReadRootCertificates(EndpointId endpoint, AttributeValueEncoder & aEncoder);
};
CHIP_ERROR OperationalCredentialsAttrAccess::ReadFabricsList(EndpointId endpoint, AttributeValueEncoder & aEncoder)
@@ -96,6 +97,24 @@
});
}
+CHIP_ERROR OperationalCredentialsAttrAccess::ReadRootCertificates(EndpointId endpoint, AttributeValueEncoder & aEncoder)
+{
+ return aEncoder.EncodeList([](const TagBoundEncoder & encoder) -> CHIP_ERROR {
+ for (auto & fabricInfo : Server::GetInstance().GetFabricTable())
+ {
+ ByteSpan cert;
+
+ if (!fabricInfo.IsInitialized())
+ continue;
+
+ ReturnErrorOnFailure(fabricInfo.GetRootCert(cert));
+ ReturnErrorOnFailure(encoder.Encode(cert));
+ }
+
+ return CHIP_NO_ERROR;
+ });
+}
+
OperationalCredentialsAttrAccess gAttrAccess;
CHIP_ERROR OperationalCredentialsAttrAccess::Read(const ConcreteAttributePath & aPath, AttributeValueEncoder & aEncoder)
@@ -107,6 +126,9 @@
case Attributes::FabricsList::Id: {
return ReadFabricsList(aPath.mEndpointId, aEncoder);
}
+ case Attributes::TrustedRootCertificates::Id: {
+ return ReadRootCertificates(aPath.mEndpointId, aEncoder);
+ }
default:
break;
}
diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap
index 6898871..9587df8 100644
--- a/src/controller/data_model/controller-clusters.zap
+++ b/src/controller/data_model/controller-clusters.zap
@@ -5138,6 +5138,21 @@
"reportableChange": 0
},
{
+ "name": "TrustedRootCertificates",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
"name": "ClusterRevision",
"code": 65533,
"mfgCode": null,
diff --git a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
index 6af16bb..aea41f7 100644
--- a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
+++ b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
@@ -7391,6 +7391,79 @@
jobject javaCallbackRef;
};
+class CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback
+ : public Callback::Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>
+{
+public:
+ CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback(jobject javaCallback) :
+ Callback::Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(CallbackFn, this)
+ {
+ JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+ if (env == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ return;
+ }
+
+ javaCallbackRef = env->NewGlobalRef(javaCallback);
+ if (javaCallbackRef == nullptr)
+ {
+ ChipLogError(Zcl, "Could not create global reference for Java callback");
+ }
+ }
+
+ static void CallbackFn(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & list)
+ {
+ chip::DeviceLayer::StackUnlock unlock;
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
+ jobject javaCallbackRef;
+
+ VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env"));
+
+ std::unique_ptr<CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback> cppCallback(
+ reinterpret_cast<CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback *>(context));
+
+ // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback.
+ javaCallbackRef = cppCallback.get()->javaCallbackRef;
+ VerifyOrReturn(javaCallbackRef != nullptr,
+ ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null"));
+
+ jclass arrayListClass;
+ err = JniReferences::GetInstance().GetClassRef(env, "java/util/ArrayList", arrayListClass);
+ VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error using Java ArrayList"));
+ JniClass arrayListJniClass(arrayListClass);
+ jmethodID arrayListCtor = env->GetMethodID(arrayListClass, "<init>", "()V");
+ jmethodID arrayListAddMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z");
+ VerifyOrReturn(arrayListCtor != nullptr && arrayListAddMethod != nullptr,
+ ChipLogError(Zcl, "Error finding Java ArrayList methods"));
+ jobject arrayListObj = env->NewObject(arrayListClass, arrayListCtor);
+ VerifyOrReturn(arrayListObj != nullptr, ChipLogError(Zcl, "Error creating Java ArrayList"));
+
+ jmethodID javaMethod;
+ err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/util/List;)V", &javaMethod);
+ VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method"));
+
+ auto iter = list.begin();
+ while (iter.Next())
+ {
+ auto & entry = iter.GetValue();
+ jbyteArray trustedRootCertificates = env->NewByteArray(entry.size());
+ env->SetByteArrayRegion(trustedRootCertificates, 0, entry.size(), reinterpret_cast<const jbyte *>(entry.data()));
+ env->CallBooleanMethod(arrayListObj, arrayListAddMethod, trustedRootCertificates);
+ }
+ VerifyOrReturn(iter.GetStatus() == CHIP_NO_ERROR,
+ ChipLogError(Zcl, "Error decoding TrustedRootCertificatesAttribute value: %" CHIP_ERROR_FORMAT,
+ iter.GetStatus().Format()));
+
+ env->ExceptionClear();
+ env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj);
+ }
+
+private:
+ jobject javaCallbackRef;
+};
+
class CHIPPowerSourceActiveBatteryFaultsAttributeCallback
: public Callback::Callback<PowerSourceActiveBatteryFaultsListAttributeCallback>
{
@@ -22246,6 +22319,34 @@
onFailure.release();
}
+JNI_METHOD(void, OperationalCredentialsCluster, readTrustedRootCertificatesAttribute)
+(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ chip::DeviceLayer::StackLock lock;
+ std::unique_ptr<CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback,
+ void (*)(CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback *)>
+ onSuccess(Platform::New<CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback>(callback),
+ Platform::Delete<CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback>);
+ VerifyOrReturn(onSuccess.get() != nullptr,
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY));
+
+ std::unique_ptr<CHIPDefaultFailureCallback, void (*)(CHIPDefaultFailureCallback *)> onFailure(
+ Platform::New<CHIPDefaultFailureCallback>(callback), Platform::Delete<CHIPDefaultFailureCallback>);
+ VerifyOrReturn(onFailure.get() != nullptr,
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY));
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ OperationalCredentialsCluster * cppCluster = reinterpret_cast<OperationalCredentialsCluster *>(clusterPtr);
+ VerifyOrReturn(cppCluster != nullptr,
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE));
+
+ err = cppCluster->ReadAttributeTrustedRootCertificates(onSuccess->Cancel(), onFailure->Cancel());
+ VerifyOrReturn(err == CHIP_NO_ERROR, ReturnIllegalStateException(env, callback, "Error reading attribute", err));
+
+ onSuccess.release();
+ onFailure.release();
+}
+
JNI_METHOD(void, OperationalCredentialsCluster, readClusterRevisionAttribute)
(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
{
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
index 00aa981..af12c13 100644
--- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
@@ -4710,6 +4710,12 @@
void onError(Exception ex);
}
+ public interface TrustedRootCertificatesAttributeCallback {
+ void onSuccess(List<byte[]> valueList);
+
+ void onError(Exception ex);
+ }
+
public void readFabricsListAttribute(FabricsListAttributeCallback callback) {
readFabricsListAttribute(chipClusterPtr, callback);
}
@@ -4722,6 +4728,11 @@
readCommissionedFabricsAttribute(chipClusterPtr, callback);
}
+ public void readTrustedRootCertificatesAttribute(
+ TrustedRootCertificatesAttributeCallback callback) {
+ readTrustedRootCertificatesAttribute(chipClusterPtr, callback);
+ }
+
public void readClusterRevisionAttribute(IntegerAttributeCallback callback) {
readClusterRevisionAttribute(chipClusterPtr, callback);
}
@@ -4735,6 +4746,9 @@
private native void readCommissionedFabricsAttribute(
long chipClusterPtr, IntegerAttributeCallback callback);
+ private native void readTrustedRootCertificatesAttribute(
+ long chipClusterPtr, TrustedRootCertificatesAttributeCallback callback);
+
private native void readClusterRevisionAttribute(
long chipClusterPtr, IntegerAttributeCallback callback);
}
diff --git a/src/controller/python/chip/clusters/CHIPClusters.cpp b/src/controller/python/chip/clusters/CHIPClusters.cpp
index f40fecc..2fadb2c 100644
--- a/src/controller/python/chip/clusters/CHIPClusters.cpp
+++ b/src/controller/python/chip/clusters/CHIPClusters.cpp
@@ -832,6 +832,52 @@
}
chip::Callback::Callback<OperationalCredentialsFabricsListListAttributeCallback>
gOperationalCredentialsFabricsListListAttributeCallback{ OnOperationalCredentialsFabricsListListAttributeResponse, nullptr };
+static void OnOperationalCredentialsTrustedRootCertificatesListAttributeResponse(
+ void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & list)
+{
+ size_t count = 0;
+ CHIP_ERROR err = list.ComputeSize(&count);
+ if (err != CHIP_NO_ERROR)
+ {
+ if (gFailureResponseDelegate != nullptr)
+ {
+ gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
+ }
+ return;
+ }
+
+ ChipLogProgress(Zcl, " attributeValue:%s", count > 0 ? "" : " []");
+
+ if (count > 0)
+ ChipLogProgress(Zcl, " [");
+
+ auto iter = list.begin();
+ while (iter.Next())
+ {
+#if CHIP_PROGRESS_LOGGING
+ auto & entry = iter.GetValue();
+#endif // CHIP_PROGRESS_LOGGING
+ ChipLogProgress(Zcl, " %s,", ByteSpanToString(entry).c_str());
+ }
+ if (iter.GetStatus() != CHIP_NO_ERROR)
+ {
+ if (gFailureResponseDelegate != nullptr)
+ {
+ gFailureResponseDelegate(EMBER_ZCL_STATUS_INVALID_VALUE);
+ }
+ return;
+ }
+
+ if (count > 0)
+ ChipLogProgress(Zcl, " ]");
+
+ if (gSuccessResponseDelegate != nullptr)
+ gSuccessResponseDelegate();
+}
+chip::Callback::Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>
+ gOperationalCredentialsTrustedRootCertificatesListAttributeCallback{
+ OnOperationalCredentialsTrustedRootCertificatesListAttributeResponse, nullptr
+ };
static void OnPowerSourceActiveBatteryFaultsListAttributeResponse(void * context,
const chip::app::DataModel::DecodableList<uint8_t> & list)
{
@@ -5628,6 +5674,18 @@
return cluster.ReadAttributeCommissionedFabrics(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}
+chip::ChipError::StorageType chip_ime_ReadAttribute_OperationalCredentials_TrustedRootCertificates(
+ chip::Controller::Device * device, chip::EndpointId ZCLendpointId, chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::OperationalCredentialsCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster
+ .ReadAttributeTrustedRootCertificates(gOperationalCredentialsTrustedRootCertificatesListAttributeCallback.Cancel(),
+ gDefaultFailureCallback.Cancel())
+ .AsInteger();
+}
+
chip::ChipError::StorageType chip_ime_ReadAttribute_OperationalCredentials_ClusterRevision(chip::Controller::Device * device,
chip::EndpointId ZCLendpointId,
chip::GroupId /* ZCLgroupId */)
diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py
index 992fd07..340432d 100644
--- a/src/controller/python/chip/clusters/CHIPClusters.py
+++ b/src/controller/python/chip/clusters/CHIPClusters.py
@@ -2561,6 +2561,11 @@
"attributeId": 0x00000003,
"type": "int",
},
+ 0x00000004: {
+ "attributeName": "TrustedRootCertificates",
+ "attributeId": 0x00000004,
+ "type": "bytes",
+ },
0x0000FFFD: {
"attributeName": "ClusterRevision",
"attributeId": 0x0000FFFD,
@@ -5965,6 +5970,9 @@
def ClusterOperationalCredentials_ReadAttributeCommissionedFabrics(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
return self._chipLib.chip_ime_ReadAttribute_OperationalCredentials_CommissionedFabrics(device, ZCLendpoint, ZCLgroupid)
+ def ClusterOperationalCredentials_ReadAttributeTrustedRootCertificates(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_OperationalCredentials_TrustedRootCertificates(device, ZCLendpoint, ZCLgroupid)
+
def ClusterOperationalCredentials_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
return self._chipLib.chip_ime_ReadAttribute_OperationalCredentials_ClusterRevision(device, ZCLendpoint, ZCLgroupid)
@@ -8425,6 +8433,10 @@
self._chipLib.chip_ime_ReadAttribute_OperationalCredentials_CommissionedFabrics.argtypes = [
ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
self._chipLib.chip_ime_ReadAttribute_OperationalCredentials_CommissionedFabrics.restype = ctypes.c_uint32
+ # Cluster OperationalCredentials ReadAttribute TrustedRootCertificates
+ self._chipLib.chip_ime_ReadAttribute_OperationalCredentials_TrustedRootCertificates.argtypes = [
+ ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_OperationalCredentials_TrustedRootCertificates.restype = ctypes.c_uint32
# Cluster OperationalCredentials ReadAttribute ClusterRevision
self._chipLib.chip_ime_ReadAttribute_OperationalCredentials_ClusterRevision.argtypes = [
ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm
index 58f0694..8e078a7 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm
@@ -378,6 +378,23 @@
DispatchSuccess(context, @ { @"value" : array });
};
+void CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge::OnSuccessFn(
+ void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & list)
+{
+ id array = [[NSMutableArray alloc] init];
+ auto iter = list.begin();
+ while (iter.Next()) {
+ auto & entry = iter.GetValue();
+ [array addObject:[NSData dataWithBytes:entry.data() length:entry.size()]];
+ }
+ if (iter.GetStatus() != CHIP_NO_ERROR) {
+ OnFailureFn(context, EMBER_ZCL_STATUS_INVALID_VALUE);
+ return;
+ }
+
+ DispatchSuccess(context, @ { @"value" : array });
+};
+
void CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge::OnSuccessFn(
void * context, const chip::app::DataModel::DecodableList<uint8_t> & list)
{
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h
index d630388..e7185ee 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h
@@ -332,6 +332,18 @@
chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType> & list);
};
+class CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge
+ : public CHIPCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>
+{
+public:
+ CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
+ CHIPActionBlock action, bool keepAlive = false) :
+ CHIPCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, handler, action, OnSuccessFn,
+ keepAlive){};
+
+ static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & list);
+};
+
class CHIPPowerSourceActiveBatteryFaultsListAttributeCallbackBridge
: public CHIPCallbackBridge<PowerSourceActiveBatteryFaultsListAttributeCallback>
{
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
index 1c0593b..93a0e97 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
@@ -1235,6 +1235,8 @@
- (void)readAttributeCommissionedFabricsWithResponseHandler:(ResponseHandler)responseHandler;
+- (void)readAttributeTrustedRootCertificatesWithResponseHandler:(ResponseHandler)responseHandler;
+
- (void)readAttributeClusterRevisionWithResponseHandler:(ResponseHandler)responseHandler;
@end
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
index 9b8ac4c..d6515e7 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
@@ -3651,6 +3651,14 @@
});
}
+- (void)readAttributeTrustedRootCertificatesWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPOperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(
+ self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeTrustedRootCertificates(success, failure);
+ });
+}
+
- (void)readAttributeClusterRevisionWithResponseHandler:(ResponseHandler)responseHandler
{
new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
index 20e78e7..51d4473 100644
--- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
+++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
@@ -16912,6 +16912,25 @@
[self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
}
+- (void)testSendClusterOperationalCredentialsReadAttributeTrustedRootCertificatesWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"OperationalCredentialsReadAttributeTrustedRootCertificatesWithResponseHandler"];
+
+ CHIPDevice * device = GetConnectedDevice();
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPOperationalCredentials * cluster = [[CHIPOperationalCredentials alloc] initWithDevice:device endpoint:0 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeTrustedRootCertificatesWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"OperationalCredentials TrustedRootCertificates Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
- (void)testSendClusterOperationalCredentialsReadAttributeClusterRevisionWithResponseHandler
{
XCTestExpectation * expectation =
diff --git a/src/transport/FabricTable.h b/src/transport/FabricTable.h
index 95d4300..47a4ec3 100644
--- a/src/transport/FabricTable.h
+++ b/src/transport/FabricTable.h
@@ -123,7 +123,7 @@
// TODO - Refactor storing and loading of fabric info from persistent storage.
// The op cert array doesn't need to be in RAM except when it's being
// transmitted to peer node during CASE session setup.
- CHIP_ERROR GetRootCert(ByteSpan & cert)
+ CHIP_ERROR GetRootCert(ByteSpan & cert) const
{
ReturnErrorCodeIf(mRootCert.empty(), CHIP_ERROR_INCORRECT_STATE);
cert = mRootCert;
diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
index c543381..2e96e1c 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
+++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
@@ -619,6 +619,34 @@
command->SetCommandExitStatus(iter.GetStatus());
}
+static void OnOperationalCredentialsTrustedRootCertificatesListAttributeResponse(
+ void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & list)
+{
+ ModelCommand * command = static_cast<ModelCommand *>(context);
+
+ size_t count = 0;
+ CHIP_ERROR err = list.ComputeSize(&count);
+ if (err != CHIP_NO_ERROR)
+ {
+ command->SetCommandExitStatus(err);
+ return;
+ }
+
+ ChipLogProgress(chipTool, "OnOperationalCredentialsTrustedRootCertificatesListAttributeResponse: %zu entries", count);
+
+ auto iter = list.begin();
+ uint16_t i = 0;
+ while (iter.Next())
+ {
+#if CHIP_PROGRESS_LOGGING
+ auto & entry = iter.GetValue();
+#endif // CHIP_PROGRESS_LOGGING
+ ++i;
+ ChipLogProgress(Zcl, " : %zu", entry.size());
+ }
+ command->SetCommandExitStatus(iter.GetStatus());
+}
+
static void OnPowerSourceActiveBatteryFaultsListAttributeResponse(void * context,
const chip::app::DataModel::DecodableList<uint8_t> & list)
{
@@ -15010,6 +15038,7 @@
| * FabricsList | 0x0001 |
| * SupportedFabrics | 0x0002 |
| * CommissionedFabrics | 0x0003 |
+| * TrustedRootCertificates | 0x0004 |
| * ClusterRevision | 0xFFFD |
\*----------------------------------------------------------------------------*/
@@ -15347,6 +15376,41 @@
};
/*
+ * Attribute TrustedRootCertificates
+ */
+class ReadOperationalCredentialsTrustedRootCertificates : public ModelCommand
+{
+public:
+ ReadOperationalCredentialsTrustedRootCertificates() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "trusted-root-certificates");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadOperationalCredentialsTrustedRootCertificates()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x003E) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::OperationalCredentialsCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeTrustedRootCertificates(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback> * onSuccessCallback =
+ new chip::Callback::Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(
+ OnOperationalCredentialsTrustedRootCertificatesListAttributeResponse, this);
+ chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
+ new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
+};
+
+/*
* Attribute ClusterRevision
*/
class ReadOperationalCredentialsClusterRevision : public ModelCommand
@@ -26586,6 +26650,7 @@
make_unique<ReadOperationalCredentialsFabricsList>(), //
make_unique<ReadOperationalCredentialsSupportedFabrics>(), //
make_unique<ReadOperationalCredentialsCommissionedFabrics>(), //
+ make_unique<ReadOperationalCredentialsTrustedRootCertificates>(), //
make_unique<ReadOperationalCredentialsClusterRevision>(), //
};
diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.cpp
index c0da73b..37b4688 100644
--- a/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.cpp
+++ b/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.cpp
@@ -502,6 +502,31 @@
#pragma GCC diagnostic pop
#endif // __clang__
+void OperationalCredentialsClusterTrustedRootCertificatesListAttributeFilter(TLV::TLVReader * tlvData,
+ Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ chip::app::DataModel::DecodableList<chip::ByteSpan> list;
+ CHIP_ERROR err = Decode(*tlvData, list);
+ if (err != CHIP_NO_ERROR)
+ {
+ if (onFailureCallback != nullptr)
+ {
+ Callback::Callback<DefaultFailureCallback> * cb =
+ Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
+ cb->mCall(cb->mContext, EMBER_ZCL_STATUS_INVALID_VALUE);
+ }
+ return;
+ }
+
+ Callback::Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback> * cb =
+ Callback::Callback<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>::FromCancelable(onSuccessCallback);
+ cb->mCall(cb->mContext, list);
+}
+#if !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // __clang__
+
void PowerSourceClusterActiveBatteryFaultsListAttributeFilter(TLV::TLVReader * tlvData, Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback)
{
diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.h b/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.h
index 0a86227..0296e3a 100644
--- a/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.h
+++ b/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.h
@@ -230,6 +230,11 @@
void * context,
const chip::app::DataModel::DecodableList<
chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType> & data);
+void OperationalCredentialsClusterTrustedRootCertificatesListAttributeFilter(chip::TLV::TLVReader * data,
+ chip::Callback::Cancelable * onSuccessCallback,
+ chip::Callback::Cancelable * onFailureCallback);
+typedef void (*OperationalCredentialsTrustedRootCertificatesListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & data);
void PowerSourceClusterActiveBatteryFaultsListAttributeFilter(chip::TLV::TLVReader * data,
chip::Callback::Cancelable * onSuccessCallback,
chip::Callback::Cancelable * onFailureCallback);
diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
index 9e40e46..c7e7fe5 100644
--- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
+++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
@@ -9773,6 +9773,18 @@
BasicAttributeFilter<Int8uAttributeCallback>);
}
+CHIP_ERROR OperationalCredentialsCluster::ReadAttributeTrustedRootCertificates(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000004;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ OperationalCredentialsClusterTrustedRootCertificatesListAttributeFilter);
+}
+
CHIP_ERROR OperationalCredentialsCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback)
{
diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
index 0e73803..27c639b 100644
--- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
+++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
@@ -1050,6 +1050,8 @@
CHIP_ERROR ReadAttributeFabricsList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
CHIP_ERROR ReadAttributeSupportedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
CHIP_ERROR ReadAttributeCommissionedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeTrustedRootCertificates(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback);
CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
private:
