interest.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ndn/common.hpp"
#include "ndn/name.hpp"
#include "ndn/signature.hpp"
 
namespace ndn {
 
class TlvEncoder;
class TlvDecoder;
 
class Interest {
public:
    Interest() = default;
 
    explicit Interest(const Name& name);
 
    static Result<Interest> fromWire(const uint8_t* buf, size_t len);
    Error encode(uint8_t* buf, size_t bufSize, size_t& encodedLen) const;
    const Name& name() const { return name_; }
 
    Name& name() { return name_; }
 
    Interest& setName(const Name& name);
 
    Error setName(std::string_view uri);
    std::optional<uint32_t> nonce() const { return nonce_; }
 
    Interest& setNonce(uint32_t nonce);
 
    Interest& generateNonce();
    uint32_t lifetime() const { return lifetime_; }
 
    Interest& setLifetime(uint32_t lifetimeMs);
    std::optional<uint8_t> hopLimit() const { return hopLimit_; }
 
    Interest& setHopLimit(uint8_t limit);
 
    Interest& decrementHopLimit();
    bool canBePrefix() const { return canBePrefix_; }
 
    Interest& setCanBePrefix(bool canBePrefix);
    bool mustBeFresh() const { return mustBeFresh_; }
 
    Interest& setMustBeFresh(bool mustBeFresh);
    Error addForwardingHint(const Name& name);
 
    Error addForwardingHint(std::string_view uri);
 
    size_t forwardingHintCount() const { return fwHintCount_; }
 
    const Name* forwardingHint(size_t index) const;
 
    void clearForwardingHints();
 
    bool hasForwardingHint() const { return fwHintCount_ > 0; }
    const uint8_t* applicationParameters() const {
        return appParamsLen_ > 0 ? appParams_ : nullptr;
    }
 
    size_t applicationParametersSize() const { return appParamsLen_; }
 
    Interest& setApplicationParameters(const uint8_t* params, size_t len);
    bool isSigned() const { return signatureSize_ > 0; }
 
    SignatureType signatureType() const { return signatureType_; }
 
    const uint8_t* signatureNonce() const { return hasSignatureNonce_ ? signatureNonce_ : nullptr; }
 
    std::optional<uint64_t> signatureTime() const { return signatureTime_; }
 
    std::optional<uint64_t> signatureSeqNum() const { return signatureSeqNum_; }
 
    Interest& setSignatureSeqNum(uint64_t seqNum);
 
    const Name* keyLocator() const { return hasKeyLocator_ ? &keyLocator_ : nullptr; }
 
    bool hasKeyLocator() const { return hasKeyLocator_; }
 
    Interest& setKeyLocator(const Name& name);
 
    Interest& clearKeyLocator();
 
    const uint8_t* signatureValue() const { return signatureValue_.data(); }
 
    size_t signatureValueSize() const { return signatureSize_; }
 
    Error signWithDigestSha256();
 
    Error signWithHmac(const uint8_t* key, size_t keyLen);
 
    bool verifyDigestSha256() const;
 
    bool verifyHmac(const uint8_t* key, size_t keyLen) const;
 
    Error signWithEcdsa(const uint8_t* privKey);
 
    bool verifyEcdsa(const uint8_t* pubKey) const;
private:
    Error encodeSignedPortion(uint8_t* buf, size_t bufSize, size_t& encodedLen) const;
 
    void generateSignatureNonce();
 
    Error encodeInterestSignatureInfo(TlvEncoder& encoder) const;
 
    static Error parseSignatureInfo(TlvDecoder& decoder, size_t elemLen, Interest& interest);
 
    static constexpr size_t APP_PARAMS_MAX_SIZE = 200;
 
    static constexpr size_t SIGNATURE_NONCE_SIZE = 8;
 
    static constexpr size_t FW_HINT_MAX_COUNT = LINK_MAX_DELEGATIONS;
 
    Name name_;                                         
    std::optional<uint32_t> nonce_;                     
    uint32_t lifetime_ = INTEREST_DEFAULT_LIFETIME_MS;  
    std::optional<uint8_t> hopLimit_;                   
    bool canBePrefix_ = false;                          
    bool mustBeFresh_ = false;                          
    std::array<Name, FW_HINT_MAX_COUNT> fwHints_{};     
    size_t fwHintCount_ = 0;                            
    uint8_t appParams_[APP_PARAMS_MAX_SIZE] = {};       
    size_t appParamsLen_ = 0;                           
 
    // Signature-related fields
    SignatureType signatureType_ = SignatureType::DigestSha256;  
    uint8_t signatureNonce_[SIGNATURE_NONCE_SIZE] = {};          
    bool hasSignatureNonce_ = false;                             
    std::optional<uint64_t> signatureTime_;                      
    std::optional<uint64_t> signatureSeqNum_;                    
    Name keyLocator_;                                            
    bool hasKeyLocator_ = false;                                 
    std::array<uint8_t, SIGNATURE_MAX_SIZE> signatureValue_{};   
    size_t signatureSize_ = 0;                                   
};
 
}  // namespace ndn