[IM] Fabric filtered read (#12710)

src/app/AttributeAccessInterface.h

@@ -23,11 +23,13 @@
 #include <app/MessageDef/AttributeReportIBs.h>
 #include <app/data-model/Decode.h>
 #include <app/data-model/Encode.h>
+#include <app/data-model/FabricScoped.h>
 #include <app/data-model/List.h> // So we can encode lists
 #include <app/data-model/TagBoundEncoder.h>
 #include <app/util/basic-types.h>
 #include <lib/core/CHIPTLV.h>
 #include <lib/core/Optional.h>
+#include <lib/support/logging/CHIPLogging.h>
 
 /**
  * Callback class that clusters can implement in order to interpose custom
@@ -97,10 +99,18 @@ class AttributeValueEncoder
  public:
  ListEncodeHelper(AttributeValueEncoder & encoder) : mAttributeValueEncoder(encoder) {}
 
- template <typename... Ts>
- CHIP_ERROR Encode(Ts &&... aArgs) const
+ template <typename T, std::enable_if_t<DataModel::IsFabricScoped<T>::value, bool> = true>
+ CHIP_ERROR Encode(T && aArg) const
  {
- return mAttributeValueEncoder.EncodeListItem(std::forward<Ts>(aArgs)...);
+ // If the fabric index does not match that present in the request, skip encoding this list item.
+ VerifyOrReturnError(aArg.MatchesFabricIndex(mAttributeValueEncoder.mAccessingFabricIndex), CHIP_NO_ERROR);
+ return mAttributeValueEncoder.EncodeListItem(std::forward<T>(aArg));
+ }
+
+ template <typename T, std::enable_if_t<!DataModel::IsFabricScoped<T>::value, bool> = true>
+ CHIP_ERROR Encode(T && aArg) const
+ {
+ return mAttributeValueEncoder.EncodeListItem(std::forward<T>(aArg));
  }
 
  private:

src/app/data-model/FabricScoped.h

@@ -0,0 +1,50 @@
+/*
+ *
+ * Copyright (c) 2021 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <lib/support/TypeTraits.h>
+#include <type_traits>
+
+namespace chip {
+namespace app {
+namespace DataModel {
+
+/*
+ * Check whether a cluster object struct is fabric scoped.
+ * A fabric scoped struct contains a field of "FabricIndex" type, however, we cannot tell the difference between that field and
+ * other uint8_t fields. Thus we add a MatchesFabricIndex member function for checking the fabric id. Here, IsFabricScoped check the
+ * presence of MatchesFabricIndex function. This template can be used with std::enable_if.
+ */
+template <typename T>
+class IsFabricScoped
+{
+private:
+ template <typename Tp>
+ static auto TestHasMatchesFabricIndex(int) -> TemplatedTrueType<decltype(&Tp::MatchesFabricIndex)>;
+
+ template <typename Tp>
+ static auto TestHasMatchesFabricIndex(long) -> std::false_type;
+
+public:
+ static constexpr bool value = decltype(TestHasMatchesFabricIndex<std::decay_t<T>>(0))::value;
+};
+
+} // namespace DataModel
+} // namespace app
+} // namespace chip

src/app/tests/TestAttributeValueEncoder.cpp

@@ -22,6 +22,7 @@
  *
  */
 
+#include <app-common/zap-generated/cluster-objects.h>
 #include <app/AttributeAccessInterface.h>
 #include <app/MessageDef/AttributeDataIB.h>
 #include <lib/support/CodeUtils.h>
@@ -32,21 +33,24 @@ using namespace chip;
 using namespace chip::app;
 using namespace chip::TLV;
 
