Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2020 Project CHIP Authors
       4             :  *    Copyright (c) 2013-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/support/CHIPMemString.h"
      19             : #include "lib/support/ScopedBuffer.h"
      20             : #include <lib/core/DataModelTypes.h>
      21             : #include <lib/support/Base64.h>
      22             : #include <lib/support/jsontlv/TlvJson.h>
      23             : 
      24             : namespace {
      25             : /*
      26             :  * Encapsulates the different types of keys permissible.
      27             :  *
      28             :  * Root Key = Key with a name of 'value'. This is the top-most key in a given JSON object generated from TLV.
      29             :  * Struct Field = Key containing the 32-bit field ID of an item in a struct.
      30             :  * Array Item = Key containing the 16-bit list index of an item in a list.
      31             :  *
      32             :  * In the latter two modes, the actual field ID/list index is encapsulated within the 'key' member.
      33             :  *
      34             :  */
      35             : struct KeyContext
      36             : {
      37             :     enum KeyType
      38             :     {
      39             :         kRoot,
      40             :         kStructField,
      41             :         kArrayItem
      42             :     };
      43             : 
      44             :     KeyContext() = default;
      45             : 
      46          24 :     KeyContext(chip::FieldId fieldId)
      47          24 :     {
      48          24 :         keyType = kStructField;
      49          24 :         key     = fieldId;
      50          24 :     }
      51             : 
      52           6 :     KeyContext(chip::ListIndex listIndex)
      53           6 :     {
      54           6 :         keyType = kArrayItem;
      55           6 :         key     = listIndex;
      56           6 :     }
      57             : 
      58             :     KeyType keyType  = kRoot;
      59             :     unsigned int key = 0;
      60             : };
      61             : } // namespace
      62             : 
      63             : //
      64             : // For now, let's put a bound of the maximum length of a byte/char string to be the size of an IPv6
      65             : // MTU. While this is smaller than that of the limit defined in the data model specification,
      66             : // strings by virtue of not being chunked are intrinsically limited in size to the size of the encompassing packet.
      67             : //
      68             : static constexpr uint16_t kMaxStringLen = 1280;
      69             : 
      70             : constexpr char kBase64Header[]    = "base64:";
      71             : constexpr size_t kBase64HeaderLen = ArraySize(kBase64Header) - 1;
      72             : 
      73             : namespace chip {
      74             : 
      75             : /*
      76             :  * This templated function inserts a key/value pair into the Json value object.
      77             :  * The value is templated to be of type T and accepts any of the following primitive
      78             :  * types:
      79             :  *      bool, uint*_t, int*_t, char *, float, double.
      80             :  *
      81             :  * This method uses the provided key context to deduce the type of element being added.
      82             :  *
      83             :  */
      84             : template <typename T>
      85          43 : void InsertKeyValue(Json::Value & json, const KeyContext & keyContext, T val)
      86             : {
      87             :     //
      88             :     // This needs to accomodate either the string 'value', or a 32-bit integer.
      89             :     // The size of the largest 32-bit integer key represented as a string is 11 characters long.
      90             :     // Tack on 1 byte for the null character.
      91             :     //
      92             :     char keyBuf[12];
      93             : 
      94          43 :     if (keyContext.keyType == KeyContext::kRoot)
      95             :     {
      96          13 :         Platform::CopyString(keyBuf, sizeof(keyBuf), "value");
      97          13 :         json[keyBuf] = val;
      98             :     }
      99          30 :     else if (keyContext.keyType == KeyContext::kStructField)
     100             :     {
     101          24 :         snprintf(keyBuf, sizeof(keyBuf), "%u", keyContext.key);
     102          24 :         json[keyBuf] = val;
     103             :     }
     104             :     else
     105             :     {
     106           6 :         json[keyContext.key] = val;
     107             :     }
     108          43 : }
     109             : 
     110          13 : std::string JsonToString(Json::Value & json)
     111             : {
     112          13 :     Json::FastWriter writer;
     113          13 :     writer.omitEndingLineFeed();
     114          13 :     return writer.write(json);
     115          13 : }
     116             : 
     117          43 : CHIP_ERROR TlvToJson(TLV::TLVReader & reader, KeyContext context, Json::Value & parent)
     118             : {
     119          43 :     switch (reader.GetType())
     120             :     {
     121          14 :     case TLV::kTLVType_UnsignedInteger: {
     122             :         uint64_t v;
     123          14 :         ReturnErrorOnFailure(reader.Get(v));
     124          14 :         InsertKeyValue(parent, context, v);
     125          14 :         break;
     126             :     }
     127             : 
     128           1 :     case TLV::kTLVType_SignedInteger: {
     129             :         int64_t v;
     130           1 :         ReturnErrorOnFailure(reader.Get(v));
     131           1 :         InsertKeyValue(parent, context, v);
     132           1 :         break;
     133             :     }
     134             : 
     135           5 :     case TLV::kTLVType_Boolean: {
     136             :         bool v;
     137           5 :         ReturnErrorOnFailure(reader.Get(v));
     138           5 :         InsertKeyValue(parent, context, v);
     139           5 :         break;
     140             :     }
     141             : 
     142           7 :     case TLV::kTLVType_FloatingPointNumber: {
     143             :         double v;
     144           7 :         ReturnErrorOnFailure(reader.Get(v));
     145           7 :         InsertKeyValue(parent, context, v);
     146           7 :         break;
     147             :     }
     148             : 
     149           4 :     case TLV::kTLVType_ByteString: {
     150           4 :         ByteSpan span;
     151             : 
     152           4 :         ReturnErrorOnFailure(reader.Get(span));
     153           4 :         VerifyOrReturnError(span.size() < kMaxStringLen, CHIP_ERROR_INVALID_TLV_ELEMENT);
     154             : 
     155           4 :         Platform::ScopedMemoryBuffer<char> byteString;
     156           4 :         byteString.Alloc(kBase64HeaderLen + BASE64_ENCODED_LEN(span.size()) + 1);
     157           4 :         VerifyOrReturnError(byteString.Get() != nullptr, CHIP_ERROR_NO_MEMORY);
     158             : 
     159           4 :         auto encodedLen = Base64Encode(span.data(), static_cast<uint16_t>(span.size()), byteString.Get() + kBase64HeaderLen);
     160           4 :         if (encodedLen)
     161             :         {
     162           4 :             memcpy(byteString.Get(), kBase64Header, kBase64HeaderLen);
     163           4 :             encodedLen = static_cast<uint16_t>(encodedLen + kBase64HeaderLen);
     164             :         }
     165           4 :         byteString.Get()[encodedLen] = '\0';
     166             : 
     167           4 :         InsertKeyValue(parent, context, byteString.Get());
     168           4 :         break;
     169           4 :     }
     170             : 
     171           4 :     case TLV::kTLVType_UTF8String: {
     172           4 :         CharSpan span;
     173             : 
     174           4 :         ReturnErrorOnFailure(reader.Get(span));
     175           4 :         VerifyOrReturnError(span.size() < kMaxStringLen, CHIP_ERROR_INVALID_TLV_ELEMENT);
     176             : 
     177           4 :         Platform::ScopedMemoryString charString(span.data(), span.size());
     178           4 :         InsertKeyValue(parent, context, charString.Get());
     179           4 :         break;
     180           4 :     }
     181             : 
     182           2 :     case TLV::kTLVType_Null: {
     183           2 :         InsertKeyValue(parent, context, Json::Value());
     184           2 :         break;
     185             :     }
     186             : 
     187           3 :     case TLV::kTLVType_Structure: {
     188             :         TLV::TLVType containerType;
     189           3 :         ReturnErrorOnFailure(reader.EnterContainer(containerType));
     190             : 
     191             :         CHIP_ERROR err;
     192           3 :         Json::Value value;
     193             : 
     194          27 :         while ((err = reader.Next()) == CHIP_NO_ERROR)
     195             :         {
     196          24 :             VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG);
     197          24 :             KeyContext context2(static_cast<chip::FieldId>(TLV::TagNumFromTag(reader.GetTag())));
     198             : 
     199             :             //
     200             :             // Recursively convert to JSON the encompassing item within the struct.
     201             :             //
     202          24 :             ReturnErrorOnFailure(TlvToJson(reader, context2, value));
     203             :         }
     204             : 
     205           3 :         VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     206           3 :         ReturnErrorOnFailure(reader.ExitContainer(containerType));
     207           3 :         InsertKeyValue(parent, context, value);
     208           3 :         break;
     209           3 :     }
     210             : 
     211           3 :     case TLV::kTLVType_Array: {
     212             :         TLV::TLVType containerType;
     213           3 :         ReturnErrorOnFailure(reader.EnterContainer(containerType));
     214             : 
     215             :         CHIP_ERROR err;
     216           3 :         Json::Value value = Json::Value(Json::arrayValue);
     217           3 :         size_t listIndex  = 0;
     218             : 
     219           9 :         while ((err = reader.Next()) == CHIP_NO_ERROR)
     220             :         {
     221           6 :             KeyContext context2(static_cast<chip::ListIndex>(listIndex++));
     222             : 
     223             :             //
     224             :             // Recursively convert to JSON the encompassing item within the array.
     225             :             //
     226           6 :             ReturnErrorOnFailure(TlvToJson(reader, context2, value));
     227             :         }
     228             : 
     229           3 :         VerifyOrReturnError(err == CHIP_END_OF_TLV, err);
     230           3 :         ReturnErrorOnFailure(reader.ExitContainer(containerType));
     231           3 :         InsertKeyValue(parent, context, value);
     232           3 :         break;
     233           3 :     }
     234             : 
     235           0 :     default:
     236           0 :         return CHIP_ERROR_INVALID_TLV_ELEMENT;
     237             :         break;
     238             :     }
     239             : 
     240          43 :     return CHIP_NO_ERROR;
     241             : }
     242             : 
     243          13 : CHIP_ERROR TlvToJson(TLV::TLVReader & reader, Json::Value & root)
     244             : {
     245          13 :     KeyContext context;
     246          13 :     return TlvToJson(reader, context, root);
     247             : }
     248             : 
     249             : } // namespace chip