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, 22 insertions, 59 deletions

diff --git a/libtransport/src/protocols/rtc/rtc_verifier.h b/libtransport/src/protocols/rtc/rtc_verifier.h
index 098984057..c83faf08a 100644
--- a/libtransport/src/protocols/rtc/rtc_verifier.h
+++ b/libtransport/src/protocols/rtc/rtc_verifier.h
@@ -27,19 +27,16 @@ namespace rtc {
 class RTCVerifier {
  public:
   explicit RTCVerifier(std::shared_ptr<auth::Verifier> verifier,
-                       uint32_t max_unverified_interval,
-                       double max_unverified_ratio);
+                       uint32_t factor_relevant, uint32_t factor_alert);
 
   virtual ~RTCVerifier() = default;
 
   void setState(std::shared_ptr<RTCState> rtc_state);
-
   void setVerifier(std::shared_ptr<auth::Verifier> verifier);
+  void setFactorRelevant(uint32_t factor_relevant);
+  void setFactorAlert(uint32_t factor_alert);
 
-  void setMaxUnverifiedInterval(uint32_t max_unverified_interval);
-
-  void setMaxUnverifiedRatio(double max_unverified_ratio);
-
+  auth::VerificationPolicy verify(core::Interest &interest);
   auth::VerificationPolicy verify(core::ContentObject &content_object,
                                   bool is_fec = false);
   auth::VerificationPolicy verifyProbe(core::ContentObject &content_object);
@@ -51,81 +48,47 @@ class RTCVerifier {
   auth::VerificationPolicy processManifest(core::ContentObject &content_object);
 
   void onDataRecoveredFec(uint32_t suffix);
-  void onJumpForward(uint32_t next_suffix);
-
-  double getBufferRatio() const;
 
  protected:
-  struct Packet;
-  using Timestamp = uint64_t;
+  using Index = uint64_t;
+  using Packet = std::pair<Index, auth::Suffix>;
   using PacketSet = std::set<Packet>;
 
-  struct Packet {
-    auth::Suffix suffix;
-    Timestamp timestamp;
-    size_t size;
-
-    bool operator==(const Packet &b) const {
-      return timestamp == b.timestamp && suffix == b.suffix;
-    }
-    bool operator<(const Packet &b) const {
-      return timestamp == b.timestamp ? suffix < b.suffix
-                                      : timestamp < b.timestamp;
-    }
-  };
-
   class Packets {
    public:
-    virtual std::pair<PacketSet::iterator, bool> add(const Packet &packet);
-    virtual PacketSet::iterator remove(PacketSet::iterator packet_it);
-    const PacketSet &set() const;
-    size_t size() const;
-
-   protected:
-    PacketSet packets_;
-    size_t size_;
-  };
-
-  class PacketsVerif : public Packets {};
-
-  class PacketsUnverif : public Packets {
-   public:
-    using Packets::add;
     std::pair<PacketSet::iterator, bool> add(const Packet &packet,
                                              const auth::CryptoHash &digest);
-    PacketSet::iterator remove(PacketSet::iterator packet_it) override;
-    PacketSet::iterator packetIt(auth::Suffix suffix);
+    PacketSet::iterator remove(PacketSet::iterator packet_it);
+    const PacketSet &set() const;
+    PacketSet::iterator packet(auth::Suffix suffix);
     const auth::Verifier::SuffixMap &suffixMap() const;
 
    private:
+    PacketSet packets_;
     std::unordered_map<auth::Suffix, PacketSet::iterator> packets_map_;
-    auth::Verifier::SuffixMap digests_map_;
+    auth::Verifier::SuffixMap suffix_map_;
   };
 
   // The RTC state.
   std::shared_ptr<RTCState> rtc_state_;
   // The verifier instance.
   std::shared_ptr<auth::Verifier> verifier_;
-  // Window to consider when verifying packets.
-  uint32_t max_unverified_interval_;
-  // Ratio of unverified packets over which an alert is triggered.
-  double max_unverified_ratio_;
-  // The suffix of the last processed manifest.
-  auth::Suffix last_manifest_;
+  // Used to compute the relevance windows size (in packets).
+  uint32_t factor_relevant_;
+  // Used to compute the alert threshold (in packets).
+  uint32_t factor_alert_;
+  // The maximum number of entries a manifest can contain.
+  uint8_t manifest_max_capacity_;
   // Hash algorithm used by manifests.
   auth::CryptoHashType manifest_hash_algo_;
   // Digests extracted from all manifests received.
   auth::Verifier::SuffixMap manifest_digests_;
-  // Verified packets with timestamp >= now - max_unverified_interval_.
-  PacketsVerif packets_verif_;
-  // Unverified packets with timestamp >= now - max_unverified_interval_.
-  PacketsUnverif packets_unverif_;
-  // Unverified erased packets with timestamp < now - max_unverified_interval_.
+  // The number of data packets processed.
+  Index current_index_;
+  // Unverified packets with index in relevance window.
+  Packets packets_unverif_;
+  // Unverified erased packets with index outside relevance window.
   std::unordered_set<auth::Suffix> packets_unverif_erased_;
-
-  // Flushes all packets with timestamp < now - max_unverified_interval_.
-  // Returns the timestamp of the oldest packet, verified or not.
-  Timestamp flush_packets(Timestamp now);
 };
 
 }  // namespace rtc