+// TODO: This unit tests contains hard code TLV data, they should be replaced with some decoding code to improve readability.
+
 namespace {
 
 // These values are easier to be recognized in the encoded buffer
 constexpr EndpointId kRandomEndpointId = 0x55;
 constexpr ClusterId kRandomClusterId = 0xaa;
 constexpr AttributeId kRandomAttributeId = 0xcc;
 constexpr DataVersion kRandomDataVersion = 0x99;
+constexpr FabricIndex kTestFabricIndex = 1;
 
 template <size_t N>
 struct LimitedTestSetup
 {
- LimitedTestSetup(nlTestSuite * aSuite,
+ LimitedTestSetup(nlTestSuite * aSuite, const FabricIndex aFabricIndex = 0,
  const AttributeValueEncoder::AttributeEncodeState & aState = AttributeValueEncoder::AttributeEncodeState()) :
- encoder(builder, 0, ConcreteAttributePath(kRandomEndpointId, kRandomClusterId, kRandomAttributeId), kRandomDataVersion,
- aState)
+ encoder(builder, aFabricIndex, ConcreteAttributePath(kRandomEndpointId, kRandomClusterId, kRandomAttributeId),
+ kRandomDataVersion, aState)
  {
  writer.Init(buf);
  {
@@ -238,6 +242,59 @@ void TestEncodeEmptyList(nlTestSuite * aSuite, void * aContext)
  VERIFY_BUFFER_STATE(aSuite, test, expected);
 }
 
+void TestEncodeFabricScoped(nlTestSuite * aSuite, void * aContext)
+{
+ TestSetup test(aSuite, kTestFabricIndex);
+ Clusters::AccessControl::Structs::ExtensionEntry::Type items[3];
+ items[0].fabricIndex = 0;
+ items[1].fabricIndex = 1;
+ items[2].fabricIndex = 2;
+
+ // We tried to encode three items, however, the encoder should only put the item with matching fabric index into the final list.
+ CHIP_ERROR err = test.encoder.EncodeList([items](const auto & encoder) -> CHIP_ERROR {
+ for (size_t i = 0; i < 3; i++)
+ {
+ ReturnErrorOnFailure(encoder.Encode(items[i]));
+ }
+ return CHIP_NO_ERROR;
+ });
+ NL_TEST_ASSERT(aSuite, err == CHIP_NO_ERROR);
+ const uint8_t expected[] = {
+ // clang-format off
+ 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01)
+ 0x15, // Start anonymous struct
+ 0x35, 0x01, // Start 1 byte tag struct + Tag (01)
+ 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version)
+ 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path)
+ 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55
+ 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa
+ 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc
+ 0x18, // End of container
+ // Intended empty array
+ 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value)
+ 0x18, // End of container
+ 0x18, // End of container
+ 0x18, // End of container
+ 0x15, // Start anonymous struct
+ 0x35, 0x01, // Start 1 byte tag struct + Tag (01)
+ 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version)
+ 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path)
+ 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55
+ 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa
+ 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc
+ 0x34, 0x05, // Tag (05) Null
+ 0x18, // End of container (attribute path)
+ 0x35, 0x02, // Tag 02 (attribute data)
+ 0x24, 0x00, 0x01, // Tag 0, UINT8 Value 1 (fabric index)
+ 0x30, 0x01, 0x00, // Tag 1, OCTET_STRING length 0 (data)
+ 0x18,
+ 0x18,
+ 0x18,
+ // clang-format on
+ };
+ VERIFY_BUFFER_STATE(aSuite, test, expected);
+}
+
 void TestEncodeListChunking(nlTestSuite * aSuite, void * aContext)
 {
  AttributeValueEncoder::AttributeEncodeState state;
@@ -252,7 +309,8 @@ void TestEncodeListChunking(nlTestSuite * aSuite, void * aContext)
  };
 
  {
- LimitedTestSetup<60> test1(aSuite);
+ // Use 60 bytes buffer to force chunking. The kTestFabricIndex is not effective in this test.
+ LimitedTestSetup<60> test1(aSuite, kTestFabricIndex);
  CHIP_ERROR err = test1.encoder.EncodeList(listEncoder);
  NL_TEST_ASSERT(aSuite, err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL);
  state = test1.encoder.GetState();
@@ -291,7 +349,8 @@ void TestEncodeListChunking(nlTestSuite * aSuite, void * aContext)
  VERIFY_BUFFER_STATE(aSuite, test1, expected);
  }
  {
- LimitedTestSetup<60> test2(aSuite, state);
+ // Use 60 bytes buffer to force chunking. The kTestFabricIndex is not effective in this test.
+ LimitedTestSetup<60> test2(aSuite, 0, state);
  CHIP_ERROR err = test2.encoder.EncodeList(listEncoder);
  NL_TEST_ASSERT(aSuite, err == CHIP_NO_ERROR);
 
@@ -321,13 +380,12 @@ void TestEncodeListChunking(nlTestSuite * aSuite, void * aContext)
 } // anonymous namespace
 
 namespace {
-const nlTest sTests[] = { NL_TEST_DEF("TestEncodeNothing", TestEncodeNothing),
- NL_TEST_DEF("TestEncodeBool", TestEncodeBool),
- NL_TEST_DEF("TestEncodeEmptyList", TestEncodeEmptyList),
- NL_TEST_DEF("TestEncodeListOfBools1", TestEncodeListOfBools1),
- NL_TEST_DEF("TestEncodeListOfBools2", TestEncodeListOfBools2),
- NL_TEST_DEF("TestEncodeListChunking", TestEncodeListChunking),
- NL_TEST_SENTINEL() };
+const nlTest sTests[] = {
+ NL_TEST_DEF("TestEncodeNothing", TestEncodeNothing), NL_TEST_DEF("TestEncodeBool", TestEncodeBool),
+ NL_TEST_DEF("TestEncodeEmptyList", TestEncodeEmptyList), NL_TEST_DEF("TestEncodeListOfBools1", TestEncodeListOfBools1),
+ NL_TEST_DEF("TestEncodeListOfBools2", TestEncodeListOfBools2), NL_TEST_DEF("TestEncodeListChunking", TestEncodeListChunking),
+ NL_TEST_DEF("TestEncodeFabricScoped", TestEncodeFabricScoped), NL_TEST_SENTINEL()
+};
 }
 
 int TestAttributeValueEncoder()

