tlv.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2022 Regents of the University of California.
 *
 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
 *
 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
 *
 * You should have received copies of the GNU General Public License and GNU Lesser
 * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
 */
 
#ifndef NDN_CXX_ENCODING_TLV_HPP
#define NDN_CXX_ENCODING_TLV_HPP
 
#include "ndn-cxx/detail/common.hpp"
 
#include <cstring>
#include <iterator>
#include <ostream>
#include <vector>
 
#include <boost/endian/conversion.hpp>
 
namespace ndn {
 
const size_t MAX_NDN_PACKET_SIZE = 8800;
 
namespace tlv {
 
class Error : public std::runtime_error
{
public:
  using std::runtime_error::runtime_error;
 
  Error(const char* expectedType, uint32_t actualType);
};
 
enum : uint32_t {
  Invalid                         = 0,
  Interest                        = 5,
  Data                            = 6,
 
  Name                            = 7,
  GenericNameComponent            = 8,
  ImplicitSha256DigestComponent   = 1,
  ParametersSha256DigestComponent = 2,
  KeywordNameComponent            = 32,
  SegmentNameComponent            = 50,
  ByteOffsetNameComponent         = 52,
  VersionNameComponent            = 54,
  TimestampNameComponent          = 56,
  SequenceNumNameComponent        = 58,
 
  CanBePrefix                     = 33,
  MustBeFresh                     = 18,
  ForwardingHint                  = 30,
  Nonce                           = 10,
  InterestLifetime                = 12,
  HopLimit                        = 34,
  ApplicationParameters           = 36,
  InterestSignatureInfo           = 44,
  InterestSignatureValue          = 46,
 
  MetaInfo                        = 20,
  Content                         = 21,
  SignatureInfo                   = 22,
  SignatureValue                  = 23,
  ContentType                     = 24,
  FreshnessPeriod                 = 25,
  FinalBlockId                    = 26,
 
  SignatureType                   = 27,
  KeyLocator                      = 28,
  KeyDigest                       = 29,
  SignatureNonce                  = 38,
  SignatureTime                   = 40,
  SignatureSeqNum                 = 42,
 
  ValidityPeriod                  = 253,
  NotBefore                       = 254,
  NotAfter                        = 255,
  AdditionalDescription           = 258,
  DescriptionEntry                = 512,
  DescriptionKey                  = 513,
  DescriptionValue                = 514,
 
  NameComponentMin = 1,
  NameComponentMax = 65535,
 
