refactor(lib, hicn-light, vpp, hiperf): HICN-723

 - move infra data structure into the shared lib
 - new packet cache using double hashing and lookup on prefix suffix
 - testing updates
 - authenticated requests using interest manifests

Co-authored-by: Mauro Sardara <msardara@cisco.com>
Co-authored-by: Jordan Augé <jordan.auge+fdio@cisco.com>
Co-authored-by: Michele Papalini <micpapal@cisco.com>
Co-authored-by: Olivier Roques <oroques+fdio@cisco.com>
Co-authored-by: Enrico Loparco <eloparco@cisco.com>

Change-Id: Iaddebfe6aa5279ea8553433b0f519578f6b9ccd9
Signed-off-by: Luca Muscariello <muscariello@ieee.org>

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