Line data    Source code

       1             : /**
       2             :  *
       3             :  *    Copyright (c) 2020 Project CHIP Authors
       4             :  *    Copyright (c) 2018 Google LLC.
       5             :  *    Copyright (c) 2016-2017 Nest Labs, Inc.
       6             :  *    Licensed under the Apache License, Version 2.0 (the "License");
       7             :  *    you may not use this file except in compliance with the License.
       8             :  *    You may obtain a copy of the License at
       9             :  *
      10             :  *        http://www.apache.org/licenses/LICENSE-2.0
      11             :  *
      12             :  *    Unless required by applicable law or agreed to in writing, software
      13             :  *    distributed under the License is distributed on an "AS IS" BASIS,
      14             :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15             :  *    See the License for the specific language governing permissions and
      16             :  *    limitations under the License.
      17             :  */
      18             : 
      19             : #include "CommandPathIB.h"
      20             : 
      21             : #include "MessageDefHelper.h"
      22             : 
      23             : #include <inttypes.h>
      24             : #include <stdarg.h>
      25             : #include <stdio.h>
      26             : 
      27             : #include <app/AppConfig.h>
      28             : 
      29             : #include <protocols/interaction_model/Constants.h>
      30             : 
      31             : using namespace chip;
      32             : using namespace chip::TLV;
      33             : 
      34             : namespace chip {
      35             : namespace app {
      36             : #if CHIP_CONFIG_IM_PRETTY_PRINT
      37          82 : CHIP_ERROR CommandPathIB::Parser::PrettyPrint() const
      38             : {
      39          82 :     CHIP_ERROR err = CHIP_NO_ERROR;
      40             :     TLV::TLVReader reader;
      41          82 :     PRETTY_PRINT("CommandPathIB =");
      42          82 :     PRETTY_PRINT("{");
      43             : 
      44             :     // make a copy of the Path reader
      45          82 :     reader.Init(mReader);
      46             : 
      47         328 :     while (CHIP_NO_ERROR == (err = reader.Next()))
      48             :     {
      49         246 :         if (!TLV::IsContextTag(reader.GetTag()))
      50             :         {
      51           0 :             continue;
      52             :         }
      53         246 :         uint32_t tagNum = TLV::TagNumFromTag(reader.GetTag());
      54         246 :         switch (tagNum)
      55             :         {
      56          82 :         case to_underlying(Tag::kEndpointId):
      57          82 :             VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
      58             : 
      59             : #if CHIP_DETAIL_LOGGING
      60             :             {
      61             :                 uint16_t endpointId;
      62          82 :                 ReturnErrorOnFailure(reader.Get(endpointId));
      63          82 :                 PRETTY_PRINT("\tEndpointId = 0x%x,", endpointId);
      64             :             }
      65             : #endif // CHIP_DETAIL_LOGGING
      66          82 :             break;
      67          82 :         case to_underlying(Tag::kClusterId):
      68          82 :             VerifyOrReturnError(TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
      69             : #if CHIP_DETAIL_LOGGING
      70             :             {
      71             :                 chip::ClusterId clusterId;
      72          82 :                 ReturnErrorOnFailure(reader.Get(clusterId));
      73          82 :                 PRETTY_PRINT("\tClusterId = 0x%" PRIx32 ",", clusterId);
      74             :             }
      75             : #endif // CHIP_DETAIL_LOGGING
      76          82 :             break;
      77          82 :         case to_underlying(Tag::kCommandId):
      78          82 :             VerifyOrReturnError(chip::TLV::kTLVType_UnsignedInteger == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE);
      79             : #if CHIP_DETAIL_LOGGING
      80             :             {
      81             :                 chip::CommandId commandId;
      82          82 :                 ReturnErrorOnFailure(reader.Get(commandId));
      83          82 :                 PRETTY_PRINT("\tCommandId = 0x%" PRIx32 ",", commandId);
      84             :             }
      85             : #endif // CHIP_DETAIL_LOGGING
      86          82 :             break;
      87           0 :         default:
      88           0 :             PRETTY_PRINT("Unknown tag num %" PRIu32, tagNum);
      89           0 :             break;
      90             :         }
      91             :     }
      92          82 :     PRETTY_PRINT("},");
      93          82 :     PRETTY_PRINT_BLANK_LINE();
      94             :     // if we have exhausted this container
      95          82 :     if (CHIP_END_OF_TLV == err)
      96             :     {
      97          82 :         err = CHIP_NO_ERROR;
      98             :     }
      99          82 :     ReturnErrorOnFailure(err);
     100          82 :     return reader.ExitContainer(mOuterContainerType);
     101             : }
     102             : #endif // CHIP_CONFIG_IM_PRETTY_PRINT
     103             : 
     104         101 : CHIP_ERROR CommandPathIB::Parser::GetEndpointId(chip::EndpointId * const apEndpointID) const
     105             : {
     106         101 :     return GetUnsignedInteger(to_underlying(Tag::kEndpointId), apEndpointID);
     107             : }
     108             : 
     109         102 : CHIP_ERROR CommandPathIB::Parser::GetClusterId(chip::ClusterId * const apClusterId) const
     110             : {
     111         102 :     return GetUnsignedInteger(to_underlying(Tag::kClusterId), apClusterId);
     112             : }
     113             : 
     114         101 : CHIP_ERROR CommandPathIB::Parser::GetCommandId(chip::CommandId * const apCommandId) const
     115             : {
     116         101 :     return GetUnsignedInteger(to_underlying(Tag::kCommandId), apCommandId);
     117             : }
     118             : 
     119          70 : CHIP_ERROR CommandPathIB::Parser::GetConcreteCommandPath(ConcreteCommandPath & aCommandPath) const
     120             : {
     121          70 :     ReturnErrorOnFailure(GetGroupCommandPath(&aCommandPath.mClusterId, &aCommandPath.mCommandId));
     122             : 
     123          69 :     return GetEndpointId(&aCommandPath.mEndpointId);
     124             : }
     125             : 
     126          70 : CHIP_ERROR CommandPathIB::Parser::GetGroupCommandPath(ClusterId * apClusterId, CommandId * apCommandId) const
     127             : {
     128          70 :     ReturnErrorOnFailure(GetClusterId(apClusterId));
     129          70 :     VerifyOrReturnError(IsValidClusterId(*apClusterId), CHIP_IM_GLOBAL_STATUS(InvalidAction));
     130             : 
     131          69 :     ReturnErrorOnFailure(GetCommandId(apCommandId));
     132          69 :     VerifyOrReturnError(IsValidCommandId(*apCommandId), CHIP_IM_GLOBAL_STATUS(InvalidAction));
     133             : 
     134          69 :     return CHIP_NO_ERROR;
     135             : }
     136             : 
     137         111 : CommandPathIB::Builder & CommandPathIB::Builder::EndpointId(const chip::EndpointId aEndpointId)
     138             : {
     139             :     // skip if error has already been set
     140         111 :     if (mError == CHIP_NO_ERROR)
     141             :     {
     142         111 :         mError = mpWriter->Put(TLV::ContextTag(Tag::kEndpointId), aEndpointId);
     143             :     }
     144         111 :     return *this;
     145             : }
     146             : 
     147         111 : CommandPathIB::Builder & CommandPathIB::Builder::ClusterId(const chip::ClusterId aClusterId)
     148             : {
     149             :     // skip if error has already been set
     150         111 :     if (mError == CHIP_NO_ERROR)
     151             :     {
     152         111 :         mError = mpWriter->Put(TLV::ContextTag(Tag::kClusterId), aClusterId);
     153             :     }
     154         111 :     return *this;
     155             : }
     156             : 
     157         111 : CommandPathIB::Builder & CommandPathIB::Builder::CommandId(const chip::CommandId aCommandId)
     158             : {
     159             :     // skip if error has already been set
     160         111 :     if (mError == CHIP_NO_ERROR)
     161             :     {
     162         111 :         mError = mpWriter->Put(TLV::ContextTag(Tag::kCommandId), aCommandId);
     163             :     }
     164         111 :     return *this;
     165             : }
     166             : 
     167         111 : CHIP_ERROR CommandPathIB::Builder::EndOfCommandPathIB()
     168             : {
     169         111 :     EndOfContainer();
     170         111 :     return GetError();
     171             : }
     172             : 
     173          40 : CHIP_ERROR CommandPathIB::Builder::Encode(const CommandPathParams & aCommandPathParams)
     174             : {
     175          40 :     if (aCommandPathParams.mFlags.Has(CommandPathFlags::kEndpointIdValid))
     176             :     {
     177          40 :         EndpointId(aCommandPathParams.mEndpointId);
     178             :     }
     179             : 
     180          40 :     return ClusterId(aCommandPathParams.mClusterId).CommandId(aCommandPathParams.mCommandId).EndOfCommandPathIB();
     181             : }
     182             : 
     183          55 : CHIP_ERROR CommandPathIB::Builder::Encode(const ConcreteCommandPath & aConcreteCommandPath)
     184             : {
     185          55 :     return EndpointId(aConcreteCommandPath.mEndpointId)
     186          55 :         .ClusterId(aConcreteCommandPath.mClusterId)
     187          55 :         .CommandId(aConcreteCommandPath.mCommandId)
     188          55 :         .EndOfCommandPathIB();
     189             : }
     190             : 
     191             : }; // namespace app
     192             : }; // namespace chip