1 files changed, 42 insertions, 51 deletions

diff --git a/libtransport/src/protocols/indexer.cc b/libtransport/src/protocols/indexer.cc
index ca12330a6..41465755b 100644
--- a/libtransport/src/protocols/indexer.cc
+++ b/libtransport/src/protocols/indexer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,67 +13,58 @@
  * limitations under the License.
  */
 
-#include <hicn/transport/utils/branch_prediction.h>
-
-#include <protocols/incremental_indexer.h>
+#include <implementation/socket_consumer.h>
+#include <protocols/errors.h>
 #include <protocols/indexer.h>
-#include <protocols/manifest_incremental_indexer.h>
-#include <protocols/protocol.h>
 
 namespace transport {
 namespace protocol {
 
-IndexManager::IndexManager(implementation::ConsumerSocket *icn_socket,
-                           TransportProtocol *transport, Reassembly *reassembly)
-    : indexer_(std::make_unique<IncrementalIndexer>(icn_socket, transport,
-                                                    reassembly)),
-      first_segment_received_(false),
-      icn_socket_(icn_socket),
-      transport_(transport),
-      reassembly_(reassembly) {}
-
-void IndexManager::onContentObject(core::Interest::Ptr &&interest,
-                                   core::ContentObject::Ptr &&content_object) {
-  if (first_segment_received_) {
-    indexer_->onContentObject(std::move(interest), std::move(content_object));
-  } else {
-    std::uint32_t segment_number = interest->getName().getSuffix();
+using namespace interface;
 
-    if (segment_number == 0) {
-      // Check if manifest
-      if (content_object->getPayloadType() == PayloadType::MANIFEST) {
-        IncrementalIndexer *indexer =
-            static_cast<IncrementalIndexer *>(indexer_.release());
-        indexer_ =
-            std::make_unique<ManifestIncrementalIndexer>(std::move(*indexer));
-        delete indexer;
-      }
+const constexpr uint32_t Indexer::invalid_index;
 
-      indexer_->onContentObject(std::move(interest), std::move(content_object));
-      auto it = interest_data_set_.begin();
-      while (it != interest_data_set_.end()) {
-        indexer_->onContentObject(
-            std::move(const_cast<core::Interest::Ptr &&>(it->first)),
-            std::move(const_cast<core::ContentObject::Ptr &&>(it->second)));
-        it = interest_data_set_.erase(it);
-      }
+Indexer::Indexer(implementation::ConsumerSocket *socket,
+                 TransportProtocol *transport)
+    : socket_(socket), transport_(transport) {
+  setVerifier();
+}
 
-      first_segment_received_ = true;
-    } else {
-      interest_data_set_.emplace(std::move(interest),
-                                 std::move(content_object));
-    }
+void Indexer::setVerifier() {
+  if (socket_) {
+    socket_->getSocketOption(GeneralTransportOptions::VERIFIER, verifier_);
   }
 }
 
-bool IndexManager::onKeyToVerify() { return indexer_->onKeyToVerify(); }
+void Indexer::applyPolicy(core::Interest &interest,
+                          core::ContentObject &content_object, bool reassembly,
+                          auth::VerificationPolicy policy) const {
+  DCHECK(reassembly_ != nullptr);
 
-void IndexManager::reset(std::uint32_t offset) {
-  indexer_ = std::make_unique<IncrementalIndexer>(icn_socket_, transport_,
-                                                  reassembly_);
-  first_segment_received_ = false;
-  interest_data_set_.clear();
+  switch (policy) {
+    case auth::VerificationPolicy::ACCEPT: {
+      if (reassembly) {
+        reassembly_->reassemble(content_object);
+      }
+      break;
+    }
+    case auth::VerificationPolicy::UNKNOWN:
+      if (reassembly && reassembly_->reassembleUnverified()) {
+        reassembly_->reassemble(content_object);
+      }
+      break;
+    case auth::VerificationPolicy::DROP:
+      transport_->onPacketDropped(
+          interest, content_object,
+          make_error_code(protocol_error::verification_failed));
+      break;
+    case auth::VerificationPolicy::ABORT: {
+      transport_->onContentReassembled(
+          make_error_code(protocol_error::session_aborted));
+      break;
+    }
+  }
 }
 
-}  // namespace protocol
-}  // namespace transport
+}  // end namespace protocol
+}  // end namespace transport