1 files changed, 301 insertions, 378 deletions

diff --git a/libtransport/src/core/packet.cc b/libtransport/src/core/packet.cc
index 51337201f..bcd0b8498 100644
--- a/libtransport/src/core/packet.cc
+++ b/libtransport/src/core/packet.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 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:
@@ -15,6 +15,7 @@
 
 #include <glog/logging.h>
 #include <hicn/transport/auth/crypto_hash.h>
+#include <hicn/transport/core/global_object_pool.h>
 #include <hicn/transport/core/packet.h>
 #include <hicn/transport/errors/malformed_packet_exception.h>
 #include <hicn/transport/utils/hash.h>
@@ -23,6 +24,7 @@ extern "C" {
 #ifndef _WIN32
 TRANSPORT_CLANG_DISABLE_WARNING("-Wextern-c-compat")
 #endif
+#include <hicn/base.h>
 #include <hicn/error.h>
 }
 
@@ -32,64 +34,70 @@ namespace core {
 
 const core::Name Packet::base_name("0::0|0");
 
-Packet::Packet(Format format, std::size_t additional_header_size)
+Packet::Packet(Type type, Format format, std::size_t additional_header_size)
     : utils::MemBuf(utils::MemBuf(CREATE, 2048)),
-      packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
-      header_offset_(0),
-      format_(format),
       payload_type_(PayloadType::UNSPECIFIED) {
-  setFormat(format_, additional_header_size);
+  /*
+   * We define the format and the storage area of the packet buffer we
+   * manipulate
+   */
+  setFormat(format);
+  setBuffer();
+  initializeType(type);  // type requires packet format
+  initialize(additional_header_size);
 }
 
-Packet::Packet(MemBuf &&buffer)
-    : utils::MemBuf(std::move(buffer)),
-      packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
-      header_offset_(0),
-      format_(getFormatFromBuffer(data(), length())),
-      payload_type_(PayloadType::UNSPECIFIED) {}
-
 Packet::Packet(CopyBufferOp, const uint8_t *buffer, std::size_t size)
     : utils::MemBuf(COPY_BUFFER, buffer, size),
-      packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
-      header_offset_(0),
-      format_(getFormatFromBuffer(data(), length())),
-      payload_type_(PayloadType::UNSPECIFIED) {}
+      payload_type_(PayloadType::UNSPECIFIED) {
+  setBuffer();
+  analyze();
+}
 
 Packet::Packet(WrapBufferOp, uint8_t *buffer, std::size_t length,
                std::size_t size)
     : utils::MemBuf(WRAP_BUFFER, buffer, length, size),
-      packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
-      header_offset_(0),
-      format_(getFormatFromBuffer(this->data(), this->length())),
-      payload_type_(PayloadType::UNSPECIFIED) {}
+      payload_type_(PayloadType::UNSPECIFIED) {
+  setBuffer();
+  analyze();
+}
 
-Packet::Packet(CreateOp, uint8_t *buffer, std::size_t length, std::size_t size,
-               Format format, std::size_t additional_header_size)
+Packet::Packet(CreateOp, Type type, uint8_t *buffer, std::size_t length,
+               std::size_t size, Format format,
+               std::size_t additional_header_size)
     : utils::MemBuf(WRAP_BUFFER, buffer, length, size),
-      packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
-      header_offset_(0),
-      format_(format),
       payload_type_(PayloadType::UNSPECIFIED) {
   clear();
-  setFormat(format_, additional_header_size);
+  setType(type);
+  setFormat(format);
+  setBuffer();
+  initialize(additional_header_size);
 }
 
-Packet::Packet(const Packet &other)
-    : utils::MemBuf(other),
-      packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
-      header_offset_(other.header_offset_),
-      format_(other.format_),
-      payload_type_(PayloadType::UNSPECIFIED) {}
+Packet::Packet(MemBuf &&buffer)
+    : utils::MemBuf(std::move(buffer)),
+      payload_type_(PayloadType::UNSPECIFIED) {
+  setBuffer();
+  analyze();
+}
+
+/*
+ * In the two following constructors, we inherit the pkbuf and only need to
+ * recompute the pointer fields, aka the buffer.
+ */
 
 Packet::Packet(Packet &&other)
     : utils::MemBuf(std::move(other)),
-      packet_start_(other.packet_start_),
-      header_offset_(other.header_offset_),
-      format_(other.format_),
+      pkbuf_(other.pkbuf_),
+      payload_type_(PayloadType::UNSPECIFIED) {
+  hicn_packet_reset(&other.pkbuf_);
+}
+
+Packet::Packet(const Packet &other)
+    : utils::MemBuf(other),
+      pkbuf_(other.pkbuf_),
       payload_type_(PayloadType::UNSPECIFIED) {
-  other.packet_start_ = nullptr;
-  other.format_ = HF_UNSPEC;
-  other.header_offset_ = 0;
+  setBuffer();
 }
 
 Packet::~Packet() {}
@@ -97,86 +105,82 @@ Packet::~Packet() {}
 Packet &Packet::operator=(const Packet &other) {
   if (this != &other) {
     *this = other;
-    packet_start_ = reinterpret_cast<hicn_header_t *>(writableData());
+    setBuffer();
   }
 
   return *this;
 }
 
-std::size_t Packet::getHeaderSizeFromBuffer(Format format,
-                                            const uint8_t *buffer) {
-  size_t header_length;
-
-  if (hicn_packet_get_header_length(format, (hicn_header_t *)buffer,
-                                    &header_length) < 0) {
-    throw errors::MalformedPacketException();
-  }
-
-  return header_length;
+std::shared_ptr<utils::MemBuf> Packet::acquireMemBufReference() {
+  return std::static_pointer_cast<utils::MemBuf>(shared_from_this());
 }
 
-bool Packet::isInterest(const uint8_t *buffer) {
-  bool is_interest = false;
-
-  if (TRANSPORT_EXPECT_FALSE(hicn_packet_test_ece(HF_INET6_TCP,
-                                                  (const hicn_header_t *)buffer,
-                                                  &is_interest) < 0)) {
-    throw errors::RuntimeException(
-        "Impossible to retrieve ece flag from packet");
-  }
+Packet::Format Packet::getFormat() const {
+  return hicn_packet_get_format(&pkbuf_);
+}
 
-  return !is_interest;
+void Packet::setFormat(Packet::Format format) {
+  hicn_packet_set_format(&pkbuf_, format);
 }
 
-void Packet::setFormat(Packet::Format format,
-                       std::size_t additional_header_size) {
-  format_ = format;
-  if (hicn_packet_init_header(format_, packet_start_) < 0) {
+void Packet::initialize(std::size_t additional_header_size) {
+  if (hicn_packet_init_header(&pkbuf_, additional_header_size) < 0) {
     throw errors::RuntimeException("Unexpected error initializing the packet.");
   }
 
-  auto header_size = getHeaderSizeFromFormat(format_);
-  assert(header_size <= tailroom());
+  auto header_size = getHeaderSizeFromFormat(getFormat());
+  DCHECK(header_size <= tailroom());
   append(header_size);
-
-  assert(additional_header_size <= tailroom());
+  DCHECK(additional_header_size <= tailroom());
   append(additional_header_size);
+}
 
-  header_offset_ = length();
+void Packet::analyze() {
+  if (hicn_packet_analyze(&pkbuf_) < 0)
+    throw errors::MalformedPacketException();
 }
 
-bool Packet::isInterest() { return Packet::isInterest(data()); }
+Packet::Type Packet::getType() const { return hicn_packet_get_type(&pkbuf_); }
 
-std::size_t Packet::getPayloadSizeFromBuffer(Format format,
-                                             const uint8_t *buffer) {
-  std::size_t payload_length;
-  if (TRANSPORT_EXPECT_FALSE(
-          hicn_packet_get_payload_length(format, (hicn_header_t *)buffer,
-                                         &payload_length) < 0)) {
-    throw errors::MalformedPacketException();
-  }
+void Packet::initializeType(Packet::Type type) {
+  hicn_packet_initialize_type(&pkbuf_, type);
+}
 
-  return payload_length;
+void Packet::setType(Packet::Type type) { hicn_packet_set_type(&pkbuf_, type); }
+
+void Packet::setBuffer() {
+  hicn_packet_set_buffer(&pkbuf_, writableData(),
+                         this->capacity() - this->headroom(), this->length());
 }
 
-std::size_t Packet::payloadSize() const {
-  std::size_t ret = 0;
+PayloadType Packet::getPayloadType() const {
+  if (payload_type_ == PayloadType::UNSPECIFIED) {
+    hicn_payload_type_t ret;
 
-  if (length()) {
-    ret = getPayloadSizeFromBuffer(format_,
-                                   reinterpret_cast<uint8_t *>(packet_start_));
+    if (hicn_packet_get_payload_type(&pkbuf_, &ret) < 0) {
+      throw errors::RuntimeException("Impossible to retrieve payload type.");
+    }
+
+    payload_type_ = (PayloadType)ret;
   }
 
-  return ret;
+  return payload_type_;
 }
 
-std::size_t Packet::headerSize() const {
-  if (header_offset_ == 0 && length()) {
-    const_cast<Packet *>(this)->header_offset_ = getHeaderSizeFromBuffer(
-        format_, reinterpret_cast<uint8_t *>(packet_start_));
+Packet &Packet::setPayloadType(PayloadType payload_type) {
+  if (hicn_packet_set_payload_type(&pkbuf_, hicn_payload_type_t(payload_type)) <
+      0) {
+    throw errors::RuntimeException("Error setting payload type of the packet.");
   }
 
-  return header_offset_;
+  payload_type_ = payload_type;
+  return *this;
+}
+
+std::unique_ptr<utils::MemBuf> Packet::getPayload() const {
+  auto ret = clone();
+  ret->trimStart(headerSize());
+  return ret;
 }
 
 Packet &Packet::appendPayload(std::unique_ptr<utils::MemBuf> &&payload) {
@@ -196,70 +200,71 @@ Packet &Packet::appendPayload(const uint8_t *buffer, std::size_t length) {
   return *this;
 }
 
-std::unique_ptr<utils::MemBuf> Packet::getPayload() const {
-  auto ret = clone();
-  ret->trimStart(headerSize());
-  return ret;
+std::size_t Packet::headerSize() const {
+  std::size_t len;
+  hicn_packet_get_header_len(&pkbuf_, &len);
+  return len;
 }
 
-Packet &Packet::updateLength(std::size_t length) {
-  std::size_t total_length = length;
+std::size_t Packet::payloadSize() const {
+  std::size_t len;
+  hicn_packet_get_payload_len(&pkbuf_, &len);
+  return len;
+}
 
-  const utils::MemBuf *current = this;
-  do {
-    total_length += current->length();
-    current = current->next();
-  } while (current != this);
+auth::CryptoHash Packet::computeDigest(auth::CryptoHashType algorithm) const {
+  auth::CryptoHash hash;
+  hash.setType(algorithm);
 
-  total_length -= headerSize();
+  // Copy IP+TCP/ICMP header before zeroing them
+  u8 header_copy[HICN_HDRLEN_MAX];
+  size_t header_len;
+  hicn_packet_save_header(&pkbuf_, header_copy, &header_len,
+                          /* copy_ah */ false);
+  const_cast<Packet *>(this)->resetForHash();
 
-  if (hicn_packet_set_payload_length(format_, packet_start_, total_length) <
-      0) {
-    throw errors::RuntimeException("Error setting the packet payload.");
-  }
+  hash.computeDigest(this);
+  hicn_packet_load_header(&pkbuf_, header_copy, header_len);
 
-  return *this;
+  return hash;
 }
 
-PayloadType Packet::getPayloadType() const {
-  if (payload_type_ == PayloadType::UNSPECIFIED) {
-    hicn_payload_type_t ret;
-    if (hicn_packet_get_payload_type(packet_start_, &ret) < 0) {
-      throw errors::RuntimeException("Impossible to retrieve payload type.");
-    }
+void Packet::reset() {
+  clear();
+  hicn_packet_reset(&pkbuf_);
+  setBuffer();
+  payload_type_ = PayloadType::UNSPECIFIED;
+  name_.clear();
 
-    payload_type_ = (PayloadType)ret;
+  if (isChained()) {
+    separateChain(next(), prev());
   }
-
-  return payload_type_;
 }
 
-Packet &Packet::setPayloadType(PayloadType payload_type) {
-  if (hicn_packet_set_payload_type(packet_start_,
-                                   hicn_payload_type_t(payload_type)) < 0) {
-    throw errors::RuntimeException("Error setting payload type of the packet.");
-  }
+bool Packet::isInterest() {
+  return hicn_packet_get_type(&pkbuf_) == HICN_PACKET_TYPE_INTEREST;
+}
 
-  payload_type_ = payload_type;
+Packet &Packet::updateLength(std::size_t length) {
+  std::size_t total_length = length;
 
-  return *this;
-}
+  const utils::MemBuf *current = this;
+  do {
+    total_length += current->length();
+    current = current->next();
+  } while (current != this);
 
-Packet::Format Packet::getFormat() const {
-  /**
-   * We check packet start because after a movement it will result in a nullptr
-   */
-  if (format_ == HF_UNSPEC && length()) {
-    if (hicn_packet_get_format(packet_start_, &format_) < 0) {
-      LOG(ERROR) << "Unexpected packet format HF_UNSPEC.";
-    }
+  if (hicn_packet_set_len(&pkbuf_, total_length) < 0) {
+    throw errors::RuntimeException("Error setting the packet length.");
   }
 
-  return format_;
-}
+  total_length -= headerSize();
 
-std::shared_ptr<utils::MemBuf> Packet::acquireMemBufReference() {
-  return std::static_pointer_cast<utils::MemBuf>(shared_from_this());
+  if (hicn_packet_set_payload_length(&pkbuf_, total_length) < 0) {
+    throw errors::RuntimeException("Error setting the packet payload length.");
+  }
+
+  return *this;
 }
 
 void Packet::dump() const {
@@ -274,364 +279,282 @@ void Packet::dump() const {
   } while (current != this);
 }
 
-void Packet::dump(uint8_t *buffer, std::size_t length) {
-  hicn_packet_dump(buffer, length);
-}
+void Packet::setChecksum() {
+  size_t header_len = 0;
+  if (hicn_packet_get_header_len(&pkbuf_, &header_len) < 0)
+    throw errors::RuntimeException(
+        "Error setting getting packet header length.");
 
-void Packet::setSignatureSize(std::size_t size_bytes) {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
+  uint16_t partial_csum = csum(data() + header_len, length() - header_len, 0);
 
-  int ret = hicn_packet_set_signature_size(format_, packet_start_, size_bytes);
+  for (utils::MemBuf *current = next(); current != this;
+       current = current->next()) {
+    partial_csum = csum(current->data(), current->length(), ~partial_csum);
+  }
 
-  if (ret < 0) {
-    throw errors::RuntimeException("Error setting signature size.");
+  if (hicn_packet_compute_header_checksum(&pkbuf_, partial_csum) < 0) {
+    throw errors::MalformedPacketException();
   }
 }
 
-void Packet::setSignatureSizeGap(std::size_t size_bytes) {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
+bool Packet::checkIntegrity() const {
+  size_t header_len = 0;
+  if (hicn_packet_get_header_len(&pkbuf_, &header_len) < 0)
+    throw errors::RuntimeException(
+        "Error setting getting packet header length.");
 
-  int ret = hicn_packet_set_signature_gap(format_, packet_start_,
-                                          (uint8_t)size_bytes);
+  uint16_t partial_csum = csum(data() + header_len, length() - header_len, 0);
 
-  if (ret < 0) {
-    throw errors::RuntimeException("Error setting signature size.");
+  for (const utils::MemBuf *current = next(); current != this;
+       current = current->next()) {
+    partial_csum = csum(current->data(), current->length(), ~partial_csum);
+  }
+
+  if (hicn_packet_check_integrity_no_payload(&pkbuf_, partial_csum) < 0) {
+    return false;
   }
+
+  return true;
 }
 
-uint8_t *Packet::getSignature() const {
-  if (!authenticationHeader()) {
+bool Packet::hasAH() const { return HICN_PACKET_FORMAT_IS_AH(getFormat()); }
+
+utils::MemBuf::Ptr Packet::getSignature() const {
+  if (!hasAH()) {
     throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
   uint8_t *signature;
-  int ret = hicn_packet_get_signature(format_, packet_start_, &signature);
+  int ret = hicn_packet_get_signature(&pkbuf_, &signature);
 
   if (ret < 0) {
     throw errors::RuntimeException("Error getting signature.");
   }
 
-  return signature;
+  utils::MemBuf::Ptr membuf = PacketManager<>::getInstance().getMemBuf();
+  membuf->append(getSignatureFieldSize());
+  memcpy(membuf->writableData(), signature, getSignatureFieldSize());
+
+  return membuf;
 }
 
-void Packet::setSignatureTimestamp(const uint64_t &timestamp) {
-  if (!authenticationHeader()) {
+std::size_t Packet::getSignatureFieldSize() const {
+  if (!hasAH()) {
     throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  int ret =
-      hicn_packet_set_signature_timestamp(format_, packet_start_, timestamp);
-
+  size_t field_size;
+  int ret = hicn_packet_get_signature_size(&pkbuf_, &field_size);
   if (ret < 0) {
-    throw errors::RuntimeException("Error setting the signature timestamp.");
+    throw errors::RuntimeException("Error reading signature field size");
   }
+  return field_size;
 }
 
-uint64_t Packet::getSignatureTimestamp() const {
-  if (!authenticationHeader()) {
+std::size_t Packet::getSignatureSize() const {
+  if (!hasAH()) {
     throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  uint64_t return_value;
-  int ret = hicn_packet_get_signature_timestamp(format_, packet_start_,
-                                                &return_value);
-
+  size_t padding;
+  int ret = hicn_packet_get_signature_padding(&pkbuf_, &padding);
   if (ret < 0) {
-    throw errors::RuntimeException("Error getting the signature timestamp.");
+    throw errors::RuntimeException("Error reading signature padding");
+  }
+
+  size_t size = getSignatureFieldSize() - padding;
+  if (size < 0) {
+    throw errors::RuntimeException("Error reading signature size");
   }
 
-  return return_value;
+  return size;
 }
 
-void Packet::setValidationAlgorithm(
-    const auth::CryptoSuite &validation_algorithm) {
-  if (!authenticationHeader()) {
+uint64_t Packet::getSignatureTimestamp() const {
+  if (!hasAH()) {
     throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  int ret = hicn_packet_set_validation_algorithm(format_, packet_start_,
-                                                 uint8_t(validation_algorithm));
-
+  uint64_t timestamp;
+  int ret = hicn_packet_get_signature_timestamp(&pkbuf_, &timestamp);
   if (ret < 0) {
-    throw errors::RuntimeException("Error setting the validation algorithm.");
+    throw errors::RuntimeException("Error getting the signature timestamp.");
   }
+  return timestamp;
 }
 
-auth::CryptoSuite Packet::getValidationAlgorithm() const {
-  if (!authenticationHeader()) {
+auth::KeyId Packet::getKeyId() const {
+  if (!hasAH()) {
     throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  uint8_t return_value;
-  int ret = hicn_packet_get_validation_algorithm(format_, packet_start_,
-                                                 &return_value);
-
+  auth::KeyId key_id;
+  int ret = hicn_packet_get_key_id(&pkbuf_, &key_id.first, &key_id.second);
   if (ret < 0) {
     throw errors::RuntimeException("Error getting the validation algorithm.");
   }
-
-  return auth::CryptoSuite(return_value);
+  return key_id;
 }
 
-void Packet::setKeyId(const auth::KeyId &key_id) {
-  if (!authenticationHeader()) {
+auth::CryptoSuite Packet::getValidationAlgorithm() const {
+  if (!hasAH()) {
     throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  int ret = hicn_packet_set_key_id(format_, packet_start_, key_id.first);
-
+  uint8_t return_value;
+  int ret = hicn_packet_get_validation_algorithm(&pkbuf_, &return_value);
   if (ret < 0) {
-    throw errors::RuntimeException("Error setting the key id.");
+    throw errors::RuntimeException("Error getting the validation algorithm.");
   }
+  return auth::CryptoSuite(return_value);
 }
 
-auth::KeyId Packet::getKeyId() const {
-  if (!authenticationHeader()) {
+void Packet::setSignature(const utils::MemBuf::Ptr &signature) {
+  if (!hasAH()) {
     throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  auth::KeyId return_value;
-  int ret = hicn_packet_get_key_id(format_, packet_start_, &return_value.first,
-                                   &return_value.second);
-
+  uint8_t *signature_field;
+  int ret = hicn_packet_get_signature(&pkbuf_, &signature_field);
   if (ret < 0) {
-    throw errors::RuntimeException("Error getting the validation algorithm.");
+    throw errors::RuntimeException("Error getting signature.");
   }
-
-  return return_value;
-}
-
-auth::CryptoHash Packet::computeDigest(auth::CryptoHashType algorithm) const {
-  auth::CryptoHash hash;
-  hash.setType(algorithm);
-
-  // Copy IP+TCP/ICMP header before zeroing them
-  hicn_header_t header_copy;
-
-  hicn_packet_copy_header(format_, packet_start_, &header_copy, false);
-
-  const_cast<Packet *>(this)->resetForHash();
-
-  hash.computeDigest(this);
-  hicn_packet_copy_header(format_, &header_copy, packet_start_, false);
-
-  return hash;
+  memcpy(signature_field, signature->data(), signature->length());
 }
 
-bool Packet::checkIntegrity() const {
-  uint16_t partial_csum =
-      csum(data() + HICN_V6_TCP_HDRLEN, length() - HICN_V6_TCP_HDRLEN, 0);
-
-  for (const utils::MemBuf *current = next(); current != this;
-       current = current->next()) {
-    partial_csum = csum(current->data(), current->length(), ~partial_csum);
-  }
-
-  if (hicn_packet_check_integrity_no_payload(format_, packet_start_,
-                                             partial_csum) < 0) {
-    return false;
+void Packet::setSignatureFieldSize(std::size_t size) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  return true;
-}
-
-void Packet::prependPayload(const uint8_t **buffer, std::size_t *size) {
-  auto last = prev();
-  auto to_copy = std::min(*size, last->tailroom());
-  std::memcpy(last->writableTail(), *buffer, to_copy);
-  last->append(to_copy);
-  *size -= to_copy;
-  *buffer += to_copy;
-}
-
-Packet &Packet::setSyn() {
-  if (hicn_packet_set_syn(format_, packet_start_) < 0) {
-    throw errors::RuntimeException("Error setting syn bit in the packet.");
+  int ret = hicn_packet_set_signature_size(&pkbuf_, size);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting signature size.");
   }
-
-  return *this;
 }
 
-Packet &Packet::resetSyn() {
-  if (hicn_packet_reset_syn(format_, packet_start_) < 0) {
-    throw errors::RuntimeException("Error resetting syn bit in the packet.");
+void Packet::setSignatureSize(std::size_t size) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  return *this;
-}
-
-bool Packet::testSyn() const {
-  bool res = false;
-  if (hicn_packet_test_syn(format_, packet_start_, &res) < 0) {
-    throw errors::RuntimeException("Error testing syn bit in the packet.");
+  size_t padding = getSignatureFieldSize() - size;
+  if (padding < 0) {
+    throw errors::RuntimeException("Error setting signature padding.");
   }
 
-  return res;
-}
-
-Packet &Packet::setAck() {
-  if (hicn_packet_set_ack(format_, packet_start_) < 0) {
-    throw errors::RuntimeException("Error setting ack bit in the packet.");
+  int ret = hicn_packet_set_signature_padding(&pkbuf_, padding);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting signature padding.");
   }
-
-  return *this;
 }
 
-Packet &Packet::resetAck() {
-  if (hicn_packet_reset_ack(format_, packet_start_) < 0) {
-    throw errors::RuntimeException("Error resetting ack bit in the packet.");
+void Packet::setSignatureTimestamp(const uint64_t &timestamp) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  return *this;
-}
-
-bool Packet::testAck() const {
-  bool res = false;
-  if (hicn_packet_test_ack(format_, packet_start_, &res) < 0) {
-    throw errors::RuntimeException("Error testing ack bit in the packet.");
+  int ret = hicn_packet_set_signature_timestamp(&pkbuf_, timestamp);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting the signature timestamp.");
   }
-
-  return res;
 }
 
-Packet &Packet::setRst() {
-  if (hicn_packet_set_rst(format_, packet_start_) < 0) {
-    throw errors::RuntimeException("Error setting rst bit in the packet.");
+void Packet::setKeyId(const auth::KeyId &key_id) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  return *this;
-}
-
-Packet &Packet::resetRst() {
-  if (hicn_packet_reset_rst(format_, packet_start_) < 0) {
-    throw errors::RuntimeException("Error resetting rst bit in the packet.");
+  int ret = hicn_packet_set_key_id(&pkbuf_, key_id.first, key_id.second);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting the key id.");
   }
-
-  return *this;
 }
 
-bool Packet::testRst() const {
-  bool res = false;
-  if (hicn_packet_test_rst(format_, packet_start_, &res) < 0) {
-    throw errors::RuntimeException("Error testing rst bit in the packet.");
+void Packet::setValidationAlgorithm(
+    const auth::CryptoSuite &validation_algorithm) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
   }
 
-  return res;
-}
-
-Packet &Packet::setFin() {
-  if (hicn_packet_set_fin(format_, packet_start_) < 0) {
-    throw errors::RuntimeException("Error setting fin bit in the packet.");
+  int ret = hicn_packet_set_validation_algorithm(&pkbuf_,
+                                                 uint8_t(validation_algorithm));
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting the validation algorithm.");
   }
-
-  return *this;
 }
 
-Packet &Packet::resetFin() {
-  if (hicn_packet_reset_fin(format_, packet_start_) < 0) {
-    throw errors::RuntimeException("Error resetting fin bit in the packet.");
-  }
-
-  return *this;
+Packet::Format Packet::toAHFormat(const Format &format) {
+  return hicn_get_ah_format(format);
 }
 
-bool Packet::testFin() const {
-  bool res = false;
-  if (hicn_packet_test_fin(format_, packet_start_, &res) < 0) {
-    throw errors::RuntimeException("Error testing fin bit in the packet.");
-  }
+Packet::Format Packet::getFormatFromBuffer(const uint8_t *buffer,
+                                           std::size_t length) {
+  hicn_packet_buffer_t pkbuf;
+  /* un-const to be able to use pkbuf API */
+  hicn_packet_set_buffer(&pkbuf, (uint8_t *)buffer, length, length);
+  if (hicn_packet_analyze(&pkbuf) < 0) throw errors::MalformedPacketException();
 
-  return res;
+  return hicn_packet_get_format(&pkbuf);
 }
 
-Packet &Packet::resetFlags() {
-  resetSyn();
-  resetAck();
-  resetRst();
-  resetFin();
-
-  return *this;
+std::size_t Packet::getHeaderSizeFromFormat(Format format,
+                                            std::size_t signature_size) {
+  std::size_t header_length;
+  hicn_packet_get_header_length_from_format(format, &header_length);
+  int is_ah = HICN_PACKET_FORMAT_IS_AH(format);
+  return is_ah * (header_length + signature_size) + (!is_ah) * header_length;
 }
 
-std::string Packet::printFlags() const {
-  std::string flags;
-
-  if (testSyn()) {
-    flags += "S";
-  }
-
-  if (testAck()) {
-    flags += "A";
-  }
+std::size_t Packet::getHeaderSizeFromBuffer(const uint8_t *buffer,
+                                            std::size_t length) {
+  size_t header_length;
 
-  if (testRst()) {
-    flags += "R";
-  }
+  hicn_packet_buffer_t pkbuf;
+  /* un-const to be able to use pkbuf API */
+  hicn_packet_set_buffer(&pkbuf, (uint8_t *)buffer, length, length);
+  if (hicn_packet_analyze(&pkbuf) < 0) throw errors::MalformedPacketException();
 
-  if (testFin()) {
-    flags += "F";
-  }
+  int rc = hicn_packet_get_header_len(&pkbuf, &header_length);
+  if (TRANSPORT_EXPECT_FALSE(rc < 0)) throw errors::MalformedPacketException();
 
-  return flags;
+  return header_length;
 }
 
-Packet &Packet::setSrcPort(uint16_t srcPort) {
-  if (hicn_packet_set_src_port(format_, packet_start_, srcPort) < 0) {
-    throw errors::RuntimeException("Error setting source port in the packet.");
-  }
+std::size_t Packet::getPayloadSizeFromBuffer(const uint8_t *buffer,
+                                             std::size_t length) {
+  std::size_t payload_length;
 
-  return *this;
-}
+  hicn_packet_buffer_t pkbuf;
+  /* un-const to be able to use pkbuf API */
+  hicn_packet_set_buffer(&pkbuf, (uint8_t *)buffer, length, length);
+  if (hicn_packet_analyze(&pkbuf) < 0) throw errors::MalformedPacketException();
 
-Packet &Packet::setDstPort(uint16_t dstPort) {
-  if (hicn_packet_set_dst_port(format_, packet_start_, dstPort) < 0) {
-    throw errors::RuntimeException(
-        "Error setting destination port in the packet.");
-  }
+  int rc = hicn_packet_get_payload_len(&pkbuf, &payload_length);
+  if (TRANSPORT_EXPECT_FALSE(rc < 0)) throw errors::MalformedPacketException();
 
-  return *this;
+  return payload_length;
 }
 
-uint16_t Packet::getSrcPort() const {
-  uint16_t port = 0;
-
-  if (hicn_packet_get_src_port(format_, packet_start_, &port) < 0) {
-    throw errors::RuntimeException("Error reading source port in the packet.");
-  }
-
-  return port;
+void Packet::dump(uint8_t *buffer, std::size_t length) {
+  hicn_packet_dump(buffer, length);
 }
 
-uint16_t Packet::getDstPort() const {
-  uint16_t port = 0;
-
-  if (hicn_packet_get_dst_port(format_, packet_start_, &port) < 0) {
-    throw errors::RuntimeException(
-        "Error reading destination port in the packet.");
-  }
-
-  return port;
+void Packet::prependPayload(const uint8_t **buffer, std::size_t *size) {
+  auto last = prev();
+  auto to_copy = std::min(*size, last->tailroom());
+  std::memcpy(last->writableTail(), *buffer, to_copy);
+  last->append(to_copy);
+  *size -= to_copy;
+  *buffer += to_copy;
 }
 
-Packet &Packet::setTTL(uint8_t hops) {
-  if (hicn_packet_set_hoplimit(packet_start_, hops) < 0) {
-    throw errors::RuntimeException("Error setting TTL.");
-  }
-
-  return *this;
+void Packet::saveHeader(u8 *header, size_t *header_len) {
+  hicn_packet_save_header(&pkbuf_, header, header_len, /* copy_ah */ false);
 }
 
-uint8_t Packet::getTTL() const {
-  uint8_t hops = 0;
-  if (hicn_packet_get_hoplimit(packet_start_, &hops) < 0) {
-    throw errors::RuntimeException("Error reading TTL.");
-  }
-
-  return hops;
+void Packet::loadHeader(u8 *header, size_t header_len) {
+  hicn_packet_load_header(&pkbuf_, header, header_len);
 }
 
 }  // end namespace core