  AppPrivateBlock1 = 128,
  AppPrivateBlock2 = 32768,
};
 
enum SignatureTypeValue : uint16_t {
  DigestSha256             = 0,
  SignatureSha256WithRsa   = 1,
  SignatureSha256WithEcdsa = 3,
  SignatureHmacWithSha256  = 4,
  SignatureEd25519         = 5,
  NullSignature            = 200,
};
 
std::ostream&
operator<<(std::ostream& os, SignatureTypeValue st);
 
enum ContentTypeValue : uint32_t {
  ContentType_Blob      = 0,    
  ContentType_Link      = 1,    
  ContentType_Key       = 2,    
  ContentType_Nack      = 3,    
  ContentType_Manifest  = 4,
  ContentType_PrefixAnn = 5,    
  ContentType_Flic      = 1024, 
};
 
std::ostream&
operator<<(std::ostream& os, ContentTypeValue ct);
 
constexpr bool
isCriticalType(uint32_t type) noexcept
{
  return type <= 31 || (type & 0x01);
}
 
template<typename Iterator>
NDN_CXX_NODISCARD bool
readVarNumber(Iterator& begin, Iterator end, uint64_t& number) noexcept;
 
template<typename Iterator>
NDN_CXX_NODISCARD bool
readType(Iterator& begin, Iterator end, uint32_t& type) noexcept;
 
template<typename Iterator>
uint64_t
readVarNumber(Iterator& begin, Iterator end);
 
template<typename Iterator>
uint32_t
readType(Iterator& begin, Iterator end);
 
constexpr size_t
sizeOfVarNumber(uint64_t number) noexcept;
 
size_t
writeVarNumber(std::ostream& os, uint64_t number);
 
template<typename Iterator>
uint64_t
readNonNegativeInteger(size_t size, Iterator& begin, Iterator end);
 
constexpr size_t
sizeOfNonNegativeInteger(uint64_t integer) noexcept;
 
size_t
writeNonNegativeInteger(std::ostream& os, uint64_t integer);
 
 
// Inline definitions
 
 
namespace detail {
 
template<typename Iterator>
class ReadNumberSlow
{
public:
  constexpr bool
  operator()(size_t size, Iterator& begin, Iterator end, uint64_t& number) const noexcept
  {
    number = 0;
    size_t count = 0;
    for (; begin != end && count < size; ++begin, ++count) {
      number = (number << 8) | *begin;
    }
    return count == size;
  }
};
 
template<typename Iterator>
class ReadNumberFast
{
public:
  constexpr bool
  operator()(size_t size, Iterator& begin, Iterator end, uint64_t& number) const noexcept
  {
    if (begin + size > end) {
      return false;
    }
 
    switch (size) {
      case 1: {
        number = *begin;
        ++begin;
        return true;
      }
      case 2: {
        uint16_t value = 0;
        std::memcpy(&value, &*begin, 2);
        begin += 2;
        number = boost::endian::big_to_native(value);
        return true;
      }
      case 4: {
        uint32_t value = 0;
        std::memcpy(&value, &*begin, 4);
        begin += 4;
        number = boost::endian::big_to_native(value);
        return true;
      }
      case 8: {
        uint64_t value = 0;
        std::memcpy(&value, &*begin, 8);
        begin += 8;
        number = boost::endian::big_to_native(value);
        return true;
      }
      default: {
        NDN_CXX_UNREACHABLE;
      }
    }
  }
};
 
template<typename Iterator,
         typename DecayedIterator = std::decay_t<Iterator>,
         typename ValueType = typename std::iterator_traits<DecayedIterator>::value_type>
constexpr bool
shouldSelectContiguousReadNumber()
{
  return (std::is_convertible<DecayedIterator, const ValueType*>::value ||
          std::is_convertible<DecayedIterator, typename std::basic_string<ValueType>::const_iterator>::value ||
          std::is_convertible<DecayedIterator, typename std::vector<ValueType>::const_iterator>::value) &&
         sizeof(ValueType) == 1 &&
         !std::is_same<ValueType, bool>::value;
}
 
template<typename Iterator>
class ReadNumber : public std::conditional_t<shouldSelectContiguousReadNumber<Iterator>(),
                                             ReadNumberFast<Iterator>, ReadNumberSlow<Iterator>>
{
};
 
} // namespace detail
 
template<typename Iterator>
bool
readVarNumber(Iterator& begin, Iterator end, uint64_t& number) noexcept
{
  if (begin == end)
    return false;
 
  uint8_t firstOctet = *begin;
  ++begin;
  if (firstOctet < 253) {
    number = firstOctet;
    return true;
  }
 
  size_t size = firstOctet == 253 ? 2 :
                firstOctet == 254 ? 4 : 8;
  return detail::ReadNumber<Iterator>()(size, begin, end, number);
}
 
template<typename Iterator>
bool
readType(Iterator& begin, Iterator end, uint32_t& type) noexcept
{
  uint64_t number = 0;
  bool isOk = readVarNumber(begin, end, number);
  if (!isOk || number == Invalid || number > std::numeric_limits<uint32_t>::max()) {
    return false;
  }
 
  type = static_cast<uint32_t>(number);
  return true;
}
 
template<typename Iterator>
uint64_t
readVarNumber(Iterator& begin, Iterator end)
{
  if (begin == end) {
    NDN_THROW(Error("Empty buffer during TLV parsing"));
  }
 
  uint64_t value = 0;
  bool isOk = readVarNumber(begin, end, value);
  if (!isOk) {
    NDN_THROW(Error("Insufficient data during TLV parsing"));
  }
 
  return value;
}
 
template<typename Iterator>
uint32_t
readType(Iterator& begin, Iterator end)
{
  uint64_t type = readVarNumber(begin, end);
  if (type == Invalid || type > std::numeric_limits<uint32_t>::max()) {
    NDN_THROW(Error("Illegal TLV-TYPE " + to_string(type)));
  }
 
  return static_cast<uint32_t>(type);
}
 
constexpr size_t
sizeOfVarNumber(uint64_t number) noexcept
{
  return number < 253 ? 1 :
         number <= std::numeric_limits<uint16_t>::max() ? 3 :
         number <= std::numeric_limits<uint32_t>::max() ? 5 : 9;
}
 
inline size_t
writeVarNumber(std::ostream& os, uint64_t number)
{
  if (number < 253) {
    os.put(static_cast<char>(number));
    return 1;
  }
  else if (number <= std::numeric_limits<uint16_t>::max()) {
    os.put(static_cast<char>(253));
    uint16_t value = boost::endian::native_to_big(static_cast<uint16_t>(number));
    os.write(reinterpret_cast<const char*>(&value), 2);
    return 3;
  }
  else if (number <= std::numeric_limits<uint32_t>::max()) {
    os.put(static_cast<char>(254));
    uint32_t value = boost::endian::native_to_big(static_cast<uint32_t>(number));
    os.write(reinterpret_cast<const char*>(&value), 4);
    return 5;
  }
  else {
    os.put(static_cast<char>(255));
    uint64_t value = boost::endian::native_to_big(number);
    os.write(reinterpret_cast<const char*>(&value), 8);
    return 9;
  }
}
 
template<typename Iterator>
uint64_t
readNonNegativeInteger(size_t size, Iterator& begin, Iterator end)
{
  if (size != 1 && size != 2 && size != 4 && size != 8) {
    NDN_THROW(Error("Invalid length " + to_string(size) + " for NonNegativeInteger"));
  }
 
  uint64_t number = 0;
  bool isOk = detail::ReadNumber<Iterator>()(size, begin, end, number);
  if (!isOk) {
    NDN_THROW(Error("Insufficient data during NonNegativeInteger parsing"));
  }
 
  return number;
}
 
constexpr size_t
sizeOfNonNegativeInteger(uint64_t integer) noexcept
{
  return integer <= std::numeric_limits<uint8_t>::max() ? 1 :
         integer <= std::numeric_limits<uint16_t>::max() ? 2 :
         integer <= std::numeric_limits<uint32_t>::max() ? 4 : 8;
}
 
inline size_t
writeNonNegativeInteger(std::ostream& os, uint64_t integer)
{
  if (integer <= std::numeric_limits<uint8_t>::max()) {
    os.put(static_cast<char>(integer));
    return 1;
  }
  else if (integer <= std::numeric_limits<uint16_t>::max()) {
    uint16_t value = boost::endian::native_to_big(static_cast<uint16_t>(integer));
    os.write(reinterpret_cast<const char*>(&value), 2);
    return 2;
  }
  else if (integer <= std::numeric_limits<uint32_t>::max()) {
    uint32_t value = boost::endian::native_to_big(static_cast<uint32_t>(integer));
    os.write(reinterpret_cast<const char*>(&value), 4);
    return 4;
  }
  else {
    uint64_t value = boost::endian::native_to_big(integer);
    os.write(reinterpret_cast<const char*>(&value), 8);
    return 8;
  }
}
 
} // namespace tlv
} // namespace ndn
 
#endif // NDN_CXX_ENCODING_TLV_HPP