Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2020-2021 Project CHIP Authors
       4             :  *    Copyright (c) 2015-2017 Nest Labs, Inc.
       5             :  *
       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             : #include <lib/core/TLVUpdater.h>
      19             : 
      20             : #include <stdint.h>
      21             : #include <string.h>
      22             : 
      23             : #include <lib/core/CHIPConfig.h>
      24             : #include <lib/core/CHIPError.h>
      25             : #include <lib/core/TLVCommon.h>
      26             : #include <lib/core/TLVReader.h>
      27             : #include <lib/core/TLVTags.h>
      28             : #include <lib/core/TLVTypes.h>
      29             : #include <lib/core/TLVWriter.h>
      30             : #include <lib/support/BufferWriter.h>
      31             : #include <lib/support/CodeUtils.h>
      32             : #include <lib/support/logging/Constants.h>
      33             : #include <lib/support/logging/TextOnlyLogging.h>
      34             : 
      35             : namespace chip {
      36             : namespace TLV {
      37             : 
      38             : using namespace chip::Encoding;
      39             : 
      40           4 : CHIP_ERROR TLVUpdater::Init(uint8_t * buf, uint32_t dataLen, uint32_t maxLen)
      41             : {
      42             :     uint32_t freeLen;
      43             : 
      44           4 :     VerifyOrReturnError(buf != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      45             : 
      46           4 :     VerifyOrReturnError(maxLen >= dataLen, CHIP_ERROR_BUFFER_TOO_SMALL);
      47             : 
      48             :     // memmove the buffer data to end of the buffer
      49           4 :     freeLen = maxLen - dataLen;
      50           4 :     memmove(buf + freeLen, buf, dataLen);
      51             : 
      52             :     // Init reader
      53           4 :     mUpdaterReader.Init(buf + freeLen, dataLen);
      54             : 
      55             :     // Init writer
      56           4 :     mUpdaterWriter.Init(buf, freeLen);
      57           4 :     mUpdaterWriter.SetCloseContainerReserved(false);
      58           4 :     mElementStartAddr = buf + freeLen;
      59             : 
      60           4 :     return CHIP_NO_ERROR;
      61             : }
      62             : 
      63           2 : CHIP_ERROR TLVUpdater::Init(TLVReader & aReader, uint32_t freeLen)
      64             : {
      65           2 :     uint8_t * buf             = const_cast<uint8_t *>(aReader.GetReadPoint());
      66           2 :     uint32_t remainingDataLen = aReader.GetRemainingLength();
      67           2 :     uint32_t readDataLen      = aReader.GetLengthRead();
      68             : 
      69             :     // TLVUpdater does not support backing stores yet
      70           2 :     VerifyOrReturnError(aReader.mBackingStore == nullptr, CHIP_ERROR_NOT_IMPLEMENTED);
      71             : 
      72             :     // TLVReader should point to a non-NULL buffer
      73           2 :     VerifyOrReturnError(buf != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
      74             : 
      75             :     // If reader is already on an element, reset it to start of element
      76           2 :     if (aReader.ElementType() != TLVElementType::NotSpecified)
      77             :     {
      78             :         uint8_t elemHeadLen;
      79             : 
      80           2 :         ReturnErrorOnFailure(aReader.GetElementHeadLength(elemHeadLen));
      81             : 
      82           2 :         buf -= elemHeadLen;
      83           2 :         remainingDataLen += elemHeadLen;
      84           2 :         readDataLen -= elemHeadLen;
      85             :     }
      86             : 
      87             :     // memmove the buffer data to end of the buffer
      88           2 :     memmove(buf + freeLen, buf, remainingDataLen);
      89             : 
      90             :     // Initialize the internal reader object
      91           2 :     mUpdaterReader.mBackingStore  = nullptr;
      92           2 :     mUpdaterReader.mReadPoint     = buf + freeLen;
      93           2 :     mUpdaterReader.mBufEnd        = buf + freeLen + remainingDataLen;
      94           2 :     mUpdaterReader.mLenRead       = readDataLen;
      95           2 :     mUpdaterReader.mMaxLen        = aReader.mMaxLen;
      96           2 :     mUpdaterReader.mControlByte   = kTLVControlByte_NotSpecified;
      97           2 :     mUpdaterReader.mElemTag       = AnonymousTag();
      98           2 :     mUpdaterReader.mElemLenOrVal  = 0;
      99           2 :     mUpdaterReader.mContainerType = aReader.mContainerType;
     100           2 :     mUpdaterReader.SetContainerOpen(false);
     101             : 
     102           2 :     mUpdaterReader.ImplicitProfileId = aReader.ImplicitProfileId;
     103           2 :     mUpdaterReader.AppData           = aReader.AppData;
     104             : 
     105             :     // TODO(#30825): Need to ensure we use TLVWriter public API rather than touch the innards.
     106             : 
     107             :     // Initialize the internal writer object
     108           2 :     mUpdaterWriter.mBackingStore  = nullptr;
     109           2 :     mUpdaterWriter.mBufStart      = buf - readDataLen;
     110           2 :     mUpdaterWriter.mWritePoint    = buf;
     111           2 :     mUpdaterWriter.mRemainingLen  = freeLen;
     112           2 :     mUpdaterWriter.mLenWritten    = readDataLen;
     113           2 :     mUpdaterWriter.mMaxLen        = readDataLen + freeLen;
     114           2 :     mUpdaterWriter.mContainerType = aReader.mContainerType;
     115           2 :     mUpdaterWriter.SetContainerOpen(false);
     116           2 :     mUpdaterWriter.SetCloseContainerReserved(false);
     117             : 
     118           2 :     mUpdaterWriter.ImplicitProfileId     = aReader.ImplicitProfileId;
     119           2 :     mUpdaterWriter.mInitializationCookie = TLVWriter::kExpectedInitializationCookie;
     120             : 
     121             :     // Cache element start address for internal use
     122           2 :     mElementStartAddr = buf + freeLen;
     123             : 
     124             :     // Clear the input reader object before returning. The user can no longer
     125             :     // use the original TLVReader object anymore.
     126           2 :     aReader.Init(static_cast<const uint8_t *>(nullptr), 0);
     127             : 
     128           2 :     return CHIP_NO_ERROR;
     129             : }
     130             : 
     131           4 : void TLVUpdater::SetImplicitProfileId(uint32_t profileId)
     132             : {
     133           4 :     mUpdaterReader.ImplicitProfileId = profileId;
     134           4 :     mUpdaterWriter.ImplicitProfileId = profileId;
     135           4 : }
     136             : 
     137          23 : CHIP_ERROR TLVUpdater::Next()
     138             : {
     139             :     // Skip current element if the reader is already positioned on an element
     140          23 :     ReturnErrorOnFailure(mUpdaterReader.Skip());
     141             : 
     142          22 :     AdjustInternalWriterFreeSpace();
     143             : 
     144             :     // Move the reader to next element
     145          22 :     ReturnErrorOnFailure(mUpdaterReader.Next());
     146             : 
     147          14 :     return CHIP_NO_ERROR;
     148             : }
     149             : 
     150           6 : CHIP_ERROR TLVUpdater::Move()
     151             : {
     152           6 :     VerifyOrReturnError(mUpdaterWriter.IsInitialized(), CHIP_ERROR_INCORRECT_STATE);
     153             : 
     154             :     const uint8_t * elementEnd;
     155             :     uint32_t copyLen;
     156             : 
     157           6 :     VerifyOrReturnError(static_cast<TLVElementType>((mUpdaterReader.mControlByte & kTLVTypeMask)) != TLVElementType::EndOfContainer,
     158             :                         CHIP_END_OF_TLV);
     159             : 
     160           6 :     VerifyOrReturnError(mUpdaterReader.GetType() != kTLVType_NotSpecified, CHIP_ERROR_INVALID_TLV_ELEMENT);
     161             : 
     162             :     // Skip to the end of the element
     163           6 :     ReturnErrorOnFailure(mUpdaterReader.Skip());
     164             : 
     165           6 :     elementEnd = mUpdaterReader.mReadPoint;
     166             : 
     167           6 :     copyLen = static_cast<uint32_t>(elementEnd - mElementStartAddr);
     168             : 
     169             :     // Move the element to output TLV
     170           6 :     memmove(mUpdaterWriter.mWritePoint, mElementStartAddr, copyLen);
     171             : 
     172             :     // Adjust the updater state
     173           6 :     mElementStartAddr += copyLen;
     174           6 :     mUpdaterWriter.mWritePoint += copyLen;
     175           6 :     mUpdaterWriter.mLenWritten += copyLen;
     176           6 :     mUpdaterWriter.mMaxLen += copyLen;
     177             : 
     178           6 :     return CHIP_NO_ERROR;
     179             : }
     180             : 
     181           3 : void TLVUpdater::MoveUntilEnd()
     182             : {
     183           3 :     VerifyOrDie(mUpdaterWriter.IsInitialized());
     184             : 
     185           3 :     const uint8_t * buffEnd = mUpdaterReader.GetReadPoint() + mUpdaterReader.GetRemainingLength();
     186             : 
     187           3 :     uint32_t copyLen = static_cast<uint32_t>(buffEnd - mElementStartAddr);
     188             : 
     189             :     // Move all elements till end to output TLV
     190           3 :     memmove(mUpdaterWriter.mWritePoint, mElementStartAddr, copyLen);
     191             : 
     192             :     // TODO(#30825): Need to ensure public API is used rather than touching the innards.
     193             :     // Adjust the updater state
     194           3 :     mElementStartAddr += copyLen;
     195           3 :     mUpdaterWriter.mWritePoint += copyLen;
     196           3 :     mUpdaterWriter.mLenWritten += copyLen;
     197           3 :     mUpdaterWriter.mMaxLen += copyLen;
     198           3 :     mUpdaterWriter.mContainerType = kTLVType_NotSpecified;
     199           3 :     mUpdaterWriter.SetContainerOpen(false);
     200           3 :     mUpdaterWriter.SetCloseContainerReserved(false);
     201           3 :     mUpdaterReader.mReadPoint += copyLen;
     202           3 :     mUpdaterReader.mLenRead += copyLen;
     203           3 :     mUpdaterReader.mControlByte   = kTLVControlByte_NotSpecified;
     204           3 :     mUpdaterReader.mElemTag       = AnonymousTag();
     205           3 :     mUpdaterReader.mElemLenOrVal  = 0;
     206           3 :     mUpdaterReader.mContainerType = kTLVType_NotSpecified;
     207           3 :     mUpdaterReader.SetContainerOpen(false);
     208           3 : }
     209             : 
     210           3 : CHIP_ERROR TLVUpdater::EnterContainer(TLVType & outerContainerType)
     211             : {
     212           3 :     VerifyOrReturnError(mUpdaterWriter.IsInitialized(), CHIP_ERROR_INCORRECT_STATE);
     213             : 
     214             :     TLVType containerType;
     215             : 
     216           3 :     VerifyOrReturnError(TLVTypeIsContainer(static_cast<TLVType>(mUpdaterReader.mControlByte & kTLVTypeMask)),
     217             :                         CHIP_ERROR_INCORRECT_STATE);
     218             : 
     219             :     // Change the updater state
     220           3 :     AdjustInternalWriterFreeSpace();
     221             : 
     222           3 :     ReturnErrorOnFailure(mUpdaterWriter.StartContainer(mUpdaterReader.GetTag(), mUpdaterReader.GetType(), containerType));
     223             : 
     224           3 :     ReturnErrorOnFailure(mUpdaterReader.EnterContainer(containerType));
     225             : 
     226           3 :     outerContainerType = containerType;
     227             : 
     228           3 :     return CHIP_NO_ERROR;
     229             : }
     230             : 
     231           3 : CHIP_ERROR TLVUpdater::ExitContainer(TLVType outerContainerType)
     232             : {
     233           3 :     ReturnErrorOnFailure(mUpdaterReader.ExitContainer(outerContainerType));
     234             : 
     235             :     // Change the updater's state
     236           3 :     AdjustInternalWriterFreeSpace();
     237             : 
     238           3 :     ReturnErrorOnFailure(mUpdaterWriter.EndContainer(outerContainerType));
     239             : 
     240           3 :     return CHIP_NO_ERROR;
     241             : }
     242             : 
     243             : /**
     244             :  * This is a private method that adjusts the TLVUpdater's free space count by
     245             :  * accounting for the freespace from mElementStartAddr to current read point.
     246             :  */
     247          28 : void TLVUpdater::AdjustInternalWriterFreeSpace()
     248             : {
     249          28 :     VerifyOrDie(mUpdaterWriter.IsInitialized());
     250             : 
     251          28 :     const uint8_t * nextElementStart = mUpdaterReader.mReadPoint;
     252             : 
     253          28 :     if (nextElementStart != mElementStartAddr)
     254             :     {
     255             :         // Increase the internal writer's free space state variables
     256          11 :         uint32_t spaceIncrease = static_cast<uint32_t>(nextElementStart - mElementStartAddr);
     257          11 :         mUpdaterWriter.mRemainingLen += spaceIncrease;
     258          11 :         mUpdaterWriter.mMaxLen += spaceIncrease;
     259             : 
     260             :         // Cache the start address of the next element
     261          11 :         mElementStartAddr = nextElementStart;
     262             :     }
     263          28 : }
     264             : 
     265             : } // namespace TLV
     266             : } // namespace chip