Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2021 Project CHIP Authors
       4             :  *    All rights reserved.
       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             : 
      19             : #include "BdxUri.h"
      20             : 
      21             : #include <lib/core/CHIPEncoding.h>
      22             : #include <lib/core/CHIPSafeCasts.h>
      23             : #include <lib/support/BufferWriter.h>
      24             : #include <lib/support/BytesToHex.h>
      25             : #include <lib/support/CodeUtils.h>
      26             : 
      27             : #include <cstring>
      28             : 
      29             : namespace chip {
      30             : namespace bdx {
      31             : 
      32             : constexpr size_t kSchemeLen    = sizeof(kScheme) - 1;
      33             : constexpr size_t kHostPos      = kSchemeLen;
      34             : constexpr size_t kHostLen      = sizeof(NodeId) * 2;
      35             : constexpr size_t kHostEnd      = kHostPos + kHostLen;
      36             : constexpr size_t kSeparatorLen = 1;
      37             : constexpr size_t kMinUriLen    = kHostEnd + kSeparatorLen + 1 /* file-designator */;
      38             : 
      39             : static_assert(sizeof(NodeId) == sizeof(uint64_t), "The code below assumes NodeId is uint64_t");
      40             : 
      41           8 : CHIP_ERROR ParseURI(CharSpan uri, NodeId & nodeId, CharSpan & fileDesignator)
      42             : {
      43           8 :     VerifyOrReturnError(uri.size() >= kMinUriLen, CHIP_ERROR_INVALID_STRING_LENGTH);
      44           7 :     VerifyOrReturnError(memcmp(uri.data(), kScheme, kSchemeLen) == 0, CHIP_ERROR_INVALID_SCHEME_PREFIX);
      45             : 
      46             :     uint8_t nodeIdBytes[sizeof(NodeId)];
      47           6 :     VerifyOrReturnError(Encoding::HexToBytes(uri.data() + kHostPos, kHostLen, nodeIdBytes, sizeof(nodeIdBytes)) ==
      48             :                             sizeof(nodeIdBytes),
      49             :                         CHIP_ERROR_INVALID_DESTINATION_NODE_ID);
      50             : 
      51           4 :     nodeId = Encoding::BigEndian::Get64(nodeIdBytes);
      52           4 :     VerifyOrReturnError(IsOperationalNodeId(nodeId), CHIP_ERROR_INVALID_DESTINATION_NODE_ID);
      53           3 :     VerifyOrReturnError(uri.data()[kHostEnd] == '/', CHIP_ERROR_MISSING_URI_SEPARATOR);
      54             : 
      55           2 :     fileDesignator = uri.SubSpan(kHostEnd + kSeparatorLen);
      56             : 
      57           2 :     return CHIP_NO_ERROR;
      58             : }
      59             : 
      60           4 : CHIP_ERROR MakeURI(NodeId nodeId, CharSpan fileDesignator, MutableCharSpan & uri)
      61             : {
      62           4 :     VerifyOrReturnError(fileDesignator.size() > 0, CHIP_ERROR_INVALID_STRING_LENGTH);
      63             : 
      64             :     uint8_t nodeIdBytes[sizeof(NodeId)];
      65           2 :     Encoding::BigEndian::Put64(nodeIdBytes, nodeId);
      66             : 
      67             :     char nodeIdHex[sizeof(NodeId) * 2];
      68           2 :     ReturnErrorOnFailure(Encoding::BytesToUppercaseHexBuffer(nodeIdBytes, sizeof(nodeIdBytes), nodeIdHex, sizeof(nodeIdHex)));
      69             : 
      70           2 :     char * buffer     = uri.data();
      71           2 :     size_t bufferSize = uri.size();
      72           2 :     memset(buffer, 0, bufferSize);
      73             : 
      74             :     // Reduce the buffer writer size by one to reserve the last byte for the null-terminator
      75           2 :     Encoding::BufferWriter writer(Uint8::from_char(buffer), bufferSize - 1);
      76           2 :     writer.Put(kScheme, kSchemeLen);
      77           2 :     writer.Put(nodeIdHex, sizeof(nodeIdHex));
      78           2 :     writer.Put("/");
      79           2 :     writer.Put(fileDesignator.data(), fileDesignator.size());
      80             : 
      81           2 :     VerifyOrReturnError(writer.Fit(), CHIP_ERROR_BUFFER_TOO_SMALL);
      82           2 :     uri.reduce_size(writer.WritePos());
      83             : 
      84           2 :     return CHIP_NO_ERROR;
      85             : }
      86             : 
      87             : } // namespace bdx
      88             : } // namespace chip