src/app/zap-templates/templates/app/cluster-objects.zapt

@@ -72,6 +72,11 @@ namespace {{asUpperCamelCase name}} {
  {{#unless struct_contains_array}}
  CHIP_ERROR Decode(TLV::TLVReader &reader);
  {{/unless}}
+ {{#if struct_is_fabric_scoped}}
+ bool MatchesFabricIndex(FabricIndex fabricIndex_) const {
+ return {{ asLowerCamelCase struct_fabric_idx_field }} == fabricIndex_;
+ }
+ {{/if}}
  };
 
  {{#if struct_contains_array}}

src/lib/support/TypeTraits.h

@@ -38,4 +38,29 @@ constexpr std::underlying_type_t<T> to_underlying(T e)
  return static_cast<std::underlying_type_t<T>>(e);
 }
 
+/**
+ * @brief This template is not designed to be used directly. A common pattern to check the presence of a member of a class is:
+ *
+ * template <typename T>
+ * class IsMagic
+ * {
+ * private:
+ * template <typename Tp>
+ * static auto TestHasMagic(int) -> TemplatedTrueType<decltype(&Tp::Magic)>;
+ *
+ * template <typename Tp>
+ * static auto TestHasMagic(long) -> std::false_type;
+ *
+ * public:
+ * static constexpr bool value = decltype(TestHasMagic<std::decay_t<T>>(0))::value;
+ * };
+ *
+ * The compiler will try to match TestHasMagicFunction(int) first, if MagicFunction is a member function of T, the match succeed
+ * and HasMagicFunction is an alias of std::true_type. If MagicFunction is not a member function of T, the match of
+ * TestHasMagicFunction(int) will result in compile error, due to SFINAE, compiler will try the next candicate, which is
+ * TestHasMagicFunction(long), it will always success for all types, and HasMagicFunction becomes an alias of std::false_type.
+ */
+template <typename T>
+using TemplatedTrueType = std::true_type;
+
 } // namespace chip