tlv.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ndn/common.hpp"
 
namespace ndn {
 
namespace tlv {
 
constexpr uint32_t Interest = 0x05;  
constexpr uint32_t Data = 0x06;      
constexpr uint32_t Name = 0x07;  
constexpr uint32_t GenericNameComponent = 0x08;    
constexpr uint32_t ImplicitSha256Digest = 0x01;    
constexpr uint32_t ParametersSha256Digest = 0x02;  
constexpr uint32_t CanBePrefix = 0x21;            
constexpr uint32_t MustBeFresh = 0x12;            
constexpr uint32_t ForwardingHint = 0x1e;         
constexpr uint32_t Nonce = 0x0a;                  
constexpr uint32_t InterestLifetime = 0x0c;       
constexpr uint32_t HopLimit = 0x22;               
constexpr uint32_t ApplicationParameters = 0x24;  
constexpr uint32_t MetaInfo = 0x14;        
constexpr uint32_t Content = 0x15;         
constexpr uint32_t SignatureInfo = 0x16;   
constexpr uint32_t SignatureValue = 0x17;  
constexpr uint32_t ContentType = 0x18;      
constexpr uint32_t FreshnessPeriod = 0x19;  
constexpr uint32_t FinalBlockId = 0x1a;     
constexpr uint32_t SignatureType = 0x1b;  
constexpr uint32_t KeyLocator = 0x1c;     
constexpr uint32_t KeyDigest = 0x1d;      
constexpr uint32_t SignatureNonce = 0x26;          
constexpr uint32_t SignatureTime = 0x28;           
constexpr uint32_t SignatureSeqNum = 0x2a;         
constexpr uint32_t InterestSignatureInfo = 0x2c;   
constexpr uint32_t InterestSignatureValue = 0x2e;  
constexpr uint32_t ValidityPeriod = 0xfd;  
constexpr uint32_t NotBefore = 0xfe;       
constexpr uint32_t NotAfter = 0xff;        
}  // namespace tlv
 
class TlvEncoder {
public:
    TlvEncoder(uint8_t* buf, size_t capacity);
 
    Error writeVarNumber(uint64_t value);
 
    Error writeNonNegativeInteger(uint64_t value);
 
    Error writeType(uint32_t type);
 
    Error writeLength(size_t length);
 
    Error writeBytes(const uint8_t* data, size_t len);
 
    Error writeTlv(uint32_t type, const uint8_t* value, size_t valueLen);
 
    Error writeTlvNonNegativeInteger(uint32_t type, uint64_t value);
 
    size_t size() const { return pos_; }
 
    size_t remaining() const { return capacity_ - pos_; }
 
    uint8_t* current() { return buf_ + pos_; }
 
    size_t position() const { return pos_; }
 
    void setPosition(size_t pos) { pos_ = pos; }
 
private:
    uint8_t* buf_;     
    size_t capacity_;  
    size_t pos_ = 0;   
};
 
class TlvDecoder {
public:
    TlvDecoder(const uint8_t* buf, size_t len);
 
    Result<uint64_t> readVarNumber();
 
    Result<uint64_t> readNonNegativeInteger(size_t numBytes);
 
    Result<uint32_t> readType();
 
    Result<size_t> readLength();
 
    struct TlvHeader {
        uint32_t type;  
        size_t length;  
    };
 
    Result<TlvHeader> readTlvHeader();
 
    Error readBytes(uint8_t* out, size_t len);
 
    Error skip(size_t len);
 
    size_t remaining() const { return len_ - pos_; }
 
    const uint8_t* current() const { return buf_ + pos_; }
 
    bool hasMore() const { return pos_ < len_; }
 
    size_t position() const { return pos_; }
 
    void setPosition(size_t pos) { pos_ = pos; }
 
private:
    const uint8_t* buf_;  
    size_t len_;          
    size_t pos_ = 0;      
};
 
constexpr size_t varNumberSize(uint64_t value) {
    if (value <= 252) {
        return 1;
    }
    if (value <= 0xFFFF) {
        return 3;
    }
    if (value <= 0xFFFFFFFF) {
        return 5;
    }
    return 9;
}
 
constexpr size_t nonNegativeIntegerSize(uint64_t value) {
    if (value <= 0xFF) {
        return 1;
    }
    if (value <= 0xFFFF) {
        return 2;
    }
    if (value <= 0xFFFFFFFF) {
        return 4;
    }
    return 8;
}
 
}  // namespace ndn