Line data    Source code

       1              : /**
       2              :  *
       3              :  *    Copyright (c) 2022 Project CHIP Authors
       4              :  *
       5              :  *    Licensed under the Apache License, Version 2.0 (the "License");
       6              :  *    you may not use this file except in compliance with the License.
       7              :  *    You may obtain a copy of the License at
       8              :  *
       9              :  *        http://www.apache.org/licenses/LICENSE-2.0
      10              :  *
      11              :  *    Unless required by applicable law or agreed to in writing, software
      12              :  *    distributed under the License is distributed on an "AS IS" BASIS,
      13              :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14              :  *    See the License for the specific language governing permissions and
      15              :  *    limitations under the License.
      16              :  */
      17              : 
      18              : #include <lib/core/CHIPConfig.h>
      19              : 
      20              : #include "privilege-storage.h"
      21              : 
      22              : #if !CHIP_CONFIG_SKIP_APP_SPECIFIC_GENERATED_HEADER_INCLUDES
      23              : #include <zap-generated/access.h>
      24              : #endif // !CHIP_CONFIG_SKIP_APP_SPECIFIC_GENERATED_HEADER_INCLUDES
      25              : 
      26              : #include <lib/support/CodeUtils.h>
      27              : 
      28              : using chip::AttributeId;
      29              : using chip::ClusterId;
      30              : using chip::CommandId;
      31              : using chip::EventId;
      32              : 
      33              : namespace {
      34              : 
      35              : #ifdef GENERATED_ACCESS_READ_ATTRIBUTE__CLUSTER
      36              : namespace GeneratedAccessReadAttribute {
      37              : constexpr ClusterId kCluster[]                 = GENERATED_ACCESS_READ_ATTRIBUTE__CLUSTER;
      38              : constexpr AttributeId kAttribute[]             = GENERATED_ACCESS_READ_ATTRIBUTE__ATTRIBUTE;
      39              : constexpr chip::Access::Privilege kPrivilege[] = GENERATED_ACCESS_READ_ATTRIBUTE__PRIVILEGE;
      40              : static_assert(MATTER_ARRAY_SIZE(kCluster) == MATTER_ARRAY_SIZE(kAttribute) &&
      41              :                   MATTER_ARRAY_SIZE(kAttribute) == MATTER_ARRAY_SIZE(kPrivilege),
      42              :               "Generated parallel arrays must be same size");
      43              : } // namespace GeneratedAccessReadAttribute
      44              : #endif
      45              : 
      46              : #ifdef GENERATED_ACCESS_WRITE_ATTRIBUTE__CLUSTER
      47              : namespace GeneratedAccessWriteAttribute {
      48              : constexpr ClusterId kCluster[]                 = GENERATED_ACCESS_WRITE_ATTRIBUTE__CLUSTER;
      49              : constexpr AttributeId kAttribute[]             = GENERATED_ACCESS_WRITE_ATTRIBUTE__ATTRIBUTE;
      50              : constexpr chip::Access::Privilege kPrivilege[] = GENERATED_ACCESS_WRITE_ATTRIBUTE__PRIVILEGE;
      51              : static_assert(MATTER_ARRAY_SIZE(kCluster) == MATTER_ARRAY_SIZE(kAttribute) &&
      52              :                   MATTER_ARRAY_SIZE(kAttribute) == MATTER_ARRAY_SIZE(kPrivilege),
      53              :               "Generated parallel arrays must be same size");
      54              : } // namespace GeneratedAccessWriteAttribute
      55              : #endif
      56              : 
      57              : #ifdef GENERATED_ACCESS_INVOKE_COMMAND__CLUSTER
      58              : namespace GeneratedAccessInvokeCommand {
      59              : constexpr ClusterId kCluster[]                 = GENERATED_ACCESS_INVOKE_COMMAND__CLUSTER;
      60              : constexpr CommandId kCommand[]                 = GENERATED_ACCESS_INVOKE_COMMAND__COMMAND;
      61              : constexpr chip::Access::Privilege kPrivilege[] = GENERATED_ACCESS_INVOKE_COMMAND__PRIVILEGE;
      62              : static_assert(MATTER_ARRAY_SIZE(kCluster) == MATTER_ARRAY_SIZE(kCommand) &&
      63              :                   MATTER_ARRAY_SIZE(kCommand) == MATTER_ARRAY_SIZE(kPrivilege),
      64              :               "Generated parallel arrays must be same size");
      65              : } // namespace GeneratedAccessInvokeCommand
      66              : #endif
      67              : 
      68              : #ifdef GENERATED_ACCESS_READ_EVENT__CLUSTER
      69              : namespace GeneratedAccessReadEvent {
      70              : constexpr ClusterId kCluster[]                 = GENERATED_ACCESS_READ_EVENT__CLUSTER;
      71              : constexpr EventId kEvent[]                     = GENERATED_ACCESS_READ_EVENT__EVENT;
      72              : constexpr chip::Access::Privilege kPrivilege[] = GENERATED_ACCESS_READ_EVENT__PRIVILEGE;
      73              : static_assert(MATTER_ARRAY_SIZE(kCluster) == MATTER_ARRAY_SIZE(kEvent) &&
      74              :                   MATTER_ARRAY_SIZE(kEvent) == MATTER_ARRAY_SIZE(kPrivilege),
      75              :               "Generated parallel arrays must be same size");
      76              : } // namespace GeneratedAccessReadEvent
      77              : #endif
      78              : 
      79              : } // anonymous namespace
      80              : 
      81        30812 : chip::Access::Privilege MatterGetAccessPrivilegeForReadAttribute(ClusterId cluster, AttributeId attribute)
      82              : {
      83              : #ifdef GENERATED_ACCESS_READ_ATTRIBUTE__CLUSTER
      84              :     using namespace GeneratedAccessReadAttribute;
      85              :     for (size_t i = 0; i < MATTER_ARRAY_SIZE(kCluster); ++i)
      86              :     {
      87              :         if (kCluster[i] == cluster && kAttribute[i] == attribute)
      88              :         {
      89              :             return kPrivilege[i];
      90              :         }
      91              :     }
      92              : #endif
      93        30812 :     return chip::Access::Privilege::kView;
      94              : }
      95              : 
      96         7406 : chip::Access::Privilege MatterGetAccessPrivilegeForWriteAttribute(ClusterId cluster, AttributeId attribute)
      97              : {
      98              : #ifdef GENERATED_ACCESS_WRITE_ATTRIBUTE__CLUSTER
      99              :     using namespace GeneratedAccessWriteAttribute;
     100              :     for (size_t i = 0; i < MATTER_ARRAY_SIZE(kCluster); ++i)
     101              :     {
     102              :         if (kCluster[i] == cluster && kAttribute[i] == attribute)
     103              :         {
     104              :             return kPrivilege[i];
     105              :         }
     106              :     }
     107              : #endif
     108         7406 :     return chip::Access::Privilege::kOperate;
     109              : }
     110              : 
     111            6 : chip::Access::Privilege MatterGetAccessPrivilegeForInvokeCommand(ClusterId cluster, CommandId command)
     112              : {
     113              : #ifdef GENERATED_ACCESS_INVOKE_COMMAND__CLUSTER
     114              :     using namespace GeneratedAccessInvokeCommand;
     115              :     for (size_t i = 0; i < MATTER_ARRAY_SIZE(kCluster); ++i)
     116              :     {
     117              :         if (kCluster[i] == cluster && kCommand[i] == command)
     118              :         {
     119              :             return kPrivilege[i];
     120              :         }
     121              :     }
     122              : #endif
     123            6 :     return chip::Access::Privilege::kOperate;
     124              : }
     125              : 
     126         2047 : chip::Access::Privilege MatterGetAccessPrivilegeForReadEvent(ClusterId cluster, EventId event)
     127              : {
     128              : #ifdef GENERATED_ACCESS_READ_EVENT__CLUSTER
     129              :     using namespace GeneratedAccessReadEvent;
     130              :     for (size_t i = 0; i < MATTER_ARRAY_SIZE(kCluster); ++i)
     131              :     {
     132              :         if (kCluster[i] == cluster && kEvent[i] == event)
     133              :         {
     134              :             return kPrivilege[i];
     135              :         }
     136              :     }
     137              : #endif
     138         2047 :     return chip::Access::Privilege::kView;
     139              : }