aboutsummaryrefslogtreecommitdiffstats
path: root/libtransport/src/core/manifest.h
diff options
context:
space:
mode:
Diffstat (limited to 'libtransport/src/core/manifest.h')
-rw-r--r--libtransport/src/core/manifest.h175
1 files changed, 41 insertions, 134 deletions
diff --git a/libtransport/src/core/manifest.h b/libtransport/src/core/manifest.h
index 5bdbfc6ff..40832bb6b 100644
--- a/libtransport/src/core/manifest.h
+++ b/libtransport/src/core/manifest.h
@@ -17,165 +17,72 @@
#include <core/manifest_format.h>
#include <glog/logging.h>
-#include <hicn/transport/core/content_object.h>
-#include <hicn/transport/core/name.h>
-
-#include <set>
+#include <hicn/transport/auth/verifier.h>
+#include <hicn/transport/core/global_object_pool.h>
+#include <hicn/transport/core/packet.h>
namespace transport {
-
namespace core {
-using typename core::Name;
-using typename core::Packet;
-using typename core::PayloadType;
-
-template <typename Base, typename FormatTraits, typename ManifestImpl>
-class Manifest : public Base {
- static_assert(std::is_base_of<Packet, Base>::value,
- "Base must inherit from packet!");
-
+template <typename FormatTraits>
+class Manifest : public FormatTraits::Encoder, public FormatTraits::Decoder {
public:
- // core::ContentObjectManifest::Ptr
+ using Ptr = std::shared_ptr<Manifest>;
using Encoder = typename FormatTraits::Encoder;
using Decoder = typename FormatTraits::Decoder;
- Manifest(Packet::Format format, std::size_t signature_size = 0)
- : Base(format, signature_size),
- encoder_(*this, signature_size),
- decoder_(*this) {
- DCHECK(_is_ah(format));
- Base::setPayloadType(PayloadType::MANIFEST);
- }
+ using Hash = typename FormatTraits::Hash;
+ using HashType = typename FormatTraits::HashType;
+ using Suffix = typename FormatTraits::Suffix;
+ using SuffixList = typename FormatTraits::SuffixList;
+ using HashEntry = std::pair<auth::CryptoHashType, std::vector<uint8_t>>;
- Manifest(Packet::Format format, const core::Name &name,
- std::size_t signature_size = 0)
- : Base(name, format, signature_size),
- encoder_(*this, signature_size),
- decoder_(*this) {
- DCHECK(_is_ah(format));
- Base::setPayloadType(PayloadType::MANIFEST);
+ Manifest(Packet::Ptr packet, bool clear = false)
+ : Encoder(packet, clear), Decoder(packet), packet_(packet) {
+ packet->setPayloadType(PayloadType::MANIFEST);
}
- template <typename T>
- Manifest(T &&base)
- : Base(std::forward<T &&>(base)),
- encoder_(*this, 0, false),
- decoder_(*this) {
- Base::setPayloadType(PayloadType::MANIFEST);
- }
-
- // Useful for decoding manifests while avoiding packet copy
- template <typename T>
- Manifest(T &base)
- : Base(base.getFormat()), encoder_(base, 0, false), decoder_(base) {}
-
virtual ~Manifest() = default;
- std::size_t estimateManifestSize(std::size_t additional_entries = 0) {
- return static_cast<ManifestImpl &>(*this).estimateManifestSizeImpl(
- additional_entries);
- }
-
- /*
- * After the call to encode, users MUST call clear before adding data
- * to the manifest.
- */
- Manifest &encode() { return static_cast<ManifestImpl &>(*this).encodeImpl(); }
-
- Manifest &decode() {
- Manifest::decoder_.decode();
-
- manifest_type_ = decoder_.getType();
- manifest_transport_type_ = decoder_.getTransportType();
- hash_algorithm_ = decoder_.getHashAlgorithm();
- is_last_ = decoder_.getIsLast();
+ Packet::Ptr getPacket() const { return packet_; }
- return static_cast<ManifestImpl &>(*this).decodeImpl();
+ void setHeaders(ManifestType type, uint8_t max_capacity, HashType hash_algo,
+ bool is_last, const Name &base_name) {
+ Encoder::setType(type);
+ Encoder::setMaxCapacity(max_capacity);
+ Encoder::setHashAlgorithm(hash_algo);
+ Encoder::setIsLast(is_last);
+ Encoder::setBaseName(base_name);
}
- static std::size_t manifestHeaderSize(
- interface::ProductionProtocolAlgorithms transport_type =
- interface::ProductionProtocolAlgorithms::UNKNOWN) {
- return Encoder::manifestHeaderSize(transport_type);
- }
+ auth::Verifier::SuffixMap getSuffixMap() const {
+ auth::Verifier::SuffixMap suffix_map;
- static std::size_t manifestEntrySize() {
- return Encoder::manifestEntrySize();
- }
+ HashType hash_algo = Decoder::getHashAlgorithm();
+ SuffixList suffix_list = Decoder::getEntries();
- Manifest &setType(ManifestType type) {
- manifest_type_ = type;
- encoder_.setType(manifest_type_);
- return *this;
- }
+ for (auto it = suffix_list.begin(); it != suffix_list.end(); ++it) {
+ Hash hash(it->second, Hash::getSize(hash_algo), hash_algo);
+ suffix_map[it->first] = hash;
+ }
- Manifest &setHashAlgorithm(auth::CryptoHashType hash_algorithm) {
- hash_algorithm_ = hash_algorithm;
- encoder_.setHashAlgorithm(hash_algorithm_);
- return *this;
+ return suffix_map;
}
- auth::CryptoHashType getHashAlgorithm() const { return hash_algorithm_; }
-
- ManifestType getType() const { return manifest_type_; }
-
- interface::ProductionProtocolAlgorithms getTransportType() const {
- return manifest_transport_type_;
- }
-
- bool getIsLast() const { return is_last_; }
-
- Manifest &setVersion(ManifestVersion version) {
- encoder_.setVersion(version);
- return *this;
- }
-
- Manifest &setParamsBytestream(const ParamsBytestream &params) {
- manifest_transport_type_ =
- interface::ProductionProtocolAlgorithms::BYTE_STREAM;
- encoder_.setParamsBytestream(params);
- return *this;
- }
-
- Manifest &setParamsRTC(const ParamsRTC &params) {
- manifest_transport_type_ =
- interface::ProductionProtocolAlgorithms::RTC_PROD;
- encoder_.setParamsRTC(params);
- return *this;
- }
-
- ParamsBytestream getParamsBytestream() const {
- return decoder_.getParamsBytestream();
- }
-
- ParamsRTC getParamsRTC() const { return decoder_.getParamsRTC(); }
-
- ManifestVersion getVersion() const { return decoder_.getVersion(); }
-
- Manifest &setIsLast(bool is_last) {
- encoder_.setIsLast(is_last);
- is_last_ = is_last;
- return *this;
- }
-
- Manifest &clear() {
- encoder_.clear();
- decoder_.clear();
- return *this;
- }
+ static Manifest::Ptr createContentManifest(Packet::Format format,
+ const core::Name &manifest_name,
+ std::size_t signature_size) {
+ ContentObject::Ptr content_object =
+ core::PacketManager<>::getInstance().getPacket<ContentObject>(
+ format, signature_size);
+ content_object->setName(manifest_name);
+ return std::make_shared<Manifest>(content_object, true);
+ };
protected:
- ManifestType manifest_type_;
- interface::ProductionProtocolAlgorithms manifest_transport_type_;
- auth::CryptoHashType hash_algorithm_;
- bool is_last_;
-
- Encoder encoder_;
- Decoder decoder_;
+ Packet::Ptr packet_;
};
} // end namespace core
-
} // end namespace transport