diff --git a/.gitignore b/.gitignore
index 23cdc5d..9d79cbd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -93,29 +93,7 @@
 
 iocore/net/test_certlookup
 iocore/net/test_UDPNet
-iocore/net/quic/test_QUICAckFrameCreator
-iocore/net/quic/test_QUICAddrVerifyState
-iocore/net/quic/test_QUICAltConnectionManager
-iocore/net/quic/test_QUICFlowController
-iocore/net/quic/test_QUICFrame
-iocore/net/quic/test_QUICFrameDispatcher
-iocore/net/quic/test_QUICFrameRetransmitter
-iocore/net/quic/test_QUICHandshake
-iocore/net/quic/test_QUICHandshakeProtocol
-iocore/net/quic/test_QUICIncomingFrameBuffer
-iocore/net/quic/test_QUICInvariants
-iocore/net/quic/test_QUICKeyGenerator
-iocore/net/quic/test_QUICLossDetector
-iocore/net/quic/test_QUICPacket
-iocore/net/quic/test_QUICPacketHeaderProtector
-iocore/net/quic/test_QUICPacketFactory
-iocore/net/quic/test_QUICStream
-iocore/net/quic/test_QUICStreamManager
-iocore/net/quic/test_QUICStreamState
-iocore/net/quic/test_QUICTransportParameters
-iocore/net/quic/test_QUICType
-iocore/net/quic/test_QUICTypeUtil
-iocore/net/quic/test_QUICVersionNegotiator
+iocore/net/quic/test_QUIC*
 iocore/aio/test_AIO
 iocore/eventsystem/test_IOBuffer
 iocore/eventsystem/test_EventSystem
diff --git a/iocore/eventsystem/I_Thread.h b/iocore/eventsystem/I_Thread.h
index 116463f..2ab995a 100644
--- a/iocore/eventsystem/I_Thread.h
+++ b/iocore/eventsystem/I_Thread.h
@@ -123,11 +123,9 @@
   ProxyAllocator http2ClientSessionAllocator;
   ProxyAllocator http2StreamAllocator;
   ProxyAllocator quicClientSessionAllocator;
-  ProxyAllocator quicHandshakeAllocator;
   ProxyAllocator quicBidiStreamAllocator;
   ProxyAllocator quicSendStreamAllocator;
   ProxyAllocator quicReceiveStreamAllocator;
-  ProxyAllocator quicStreamManagerAllocator;
   ProxyAllocator httpServerSessionAllocator;
   ProxyAllocator hdrHeapAllocator;
   ProxyAllocator strHeapAllocator;
diff --git a/iocore/net/P_QUICNetVConnection.h b/iocore/net/P_QUICNetVConnection.h
index 925a4fe..d39824e 100644
--- a/iocore/net/P_QUICNetVConnection.h
+++ b/iocore/net/P_QUICNetVConnection.h
@@ -54,14 +54,18 @@
 #include "quic/QUICHandshakeProtocol.h"
 #include "quic/QUICAckFrameCreator.h"
 #include "quic/QUICPinger.h"
+#include "quic/QUICPadder.h"
 #include "quic/QUICLossDetector.h"
 #include "quic/QUICStreamManager.h"
 #include "quic/QUICAltConnectionManager.h"
 #include "quic/QUICPathValidator.h"
+#include "quic/QUICPathManager.h"
 #include "quic/QUICApplicationMap.h"
 #include "quic/QUICPacketReceiveQueue.h"
 #include "quic/QUICAddrVerifyState.h"
 #include "quic/QUICPacketProtectionKeyInfo.h"
+#include "quic/QUICContext.h"
+#include "quic/QUICTokenCreator.h"
 
 // Size of connection ids for debug log : e.g. aaaaaaaa-bbbbbbbb\0
 static constexpr size_t MAX_CIDS_SIZE = 8 + 1 + 8 + 1;
@@ -127,11 +131,7 @@
  *    WRITE:
  *      Do nothing
  **/
-class QUICNetVConnection : public UnixNetVConnection,
-                           public QUICConnection,
-                           public QUICFrameGenerator,
-                           public RefCountObj,
-                           public ALPNSupport
+class QUICNetVConnection : public UnixNetVConnection, public QUICConnection, public RefCountObj, public ALPNSupport
 {
   using super = UnixNetVConnection; ///< Parent type.
 
@@ -145,6 +145,9 @@
   // accept new conn_id
   int acceptEvent(int event, Event *e);
 
+  // NetVConnection
+  void set_local_addr() override;
+
   // UnixNetVConnection
   void reenable(VIO *vio) override;
   VIO *do_io_read(Continuation *c, int64_t nbytes, MIOBuffer *buf) override;
@@ -197,11 +200,6 @@
   std::vector<QUICFrameType> interests() override;
   QUICConnectionErrorUPtr handle_frame(QUICEncryptionLevel level, const QUICFrame &frame) override;
 
-  // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
-  QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
-
   int in_closed_queue = 0;
 
   bool shouldDestroy();
@@ -231,7 +229,6 @@
   QUICPacketFactory _packet_factory;
   QUICFrameFactory _frame_factory;
   QUICAckFrameManager _ack_frame_manager;
-  QUICPinger _pinger;
   QUICPacketHeaderProtector _ph_protector;
   QUICRTTMeasure _rtt_measure;
   QUICApplicationMap *_application_map = nullptr;
@@ -240,6 +237,8 @@
 
   // TODO: use custom allocator and make them std::unique_ptr or std::shared_ptr
   // or make them just member variables.
+  QUICPinger *_pinger                               = nullptr;
+  QUICPadder *_padder                               = nullptr;
   QUICHandshake *_handshake_handler                 = nullptr;
   QUICHandshakeProtocol *_hs_protocol               = nullptr;
   QUICLossDetector *_loss_detector                  = nullptr;
@@ -251,8 +250,10 @@
   QUICConnectionTable *_ctable                      = nullptr;
   QUICAltConnectionManager *_alt_con_manager        = nullptr;
   QUICPathValidator *_path_validator                = nullptr;
+  QUICPathManager *_path_manager                    = nullptr;
+  QUICTokenCreator *_token_creator                  = nullptr;
 
-  std::vector<QUICFrameGenerator *> _frame_generators;
+  QUICFrameGeneratorManager _frame_generators;
 
   QUICPacketReceiveQueue _packet_recv_queue = {this->_packet_factory, this->_ph_protector};
 
@@ -276,11 +277,6 @@
   void _close_closed_event(Event *data);
   Event *_closed_event = nullptr;
 
-  void _schedule_path_validation_timeout(ink_hrtime interval);
-  void _unschedule_path_validation_timeout();
-  void _close_path_validation_timeout(Event *data);
-  Event *_path_validation_timeout = nullptr;
-
   void _schedule_ack_manager_periodic(ink_hrtime interval);
   void _unschedule_ack_manager_periodic();
   Event *_ack_manager_periodic = nullptr;
@@ -296,7 +292,6 @@
                                   std::vector<QUICFrameInfo> &frames);
   QUICPacketUPtr _packetize_frames(QUICEncryptionLevel level, uint64_t max_packet_size, std::vector<QUICFrameInfo> &frames);
   void _packetize_closing_frame();
-  Ptr<IOBufferBlock> _generate_padding_frame(size_t frame_size);
   QUICPacketUPtr _build_packet(QUICEncryptionLevel level, Ptr<IOBufferBlock> parent_block, bool retransmittable, bool probing,
                                bool crypto);
 
@@ -324,7 +319,7 @@
                                  const std::shared_ptr<const QUICTransportParameters> &remote_tp);
   void _handle_error(QUICConnectionErrorUPtr error);
   QUICPacketUPtr _dequeue_recv_packet(QUICPacketCreationResult &result);
-  void _validate_new_path();
+  void _validate_new_path(const QUICPath &path);
 
   int _complete_handshake_if_possible();
   void _switch_to_handshake_state();
@@ -337,7 +332,6 @@
   void _start_application();
 
   void _handle_periodic_ack_event();
-  void _handle_path_validation_timeout(Event *data);
   void _handle_idle_timeout();
 
   QUICConnectionErrorUPtr _handle_frame(const QUICNewConnectionIdFrame &frame);
@@ -352,19 +346,16 @@
   QUICPacketUPtr _the_final_packet = QUICPacketFactory::create_null_packet();
   QUICStatelessResetToken _reset_token;
 
-  ats_unique_buf _av_token       = {nullptr};
-  size_t _av_token_len           = 0;
-  bool _is_resumption_token_sent = false;
+  ats_unique_buf _av_token = {nullptr};
+  size_t _av_token_len     = 0;
 
   uint64_t _stream_frames_sent = 0;
+  uint32_t _seq_num            = 0;
 
   // TODO: Source addresses verification through an address validation token
-  bool _has_ack_eliciting_packet_out = true;
-
   QUICAddrVerifyState _verfied_state;
 
-  // QUICFrameGenerator
-  void _on_frame_lost(QUICFrameInformationUPtr &info) override;
+  std::unique_ptr<QUICContextImpl> _context;
 };
 
 typedef int (QUICNetVConnection::*QUICNetVConnHandler)(int, void *);
diff --git a/iocore/net/QUICNetVConnection.cc b/iocore/net/QUICNetVConnection.cc
index 7070727..22d2e61 100644
--- a/iocore/net/QUICNetVConnection.cc
+++ b/iocore/net/QUICNetVConnection.cc
@@ -64,7 +64,7 @@
 static constexpr ink_hrtime WRITE_READY_INTERVAL      = HRTIME_MSECONDS(2);
 static constexpr uint32_t PACKET_PER_EVENT            = 256;
 static constexpr uint32_t MAX_CONSECUTIVE_STREAMS     = 8; ///< Interrupt sending STREAM frames to send ACK frame
-static constexpr uint32_t MIN_PKT_PAYLOAD_LEN         = 3; ///< Minimum payload length for sampling for header protection
+// static constexpr uint32_t MIN_PKT_PAYLOAD_LEN         = 3; ///< Minimum payload length for sampling for header protection
 
 static constexpr uint32_t STATE_CLOSING_MAX_SEND_PKT_NUM  = 8; ///< Max number of sending packets which contain a closing frame.
 static constexpr uint32_t STATE_CLOSING_MAX_RECV_PKT_WIND = 1 << STATE_CLOSING_MAX_SEND_PKT_NUM;
@@ -178,83 +178,21 @@
     }
   }
 
+  uint8_t
+  active_cid_limit() const override
+  {
+    if (this->_ctx == NET_VCONNECTION_IN) {
+      return this->_params->active_cid_limit_in();
+    } else {
+      return this->_params->active_cid_limit_out();
+    }
+  }
+
 private:
   const QUICConfigParams *_params;
   NetVConnectionContext_t _ctx;
 };
 
-class QUICCCConfigQCP : public QUICCCConfig
-{
-public:
-  QUICCCConfigQCP(const QUICConfigParams *params) : _params(params) {}
-
-  uint32_t
-  max_datagram_size() const override
-  {
-    return this->_params->cc_max_datagram_size();
-  }
-
-  uint32_t
-  initial_window() const override
-  {
-    return this->_params->cc_initial_window();
-  }
-
-  uint32_t
-  minimum_window() const override
-  {
-    return this->_params->cc_minimum_window();
-  }
-
-  float
-  loss_reduction_factor() const override
-  {
-    return this->_params->cc_loss_reduction_factor();
-  }
-
-  uint32_t
-  persistent_congestion_threshold() const override
-  {
-    return this->_params->cc_persistent_congestion_threshold();
-  }
-
-private:
-  const QUICConfigParams *_params;
-};
-
-class QUICLDConfigQCP : public QUICLDConfig
-{
-public:
-  QUICLDConfigQCP(const QUICConfigParams *params) : _params(params) {}
-
-  uint32_t
-  packet_threshold() const override
-  {
-    return this->_params->ld_packet_threshold();
-  }
-
-  float
-  time_threshold() const override
-  {
-    return this->_params->ld_time_threshold();
-  }
-
-  ink_hrtime
-  granularity() const override
-  {
-    return this->_params->ld_granularity();
-  }
-
-  ink_hrtime
-  initial_rtt() const override
-  {
-    return this->_params->ld_initial_rtt();
-  }
-
-private:
-  const QUICConfigParams *_params;
-};
-
 QUICNetVConnection::QUICNetVConnection() : _packet_factory(this->_pp_key_info), _ph_protector(this->_pp_key_info) {}
 
 QUICNetVConnection::~QUICNetVConnection()
@@ -263,7 +201,6 @@
   this->_unschedule_packet_write_ready();
   this->_unschedule_closing_timeout();
   this->_unschedule_closed_event();
-  this->_unschedule_path_validation_timeout();
 }
 
 // XXX This might be called on ET_UDP thread
@@ -419,8 +356,9 @@
 QUICNetVConnection::start()
 {
   ink_release_assert(this->thread != nullptr);
-
+  this->_context = std::make_unique<QUICContextImpl>(&this->_rtt_measure, this, &this->_pp_key_info);
   this->_five_tuple.update(this->local_addr, this->remote_addr, SOCK_DGRAM);
+  QUICPath trusted_path = {{}, {}};
   // Version 0x00000001 uses stream 0 for cryptographic handshake with TLS 1.3, but newer version may not
   if (this->direction() == NET_VCONNECTION_IN) {
     QUICCertConfig::scoped_config server_cert;
@@ -434,6 +372,7 @@
     this->_ack_frame_manager.set_max_ack_delay(this->_quic_config->max_ack_delay_in());
     this->_schedule_ack_manager_periodic(this->_quic_config->max_ack_delay_in());
   } else {
+    trusted_path = {this->local_addr, this->remote_addr};
     QUICTPConfigQCP tp_config(this->_quic_config, NET_VCONNECTION_OUT);
     this->_pp_key_info.set_context(QUICPacketProtectionKeyInfo::Context::CLIENT);
     this->_ack_frame_manager.set_ack_delay_exponent(this->_quic_config->ack_delay_exponent_out());
@@ -450,27 +389,47 @@
   this->_frame_dispatcher = new QUICFrameDispatcher(this);
 
   // Create frame handlers
-  QUICCCConfigQCP cc_config(this->_quic_config);
-  QUICLDConfigQCP ld_config(this->_quic_config);
-  this->_rtt_measure.init(ld_config);
-  this->_congestion_controller = new QUICCongestionController(this->_rtt_measure, this, cc_config);
-  this->_loss_detector         = new QUICLossDetector(this, this->_congestion_controller, &this->_rtt_measure, ld_config);
+  this->_pinger = new QUICPinger();
+  this->_padder = new QUICPadder(this->netvc_context);
+  this->_rtt_measure.init(this->_context->ld_config());
+  this->_congestion_controller = new QUICNewRenoCongestionController(*_context);
+  this->_loss_detector =
+    new QUICLossDetector(*_context, this->_congestion_controller, &this->_rtt_measure, this->_pinger, this->_padder);
   this->_frame_dispatcher->add_handler(this->_loss_detector);
 
   this->_remote_flow_controller = new QUICRemoteConnectionFlowController(UINT64_MAX);
   this->_local_flow_controller  = new QUICLocalConnectionFlowController(&this->_rtt_measure, UINT64_MAX);
-  this->_path_validator         = new QUICPathValidator();
+  this->_path_validator         = new QUICPathValidator(*this, [this](bool succeeded) {
+    if (succeeded) {
+      this->_alt_con_manager->drop_cid(this->_peer_old_quic_connection_id);
+      // FIXME This is a kind of workaround for connection migration.
+      // This PING make peer to send an ACK frame so that ATS can detect packet loss.
+      // It would be better if QUICLossDetector could detect the loss in another way.
+      this->ping();
+    }
+  });
   this->_stream_manager         = new QUICStreamManager(this, &this->_rtt_measure, this->_application_map);
+  this->_path_manager           = new QUICPathManager(*this, *this->_path_validator);
+  this->_path_manager->set_trusted_path(trusted_path);
+  this->_token_creator = new QUICTokenCreator(this->_context.get());
+
+  static constexpr int QUIC_STREAM_MANAGER_WEIGHT = QUICFrameGeneratorWeight::AFTER_DATA - 1;
+  static constexpr int QUIC_PINGER_WEIGHT         = QUICFrameGeneratorWeight::LATE + 1;
+  static constexpr int QUIC_PADDER_WEIGHT         = QUICFrameGeneratorWeight::LATE + 2;
 
   // Register frame generators
-  this->_frame_generators.push_back(this->_handshake_handler);      // CRYPTO
-  this->_frame_generators.push_back(this->_path_validator);         // PATH_CHALLENGE, PATH_RESPOSNE
-  this->_frame_generators.push_back(this->_local_flow_controller);  // MAX_DATA
-  this->_frame_generators.push_back(this->_remote_flow_controller); // DATA_BLOCKED
-  this->_frame_generators.push_back(this);                          // NEW_TOKEN
-  this->_frame_generators.push_back(this->_stream_manager);         // STREAM, MAX_STREAM_DATA, STREAM_DATA_BLOCKED
-  this->_frame_generators.push_back(&this->_ack_frame_manager);     // ACK
-  this->_frame_generators.push_back(&this->_pinger);                // PING
+  this->_frame_generators.add_generator(*this->_handshake_handler, QUICFrameGeneratorWeight::EARLY); // CRYPTO
+  this->_frame_generators.add_generator(*this->_path_validator, QUICFrameGeneratorWeight::EARLY); // PATH_CHALLENGE, PATH_RESPOSNE
+  this->_frame_generators.add_generator(*this->_local_flow_controller, QUICFrameGeneratorWeight::BEFORE_DATA);  // MAX_DATA
+  this->_frame_generators.add_generator(*this->_remote_flow_controller, QUICFrameGeneratorWeight::BEFORE_DATA); // DATA_BLOCKED
+  this->_frame_generators.add_generator(*this->_token_creator, QUICFrameGeneratorWeight::BEFORE_DATA);          // NEW_TOKEN
+  this->_frame_generators.add_generator(*this->_stream_manager,
+                                        QUIC_STREAM_MANAGER_WEIGHT); // STREAM, MAX_STREAM_DATA, STREAM_DATA_BLOCKED
+  this->_frame_generators.add_generator(this->_ack_frame_manager, QUICFrameGeneratorWeight::BEFORE_DATA); // ACK
+
+  this->_frame_generators.add_generator(*this->_pinger, QUIC_PINGER_WEIGHT); // PING
+  // Warning: padder should be tail of the frame generators
+  this->_frame_generators.add_generator(*this->_padder, QUIC_PADDER_WEIGHT); // PADDING
 
   // Register frame handlers
   this->_frame_dispatcher->add_handler(this);
@@ -542,6 +501,13 @@
 }
 
 void
+QUICNetVConnection::set_local_addr()
+{
+  int local_sa_size = sizeof(local_addr);
+  ATS_UNUSED_RETURN(safe_getsockname(this->_udp_con->getFd(), &local_addr.sa, &local_sa_size));
+}
+
+void
 QUICNetVConnection::reenable(VIO *vio)
 {
   return;
@@ -566,6 +532,9 @@
   // FIXME: complete do_io_xxxx instead
   this->read.enabled = 1;
 
+  this->set_local_addr();
+  this->remote_addr = con.addr;
+
   this->start();
 
   // start QUIC handshake
@@ -672,7 +641,7 @@
 void
 QUICNetVConnection::ping()
 {
-  this->_pinger.request(QUICEncryptionLevel::ONE_RTT);
+  this->_pinger->request();
 }
 
 void
@@ -808,9 +777,6 @@
     // Reschedule WRITE_READY
     this->_schedule_packet_write_ready(true);
     break;
-  case QUIC_EVENT_PATH_VALIDATION_TIMEOUT:
-    this->_handle_path_validation_timeout(data);
-    break;
   case VC_EVENT_INACTIVITY_TIMEOUT:
     // Start Immediate Close because of Idle Timeout
     this->_handle_idle_timeout();
@@ -844,9 +810,6 @@
     // Reschedule WRITE_READY
     this->_schedule_packet_write_ready(true);
     break;
-  case QUIC_EVENT_PATH_VALIDATION_TIMEOUT:
-    this->_handle_path_validation_timeout(data);
-    break;
   case VC_EVENT_INACTIVITY_TIMEOUT:
     // Start Immediate Close because of Idle Timeout
     this->_handle_idle_timeout();
@@ -877,9 +840,6 @@
     this->_close_packet_write_ready(data);
     this->_state_closing_send_packet();
     break;
-  case QUIC_EVENT_PATH_VALIDATION_TIMEOUT:
-    this->_handle_path_validation_timeout(data);
-    break;
   case QUIC_EVENT_CLOSING_TIMEOUT:
     this->_close_closing_timeout(data);
     this->_switch_to_close_state();
@@ -908,9 +868,6 @@
     // This should be the only difference between this and closing_state.
     this->_close_packet_write_ready(data);
     break;
-  case QUIC_EVENT_PATH_VALIDATION_TIMEOUT:
-    this->_handle_path_validation_timeout(data);
-    break;
   case QUIC_EVENT_CLOSING_TIMEOUT:
     this->_close_closing_timeout(data);
     this->_switch_to_close_state();
@@ -933,7 +890,6 @@
     this->_unschedule_ack_manager_periodic();
     this->_unschedule_packet_write_ready();
     this->_unschedule_closing_timeout();
-    this->_unschedule_path_validation_timeout();
     this->_close_closed_event(data);
     this->next_inactivity_timeout_at = 0;
     this->next_activity_timeout_at   = 0;
@@ -1139,12 +1095,16 @@
 
   // Start handshake
   if (this->netvc_context == NET_VCONNECTION_IN) {
+    this->local_addr.sa  = packet.to().sa;
+    this->remote_addr.sa = packet.from().sa;
+    this->_five_tuple.update(this->local_addr, this->remote_addr, SOCK_DGRAM);
+
     if (!this->_alt_con_manager) {
       this->_alt_con_manager =
         new QUICAltConnectionManager(this, *this->_ctable, this->_peer_quic_connection_id, this->_quic_config->instance_id(),
-                                     this->_quic_config->num_alt_connection_ids(), this->_quic_config->preferred_address_ipv4(),
+                                     this->_quic_config->active_cid_limit_in(), this->_quic_config->preferred_address_ipv4(),
                                      this->_quic_config->preferred_address_ipv6());
-      this->_frame_generators.push_back(this->_alt_con_manager);
+      this->_frame_generators.add_generator(*this->_alt_con_manager, QUICFrameGeneratorWeight::EARLY);
       this->_frame_dispatcher->add_handler(this->_alt_con_manager);
     }
     QUICTPConfigQCP tp_config(this->_quic_config, NET_VCONNECTION_IN);
@@ -1159,6 +1119,14 @@
       }
     }
   } else {
+    if (!this->_alt_con_manager) {
+      this->_alt_con_manager =
+        new QUICAltConnectionManager(this, *this->_ctable, this->_peer_quic_connection_id, this->_quic_config->instance_id(),
+                                     this->_quic_config->active_cid_limit_out());
+      this->_frame_generators.add_generator(*this->_alt_con_manager, QUICFrameGeneratorWeight::BEFORE_DATA);
+      this->_frame_dispatcher->add_handler(this->_alt_con_manager);
+    }
+
     // on client side, _handshake_handler is already started. Just process packet like _state_handshake_process_handshake_packet()
     error = this->_recv_and_ack(packet);
   }
@@ -1184,6 +1152,8 @@
   this->_av_token     = ats_unique_malloc(this->_av_token_len);
   memcpy(this->_av_token.get(), packet.payload(), this->_av_token_len);
 
+  this->_padder->set_av_token_len(this->_av_token_len);
+
   // discard all transport state
   this->_handshake_handler->reset();
   this->_packet_factory.reset();
@@ -1366,7 +1336,7 @@
   uint32_t packet_count = 0;
   uint32_t error        = 0;
   while (error == 0 && packet_count < PACKET_PER_EVENT) {
-    uint32_t window = this->_congestion_controller->open_window();
+    uint32_t window = this->_congestion_controller->credit();
 
     if (window == 0) {
       break;
@@ -1418,7 +1388,9 @@
         written += len;
 
         int dcil = (this->_peer_quic_connection_id == QUICConnectionId::ZERO()) ? 0 : this->_peer_quic_connection_id.length();
-        this->_ph_protector.protect(buf, len, dcil);
+        if (!this->_ph_protector.protect(buf, len, dcil)) {
+          ink_assert(!"failed to protect buffer");
+        }
 
         QUICConDebug("[TX] %s packet #%" PRIu64 " size=%zu", QUICDebugNames::packet_type(packet->type()), packet->packet_number(),
                      len);
@@ -1507,25 +1479,9 @@
   return parent_block;
 }
 
-// FIXME QUICNetVConnection should not know the actual type value of PADDING frame
-Ptr<IOBufferBlock>
-QUICNetVConnection::_generate_padding_frame(size_t frame_size)
-{
-  Ptr<IOBufferBlock> block = make_ptr<IOBufferBlock>(new_IOBufferBlock());
-  block->alloc(iobuffer_size_to_index(frame_size));
-  memset(block->start(), 0, frame_size);
-  block->fill(frame_size);
-
-  ink_assert(frame_size == static_cast<size_t>(block->size()));
-
-  return block;
-}
-
 QUICPacketUPtr
 QUICNetVConnection::_packetize_frames(QUICEncryptionLevel level, uint64_t max_packet_size, std::vector<QUICFrameInfo> &frames)
 {
-  ink_hrtime timestamp = Thread::get_hrtime();
-
   QUICPacketUPtr packet = QUICPacketFactory::create_null_packet();
   if (max_packet_size <= MAX_PACKET_OVERHEAD) {
     return packet;
@@ -1546,30 +1502,43 @@
   first_block->alloc(iobuffer_size_to_index(0));
   first_block->fill(0);
 
-  if (!this->_has_ack_eliciting_packet_out) {
-    // Sent too much ack_only packet. At this moment we need to packetize a ping frame
-    // to force peer send ack frame.
-    this->_pinger.request(level);
-  }
-
+  uint32_t seq_num   = this->_seq_num++;
   size_t size_added  = 0;
   bool ack_eliciting = false;
   bool crypto        = false;
   uint8_t frame_instance_buffer[QUICFrame::MAX_INSTANCE_SIZE]; // This is for a frame instance but not serialized frame data
   QUICFrame *frame = nullptr;
-  for (auto g : this->_frame_generators) {
-    while (g->will_generate_frame(level, timestamp)) {
+  for (auto g : this->_frame_generators.generators()) {
+    // a non-ack_eliciting packet is ready, but we can not send continuous two ack_eliciting packets.
+    while (g->will_generate_frame(level, len, ack_eliciting, seq_num)) {
       // FIXME will_generate_frame should receive more parameters so we don't need extra checks
-      if (g == this->_remote_flow_controller && !this->_stream_manager->will_generate_frame(level, timestamp)) {
-        break;
-      }
-      if (g == this->_stream_manager && this->_path_validator->is_validating()) {
+      if (g == this->_remote_flow_controller && !this->_stream_manager->will_generate_frame(level, len, ack_eliciting, seq_num)) {
         break;
       }
 
+      if (g == this->_stream_manager) {
+        // Don't send DATA frames if current path is not validated
+        // FIXME will_generate_frame should receive more parameters so we don't need extra checks
+        if (auto path = this->_path_manager->get_verified_path(); !path.remote_ep().isValid()) {
+          break;
+        }
+      }
+
       // Common block
-      frame = g->generate_frame(frame_instance_buffer, level, this->_remote_flow_controller->credit(), max_frame_size, timestamp);
+      frame =
+        g->generate_frame(frame_instance_buffer, level, this->_remote_flow_controller->credit(), max_frame_size, len, seq_num);
       if (frame) {
+        // Some frame types must not be sent on Initial and Handshake packets
+        switch (auto t = frame->type(); level) {
+        case QUICEncryptionLevel::INITIAL:
+        case QUICEncryptionLevel::HANDSHAKE:
+          ink_assert(t == QUICFrameType::CRYPTO || t == QUICFrameType::ACK || t == QUICFrameType::PADDING ||
+                     t == QUICFrameType::CONNECTION_CLOSE);
+          break;
+        default:
+          break;
+        }
+
         ++frame_count;
         probing |= frame->is_probing_frame();
         if (frame->is_flow_controlled()) {
@@ -1588,13 +1557,11 @@
           }
         }
 
-        if (!ack_eliciting && frame->type() != QUICFrameType::ACK) {
+        if (!ack_eliciting && frame->ack_eliciting()) {
           ack_eliciting = true;
-          this->_pinger.cancel(level);
         }
 
-        if (frame->type() == QUICFrameType::CRYPTO &&
-            (level == QUICEncryptionLevel::INITIAL || level == QUICEncryptionLevel::HANDSHAKE)) {
+        if (frame->type() == QUICFrameType::CRYPTO && frame->ack_eliciting()) {
           crypto = true;
         }
 
@@ -1608,31 +1575,8 @@
 
   // Schedule a packet
   if (len != 0) {
-    if (level == QUICEncryptionLevel::INITIAL && this->netvc_context == NET_VCONNECTION_OUT) {
-      // Pad with PADDING frames
-      uint64_t min_size = this->_minimum_quic_packet_size();
-      if (this->_av_token) {
-        min_size = min_size - this->_av_token_len;
-      }
-      min_size = std::min(min_size, max_packet_size);
-
-      if (min_size > len) {
-        Ptr<IOBufferBlock> pad_block = _generate_padding_frame(min_size - len);
-        last_block->next             = pad_block;
-        len += pad_block->size();
-      }
-    } else {
-      // Pad with PADDING frames to make sure payload length satisfy the minimum length for sampling for header protection
-      if (MIN_PKT_PAYLOAD_LEN > len) {
-        Ptr<IOBufferBlock> pad_block = _generate_padding_frame(MIN_PKT_PAYLOAD_LEN - len);
-        last_block->next             = pad_block;
-        len += pad_block->size();
-      }
-    }
-
     // Packet is retransmittable if it's not ack only packet
-    packet                              = this->_build_packet(level, first_block, ack_eliciting, probing, crypto);
-    this->_has_ack_eliciting_packet_out = ack_eliciting;
+    packet = this->_build_packet(level, first_block, ack_eliciting, probing, crypto);
   }
 
   return packet;
@@ -1683,7 +1627,8 @@
     *has_non_probing_frame = false;
   }
 
-  error = this->_frame_dispatcher->receive_frames(level, payload, size, ack_only, is_flow_controlled, has_non_probing_frame);
+  error =
+    this->_frame_dispatcher->receive_frames(level, payload, size, ack_only, is_flow_controlled, has_non_probing_frame, &packet);
   if (error != nullptr) {
     return error;
   }
@@ -1987,33 +1932,6 @@
 }
 
 void
-QUICNetVConnection::_schedule_path_validation_timeout(ink_hrtime interval)
-{
-  if (!this->_path_validation_timeout) {
-    QUICConDebug("Schedule %s event in %" PRIu64 "ms", QUICDebugNames::quic_event(QUIC_EVENT_PATH_VALIDATION_TIMEOUT),
-                 interval / HRTIME_MSECOND);
-    this->_path_validation_timeout = this->thread->schedule_in_local(this, interval, QUIC_EVENT_PATH_VALIDATION_TIMEOUT);
-  }
-}
-
-void
-QUICNetVConnection::_unschedule_path_validation_timeout()
-{
-  if (this->_path_validation_timeout) {
-    QUICConDebug("Unschedule %s event", QUICDebugNames::quic_event(QUIC_EVENT_PATH_VALIDATION_TIMEOUT));
-    this->_path_validation_timeout->cancel();
-    this->_path_validation_timeout = nullptr;
-  }
-}
-
-void
-QUICNetVConnection::_close_path_validation_timeout(Event *data)
-{
-  ink_assert(this->_path_validation_timeout == data);
-  this->_path_validation_timeout = nullptr;
-}
-
-void
 QUICNetVConnection::_start_application()
 {
   if (!this->_application_started) {
@@ -2029,7 +1947,7 @@
 
     if (netvc_context == NET_VCONNECTION_IN) {
       if (!this->setSelectedProtocol(app_name, app_name_len)) {
-        this->_handle_error(std::make_unique<QUICConnectionError>(QUICTransErrorCode::VERSION_NEGOTIATION_ERROR));
+        this->_handle_error(std::make_unique<QUICConnectionError>(QUICTransErrorCode::PROTOCOL_VIOLATION));
       } else {
         this->endpoint()->handleEvent(NET_EVENT_ACCEPT, this);
       }
@@ -2055,15 +1973,22 @@
 
     SET_HANDLER((NetVConnHandler)&QUICNetVConnection::state_connection_established);
 
+    std::shared_ptr<const QUICTransportParameters> remote_tp = this->_handshake_handler->remote_transport_parameters();
+
+    uint64_t active_cid_limit = remote_tp->getAsUInt(QUICTransportParameterId::ACTIVE_CONNECTION_ID_LIMIT);
+    if (active_cid_limit) {
+      this->_alt_con_manager->set_remote_active_cid_limit(active_cid_limit);
+    }
+
     if (this->direction() == NET_VCONNECTION_OUT) {
-      std::shared_ptr<const QUICTransportParameters> remote_tp = this->_handshake_handler->remote_transport_parameters();
-      const uint8_t *pref_addr_buf;
       uint16_t len;
-      pref_addr_buf          = remote_tp->getAsBytes(QUICTransportParameterId::PREFERRED_ADDRESS, len);
-      this->_alt_con_manager = new QUICAltConnectionManager(this, *this->_ctable, this->_peer_quic_connection_id,
-                                                            this->_quic_config->instance_id(), 1, {pref_addr_buf, len});
-      this->_frame_generators.push_back(this->_alt_con_manager);
-      this->_frame_dispatcher->add_handler(this->_alt_con_manager);
+      const uint8_t *pref_addr_buf = remote_tp->getAsBytes(QUICTransportParameterId::PREFERRED_ADDRESS, len);
+      if (pref_addr_buf) {
+        this->_alt_con_manager->set_remote_preferred_address({pref_addr_buf, len});
+      }
+    } else {
+      QUICPath trusted_path = {this->local_addr, this->remote_addr};
+      this->_path_manager->set_trusted_path(trusted_path);
     }
   } else {
     // Illegal state change
@@ -2135,7 +2060,6 @@
 QUICNetVConnection::_switch_to_close_state()
 {
   this->_unschedule_closing_timeout();
-  this->_unschedule_path_validation_timeout();
 
   if (this->_complete_handshake_if_possible() != 0) {
     QUICConDebug("Switching state without handshake completion");
@@ -2155,13 +2079,12 @@
 }
 
 void
-QUICNetVConnection::_validate_new_path()
+QUICNetVConnection::_validate_new_path(const QUICPath &path)
 {
-  this->_path_validator->validate();
   // Not sure how long we should wait. The spec says just "enough time".
   // Use the same time amount as the closing timeout.
   ink_hrtime rto = this->_rtt_measure.current_pto_period();
-  this->_schedule_path_validation_timeout(3 * rto);
+  this->_path_manager->open_new_path(path, 3 * rto);
 }
 
 void
@@ -2253,6 +2176,7 @@
   }
 
   if (this->connection_id() == dcid) {
+    QUICConDebug("Maybe NAT rebinding");
     // On client side (NET_VCONNECTION_OUT), nothing to do any more
     if (this->netvc_context == NET_VCONNECTION_IN) {
       Connection con;
@@ -2260,9 +2184,12 @@
       this->con.move(con);
       this->set_remote_addr();
       this->_udp_con = p.udp_con();
-      this->_validate_new_path();
+
+      QUICPath new_path = {p.to(), p.from()};
+      this->_validate_new_path(new_path);
     }
   } else {
+    QUICConDebug("Different CID");
     if (this->_alt_con_manager->migrate_to(dcid, this->_reset_token)) {
       // DCID of received packet is local cid
       this->_update_local_cid(dcid);
@@ -2276,7 +2203,9 @@
         this->_udp_con = p.udp_con();
 
         this->_update_peer_cid(this->_alt_con_manager->migrate_to_alt_cid());
-        this->_validate_new_path();
+
+        QUICPath new_path = {this->local_addr, con.addr};
+        this->_validate_new_path(new_path);
       }
     } else {
       char dcid_str[QUICConnectionId::MAX_HEX_STR_LENGTH];
@@ -2298,13 +2227,12 @@
   ink_assert(this->netvc_context == NET_VCONNECTION_OUT);
 
   QUICConnectionErrorUPtr error = nullptr;
-  ink_hrtime timestamp          = Thread::get_hrtime();
 
   std::shared_ptr<const QUICTransportParameters> remote_tp = this->_handshake_handler->remote_transport_parameters();
 
-  if (this->_connection_migration_initiated || remote_tp->contains(QUICTransportParameterId::DISABLE_MIGRATION) ||
+  if (this->_connection_migration_initiated || remote_tp->contains(QUICTransportParameterId::DISABLE_ACTIVE_MIGRATION) ||
       !this->_alt_con_manager->is_ready_to_migrate() ||
-      this->_alt_con_manager->will_generate_frame(QUICEncryptionLevel::ONE_RTT, timestamp)) {
+      this->_alt_con_manager->will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0, true, this->_seq_num++)) {
     return error;
   }
 
@@ -2313,7 +2241,9 @@
 
   this->_update_peer_cid(this->_alt_con_manager->migrate_to_alt_cid());
 
-  this->_validate_new_path();
+  auto current_path = this->_path_manager->get_verified_path();
+  QUICPath new_path = {current_path.local_ep(), current_path.remote_ep()};
+  this->_validate_new_path(new_path);
 
   return error;
 }
@@ -2321,10 +2251,9 @@
 void
 QUICNetVConnection::_handle_periodic_ack_event()
 {
-  ink_hrtime timestamp = Thread::get_hrtime();
-  bool need_schedule   = false;
+  bool need_schedule = false;
   for (int i = static_cast<int>(this->_minimum_encryption_level); i <= static_cast<int>(QUICEncryptionLevel::ONE_RTT); ++i) {
-    if (this->_ack_frame_manager.will_generate_frame(QUIC_ENCRYPTION_LEVELS[i], timestamp)) {
+    if (this->_ack_frame_manager.will_generate_frame(QUIC_ENCRYPTION_LEVELS[i], 0, true, this->_seq_num++)) {
       need_schedule = true;
       break;
     }
@@ -2336,68 +2265,3 @@
     this->_schedule_packet_write_ready();
   }
 }
-
-void
-QUICNetVConnection::_handle_path_validation_timeout(Event *data)
-{
-  this->_close_path_validation_timeout(data);
-  if (this->_path_validator->is_validated()) {
-    QUICConDebug("Path validated");
-    this->_alt_con_manager->drop_cid(this->_peer_old_quic_connection_id);
-    // FIXME This is a kind of workaround for connection migration.
-    // This PING make peer to send an ACK frame so that ATS can detect packet loss.
-    // It would be better if QUICLossDetector could detect the loss in another way.
-    this->ping();
-  } else {
-    QUICConDebug("Path validation failed");
-    this->_switch_to_close_state();
-  }
-}
-
-// QUICFrameGenerator
-bool
-QUICNetVConnection::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
-{
-  if (!this->_is_level_matched(level)) {
-    return false;
-  }
-
-  return !this->_is_resumption_token_sent;
-}
-
-QUICFrame *
-QUICNetVConnection::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                                   ink_hrtime timestamp)
-{
-  QUICFrame *frame = nullptr;
-
-  if (!this->_is_level_matched(level)) {
-    return frame;
-  }
-
-  if (this->_is_resumption_token_sent) {
-    return frame;
-  }
-
-  if (this->direction() == NET_VCONNECTION_IN) {
-    // TODO Make expiration period configurable
-    QUICResumptionToken token(this->get_remote_endpoint(), this->connection_id(), Thread::get_hrtime() + HRTIME_HOURS(24));
-    frame = QUICFrameFactory::create_new_token_frame(buf, token, this->_issue_frame_id(), this);
-    if (frame) {
-      if (frame->size() < maximum_frame_size) {
-        this->_is_resumption_token_sent = true;
-      } else {
-        // Cancel generating frame
-        frame = nullptr;
-      }
-    }
-  }
-
-  return frame;
-}
-
-void
-QUICNetVConnection::_on_frame_lost(QUICFrameInformationUPtr &info)
-{
-  this->_is_resumption_token_sent = false;
-}
diff --git a/iocore/net/QUICPacketHandler.cc b/iocore/net/QUICPacketHandler.cc
index fc906b2..230acbb 100644
--- a/iocore/net/QUICPacketHandler.cc
+++ b/iocore/net/QUICPacketHandler.cc
@@ -30,8 +30,7 @@
 #include "QUICDebugNames.h"
 #include "QUICEvents.h"
 
-static constexpr int LONG_HDR_OFFSET_CONNECTION_ID = 6;
-static constexpr char debug_tag[]                  = "quic_sec";
+static constexpr char debug_tag[] = "quic_sec";
 
 #define QUICDebug(fmt, ...) Debug(debug_tag, fmt, ##__VA_ARGS__)
 #define QUICDebugQC(qc, fmt, ...) Debug(debug_tag, "[%s] " fmt, qc->cids().data(), ##__VA_ARGS__)
@@ -381,9 +380,10 @@
   }
 
   // TODO: refine packet parsers in here, QUICPacketLongHeader, and QUICPacketReceiveQueue
-  size_t token_length            = 0;
-  uint8_t token_length_field_len = 0;
-  if (!QUICPacketLongHeader::token_length(token_length, &token_length_field_len, buf, buf_len)) {
+  size_t token_length              = 0;
+  uint8_t token_length_field_len   = 0;
+  size_t token_length_field_offset = 0;
+  if (!QUICPacketLongHeader::token_length(token_length, token_length_field_len, token_length_field_offset, buf, buf_len)) {
     return -1;
   }
 
@@ -393,19 +393,18 @@
     local_cid.randomize();
     QUICPacketUPtr retry_packet = QUICPacketFactory::create_retry_packet(scid, local_cid, dcid, token);
 
+    QUICDebug("[TX] %s packet ODCID=%" PRIx64, QUICDebugNames::packet_type(retry_packet->type()),
+              static_cast<uint64_t>(static_cast<const QUICPacketLongHeader &>(retry_packet->header()).original_dcid()));
     this->_send_packet(*retry_packet, connection, from, 1200, nullptr, 0);
 
     return -2;
   } else {
-    uint8_t dcil, scil;
-    QUICPacketLongHeader::dcil(dcil, buf, buf_len);
-    QUICPacketLongHeader::scil(scil, buf, buf_len);
-    const uint8_t *token = buf + LONG_HDR_OFFSET_CONNECTION_ID + dcil + scil + token_length_field_len;
+    size_t token_offset = token_length_field_offset + token_length_field_len;
 
-    if (QUICAddressValidationToken::type(token) == QUICAddressValidationToken::Type::RETRY) {
-      QUICRetryToken token1(token, token_length);
-      if (token1.is_valid(from)) {
-        *original_cid = token1.original_dcid();
+    if (QUICAddressValidationToken::type(buf + token_offset) == QUICAddressValidationToken::Type::RETRY) {
+      QUICRetryToken token(buf + token_offset, token_length);
+      if (token.is_valid(from)) {
+        *original_cid = token.original_dcid();
         return 0;
       } else {
         return -3;
diff --git a/iocore/net/quic/Makefile.am b/iocore/net/quic/Makefile.am
index e13d1de..73c4e5f 100644
--- a/iocore/net/quic/Makefile.am
+++ b/iocore/net/quic/Makefile.am
@@ -56,7 +56,7 @@
   QUICVersionNegotiator.cc \
   QUICLossDetector.cc \
   QUICStreamManager.cc \
-  QUICCongestionController.cc \
+  QUICNewRenoCongestionController.cc \
   QUICFlowController.cc \
   QUICStreamState.cc \
   QUICStream.cc \
@@ -82,6 +82,7 @@
   QUICApplicationMap.cc \
   QUICIncomingFrameBuffer.cc \
   QUICPacketReceiveQueue.cc \
+  QUICPathManager.cc \
   QUICPathValidator.cc \
   QUICPinger.cc \
   QUICFrameGenerator.cc \
@@ -90,7 +91,10 @@
   QUICBidirectionalStream.cc \
   QUICCryptoStream.cc \
   QUICUnidirectionalStream.cc \
-  QUICStreamFactory.cc
+  QUICStreamFactory.cc \
+  QUICPadder.cc \
+  QUICContext.cc \
+  QUICTokenCreator.cc
 
 #
 # Check Programs
@@ -109,6 +113,7 @@
   test_QUICPacket \
   test_QUICPacketHeaderProtector \
   test_QUICPacketFactory \
+  test_QUICPathValidator \
   test_QUICStream \
   test_QUICStreamManager \
   test_QUICStreamState \
@@ -117,7 +122,8 @@
   test_QUICTypeUtil \
   test_QUICVersionNegotiator \
   test_QUICFrameRetransmitter \
-  test_QUICAddrVerifyState
+  test_QUICAddrVerifyState \
+  test_QUICPinger
 
 TESTS = $(check_PROGRAMS)
 
@@ -226,6 +232,13 @@
   $(test_main_SOURCES) \
   ./test/test_QUICPacketFactory.cc
 
+test_QUICPathValidator_CPPFLAGS = $(test_CPPFLAGS)
+test_QUICPathValidator_LDFLAGS = @AM_LDFLAGS@
+test_QUICPathValidator_LDADD = $(test_LDADD)
+test_QUICPathValidator_SOURCES = \
+  $(test_main_SOURCES) \
+  ./test/test_QUICPathValidator.cc
+
 test_QUICPacketHeaderProtector_CPPFLAGS = $(test_CPPFLAGS)
 test_QUICPacketHeaderProtector_LDFLAGS = @AM_LDFLAGS@
 test_QUICPacketHeaderProtector_LDADD = $(test_LDADD)
@@ -296,6 +309,13 @@
   $(test_main_SOURCES) \
   ./test/test_QUICAddrVerifyState.cc
 
+test_QUICPinger_CPPFLAGS = $(test_CPPFLAGS)
+test_QUICPinger_LDFLAGS = @AM_LDFLAGS@
+test_QUICPinger_LDADD = $(test_LDADD)
+test_QUICPinger_SOURCES = \
+  $(test_main_SOURCES) \
+  ./test/test_QUICPinger.cc
+
 #
 # clang-tidy
 #
diff --git a/iocore/net/quic/Mock.h b/iocore/net/quic/Mock.h
index d4692b0..535dff5 100644
--- a/iocore/net/quic/Mock.h
+++ b/iocore/net/quic/Mock.h
@@ -30,13 +30,147 @@
 #include "QUICLossDetector.h"
 #include "QUICEvents.h"
 
+class MockQUICContext;
+
 using namespace std::literals;
-std::string_view negotiated_application_name_sv = "h3-20"sv;
+std::string_view negotiated_application_name_sv = "h3-23"sv;
+
+class MockQUICLDConfig : public QUICLDConfig
+{
+  uint32_t
+  packet_threshold() const
+  {
+    return 3;
+  }
+
+  float
+  time_threshold() const
+  {
+    return 1.25;
+  }
+
+  ink_hrtime
+  granularity() const
+  {
+    return HRTIME_MSECONDS(1);
+  }
+
+  ink_hrtime
+  initial_rtt() const
+  {
+    return HRTIME_MSECONDS(100);
+  }
+};
+
+class MockQUICCCConfig : public QUICCCConfig
+{
+  uint32_t
+  max_datagram_size() const
+  {
+    return 1200;
+  }
+
+  uint32_t
+  initial_window() const
+  {
+    return 10;
+  }
+
+  uint32_t
+  minimum_window() const
+  {
+    return 2;
+  }
+
+  float
+  loss_reduction_factor() const
+  {
+    return 0.5;
+  }
+
+  uint32_t
+  persistent_congestion_threshold() const
+  {
+    return 2;
+  }
+};
+
+class MockQUICConnectionInfoProvider : public QUICConnectionInfoProvider
+{
+  QUICConnectionId
+  connection_id() const override
+  {
+    return {reinterpret_cast<const uint8_t *>("\x00"), 1};
+  }
+
+  QUICConnectionId
+  peer_connection_id() const override
+  {
+    return {reinterpret_cast<const uint8_t *>("\x00"), 1};
+  }
+
+  QUICConnectionId
+  original_connection_id() const override
+  {
+    return {reinterpret_cast<const uint8_t *>("\x00"), 1};
+  }
+
+  QUICConnectionId
+  first_connection_id() const override
+  {
+    return {reinterpret_cast<const uint8_t *>("\x00"), 1};
+  }
+
+  const QUICFiveTuple
+  five_tuple() const override
+  {
+    return QUICFiveTuple();
+  }
+
+  std::string_view
+  cids() const override
+  {
+    using namespace std::literals;
+    return std::string_view("00000000-00000000"sv);
+  }
+
+  uint32_t
+  pmtu() const override
+  {
+    return 1280;
+  }
+
+  NetVConnectionContext_t
+  direction() const override
+  {
+    return NET_VCONNECTION_OUT;
+  }
+
+  int
+  select_next_protocol(SSL *ssl, const unsigned char **out, unsigned char *outlen, const unsigned char *in,
+                       unsigned inlen) const override
+  {
+    return SSL_TLSEXT_ERR_OK;
+  }
+
+  bool
+  is_closed() const override
+  {
+    return false;
+  }
+
+  std::string_view
+  negotiated_application_name() const override
+  {
+    return negotiated_application_name_sv;
+  }
+};
 
 class MockQUICStreamManager : public QUICStreamManager
 {
 public:
-  MockQUICStreamManager() : QUICStreamManager() {}
+  MockQUICStreamManager(QUICConnectionInfoProvider *info) : QUICStreamManager(info, nullptr, nullptr) {}
+
   // Override
   virtual QUICConnectionErrorUPtr
   handle_frame(QUICEncryptionLevel level, const QUICFrame &f) override
@@ -263,92 +397,18 @@
   int _transmit_count   = 0;
   int _retransmit_count = 0;
   Ptr<ProxyMutex> _mutex;
-  int _totalFrameCount = 0;
-  int _frameCount[256] = {0};
-  MockQUICStreamManager _stream_manager;
+  int _totalFrameCount                  = 0;
+  int _frameCount[256]                  = {0};
+  MockQUICStreamManager _stream_manager = {this};
 
   QUICTransportParametersInEncryptedExtensions dummy_transport_parameters();
   NetVConnectionContext_t _direction;
 };
 
-class MockQUICConnectionInfoProvider : public QUICConnectionInfoProvider
-{
-  QUICConnectionId
-  connection_id() const override
-  {
-    return {reinterpret_cast<const uint8_t *>("\x00"), 1};
-  }
-
-  QUICConnectionId
-  peer_connection_id() const override
-  {
-    return {reinterpret_cast<const uint8_t *>("\x00"), 1};
-  }
-
-  QUICConnectionId
-  original_connection_id() const override
-  {
-    return {reinterpret_cast<const uint8_t *>("\x00"), 1};
-  }
-
-  QUICConnectionId
-  first_connection_id() const override
-  {
-    return {reinterpret_cast<const uint8_t *>("\x00"), 1};
-  }
-
-  const QUICFiveTuple
-  five_tuple() const override
-  {
-    return QUICFiveTuple();
-  }
-
-  std::string_view
-  cids() const override
-  {
-    using namespace std::literals;
-    return std::string_view("00000000-00000000"sv);
-  }
-
-  uint32_t
-  pmtu() const override
-  {
-    return 1280;
-  }
-
-  NetVConnectionContext_t
-  direction() const override
-  {
-    return NET_VCONNECTION_OUT;
-  }
-
-  int
-  select_next_protocol(SSL *ssl, const unsigned char **out, unsigned char *outlen, const unsigned char *in,
-                       unsigned inlen) const override
-  {
-    return SSL_TLSEXT_ERR_OK;
-  }
-
-  bool
-  is_closed() const override
-  {
-    return false;
-  }
-
-  std::string_view
-  negotiated_application_name() const override
-  {
-    return negotiated_application_name_sv;
-  }
-};
-
 class MockQUICCongestionController : public QUICCongestionController
 {
 public:
-  MockQUICCongestionController(QUICConnectionInfoProvider *info, const QUICCCConfig &cc_config)
-    : QUICCongestionController(this->_rtt_measure, info, cc_config)
-  {
-  }
+  MockQUICCongestionController() {}
   // Override
   virtual void
   on_packets_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &packets) override
@@ -358,6 +418,32 @@
     }
   }
 
+  virtual void
+  on_packet_sent(size_t bytes_sent) override
+  {
+  }
+  virtual void
+  on_packet_acked(const QUICPacketInfo &acked_packet) override
+  {
+  }
+  virtual void
+  process_ecn(const QUICPacketInfo &acked_largest_packet, const QUICAckFrame::EcnSection *ecn_section) override
+  {
+  }
+  virtual void
+  add_extra_credit() override
+  {
+  }
+  virtual void
+  reset() override
+  {
+  }
+  virtual uint32_t
+  credit() const override
+  {
+    return 0;
+  }
+
   // for Test
   int
   getStreamFrameCount()
@@ -388,16 +474,90 @@
 private:
   int _totalFrameCount = 0;
   int _frameCount[256] = {0};
+};
 
+class MockQUICPacketProtectionKeyInfo : public QUICPacketProtectionKeyInfo
+{
+public:
+  const EVP_CIPHER *
+  get_cipher(QUICKeyPhase phase) const override
+  {
+    return EVP_aes_128_gcm();
+  }
+
+  size_t
+  get_tag_len(QUICKeyPhase phase) const override
+  {
+    return EVP_GCM_TLS_TAG_LEN;
+  }
+
+  const size_t *encryption_iv_len(QUICKeyPhase) const override
+  {
+    static size_t dummy = 12;
+    return &dummy;
+  }
+};
+
+class MockQUICContext : public QUICContext, public QUICLDContext, public QUICCCContext
+{
+public:
+  MockQUICContext()
+  {
+    _info      = std::make_unique<MockQUICConnectionInfoProvider>();
+    _key_info  = std::make_unique<MockQUICPacketProtectionKeyInfo>();
+    _ld_config = std::make_unique<MockQUICLDConfig>();
+    _cc_config = std::make_unique<MockQUICCCConfig>();
+  }
+
+  virtual QUICConnectionInfoProvider *
+  connection_info() const override
+  {
+    return _info.get();
+  }
+  virtual QUICConfig::scoped_config
+  config() const override
+  {
+    return _config;
+  }
+  virtual QUICRTTProvider *
+  rtt_provider() const override
+  {
+    return const_cast<QUICRTTMeasure *>(&_rtt_measure);
+  }
+
+  virtual QUICPacketProtectionKeyInfo *
+  key_info() const override
+  {
+    return _key_info.get();
+  }
+
+  virtual QUICLDConfig &
+  ld_config() const override
+  {
+    return *_ld_config;
+  }
+
+  virtual QUICCCConfig &
+  cc_config() const override
+  {
+    return *_cc_config;
+  }
+
+private:
+  QUICConfig::scoped_config _config;
   QUICRTTMeasure _rtt_measure;
+  std::unique_ptr<QUICConnectionInfoProvider> _info;
+  std::unique_ptr<QUICPacketProtectionKeyInfo> _key_info;
+  std::unique_ptr<QUICLDConfig> _ld_config;
+  std::unique_ptr<QUICCCConfig> _cc_config;
 };
 
 class MockQUICLossDetector : public QUICLossDetector
 {
 public:
-  MockQUICLossDetector(QUICConnectionInfoProvider *info, QUICCongestionController *cc, QUICRTTMeasure *rtt_measure,
-                       const QUICLDConfig &ld_config)
-    : QUICLossDetector(info, cc, rtt_measure, ld_config)
+  MockQUICLossDetector(MockQUICContext &context)
+    : QUICLossDetector(context, &_cc, &_rtt_measure, &this->_pinger, &this->_padder),
+      _padder(NetVConnectionContext_t::NET_VCONNECTION_UNSET)
   {
   }
   void
@@ -409,6 +569,12 @@
   on_packet_sent(QUICPacketUPtr packet)
   {
   }
+
+private:
+  QUICPinger _pinger;
+  QUICPadder _padder;
+  QUICRTTMeasure _rtt_measure;
+  MockQUICCongestionController _cc;
 };
 
 class MockQUICApplication : public QUICApplication
@@ -436,26 +602,36 @@
   }
 };
 
-class MockQUICPacketProtectionKeyInfo : public QUICPacketProtectionKeyInfo
+class MockQUICPacket : public QUICPacket
 {
 public:
-  const EVP_CIPHER *
-  get_cipher(QUICKeyPhase phase) const override
+  const IpEndpoint &
+  from() const override
   {
-    return EVP_aes_128_gcm();
+    return this->_from;
   }
 
-  size_t
-  get_tag_len(QUICKeyPhase phase) const override
+  const IpEndpoint &
+  to() const override
   {
-    return EVP_GCM_TLS_TAG_LEN;
+    return this->_to;
   }
 
-  const size_t *encryption_iv_len(QUICKeyPhase) const override
+  void
+  set_to(const IpEndpoint ep)
   {
-    static size_t dummy = 12;
-    return &dummy;
+    this->_to = ep;
   }
+
+  void
+  set_from(const IpEndpoint ep)
+  {
+    this->_from = ep;
+  }
+
+private:
+  IpEndpoint _to;
+  IpEndpoint _from;
 };
 
 class MockQUICHandshakeProtocol : public QUICHandshakeProtocol
@@ -646,14 +822,14 @@
 {
 public:
   bool
-  will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override
+  will_generate_frame(QUICEncryptionLevel level, size_t connection_credit, bool ack_eliciting, uint32_t seq_num) override
   {
     return true;
   }
 
   QUICFrame *
   generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                 ink_hrtime timestamp) override
+                 size_t current_packet_size, uint32_t seq_num) override
   {
     QUICFrame *frame              = QUICFrameFactory::create_ping_frame(buf, 0, this);
     QUICFrameInformationUPtr info = QUICFrameInformationUPtr(quicFrameInformationAllocator.alloc());
@@ -670,63 +846,3 @@
     lost_frame_count++;
   }
 };
-
-class MockQUICLDConfig : public QUICLDConfig
-{
-  uint32_t
-  packet_threshold() const
-  {
-    return 3;
-  }
-
-  float
-  time_threshold() const
-  {
-    return 1.25;
-  }
-
-  ink_hrtime
-  granularity() const
-  {
-    return HRTIME_MSECONDS(1);
-  }
-
-  ink_hrtime
-  initial_rtt() const
-  {
-    return HRTIME_MSECONDS(100);
-  }
-};
-
-class MockQUICCCConfig : public QUICCCConfig
-{
-  uint32_t
-  max_datagram_size() const
-  {
-    return 1200;
-  }
-
-  uint32_t
-  initial_window() const
-  {
-    return 10;
-  }
-
-  uint32_t
-  minimum_window() const
-  {
-    return 2;
-  }
-
-  float
-  loss_reduction_factor() const
-  {
-    return 0.5;
-  }
-
-  uint32_t
-  persistent_congestion_threshold() const
-  {
-    return 2;
-  }
-};
diff --git a/iocore/net/quic/QUICAckFrameCreator.cc b/iocore/net/quic/QUICAckFrameCreator.cc
index 27923b0..98ca898 100644
--- a/iocore/net/quic/QUICAckFrameCreator.cc
+++ b/iocore/net/quic/QUICAckFrameCreator.cc
@@ -61,7 +61,7 @@
  */
 QUICFrame *
 QUICAckFrameManager::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t /* connection_credit */,
-                                    uint16_t maximum_frame_size, ink_hrtime timestamp)
+                                    uint16_t maximum_frame_size, size_t current_packet_size, uint32_t seq_num)
 {
   QUICAckFrame *ack_frame = nullptr;
 
@@ -87,7 +87,8 @@
 }
 
 bool
-QUICAckFrameManager::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICAckFrameManager::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting,
+                                         uint32_t seq_num)
 {
   // No ACK frame on ZERO_RTT level
   if (!this->_is_level_matched(level) || level == QUICEncryptionLevel::ZERO_RTT) {
diff --git a/iocore/net/quic/QUICAckFrameCreator.h b/iocore/net/quic/QUICAckFrameCreator.h
index 08b50d4..58e28e8 100644
--- a/iocore/net/quic/QUICAckFrameCreator.h
+++ b/iocore/net/quic/QUICAckFrameCreator.h
@@ -100,13 +100,13 @@
   /*
    * Returns true only if should send ack.
    */
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
 
   /*
    * Calls create directly.
    */
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
   QUICFrameId issue_frame_id();
   uint8_t ack_delay_exponent() const;
diff --git a/iocore/net/quic/QUICAltConnectionManager.cc b/iocore/net/quic/QUICAltConnectionManager.cc
index faca19e..4e39e93 100644
--- a/iocore/net/quic/QUICAltConnectionManager.cc
+++ b/iocore/net/quic/QUICAltConnectionManager.cc
@@ -21,6 +21,9 @@
   limitations under the License.
  */
 
+#include "algorithm"
+#include "tscore/ink_assert.h"
+#include "tscore/ink_defs.h"
 #include "QUICAltConnectionManager.h"
 #include "QUICConnectionTable.h"
 
@@ -30,43 +33,47 @@
 
 QUICAltConnectionManager::QUICAltConnectionManager(QUICConnection *qc, QUICConnectionTable &ctable,
                                                    const QUICConnectionId &peer_initial_cid, uint32_t instance_id,
-                                                   uint8_t num_alt_con, const QUICPreferredAddress &preferred_address)
-  : _qc(qc), _ctable(ctable), _instance_id(instance_id), _nids(num_alt_con)
-{
-  // Sequence number of the initial CID is 0
-  this->_alt_quic_connection_ids_remote.push_back({0, peer_initial_cid, {}, {true}});
-
-  // Sequence number of the preferred address is 1 if available
-  if (preferred_address.is_available()) {
-    this->_alt_quic_connection_ids_remote.push_back({1, preferred_address.cid(), preferred_address.token(), {false}});
-  }
-
-  this->_alt_quic_connection_ids_local = static_cast<AltConnectionInfo *>(ats_malloc(sizeof(AltConnectionInfo) * this->_nids));
-}
-
-QUICAltConnectionManager::QUICAltConnectionManager(QUICConnection *qc, QUICConnectionTable &ctable,
-                                                   const QUICConnectionId &peer_initial_cid, uint32_t instance_id,
-                                                   uint8_t num_alt_con, const IpEndpoint *preferred_endpoint_ipv4,
+                                                   uint8_t local_active_cid_limit, const IpEndpoint *preferred_endpoint_ipv4,
                                                    const IpEndpoint *preferred_endpoint_ipv6)
-  : _qc(qc), _ctable(ctable), _instance_id(instance_id), _nids(num_alt_con)
+  : _qc(qc), _ctable(ctable), _instance_id(instance_id), _local_active_cid_limit(local_active_cid_limit)
 {
   // Sequence number of the initial CID is 0
   this->_alt_quic_connection_ids_remote.push_back({0, peer_initial_cid, {}, {true}});
 
-  this->_alt_quic_connection_ids_local = static_cast<AltConnectionInfo *>(ats_malloc(sizeof(AltConnectionInfo) * this->_nids));
-  this->_init_alt_connection_ids(preferred_endpoint_ipv4, preferred_endpoint_ipv6);
+  if ((preferred_endpoint_ipv4 && !ats_ip_addr_port_eq(*preferred_endpoint_ipv4, qc->five_tuple().source())) ||
+      (preferred_endpoint_ipv6 && !ats_ip_addr_port_eq(*preferred_endpoint_ipv6, qc->five_tuple().source()))) {
+    this->_alt_quic_connection_ids_local[0] = this->_generate_next_alt_con_info();
+    // This alt cid will be advertised via Transport Parameter, so no need to advertise it via NCID frame
+    this->_alt_quic_connection_ids_local[0].advertised = true;
+
+    IpEndpoint empty_endpoint_ipv4;
+    IpEndpoint empty_endpoint_ipv6;
+    empty_endpoint_ipv4.sa.sa_family = AF_UNSPEC;
+    empty_endpoint_ipv6.sa.sa_family = AF_UNSPEC;
+    if (preferred_endpoint_ipv4 == nullptr) {
+      preferred_endpoint_ipv4 = &empty_endpoint_ipv4;
+    }
+    if (preferred_endpoint_ipv6 == nullptr) {
+      preferred_endpoint_ipv6 = &empty_endpoint_ipv6;
+    }
+
+    // FIXME Check nullptr dereference
+    this->_local_preferred_address =
+      new QUICPreferredAddress(*preferred_endpoint_ipv4, *preferred_endpoint_ipv6, this->_alt_quic_connection_ids_local[0].id,
+                               this->_alt_quic_connection_ids_local[0].token);
+  }
 }
 
 QUICAltConnectionManager::~QUICAltConnectionManager()
 {
   ats_free(this->_alt_quic_connection_ids_local);
-  delete this->_preferred_address;
+  delete this->_local_preferred_address;
 }
 
 const QUICPreferredAddress *
 QUICAltConnectionManager::preferred_address() const
 {
-  return this->_preferred_address;
+  return this->_local_preferred_address;
 }
 
 std::vector<QUICFrameType>
@@ -118,32 +125,9 @@
 }
 
 void
-QUICAltConnectionManager::_init_alt_connection_ids(const IpEndpoint *preferred_endpoint_ipv4,
-                                                   const IpEndpoint *preferred_endpoint_ipv6)
+QUICAltConnectionManager::_init_alt_connection_ids()
 {
-  if (preferred_endpoint_ipv4 || preferred_endpoint_ipv6) {
-    this->_alt_quic_connection_ids_local[0] = this->_generate_next_alt_con_info();
-    // This alt cid will be advertised via Transport Parameter
-    this->_alt_quic_connection_ids_local[0].advertised = true;
-
-    IpEndpoint empty_endpoint_ipv4;
-    IpEndpoint empty_endpoint_ipv6;
-    empty_endpoint_ipv4.sa.sa_family = AF_UNSPEC;
-    empty_endpoint_ipv6.sa.sa_family = AF_UNSPEC;
-    if (preferred_endpoint_ipv4 == nullptr) {
-      preferred_endpoint_ipv4 = &empty_endpoint_ipv4;
-    }
-    if (preferred_endpoint_ipv6 == nullptr) {
-      preferred_endpoint_ipv6 = &empty_endpoint_ipv6;
-    }
-
-    // FIXME Check nullptr dereference
-    this->_preferred_address =
-      new QUICPreferredAddress(*preferred_endpoint_ipv4, *preferred_endpoint_ipv6, this->_alt_quic_connection_ids_local[0].id,
-                               this->_alt_quic_connection_ids_local[0].token);
-  }
-
-  for (int i = (preferred_endpoint_ipv4 || preferred_endpoint_ipv6 ? 1 : 0); i < this->_nids; ++i) {
+  for (int i = 0; i < this->_remote_active_cid_limit; ++i) {
     this->_alt_quic_connection_ids_local[i] = this->_generate_next_alt_con_info();
   }
   this->_need_advertise = true;
@@ -152,19 +136,24 @@
 bool
 QUICAltConnectionManager::_update_alt_connection_id(uint64_t chosen_seq_num)
 {
-  for (int i = 0; i < this->_nids; ++i) {
-    if (_alt_quic_connection_ids_local[i].seq_num == chosen_seq_num) {
-      _alt_quic_connection_ids_local[i] = this->_generate_next_alt_con_info();
-      this->_need_advertise             = true;
-      return true;
-    }
-  }
-
   // Seq 0 is special so it's not in the array
   if (chosen_seq_num == 0) {
     return true;
   }
 
+  // Seq 1 is for Preferred Address
+  if (chosen_seq_num == 1) {
+    return true;
+  }
+
+  for (int i = 0; i < this->_remote_active_cid_limit; ++i) {
+    if (this->_alt_quic_connection_ids_local[i].seq_num == chosen_seq_num) {
+      this->_alt_quic_connection_ids_local[i] = this->_generate_next_alt_con_info();
+      this->_need_advertise                   = true;
+      return true;
+    }
+  }
+
   return false;
 }
 
@@ -177,8 +166,15 @@
     error = std::make_unique<QUICConnectionError>(QUICTransErrorCode::PROTOCOL_VIOLATION, "received zero-length cid",
                                                   QUICFrameType::NEW_CONNECTION_ID);
   } else {
-    this->_alt_quic_connection_ids_remote.push_back(
-      {frame.sequence(), frame.connection_id(), frame.stateless_reset_token(), {false}});
+    int unused = std::count_if(this->_alt_quic_connection_ids_remote.begin(), this->_alt_quic_connection_ids_remote.end(),
+                               [](AltConnectionInfo info) { return info.used == false && info.seq_num != 1; });
+    if (unused > this->_local_active_cid_limit) {
+      error = std::make_unique<QUICConnectionError>(QUICTransErrorCode::PROTOCOL_VIOLATION, "received too many alt CIDs",
+                                                    QUICFrameType::NEW_CONNECTION_ID);
+    } else {
+      this->_alt_quic_connection_ids_remote.push_back(
+        {frame.sequence(), frame.connection_id(), frame.stateless_reset_token(), {false}});
+    }
   }
 
   return error;
@@ -214,10 +210,6 @@
 QUICConnectionId
 QUICAltConnectionManager::migrate_to_alt_cid()
 {
-  if (this->_qc->direction() == NET_VCONNECTION_OUT) {
-    this->_init_alt_connection_ids();
-  }
-
   for (auto &info : this->_alt_quic_connection_ids_remote) {
     if (info.used) {
       continue;
@@ -233,7 +225,14 @@
 bool
 QUICAltConnectionManager::migrate_to(const QUICConnectionId &cid, QUICStatelessResetToken &new_reset_token)
 {
-  for (unsigned int i = 0; i < this->_nids; ++i) {
+  if (this->_local_preferred_address) {
+    if (cid == this->_local_preferred_address->cid()) {
+      new_reset_token = this->_local_preferred_address->token();
+      return true;
+    }
+  }
+
+  for (int i = 0; i < this->_remote_active_cid_limit; ++i) {
     AltConnectionInfo &info = this->_alt_quic_connection_ids_local[i];
     if (info.id == cid) {
       // Migrate connection
@@ -260,13 +259,33 @@
 void
 QUICAltConnectionManager::invalidate_alt_connections()
 {
-  for (unsigned int i = 0; i < this->_nids; ++i) {
+  int n = this->_remote_active_cid_limit + ((this->_local_preferred_address == nullptr) ? 1 : 0);
+
+  for (int i = 0; i < n; ++i) {
     this->_ctable.erase(this->_alt_quic_connection_ids_local[i].id, this->_qc);
   }
 }
 
+void
+QUICAltConnectionManager::set_remote_preferred_address(const QUICPreferredAddress &preferred_address)
+{
+  ink_assert(preferred_address.is_available());
+
+  // Sequence number of the preferred address is 1 if available
+  this->_alt_quic_connection_ids_remote.push_back({1, preferred_address.cid(), preferred_address.token(), {false}});
+}
+
+void
+QUICAltConnectionManager::set_remote_active_cid_limit(uint8_t active_cid_limit)
+{
+  this->_remote_active_cid_limit =
+    std::min(static_cast<unsigned int>(active_cid_limit), countof(this->_alt_quic_connection_ids_local));
+  this->_init_alt_connection_ids();
+}
+
 bool
-QUICAltConnectionManager::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICAltConnectionManager::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting,
+                                              uint32_t seq_num)
 {
   if (!this->_is_level_matched(level)) {
     return false;
@@ -280,7 +299,7 @@
  */
 QUICFrame *
 QUICAltConnectionManager::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t /* connection_credit */,
-                                         uint16_t maximum_frame_size, ink_hrtime timestamp)
+                                         uint16_t maximum_frame_size, size_t current_packet_size, uint32_t seq_num)
 {
   QUICFrame *frame = nullptr;
   if (!this->_is_level_matched(level)) {
@@ -288,10 +307,10 @@
   }
 
   if (this->_need_advertise) {
-    int count = this->_nids;
-    for (int i = 0; i < count; ++i) {
+    for (int i = 0; i < this->_remote_active_cid_limit; ++i) {
       if (!this->_alt_quic_connection_ids_local[i].advertised) {
-        frame = QUICFrameFactory::create_new_connection_id_frame(buf, this->_alt_quic_connection_ids_local[i].seq_num,
+        // FIXME Should send a sequence number for retire_prior_to. Sending 0 for now.
+        frame = QUICFrameFactory::create_new_connection_id_frame(buf, this->_alt_quic_connection_ids_local[i].seq_num, 0,
                                                                  this->_alt_quic_connection_ids_local[i].id,
                                                                  this->_alt_quic_connection_ids_local[i].token);
 
@@ -310,12 +329,11 @@
   }
 
   if (!this->_retired_seq_nums.empty()) {
-    if (auto s = this->_retired_seq_nums.front()) {
-      frame = QUICFrameFactory::create_retire_connection_id_frame(buf, s);
-      this->_records_retire_connection_id_frame(level, static_cast<const QUICRetireConnectionIdFrame &>(*frame));
-      this->_retired_seq_nums.pop();
-      return frame;
-    }
+    auto s = this->_retired_seq_nums.front();
+    frame  = QUICFrameFactory::create_retire_connection_id_frame(buf, s);
+    this->_records_retire_connection_id_frame(level, static_cast<const QUICRetireConnectionIdFrame &>(*frame));
+    this->_retired_seq_nums.pop();
+    return frame;
   }
 
   return frame;
@@ -351,7 +369,7 @@
   switch (info->type) {
   case QUICFrameType::NEW_CONNECTION_ID: {
     AltConnectionInfo *frame_info = reinterpret_cast<AltConnectionInfo *>(info->data);
-    for (int i = 0; i < this->_nids; ++i) {
+    for (int i = 0; i < this->_remote_active_cid_limit; ++i) {
       if (this->_alt_quic_connection_ids_local[i].seq_num == frame_info->seq_num) {
         ink_assert(this->_alt_quic_connection_ids_local[i].advertised);
         this->_alt_quic_connection_ids_local[i].advertised = false;
diff --git a/iocore/net/quic/QUICAltConnectionManager.h b/iocore/net/quic/QUICAltConnectionManager.h
index 501ab99..09b99ca 100644
--- a/iocore/net/quic/QUICAltConnectionManager.h
+++ b/iocore/net/quic/QUICAltConnectionManager.h
@@ -35,16 +35,8 @@
 class QUICAltConnectionManager : public QUICFrameHandler, public QUICFrameGenerator
 {
 public:
-  /**
-   * Constructor for clients
-   */
   QUICAltConnectionManager(QUICConnection *qc, QUICConnectionTable &ctable, const QUICConnectionId &peer_initial_cid,
-                           uint32_t instance_id, uint8_t num_alt_con, const QUICPreferredAddress &preferred_address);
-  /**
-   * Constructor for servers
-   */
-  QUICAltConnectionManager(QUICConnection *qc, QUICConnectionTable &ctable, const QUICConnectionId &peer_initial_cid,
-                           uint32_t instance_id, uint8_t num_alt_con, const IpEndpoint *preferred_endpoint_ipv4 = nullptr,
+                           uint32_t instance_id, uint8_t active_cid_limit, const IpEndpoint *preferred_endpoint_ipv4 = nullptr,
                            const IpEndpoint *preferred_endpoint_ipv6 = nullptr);
   ~QUICAltConnectionManager();
 
@@ -68,6 +60,9 @@
 
   void drop_cid(const QUICConnectionId &cid);
 
+  void set_remote_preferred_address(const QUICPreferredAddress &preferred_address);
+  void set_remote_active_cid_limit(uint8_t active_cid_limit);
+
   /**
    * Invalidate all CIDs prepared
    */
@@ -83,9 +78,9 @@
   virtual QUICConnectionErrorUPtr handle_frame(QUICEncryptionLevel level, const QUICFrame &frame) override;
 
   // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
 private:
   struct AltConnectionInfo {
@@ -100,18 +95,18 @@
 
   QUICConnection *_qc = nullptr;
   QUICConnectionTable &_ctable;
-  AltConnectionInfo *_alt_quic_connection_ids_local;
+  AltConnectionInfo _alt_quic_connection_ids_local[8]; // 8 is perhaps enough
   std::vector<AltConnectionInfo> _alt_quic_connection_ids_remote;
   std::queue<uint64_t> _retired_seq_nums;
-  uint32_t _instance_id                    = 0;
-  uint8_t _nids                            = 1;
-  uint64_t _alt_quic_connection_id_seq_num = 0;
-  bool _need_advertise                     = false;
-  QUICPreferredAddress *_preferred_address = nullptr;
+  uint32_t _instance_id                          = 0;
+  uint8_t _local_active_cid_limit                = 0;
+  uint8_t _remote_active_cid_limit               = 0;
+  uint64_t _alt_quic_connection_id_seq_num       = 0;
+  bool _need_advertise                           = false;
+  QUICPreferredAddress *_local_preferred_address = nullptr;
 
   AltConnectionInfo _generate_next_alt_con_info();
-  void _init_alt_connection_ids(const IpEndpoint *preferred_endpoint_ipv4 = nullptr,
-                                const IpEndpoint *preferred_endpoint_ipv6 = nullptr);
+  void _init_alt_connection_ids();
   bool _update_alt_connection_id(uint64_t chosen_seq_num);
 
   void _records_new_connection_id_frame(QUICEncryptionLevel level, const QUICNewConnectionIdFrame &frame);
diff --git a/iocore/net/quic/QUICBidirectionalStream.cc b/iocore/net/quic/QUICBidirectionalStream.cc
index bbd98d9..c028998 100644
--- a/iocore/net/quic/QUICBidirectionalStream.cc
+++ b/iocore/net/quic/QUICBidirectionalStream.cc
@@ -352,15 +352,16 @@
 }
 
 bool
-QUICBidirectionalStream::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICBidirectionalStream::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting,
+                                             uint32_t seq_num)
 {
-  return this->_local_flow_controller.will_generate_frame(level, timestamp) || !this->is_retransmited_frame_queue_empty() ||
-         this->_write_vio.get_reader()->is_read_avail_more_than(0);
+  return this->_local_flow_controller.will_generate_frame(level, current_packet_size, ack_eliciting, seq_num) ||
+         !this->is_retransmited_frame_queue_empty() || this->_write_vio.get_reader()->is_read_avail_more_than(0);
 }
 
 QUICFrame *
 QUICBidirectionalStream::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit,
-                                        uint16_t maximum_frame_size, ink_hrtime timestamp)
+                                        uint16_t maximum_frame_size, size_t current_packet_size, uint32_t seq_num)
 {
   SCOPED_MUTEX_LOCK(lock, this->_write_vio.mutex, this_ethread());
 
@@ -391,7 +392,7 @@
   }
 
   // MAX_STREAM_DATA
-  frame = this->_local_flow_controller.generate_frame(buf, level, UINT16_MAX, maximum_frame_size, timestamp);
+  frame = this->_local_flow_controller.generate_frame(buf, level, UINT16_MAX, maximum_frame_size, current_packet_size, seq_num);
   if (frame) {
     return frame;
   }
@@ -427,7 +428,8 @@
     uint64_t stream_credit = this->_remote_flow_controller.credit();
     if (stream_credit == 0) {
       // STREAM_DATA_BLOCKED
-      frame = this->_remote_flow_controller.generate_frame(buf, level, UINT16_MAX, maximum_frame_size, timestamp);
+      frame =
+        this->_remote_flow_controller.generate_frame(buf, level, UINT16_MAX, maximum_frame_size, current_packet_size, seq_num);
       return frame;
     }
 
diff --git a/iocore/net/quic/QUICBidirectionalStream.h b/iocore/net/quic/QUICBidirectionalStream.h
index fcbd5d7..d64f899 100644
--- a/iocore/net/quic/QUICBidirectionalStream.h
+++ b/iocore/net/quic/QUICBidirectionalStream.h
@@ -44,9 +44,9 @@
   int state_stream_closed(int event, void *data);
 
   // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
   virtual QUICConnectionErrorUPtr recv(const QUICStreamFrame &frame) override;
   virtual QUICConnectionErrorUPtr recv(const QUICMaxStreamDataFrame &frame) override;
diff --git a/iocore/net/quic/QUICConfig.cc b/iocore/net/quic/QUICConfig.cc
index 600cef8..1cfe703 100644
--- a/iocore/net/quic/QUICConfig.cc
+++ b/iocore/net/quic/QUICConfig.cc
@@ -117,7 +117,6 @@
 {
   REC_EstablishStaticConfigInt32U(this->_instance_id, "proxy.config.quic.instance_id");
   REC_EstablishStaticConfigInt32(this->_connection_table_size, "proxy.config.quic.connection_table.size");
-  REC_EstablishStaticConfigInt32U(this->_num_alt_connection_ids, "proxy.config.quic.num_alt_connection_ids");
   REC_EstablishStaticConfigInt32U(this->_stateless_retry, "proxy.config.quic.server.stateless_retry_enabled");
   REC_EstablishStaticConfigInt32U(this->_vn_exercise_enabled, "proxy.config.quic.client.vn_exercise_enabled");
   REC_EstablishStaticConfigInt32U(this->_cm_exercise_enabled, "proxy.config.quic.client.cm_exercise_enabled");
@@ -158,6 +157,8 @@
   REC_EstablishStaticConfigInt32U(this->_ack_delay_exponent_out, "proxy.config.quic.ack_delay_exponent_out");
   REC_EstablishStaticConfigInt32U(this->_max_ack_delay_in, "proxy.config.quic.max_ack_delay_in");
   REC_EstablishStaticConfigInt32U(this->_max_ack_delay_out, "proxy.config.quic.max_ack_delay_out");
+  REC_EstablishStaticConfigInt32U(this->_active_cid_limit_in, "proxy.config.quic.active_cid_limit_in");
+  REC_EstablishStaticConfigInt32U(this->_active_cid_limit_out, "proxy.config.quic.active_cid_limit_out");
 
   // Loss Detection
   REC_EstablishStaticConfigInt32U(this->_ld_packet_threshold, "proxy.config.quic.loss_detection.packet_threshold");
@@ -226,12 +227,6 @@
 }
 
 uint32_t
-QUICConfigParams::num_alt_connection_ids() const
-{
-  return this->_num_alt_connection_ids;
-}
-
-uint32_t
 QUICConfigParams::stateless_retry() const
 {
   return this->_stateless_retry;
@@ -345,6 +340,18 @@
   return this->_max_ack_delay_out;
 }
 
+uint8_t
+QUICConfigParams::active_cid_limit_in() const
+{
+  return this->_active_cid_limit_in;
+}
+
+uint8_t
+QUICConfigParams::active_cid_limit_out() const
+{
+  return this->_active_cid_limit_out;
+}
+
 const char *
 QUICConfigParams::server_supported_groups() const
 {
diff --git a/iocore/net/quic/QUICConfig.h b/iocore/net/quic/QUICConfig.h
index 36ff7af..67106e6 100644
--- a/iocore/net/quic/QUICConfig.h
+++ b/iocore/net/quic/QUICConfig.h
@@ -37,7 +37,6 @@
   void initialize();
 
   uint32_t instance_id() const;
-  uint32_t num_alt_connection_ids() const;
   uint32_t stateless_retry() const;
   uint32_t vn_exercise_enabled() const;
   uint32_t cm_exercise_enabled() const;
@@ -70,6 +69,8 @@
   uint8_t ack_delay_exponent_out() const;
   uint8_t max_ack_delay_in() const;
   uint8_t max_ack_delay_out() const;
+  uint8_t active_cid_limit_in() const;
+  uint8_t active_cid_limit_out() const;
 
   // Loss Detection
   uint32_t ld_packet_threshold() const;
@@ -92,11 +93,10 @@
   // TODO: make configurable
   static const uint8_t _scid_len = 18; //< Length of Source Connection ID
 
-  uint32_t _instance_id            = 0;
-  uint32_t _num_alt_connection_ids = 0;
-  uint32_t _stateless_retry        = 0;
-  uint32_t _vn_exercise_enabled    = 0;
-  uint32_t _cm_exercise_enabled    = 0;
+  uint32_t _instance_id         = 0;
+  uint32_t _stateless_retry     = 0;
+  uint32_t _vn_exercise_enabled = 0;
+  uint32_t _cm_exercise_enabled = 0;
 
   char *_server_supported_groups = nullptr;
   char *_client_supported_groups = nullptr;
@@ -128,19 +128,21 @@
   uint32_t _ack_delay_exponent_out                  = 0;
   uint32_t _max_ack_delay_in                        = 0;
   uint32_t _max_ack_delay_out                       = 0;
+  uint32_t _active_cid_limit_in                     = 0;
+  uint32_t _active_cid_limit_out                    = 0;
 
   // [draft-17 recovery] 6.4.1.  Constants of interest
   uint32_t _ld_packet_threshold = 3;
   float _ld_time_threshold      = 1.25;
   ink_hrtime _ld_granularity    = HRTIME_MSECONDS(1);
-  ink_hrtime _ld_initial_rtt    = HRTIME_MSECONDS(100);
+  ink_hrtime _ld_initial_rtt    = HRTIME_MSECONDS(500);
 
   // [draft-11 recovery] 4.7.1.  Constants of interest
   uint32_t _cc_max_datagram_size               = 1200;
   uint32_t _cc_initial_window_scale            = 10; // Actual initial window size is this value multiplied by the _cc_default_mss
   uint32_t _cc_minimum_window_scale            = 2;  // Actual minimum window size is this value multiplied by the _cc_default_mss
   float _cc_loss_reduction_factor              = 0.5;
-  uint32_t _cc_persistent_congestion_threshold = 2;
+  uint32_t _cc_persistent_congestion_threshold = 3;
 };
 
 class QUICConfig
diff --git a/iocore/net/quic/QUICCongestionController.h b/iocore/net/quic/QUICCongestionController.h
new file mode 100644
index 0000000..46341dc
--- /dev/null
+++ b/iocore/net/quic/QUICCongestionController.h
@@ -0,0 +1,53 @@
+/** @file
+ *
+ *  A brief file description
+ *
+ *  @section license License
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+struct QUICPacketInfo {
+  // 6.3.1.  Sent Packet Fields
+  QUICPacketNumber packet_number;
+  ink_hrtime time_sent;
+  bool ack_eliciting;
+  bool is_crypto_packet;
+  bool in_flight;
+  size_t sent_bytes;
+
+  // addition
+  QUICPacketType type;
+  std::vector<QUICFrameInfo> frames;
+  QUICPacketNumberSpace pn_space;
+  // end
+};
+
+class QUICCongestionController
+{
+public:
+  virtual ~QUICCongestionController() {}
+  virtual void on_packet_sent(size_t bytes_sent)                                                                    = 0;
+  virtual void on_packet_acked(const QUICPacketInfo &acked_packet)                                                  = 0;
+  virtual void process_ecn(const QUICPacketInfo &acked_largest_packet, const QUICAckFrame::EcnSection *ecn_section) = 0;
+  virtual void on_packets_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &packets)                         = 0;
+  virtual void add_extra_credit()                                                                                   = 0;
+  virtual void reset()                                                                                              = 0;
+  virtual uint32_t credit() const                                                                                   = 0;
+};
diff --git a/iocore/net/quic/QUICConnection.h b/iocore/net/quic/QUICConnection.h
index d2c3d56..28c5a83 100644
--- a/iocore/net/quic/QUICConnection.h
+++ b/iocore/net/quic/QUICConnection.h
@@ -34,6 +34,7 @@
 class QUICConnectionInfoProvider
 {
 public:
+  virtual ~QUICConnectionInfoProvider() {}
   virtual QUICConnectionId peer_connection_id() const     = 0;
   virtual QUICConnectionId original_connection_id() const = 0;
   virtual QUICConnectionId first_connection_id() const    = 0;
diff --git a/iocore/net/quic/QUICContext.cc b/iocore/net/quic/QUICContext.cc
new file mode 100644
index 0000000..7ccb9e4
--- /dev/null
+++ b/iocore/net/quic/QUICContext.cc
@@ -0,0 +1,147 @@
+/** @file
+
+  A brief file description
+
+  @section license License
+
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you 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
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+#include "QUICContext.h"
+#include "QUICConnection.h"
+#include "QUICLossDetector.h"
+#include "QUICPacketProtectionKeyInfo.h"
+
+class QUICCCConfigQCP : public QUICCCConfig
+{
+public:
+  virtual ~QUICCCConfigQCP() {}
+  QUICCCConfigQCP(const QUICConfigParams *params) : _params(params) {}
+
+  uint32_t
+  max_datagram_size() const override
+  {
+    return this->_params->cc_max_datagram_size();
+  }
+
+  uint32_t
+  initial_window() const override
+  {
+    return this->_params->cc_initial_window();
+  }
+
+  uint32_t
+  minimum_window() const override
+  {
+    return this->_params->cc_minimum_window();
+  }
+
+  float
+  loss_reduction_factor() const override
+  {
+    return this->_params->cc_loss_reduction_factor();
+  }
+
+  uint32_t
+  persistent_congestion_threshold() const override
+  {
+    return this->_params->cc_persistent_congestion_threshold();
+  }
+
+private:
+  const QUICConfigParams *_params;
+};
+
+class QUICLDConfigQCP : public QUICLDConfig
+{
+public:
+  virtual ~QUICLDConfigQCP() {}
+  QUICLDConfigQCP(const QUICConfigParams *params) : _params(params) {}
+
+  uint32_t
+  packet_threshold() const override
+  {
+    return this->_params->ld_packet_threshold();
+  }
+
+  float
+  time_threshold() const override
+  {
+    return this->_params->ld_time_threshold();
+  }
+
+  ink_hrtime
+  granularity() const override
+  {
+    return this->_params->ld_granularity();
+  }
+
+  ink_hrtime
+  initial_rtt() const override
+  {
+    return this->_params->ld_initial_rtt();
+  }
+
+private:
+  const QUICConfigParams *_params;
+};
+
+QUICContextImpl::QUICContextImpl(QUICRTTProvider *rtt, QUICConnectionInfoProvider *info,
+                                 QUICPacketProtectionKeyInfoProvider *key_info)
+  : _key_info(key_info),
+    _connection_info(info),
+    _rtt_provider(rtt),
+    _ld_config(std::make_unique<QUICLDConfigQCP>(_config)),
+    _cc_config(std::make_unique<QUICCCConfigQCP>(_config))
+{
+}
+
+QUICConnectionInfoProvider *
+QUICContextImpl::connection_info() const
+{
+  return _connection_info;
+}
+
+QUICConfig::scoped_config
+QUICContextImpl::config() const
+{
+  return _config;
+}
+
+QUICPacketProtectionKeyInfoProvider *
+QUICContextImpl::key_info() const
+{
+  return _key_info;
+}
+
+QUICRTTProvider *
+QUICContextImpl::rtt_provider() const
+{
+  return _rtt_provider;
+}
+
+QUICLDConfig &
+QUICContextImpl::ld_config() const
+{
+  return *_ld_config;
+}
+
+QUICCCConfig &
+QUICContextImpl::cc_config() const
+{
+  return *_cc_config;
+}
diff --git a/iocore/net/quic/QUICContext.h b/iocore/net/quic/QUICContext.h
new file mode 100644
index 0000000..57e6c0b
--- /dev/null
+++ b/iocore/net/quic/QUICContext.h
@@ -0,0 +1,84 @@
+/** @file
+
+  A brief file description
+
+  @section license License
+
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you 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
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+#pragma once
+
+#include "QUICConnection.h"
+#include "QUICConfig.h"
+
+class QUICRTTProvider;
+class QUICCongestionController;
+class QUICPacketProtectionKeyInfoProvider;
+
+class QUICNetVConnection;
+
+class QUICContext
+{
+public:
+  virtual ~QUICContext(){};
+  virtual QUICConnectionInfoProvider *connection_info() const = 0;
+  virtual QUICConfig::scoped_config config() const            = 0;
+};
+
+class QUICLDContext
+{
+public:
+  virtual ~QUICLDContext() {}
+  virtual QUICConnectionInfoProvider *connection_info() const   = 0;
+  virtual QUICLDConfig &ld_config() const                       = 0;
+  virtual QUICPacketProtectionKeyInfoProvider *key_info() const = 0;
+};
+
+class QUICCCContext
+{
+public:
+  virtual ~QUICCCContext() {}
+  virtual QUICConnectionInfoProvider *connection_info() const = 0;
+  virtual QUICCCConfig &cc_config() const                     = 0;
+  virtual QUICRTTProvider *rtt_provider() const               = 0;
+};
+
+class QUICContextImpl : public QUICContext, public QUICCCContext, public QUICLDContext
+{
+public:
+  QUICContextImpl(QUICRTTProvider *rtt, QUICConnectionInfoProvider *info, QUICPacketProtectionKeyInfoProvider *key_info);
+
+  virtual QUICConnectionInfoProvider *connection_info() const override;
+  virtual QUICConfig::scoped_config config() const override;
+  virtual QUICRTTProvider *rtt_provider() const override;
+
+  // TODO should be more abstract
+  virtual QUICPacketProtectionKeyInfoProvider *key_info() const override;
+
+  virtual QUICLDConfig &ld_config() const override;
+  virtual QUICCCConfig &cc_config() const override;
+
+private:
+  QUICConfig::scoped_config _config;
+  QUICPacketProtectionKeyInfoProvider *_key_info = nullptr;
+  QUICConnectionInfoProvider *_connection_info   = nullptr;
+  QUICRTTProvider *_rtt_provider                 = nullptr;
+
+  std::unique_ptr<QUICLDConfig> _ld_config = nullptr;
+  std::unique_ptr<QUICCCConfig> _cc_config = nullptr;
+};
diff --git a/iocore/net/quic/QUICCryptoStream.cc b/iocore/net/quic/QUICCryptoStream.cc
index f3b702c..ba3afa2 100644
--- a/iocore/net/quic/QUICCryptoStream.cc
+++ b/iocore/net/quic/QUICCryptoStream.cc
@@ -102,7 +102,7 @@
 }
 
 bool
-QUICCryptoStream::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICCryptoStream::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num)
 {
   return this->_write_buffer_reader->is_read_avail_more_than(0) || !this->is_retransmited_frame_queue_empty();
 }
@@ -112,7 +112,7 @@
  */
 QUICFrame *
 QUICCryptoStream::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t /* connection_credit */,
-                                 uint16_t maximum_frame_size, ink_hrtime timestamp)
+                                 uint16_t maximum_frame_size, size_t current_packet_size, uint32_t seq_num)
 {
   QUICConnectionErrorUPtr error = nullptr;
 
diff --git a/iocore/net/quic/QUICCryptoStream.h b/iocore/net/quic/QUICCryptoStream.h
index 6da3b2f..42f99db 100644
--- a/iocore/net/quic/QUICCryptoStream.h
+++ b/iocore/net/quic/QUICCryptoStream.h
@@ -53,9 +53,9 @@
   int64_t write(const uint8_t *buf, int64_t len);
 
   // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
 private:
   void _on_frame_acked(QUICFrameInformationUPtr &info) override;
diff --git a/iocore/net/quic/QUICDebugNames.cc b/iocore/net/quic/QUICDebugNames.cc
index b70d959..bf9d2d8 100644
--- a/iocore/net/quic/QUICDebugNames.cc
+++ b/iocore/net/quic/QUICDebugNames.cc
@@ -121,22 +121,20 @@
     return "INTERNAL_ERROR";
   case static_cast<uint16_t>(QUICTransErrorCode::FLOW_CONTROL_ERROR):
     return "FLOW_CONTROL_ERROR";
-  case static_cast<uint16_t>(QUICTransErrorCode::STREAM_ID_ERROR):
-    return "STREAM_ID_ERROR";
+  case static_cast<uint16_t>(QUICTransErrorCode::STREAM_LIMIT_ERROR):
+    return "STREAM_LIMIT_ERROR";
   case static_cast<uint16_t>(QUICTransErrorCode::STREAM_STATE_ERROR):
     return "STREAM_STATE_ERROR";
-  case static_cast<uint16_t>(QUICTransErrorCode::FINAL_OFFSET_ERROR):
-    return "FINAL_OFFSET_ERROR";
+  case static_cast<uint16_t>(QUICTransErrorCode::FINAL_SIZE_ERROR):
+    return "FINAL_SIZE_ERROR";
   case static_cast<uint16_t>(QUICTransErrorCode::FRAME_ENCODING_ERROR):
     return "FRAME_ENCODING_ERROR";
   case static_cast<uint16_t>(QUICTransErrorCode::TRANSPORT_PARAMETER_ERROR):
     return "TRANSPORT_PARAMETER_ERROR";
-  case static_cast<uint16_t>(QUICTransErrorCode::VERSION_NEGOTIATION_ERROR):
-    return "VERSION_NEGOTIATION_ERROR";
   case static_cast<uint16_t>(QUICTransErrorCode::PROTOCOL_VIOLATION):
     return "PROTOCOL_VIOLATION";
-  case static_cast<uint16_t>(QUICTransErrorCode::INVALID_MIGRATION):
-    return "INVALID_MIGRATION";
+  case static_cast<uint16_t>(QUICTransErrorCode::CRYPTO_BUFFER_EXCEEDED):
+    return "CRYPTO_BUFFER_EXCEEDED";
   default:
     if (0x0100 <= code && code <= 0x01FF) {
       return "CRYPTO_ERROR";
@@ -193,8 +191,8 @@
     return "ACK_DELAY_EXPONENT";
   case QUICTransportParameterId::INITIAL_MAX_STREAMS_UNI:
     return "INITIAL_MAX_STREAMS_UNI";
-  case QUICTransportParameterId::DISABLE_MIGRATION:
-    return "DISABLE_MIGRATION";
+  case QUICTransportParameterId::DISABLE_ACTIVE_MIGRATION:
+    return "DISABLE_ACTIVE_MIGRATION";
   case QUICTransportParameterId::INITIAL_MAX_STREAM_DATA_BIDI_REMOTE:
     return "INITIAL_MAX_STREAM_DATA_BIDI_REMOTE";
   case QUICTransportParameterId::INITIAL_MAX_STREAM_DATA_UNI:
@@ -203,6 +201,8 @@
     return "INITIAL_MAX_ACK_DELAY";
   case QUICTransportParameterId::ORIGINAL_CONNECTION_ID:
     return "INITIAL_ORIGINAL_CONNECTION_ID";
+  case QUICTransportParameterId::ACTIVE_CONNECTION_ID_LIMIT:
+    return "ACTIVE_CONNECTION_ID_LIMIT";
   default:
     return "UNKNOWN";
   }
diff --git a/iocore/net/quic/QUICFlowController.cc b/iocore/net/quic/QUICFlowController.cc
index 7c2e3db..b5275d0 100644
--- a/iocore/net/quic/QUICFlowController.cc
+++ b/iocore/net/quic/QUICFlowController.cc
@@ -96,7 +96,7 @@
 
 // For RemoteFlowController, caller of this function should also check QUICStreamManager::will_generate_frame()
 bool
-QUICFlowController::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICFlowController::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num)
 {
   if (!this->_is_level_matched(level)) {
     return false;
@@ -110,7 +110,7 @@
  */
 QUICFrame *
 QUICFlowController::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t /* connection_credit */,
-                                   uint16_t maximum_frame_size, ink_hrtime timestamp)
+                                   uint16_t maximum_frame_size, size_t current_packet_size, uint32_t seq_num)
 {
   QUICFrame *frame = nullptr;
 
diff --git a/iocore/net/quic/QUICFlowController.h b/iocore/net/quic/QUICFlowController.h
index c3cb637..62adf9f 100644
--- a/iocore/net/quic/QUICFlowController.h
+++ b/iocore/net/quic/QUICFlowController.h
@@ -60,9 +60,9 @@
   virtual void set_limit(QUICOffset limit);
 
   // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
 protected:
   QUICFlowController(uint64_t initial_limit) : _limit(initial_limit) {}
diff --git a/iocore/net/quic/QUICFrame.cc b/iocore/net/quic/QUICFrame.cc
index 903c4e9..0c4e0ba 100644
--- a/iocore/net/quic/QUICFrame.cc
+++ b/iocore/net/quic/QUICFrame.cc
@@ -59,6 +59,20 @@
 }
 
 bool
+QUICFrame::ack_eliciting() const
+{
+  auto type = this->type();
+
+  return type != QUICFrameType::PADDING && type != QUICFrameType::ACK;
+}
+
+const QUICPacket *
+QUICFrame::packet() const
+{
+  return this->_packet;
+}
+
+bool
 QUICFrame::is_probing_frame() const
 {
   return false;
@@ -105,22 +119,6 @@
   }
 }
 
-Ptr<IOBufferBlock>
-QUICFrame::to_io_buffer_block(size_t limit) const
-{
-  // FIXME Each classes should override this and drop store().
-  // This just wraps store() for now.
-
-  Ptr<IOBufferBlock> block = make_ptr<IOBufferBlock>(new_IOBufferBlock());
-  block->alloc(iobuffer_size_to_index(limit));
-
-  size_t written_len = 0;
-  this->store(reinterpret_cast<uint8_t *>(block->start()), &written_len, limit);
-  block->fill(written_len);
-
-  return block;
-}
-
 int
 QUICFrame::debug_msg(char *msg, size_t msg_len) const
 {
@@ -149,9 +147,9 @@
 {
 }
 
-QUICStreamFrame::QUICStreamFrame(const uint8_t *buf, size_t len)
+QUICStreamFrame::QUICStreamFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 QUICStreamFrame::QUICStreamFrame(const QUICStreamFrame &o)
@@ -166,10 +164,11 @@
 }
 
 void
-QUICStreamFrame::parse(const uint8_t *buf, size_t len)
+QUICStreamFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
+  this->_packet = packet;
 
   uint8_t *pos            = const_cast<uint8_t *>(buf);
   this->_has_offset_field = (buf[0] & 0x04) != 0; // "O" of "0b00010OLF"
@@ -261,12 +260,6 @@
   return true;
 }
 
-size_t
-QUICStreamFrame::store(uint8_t *buf, size_t *len, size_t limit) const
-{
-  return this->store(buf, len, limit, true);
-}
-
 int
 QUICStreamFrame::debug_msg(char *msg, size_t msg_len) const
 {
@@ -333,13 +326,6 @@
   return *len;
 }
 
-size_t
-QUICStreamFrame::store(uint8_t *buf, size_t *len, size_t limit, bool include_length_field) const
-{
-  ink_assert(!"Call to_io_buffer_block() instead");
-  return 0;
-}
-
 QUICStreamId
 QUICStreamFrame::stream_id() const
 {
@@ -406,9 +392,9 @@
 {
 }
 
-QUICCryptoFrame::QUICCryptoFrame(const uint8_t *buf, size_t len)
+QUICCryptoFrame::QUICCryptoFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 QUICCryptoFrame::QUICCryptoFrame(const QUICCryptoFrame &o)
@@ -417,11 +403,12 @@
 }
 
 void
-QUICCryptoFrame::parse(const uint8_t *buf, size_t len)
+QUICCryptoFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_offset, field_len)) {
@@ -488,14 +475,34 @@
                   this->data_length());
 }
 
-size_t
-QUICCryptoFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICCryptoFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> header;
+
   if (limit < this->size()) {
-    return 0;
+    return header;
   }
 
-  // Frame Type
+  // Create header block
+  size_t written_len = 0;
+  header             = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  header->alloc(iobuffer_size_to_index(MAX_HEADER_SIZE));
+  this->_store_header(reinterpret_cast<uint8_t *>(header->start()), &written_len);
+  header->fill(written_len);
+
+  // Append payload block to a chain
+  ink_assert(written_len + this->data_length() <= limit);
+  header->next = this->data();
+
+  // Return the chain
+  return header;
+}
+
+size_t
+QUICCryptoFrame::_store_header(uint8_t *buf, size_t *len) const
+{
+  // Type
   buf[0] = static_cast<uint8_t>(QUICFrameType::CRYPTO);
   *len   = 1;
 
@@ -509,10 +516,6 @@
   QUICIntUtil::write_QUICVariableInt(this->data_length(), buf + *len, &n);
   *len += n;
 
-  // Crypto Data (*)
-  memcpy(buf + *len, this->data()->start(), this->data_length());
-  *len += this->data_length();
-
   return *len;
 }
 
@@ -538,18 +541,19 @@
 // ACK frame
 //
 
-QUICAckFrame::QUICAckFrame(const uint8_t *buf, size_t len)
+QUICAckFrame::QUICAckFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
-QUICAckFrame::parse(const uint8_t *buf, size_t len)
+QUICAckFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
-  bool has_ecn = (buf[0] == static_cast<uint8_t>(QUICFrameType::ACK_WITH_ECN));
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
+  bool has_ecn  = (buf[0] == static_cast<uint8_t>(QUICFrameType::ACK_WITH_ECN));
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_largest_acknowledged, field_len)) {
@@ -666,33 +670,43 @@
   return pre_len;
 }
 
-size_t
-QUICAckFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICAckFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  uint8_t *p = buf;
-  size_t n;
-  *p = static_cast<uint8_t>(QUICFrameType::ACK);
-  ++p;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + 24));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  QUICIntUtil::write_QUICVariableInt(this->_largest_acknowledged, p, &n);
-  p += n;
-  QUICIntUtil::write_QUICVariableInt(this->_ack_delay, p, &n);
-  p += n;
-  QUICIntUtil::write_QUICVariableInt(this->ack_block_count(), p, &n);
-  p += n;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::ACK);
+  n += 1;
 
-  ink_assert(limit >= static_cast<size_t>(p - buf));
-  limit -= (p - buf);
-  this->_ack_block_section->store(p, &n, limit);
-  p += n;
+  // Largest Acknowledged (i)
+  QUICIntUtil::write_QUICVariableInt(this->_largest_acknowledged, block_start + n, &written_len);
+  n += written_len;
 
-  *len = p - buf;
+  // Ack Delay (i)
+  QUICIntUtil::write_QUICVariableInt(this->_ack_delay, block_start + n, &written_len);
+  n += written_len;
 
-  return *len;
+  // Ack Range Count (i)
+  QUICIntUtil::write_QUICVariableInt(this->ack_block_count(), block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+
+  // First Ack Range (i) + Ack Ranges (*)
+  block->next = this->_ack_block_section->to_io_buffer_block(limit - n);
+
+  return block;
 }
 
 int
@@ -829,29 +843,33 @@
   return n;
 }
 
-size_t
-QUICAckFrame::AckBlockSection::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICAckFrame::AckBlockSection::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(limit));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  QUICIntUtil::write_QUICVariableInt(this->_first_ack_block, p, &n);
-  p += n;
+  QUICIntUtil::write_QUICVariableInt(this->_first_ack_block, block_start + n, &written_len);
+  n += written_len;
 
   for (auto &&block : *this) {
-    QUICIntUtil::write_QUICVariableInt(block.gap(), p, &n);
-    p += n;
-    QUICIntUtil::write_QUICVariableInt(block.length(), p, &n);
-    p += n;
+    QUICIntUtil::write_QUICVariableInt(block.gap(), block_start + n, &written_len);
+    n += written_len;
+    QUICIntUtil::write_QUICVariableInt(block.length(), block_start + n, &written_len);
+    n += written_len;
   }
 
-  *len = p - buf;
-
-  return *len;
+  block->fill(n);
+  return block;
 }
 
 uint64_t
@@ -979,30 +997,35 @@
 {
 }
 
-QUICRstStreamFrame::QUICRstStreamFrame(const uint8_t *buf, size_t len)
+QUICRstStreamFrame::QUICRstStreamFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
-QUICRstStreamFrame::parse(const uint8_t *buf, size_t len)
+QUICRstStreamFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = 1 + const_cast<uint8_t *>(buf);
+  this->_packet = packet;
+  uint8_t *pos  = 1 + const_cast<uint8_t *>(buf);
 
   size_t field_len = 0;
+
+  // Stream ID (i)
   if (!read_varint(pos, LEFT_SPACE(pos), this->_stream_id, field_len)) {
     return;
   }
 
-  if (LEFT_SPACE(pos) < 2) {
+  // Error Code (i)
+  if (LEFT_SPACE(pos) < 1) {
+    return;
+  }
+  if (!read_varint(pos, LEFT_SPACE(pos), this->_error_code, field_len)) {
     return;
   }
 
-  this->_error_code = QUICIntUtil::read_nbytes_as_uint(pos, 2);
-  pos += 2;
-
+  // Final Offset (i)
   if (!read_varint(pos, LEFT_SPACE(pos), this->_final_offset, field_len)) {
     return;
   }
@@ -1037,36 +1060,49 @@
     return this->_size;
   }
 
-  return 1 + QUICVariableInt::size(this->_stream_id) + sizeof(QUICAppErrorCode) + QUICVariableInt::size(this->_final_offset);
+  return 1 + QUICVariableInt::size(this->_stream_id) + QUICVariableInt::size(this->_error_code) +
+         QUICVariableInt::size(this->_final_offset);
 }
 
-size_t
-QUICRstStreamFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICRstStreamFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
-  *p         = static_cast<uint8_t>(QUICFrameType::RESET_STREAM);
-  ++p;
-  QUICTypeUtil::write_QUICStreamId(this->_stream_id, p, &n);
-  p += n;
-  QUICTypeUtil::write_QUICAppErrorCode(this->_error_code, p, &n);
-  p += n;
-  QUICTypeUtil::write_QUICOffset(this->_final_offset, p, &n);
-  p += n;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + 24));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *len = p - buf;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::RESET_STREAM);
+  n += 1;
 
-  return *len;
+  // Stream ID (i)
+  QUICTypeUtil::write_QUICStreamId(this->_stream_id, block_start + n, &written_len);
+  n += written_len;
+
+  // Application Error Code (i)
+  QUICTypeUtil::write_QUICAppErrorCode(this->_error_code, block_start + n, &written_len);
+  n += written_len;
+
+  // Final Size (i)
+  QUICTypeUtil::write_QUICOffset(this->_final_offset, block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+  return block;
 }
 
 int
 QUICRstStreamFrame::debug_msg(char *msg, size_t msg_len) const
 {
-  return snprintf(msg, msg_len, "RESET_STREAM size=%zu stream_id=%" PRIu64 " code=0x%" PRIx16, this->size(), this->stream_id(),
+  return snprintf(msg, msg_len, "RESET_STREAM size=%zu stream_id=%" PRIu64 " code=0x%" PRIx64, this->size(), this->stream_id(),
                   this->error_code());
 }
 
@@ -1092,17 +1128,18 @@
 // PING frame
 //
 
-QUICPingFrame::QUICPingFrame(const uint8_t *buf, size_t len)
+QUICPingFrame::QUICPingFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
-QUICPingFrame::parse(const uint8_t *buf, size_t len)
+QUICPingFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   this->_reset();
-  this->_valid = true;
-  this->_size  = 1;
+  this->_packet = packet;
+  this->_valid  = true;
+  this->_size   = 1;
 }
 
 QUICFrameType
@@ -1117,33 +1154,52 @@
   return 1;
 }
 
-size_t
-QUICPingFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICPingFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  *len   = this->size();
-  buf[0] = static_cast<uint8_t>(QUICFrameType::PING);
-  return *len;
+  block = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(this->size()));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
+
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::PING);
+  n += 1;
+
+  block->fill(n);
+  return block;
 }
 
 //
 // PADDING frame
 //
-QUICPaddingFrame::QUICPaddingFrame(const uint8_t *buf, size_t len)
+QUICPaddingFrame::QUICPaddingFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
-QUICPaddingFrame::parse(const uint8_t *buf, size_t len)
+QUICPaddingFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  this->_valid = true;
-  this->_size  = 1;
+  this->_packet = packet;
+  this->_size   = 0;
+  this->_valid  = true;
+  // find out how many padding frames in this buf
+  for (size_t i = 0; i < len; i++) {
+    if (*(buf + i) == static_cast<uint8_t>(QUICFrameType::PADDING)) {
+      ++this->_size;
+    } else {
+      break;
+    }
+  }
 }
 
 QUICFrameType
@@ -1155,7 +1211,7 @@
 size_t
 QUICPaddingFrame::size() const
 {
-  return 1;
+  return this->_size;
 }
 
 bool
@@ -1164,22 +1220,31 @@
   return true;
 }
 
-size_t
-QUICPaddingFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICPaddingFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  buf[0] = static_cast<uint8_t>(QUICFrameType::PADDING);
-  *len   = 1;
-  return *len;
+  block = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(this->_size));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
+
+  memset(block_start, 0, this->_size);
+  n = this->_size;
+
+  block->fill(n);
+  return block;
 }
 
 //
 // CONNECTION_CLOSE frame
 //
-QUICConnectionCloseFrame::QUICConnectionCloseFrame(uint16_t error_code, QUICFrameType frame_type, uint64_t reason_phrase_length,
+QUICConnectionCloseFrame::QUICConnectionCloseFrame(uint64_t error_code, QUICFrameType frame_type, uint64_t reason_phrase_length,
                                                    const char *reason_phrase, QUICFrameId id, QUICFrameGenerator *owner)
   : QUICFrame(id, owner),
     _type(0x1c),
@@ -1190,7 +1255,7 @@
 {
 }
 
-QUICConnectionCloseFrame::QUICConnectionCloseFrame(uint16_t error_code, uint64_t reason_phrase_length, const char *reason_phrase,
+QUICConnectionCloseFrame::QUICConnectionCloseFrame(uint64_t error_code, uint64_t reason_phrase_length, const char *reason_phrase,
                                                    QUICFrameId id, QUICFrameGenerator *owner)
   : QUICFrame(id, owner),
     _type(0x1d),
@@ -1200,9 +1265,10 @@
 {
 }
 
-QUICConnectionCloseFrame::QUICConnectionCloseFrame(const uint8_t *buf, size_t len)
+QUICConnectionCloseFrame::QUICConnectionCloseFrame(const uint8_t *buf, size_t len, const QUICPacket *packet)
+  : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
@@ -1220,28 +1286,29 @@
 }
 
 void
-QUICConnectionCloseFrame::parse(const uint8_t *buf, size_t len)
+QUICConnectionCloseFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  this->_type  = buf[0];
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
-
-  if (LEFT_SPACE(pos) < 2) {
-    return;
-  }
-
-  this->_error_code = QUICIntUtil::read_nbytes_as_uint(pos, 2);
-  pos += 2;
+  this->_packet = packet;
+  this->_type   = buf[0];
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   uint64_t field   = 0;
 
+  // Error Code (i)
+  if (LEFT_SPACE(pos) < 1) {
+    return;
+  }
+  read_varint(pos, LEFT_SPACE(pos), field, field_len);
+  this->_error_code = field;
+
   if (this->_type == 0x1c) {
+    // Frame Type (i)
     if (!read_varint(pos, LEFT_SPACE(pos), field, field_len)) {
       return;
     }
-
     this->_frame_type = static_cast<QUICFrameType>(field);
 
     /**
@@ -1255,16 +1322,21 @@
     }
   }
 
+  // Reason Phrase Length (i)
+  if (LEFT_SPACE(pos) < 1) {
+    return;
+  }
   if (!read_varint(pos, LEFT_SPACE(pos), this->_reason_phrase_length, field_len)) {
     return;
   }
 
+  // Reason Phrase
   if (LEFT_SPACE(pos) < this->_reason_phrase_length) {
     return;
   }
-
-  this->_valid         = true;
   this->_reason_phrase = reinterpret_cast<const char *>(pos);
+
+  this->_valid = true;
   pos += this->_reason_phrase_length;
   this->_size = FRAME_SIZE(pos);
 }
@@ -1282,7 +1354,7 @@
     return this->_size;
   }
 
-  return 1 + sizeof(QUICTransErrorCode) + QUICVariableInt::size(sizeof(QUICFrameType)) +
+  return 1 + QUICVariableInt::size(sizeof(QUICTransErrorCode)) + QUICVariableInt::size(sizeof(QUICFrameType)) +
          QUICVariableInt::size(this->_reason_phrase_length) + this->_reason_phrase_length;
 }
 
@@ -1292,42 +1364,58 @@
    PADDING frame in Frame Type field means frame type that triggered the error is unknown.
    When `_frame_type` is QUICFrameType::UNKNOWN, it's converted to QUICFrameType::PADDING (0x0).
  */
-size_t
-QUICConnectionCloseFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICConnectionCloseFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> first_block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return first_block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
-  *p         = this->_type;
-  ++p;
+  // Create a block for Error Code(i) and Frame Type(i)
+  size_t written_len = 0;
+  first_block        = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  first_block->alloc(iobuffer_size_to_index(1 + 24));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(first_block->start());
 
-  // Error Code (16)
-  QUICTypeUtil::write_QUICTransErrorCode(this->_error_code, p, &n);
-  p += n;
+  // Type
+  block_start[0] = this->_type;
+  n += 1;
+
+  // Error Code (i)
+  QUICIntUtil::write_QUICVariableInt(this->_error_code, block_start + n, &written_len);
+  n += written_len;
 
   // Frame Type (i)
   QUICFrameType frame_type = this->_frame_type;
   if (frame_type == QUICFrameType::UNKNOWN) {
     frame_type = QUICFrameType::PADDING;
   }
-  *p = static_cast<uint8_t>(frame_type);
-  ++p;
+  QUICIntUtil::write_QUICVariableInt(static_cast<uint64_t>(frame_type), block_start + n, &written_len);
+  n += written_len;
 
   // Reason Phrase Length (i)
-  QUICIntUtil::write_QUICVariableInt(this->_reason_phrase_length, p, &n);
-  p += n;
+  QUICIntUtil::write_QUICVariableInt(this->_reason_phrase_length, block_start + n, &written_len);
+  n += written_len;
 
-  // Reason Phrase (*)
-  if (this->_reason_phrase_length > 0) {
-    memcpy(p, this->_reason_phrase, this->_reason_phrase_length);
-    p += this->_reason_phrase_length;
+  first_block->fill(n);
+
+  // Create a block for reason if necessary
+  if (this->_reason_phrase_length != 0) {
+    // Reason Phrase (*)
+    Ptr<IOBufferBlock> reason_block = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+    reason_block->alloc(iobuffer_size_to_index(this->_reason_phrase_length));
+    memcpy(reinterpret_cast<uint8_t *>(reason_block->start()), this->_reason_phrase, this->_reason_phrase_length);
+    reason_block->fill(this->_reason_phrase_length);
+
+    // Append reason block to the first block
+    first_block->next = reason_block;
   }
 
-  *len = p - buf;
-  return *len;
+  // Return the chain
+  return first_block;
 }
 
 int
@@ -1400,17 +1488,18 @@
   this->_size  = 0;
 }
 
-QUICMaxDataFrame::QUICMaxDataFrame(const uint8_t *buf, size_t len)
+QUICMaxDataFrame::QUICMaxDataFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
-QUICMaxDataFrame::parse(const uint8_t *buf, size_t len)
+QUICMaxDataFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = 1 + const_cast<uint8_t *>(buf);
+  this->_packet = packet;
+  uint8_t *pos  = 1 + const_cast<uint8_t *>(buf);
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_maximum_data, field_len)) {
@@ -1437,22 +1526,31 @@
   return sizeof(QUICFrameType) + QUICVariableInt::size(this->_maximum_data);
 }
 
-size_t
-QUICMaxDataFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICMaxDataFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
-  *p         = static_cast<uint8_t>(QUICFrameType::MAX_DATA);
-  ++p;
-  QUICTypeUtil::write_QUICMaxData(this->_maximum_data, p, &n);
-  p += n;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + sizeof(size_t)));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *len = p - buf;
-  return *len;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::MAX_DATA);
+  n += 1;
+
+  // Maximum Data (i)
+  QUICTypeUtil::write_QUICMaxData(this->_maximum_data, block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+  return block;
 }
 
 int
@@ -1490,17 +1588,19 @@
   this->_size  = 0;
 }
 
-QUICMaxStreamDataFrame::QUICMaxStreamDataFrame(const uint8_t *buf, size_t len)
+QUICMaxStreamDataFrame::QUICMaxStreamDataFrame(const uint8_t *buf, size_t len, const QUICPacket *packet)
+  : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
-QUICMaxStreamDataFrame::parse(const uint8_t *buf, size_t len)
+QUICMaxStreamDataFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_stream_id, field_len)) {
@@ -1531,23 +1631,35 @@
   return sizeof(QUICFrameType) + QUICVariableInt::size(this->_maximum_stream_data) + QUICVariableInt::size(this->_stream_id);
 }
 
-size_t
-QUICMaxStreamDataFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICMaxStreamDataFrame::to_io_buffer_block(size_t limit) const
 {
-  if (limit < this->size()) {
-    return 0;
-  }
-  size_t n;
-  uint8_t *p = buf;
-  *p         = static_cast<uint8_t>(QUICFrameType::MAX_STREAM_DATA);
-  ++p;
-  QUICTypeUtil::write_QUICStreamId(this->_stream_id, p, &n);
-  p += n;
-  QUICTypeUtil::write_QUICMaxData(this->_maximum_stream_data, p, &n);
-  p += n;
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
 
-  *len = p - buf;
-  return *len;
+  if (limit < this->size()) {
+    return block;
+  }
+
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + sizeof(uint64_t) + sizeof(size_t)));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
+
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::MAX_STREAM_DATA);
+  n += 1;
+
+  // Stream ID (i)
+  QUICTypeUtil::write_QUICStreamId(this->_stream_id, block_start + n, &written_len);
+  n += written_len;
+
+  // Maximum Stream Data (i)
+  QUICTypeUtil::write_QUICMaxData(this->_maximum_stream_data, block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+  return block;
 }
 
 int
@@ -1589,17 +1701,18 @@
   this->_size  = 0;
 }
 
-QUICMaxStreamsFrame::QUICMaxStreamsFrame(const uint8_t *buf, size_t len)
+QUICMaxStreamsFrame::QUICMaxStreamsFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
-QUICMaxStreamsFrame::parse(const uint8_t *buf, size_t len)
+QUICMaxStreamsFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_maximum_streams, field_len)) {
@@ -1626,22 +1739,31 @@
   return sizeof(QUICFrameType) + QUICVariableInt::size(this->_maximum_streams);
 }
 
-size_t
-QUICMaxStreamsFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICMaxStreamsFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
-  *p         = static_cast<uint8_t>(QUICFrameType::MAX_STREAMS);
-  ++p;
-  QUICTypeUtil::write_QUICStreamId(this->_maximum_streams, p, &n);
-  p += n;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + sizeof(size_t)));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *len = p - buf;
-  return *len;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::MAX_STREAMS);
+  n += 1;
+
+  // Maximum Streams (i)
+  QUICTypeUtil::write_QUICStreamId(this->_maximum_streams, block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+  return block;
 }
 
 uint64_t
@@ -1653,9 +1775,9 @@
 //
 // DATA_BLOCKED frame
 //
-QUICDataBlockedFrame::QUICDataBlockedFrame(const uint8_t *buf, size_t len)
+QUICDataBlockedFrame::QUICDataBlockedFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
@@ -1670,11 +1792,12 @@
 }
 
 void
-QUICDataBlockedFrame::parse(const uint8_t *buf, size_t len)
+QUICDataBlockedFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_offset, field_len)) {
@@ -1707,24 +1830,31 @@
   return sizeof(QUICFrameType) + QUICVariableInt::size(this->offset());
 }
 
-size_t
-QUICDataBlockedFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICDataBlockedFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + sizeof(size_t)));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *p = static_cast<uint8_t>(QUICFrameType::DATA_BLOCKED);
-  ++p;
-  QUICTypeUtil::write_QUICOffset(this->_offset, p, &n);
-  p += n;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::DATA_BLOCKED);
+  n += 1;
 
-  *len = p - buf;
+  // Data Limit (i)
+  QUICTypeUtil::write_QUICOffset(this->_offset, block_start + n, &written_len);
+  n += written_len;
 
-  return *len;
+  block->fill(n);
+  return block;
 }
 
 QUICOffset
@@ -1736,9 +1866,10 @@
 //
 // STREAM_DATA_BLOCKED frame
 //
-QUICStreamDataBlockedFrame::QUICStreamDataBlockedFrame(const uint8_t *buf, size_t len)
+QUICStreamDataBlockedFrame::QUICStreamDataBlockedFrame(const uint8_t *buf, size_t len, const QUICPacket *packet)
+  : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
@@ -1754,11 +1885,12 @@
 }
 
 void
-QUICStreamDataBlockedFrame::parse(const uint8_t *buf, size_t len)
+QUICStreamDataBlockedFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_stream_id, field_len)) {
@@ -1796,25 +1928,35 @@
   return sizeof(QUICFrameType) + QUICVariableInt::size(this->_offset) + QUICVariableInt::size(this->_stream_id);
 }
 
-size_t
-QUICStreamDataBlockedFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICStreamDataBlockedFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
-  *p         = static_cast<uint8_t>(QUICFrameType::STREAM_DATA_BLOCKED);
-  ++p;
-  QUICTypeUtil::write_QUICStreamId(this->_stream_id, p, &n);
-  p += n;
-  QUICTypeUtil::write_QUICOffset(this->_offset, p, &n);
-  p += n;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + sizeof(size_t)));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *len = p - buf;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::STREAM_DATA_BLOCKED);
+  n += 1;
 
-  return *len;
+  // Stream ID (i)
+  QUICTypeUtil::write_QUICStreamId(this->_stream_id, block_start + n, &written_len);
+  n += written_len;
+
+  // Data Limit (i)
+  QUICTypeUtil::write_QUICOffset(this->_offset, block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+  return block;
 }
 
 QUICStreamId
@@ -1832,9 +1974,10 @@
 //
 // STREAMS_BLOCKED frame
 //
-QUICStreamIdBlockedFrame::QUICStreamIdBlockedFrame(const uint8_t *buf, size_t len)
+QUICStreamIdBlockedFrame::QUICStreamIdBlockedFrame(const uint8_t *buf, size_t len, const QUICPacket *packet)
+  : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
@@ -1849,11 +1992,12 @@
 }
 
 void
-QUICStreamIdBlockedFrame::parse(const uint8_t *buf, size_t len)
+QUICStreamIdBlockedFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_stream_id, field_len)) {
@@ -1880,23 +2024,31 @@
   return sizeof(QUICFrameType) + QUICVariableInt::size(this->_stream_id);
 }
 
-size_t
-QUICStreamIdBlockedFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICStreamIdBlockedFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + sizeof(size_t)));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *p = static_cast<uint8_t>(QUICFrameType::STREAMS_BLOCKED);
-  ++p;
-  QUICTypeUtil::write_QUICStreamId(this->_stream_id, p, &n);
-  p += n;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::STREAMS_BLOCKED);
+  n += 1;
 
-  *len = p - buf;
-  return *len;
+  // Stream Limit (i)
+  QUICTypeUtil::write_QUICStreamId(this->_stream_id, block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+  return block;
 }
 
 QUICStreamId
@@ -1908,16 +2060,18 @@
 //
 // NEW_CONNECTION_ID frame
 //
-QUICNewConnectionIdFrame::QUICNewConnectionIdFrame(const uint8_t *buf, size_t len)
+QUICNewConnectionIdFrame::QUICNewConnectionIdFrame(const uint8_t *buf, size_t len, const QUICPacket *packet)
+  : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
 QUICNewConnectionIdFrame::_reset()
 {
-  this->_sequence      = 0;
-  this->_connection_id = QUICConnectionId::ZERO();
+  this->_sequence        = 0;
+  this->_retire_prior_to = 0;
+  this->_connection_id   = QUICConnectionId::ZERO();
 
   this->_owner = nullptr;
   this->_id    = 0;
@@ -1926,38 +2080,49 @@
 }
 
 void
-QUICNewConnectionIdFrame::parse(const uint8_t *buf, size_t len)
+QUICNewConnectionIdFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
+  // Sequence Number (i)
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_sequence, field_len)) {
     return;
   }
 
+  // Retire Prior To (i)
   if (LEFT_SPACE(pos) < 1) {
     return;
   }
-
-  size_t cid_len = *pos;
-  pos += 1;
-
-  if (LEFT_SPACE(pos) < cid_len) {
+  if (!read_varint(pos, LEFT_SPACE(pos), this->_retire_prior_to, field_len)) {
     return;
   }
 
+  // Length (8)
+  if (LEFT_SPACE(pos) < 1) {
+    return;
+  }
+  size_t cid_len = *pos;
+  pos += 1;
+
+  // Connection ID (8..160)
+  if (LEFT_SPACE(pos) < cid_len) {
+    return;
+  }
   this->_connection_id = QUICTypeUtil::read_QUICConnectionId(pos, cid_len);
   pos += cid_len;
 
-  if (LEFT_SPACE(pos) < 16) {
+  // Stateless Reset Token (128)
+  if (LEFT_SPACE(pos) < QUICStatelessResetToken::LEN) {
     return;
   }
 
   this->_stateless_reset_token = QUICStatelessResetToken(pos);
   this->_valid                 = true;
-  this->_size                  = FRAME_SIZE(pos) + 16;
+  this->_size                  = FRAME_SIZE(pos) + QUICStatelessResetToken::LEN;
 }
 
 QUICFrameType
@@ -1973,31 +2138,52 @@
     return this->_size;
   }
 
-  return sizeof(QUICFrameType) + QUICVariableInt::size(this->_sequence) + 1 + this->_connection_id.length() + 16;
+  return sizeof(QUICFrameType) + QUICVariableInt::size(this->_sequence) + QUICVariableInt::size(this->_retire_prior_to) + 1 +
+         this->_connection_id.length() + QUICStatelessResetToken::LEN;
 }
 
-size_t
-QUICNewConnectionIdFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICNewConnectionIdFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
-  *p         = static_cast<uint8_t>(QUICFrameType::NEW_CONNECTION_ID);
-  ++p;
-  QUICIntUtil::write_QUICVariableInt(this->_sequence, p, &n);
-  p += n;
-  *p = this->_connection_id.length();
-  p += 1;
-  QUICTypeUtil::write_QUICConnectionId(this->_connection_id, p, &n);
-  p += n;
-  memcpy(p, this->_stateless_reset_token.buf(), QUICStatelessResetToken::LEN);
-  p += QUICStatelessResetToken::LEN;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + sizeof(uint64_t) + sizeof(uint64_t) + 1 + QUICConnectionId::MAX_LENGTH +
+                                      QUICStatelessResetToken::LEN));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *len = p - buf;
-  return *len;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::NEW_CONNECTION_ID);
+  n += 1;
+
+  // Sequence Number (i)
+  QUICIntUtil::write_QUICVariableInt(this->_sequence, block_start + n, &written_len);
+  n += written_len;
+
+  // Retire Prior To (i)
+  QUICIntUtil::write_QUICVariableInt(this->_retire_prior_to, block_start + n, &written_len);
+  n += written_len;
+
+  // Length (8)
+  *(block_start + n) = this->_connection_id.length();
+  n += 1;
+
+  // Connection ID (8..160)
+  QUICTypeUtil::write_QUICConnectionId(this->_connection_id, block_start + n, &written_len);
+  n += written_len;
+
+  // Stateless Reset Token (128)
+  memcpy(block_start + n, this->_stateless_reset_token.buf(), QUICStatelessResetToken::LEN);
+  n += QUICStatelessResetToken::LEN;
+
+  block->fill(n);
+  return block;
 }
 
 int
@@ -2006,7 +2192,8 @@
   char cid_str[QUICConnectionId::MAX_HEX_STR_LENGTH];
   this->connection_id().hex(cid_str, QUICConnectionId::MAX_HEX_STR_LENGTH);
 
-  return snprintf(msg, msg_len, "NEW_CONNECTION_ID size=%zu seq=%" PRIu64 " cid=0x%s", this->size(), this->sequence(), cid_str);
+  return snprintf(msg, msg_len, "NEW_CONNECTION_ID size=%zu seq=%" PRIu64 " rpt=%" PRIu64 " cid=0x%s", this->size(),
+                  this->sequence(), this->retire_prior_to(), cid_str);
 }
 
 uint64_t
@@ -2015,6 +2202,12 @@
   return this->_sequence;
 }
 
+uint64_t
+QUICNewConnectionIdFrame::retire_prior_to() const
+{
+  return this->_retire_prior_to;
+}
+
 QUICConnectionId
 QUICNewConnectionIdFrame::connection_id() const
 {
@@ -2049,30 +2242,35 @@
   this->_size  = 0;
 }
 
-QUICStopSendingFrame::QUICStopSendingFrame(const uint8_t *buf, size_t len)
+QUICStopSendingFrame::QUICStopSendingFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
-QUICStopSendingFrame::parse(const uint8_t *buf, size_t len)
+QUICStopSendingFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
+  // Stream ID (i)
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_stream_id, field_len)) {
     return;
   }
 
-  if (LEFT_SPACE(pos) < 2) {
+  // Error Code (i)
+  if (LEFT_SPACE(pos) < 1) {
+    return;
+  }
+  if (!read_varint(pos, LEFT_SPACE(pos), this->_error_code, field_len)) {
     return;
   }
 
-  this->_error_code = static_cast<QUICAppErrorCode>(QUICIntUtil::read_nbytes_as_uint(pos, 2));
-  this->_valid      = true;
-  this->_size       = FRAME_SIZE(pos) + 2;
+  this->_valid = true;
+  this->_size  = FRAME_SIZE(pos);
 }
 
 QUICFrameType
@@ -2088,27 +2286,38 @@
     return this->_size;
   }
 
-  return sizeof(QUICFrameType) + QUICVariableInt::size(this->_stream_id) + sizeof(QUICAppErrorCode);
+  return sizeof(QUICFrameType) + QUICVariableInt::size(this->_stream_id) + QUICVariableInt::size(sizeof(QUICAppErrorCode));
 }
 
-size_t
-QUICStopSendingFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICStopSendingFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
-  *p         = static_cast<uint8_t>(QUICFrameType::STOP_SENDING);
-  ++p;
-  QUICTypeUtil::write_QUICStreamId(this->_stream_id, p, &n);
-  p += n;
-  QUICTypeUtil::write_QUICAppErrorCode(this->_error_code, p, &n);
-  p += n;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + 24));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *len = p - buf;
-  return *len;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::STOP_SENDING);
+  n += 1;
+
+  // Stream ID (i)
+  QUICTypeUtil::write_QUICStreamId(this->_stream_id, block_start + n, &written_len);
+  n += written_len;
+
+  // Application Error Code (i)
+  QUICTypeUtil::write_QUICAppErrorCode(this->_error_code, block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+  return block;
 }
 
 QUICAppErrorCode
@@ -2126,9 +2335,10 @@
 //
 // PATH_CHALLENGE frame
 //
-QUICPathChallengeFrame::QUICPathChallengeFrame(const uint8_t *buf, size_t len)
+QUICPathChallengeFrame::QUICPathChallengeFrame(const uint8_t *buf, size_t len, const QUICPacket *packet)
+  : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
@@ -2142,11 +2352,12 @@
 }
 
 void
-QUICPathChallengeFrame::parse(const uint8_t *buf, size_t len)
+QUICPathChallengeFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   if (LEFT_SPACE(pos) < QUICPathChallengeFrame::DATA_LEN) {
     return;
@@ -2180,19 +2391,38 @@
   return true;
 }
 
-size_t
-QUICPathChallengeFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICPathChallengeFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  *len = this->size();
+  block = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + QUICPathChallengeFrame::DATA_LEN));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  buf[0] = static_cast<uint8_t>(QUICFrameType::PATH_CHALLENGE);
-  memcpy(buf + 1, this->data(), QUICPathChallengeFrame::DATA_LEN);
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::PATH_CHALLENGE);
+  n += 1;
 
-  return *len;
+  // Data (64)
+  memcpy(block_start + n, this->data(), QUICPathChallengeFrame::DATA_LEN);
+  n += QUICPathChallengeFrame::DATA_LEN;
+
+  block->fill(n);
+  return block;
+}
+
+int
+QUICPathChallengeFrame::debug_msg(char *msg, size_t msg_len) const
+{
+  auto data = this->data();
+  return snprintf(msg, msg_len, "PATH_CHALLENGE size=%zu data=0x%02x%02x%02x%02x%02x%02x%02x%02x", this->size(), data[0], data[1],
+                  data[2], data[3], data[4], data[5], data[6], data[7]);
 }
 
 const uint8_t *
@@ -2204,9 +2434,10 @@
 //
 // PATH_RESPONSE frame
 //
-QUICPathResponseFrame::QUICPathResponseFrame(const uint8_t *buf, size_t len)
+QUICPathResponseFrame::QUICPathResponseFrame(const uint8_t *buf, size_t len, const QUICPacket *packet)
+  : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
@@ -2219,12 +2450,39 @@
   this->_size  = 0;
 }
 
+Ptr<IOBufferBlock>
+QUICPathResponseFrame::to_io_buffer_block(size_t limit) const
+{
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
+  if (limit < this->size()) {
+    return block;
+  }
+
+  block = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + QUICPathResponseFrame::DATA_LEN));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
+
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::PATH_RESPONSE);
+  n += 1;
+
+  // Data (64)
+  memcpy(block_start + n, this->data(), QUICPathChallengeFrame::DATA_LEN);
+  n += QUICPathChallengeFrame::DATA_LEN;
+
+  block->fill(n);
+  return block;
+}
+
 void
-QUICPathResponseFrame::parse(const uint8_t *buf, size_t len)
+QUICPathResponseFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   if (LEFT_SPACE(pos) < QUICPathChallengeFrame::DATA_LEN) {
     return;
@@ -2254,19 +2512,12 @@
   return true;
 }
 
-size_t
-QUICPathResponseFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+int
+QUICPathResponseFrame::debug_msg(char *msg, size_t msg_len) const
 {
-  if (limit < this->size()) {
-    return 0;
-  }
-
-  *len = this->size();
-
-  buf[0] = static_cast<uint8_t>(QUICFrameType::PATH_RESPONSE);
-  memcpy(buf + 1, this->data(), QUICPathResponseFrame::DATA_LEN);
-
-  return *len;
+  auto data = this->data();
+  return snprintf(msg, msg_len, "PATH_RESPONSE size=%zu data=0x%02x%02x%02x%02x%02x%02x%02x%02x", this->size(), data[0], data[1],
+                  data[2], data[3], data[4], data[5], data[6], data[7]);
 }
 
 const uint8_t *
@@ -2278,9 +2529,9 @@
 //
 // QUICNewTokenFrame
 //
-QUICNewTokenFrame::QUICNewTokenFrame(const uint8_t *buf, size_t len)
+QUICNewTokenFrame::QUICNewTokenFrame(const uint8_t *buf, size_t len, const QUICPacket *packet) : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
@@ -2296,11 +2547,12 @@
 }
 
 void
-QUICNewTokenFrame::parse(const uint8_t *buf, size_t len)
+QUICNewTokenFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_token_length, field_len)) {
@@ -2333,30 +2585,35 @@
   return 1 + QUICVariableInt::size(this->_token_length) + this->token_length();
 }
 
-size_t
-QUICNewTokenFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICNewTokenFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  uint8_t *p = buf;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + 24));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  // Type (i)
-  *p = static_cast<uint8_t>(QUICFrameType::NEW_TOKEN);
-  ++p;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::NEW_TOKEN);
+  n += 1;
 
   // Token Length (i)
-  size_t n;
-  QUICIntUtil::write_QUICVariableInt(this->_token_length, p, &n);
-  p += n;
+  QUICIntUtil::write_QUICVariableInt(this->_token_length, block_start + n, &written_len);
+  n += written_len;
 
   // Token (*)
-  memcpy(p, this->token(), this->token_length());
-  p += this->token_length();
+  memcpy(block_start + n, this->token(), this->token_length());
+  n += this->token_length();
 
-  *len = p - buf;
-  return *len;
+  block->fill(n);
+  return block;
 }
 
 uint64_t
@@ -2374,9 +2631,10 @@
 //
 // RETIRE_CONNECTION_ID frame
 //
-QUICRetireConnectionIdFrame::QUICRetireConnectionIdFrame(const uint8_t *buf, size_t len)
+QUICRetireConnectionIdFrame::QUICRetireConnectionIdFrame(const uint8_t *buf, size_t len, const QUICPacket *packet)
+  : QUICFrame(0, nullptr, packet)
 {
-  this->parse(buf, len);
+  this->parse(buf, len, packet);
 }
 
 void
@@ -2392,11 +2650,12 @@
 }
 
 void
-QUICRetireConnectionIdFrame::parse(const uint8_t *buf, size_t len)
+QUICRetireConnectionIdFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   ink_assert(len >= 1);
   this->_reset();
-  uint8_t *pos = const_cast<uint8_t *>(buf) + 1;
+  this->_packet = packet;
+  uint8_t *pos  = const_cast<uint8_t *>(buf) + 1;
 
   size_t field_len = 0;
   if (!read_varint(pos, LEFT_SPACE(pos), this->_seq_num, field_len)) {
@@ -2423,23 +2682,31 @@
   return sizeof(QUICFrameType) + QUICVariableInt::size(this->_seq_num);
 }
 
-size_t
-QUICRetireConnectionIdFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICRetireConnectionIdFrame::to_io_buffer_block(size_t limit) const
 {
+  Ptr<IOBufferBlock> block;
+  size_t n = 0;
+
   if (limit < this->size()) {
-    return 0;
+    return block;
   }
 
-  size_t n;
-  uint8_t *p = buf;
-  *p         = static_cast<uint8_t>(QUICFrameType::RETIRE_CONNECTION_ID);
-  ++p;
-  QUICIntUtil::write_QUICVariableInt(this->_seq_num, p, &n);
-  p += n;
+  size_t written_len = 0;
+  block              = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+  block->alloc(iobuffer_size_to_index(1 + sizeof(uint64_t)));
+  uint8_t *block_start = reinterpret_cast<uint8_t *>(block->start());
 
-  *len = p - buf;
+  // Type
+  block_start[0] = static_cast<uint8_t>(QUICFrameType::RETIRE_CONNECTION_ID);
+  n += 1;
 
-  return *len;
+  // Sequence Number (i)
+  QUICIntUtil::write_QUICVariableInt(this->_seq_num, block_start + n, &written_len);
+  n += written_len;
+
+  block->fill(n);
+  return block;
 }
 
 int
@@ -2470,15 +2737,17 @@
   return 0;
 }
 
-size_t
-QUICUnknownFrame::store(uint8_t *buf, size_t *len, size_t limit) const
+Ptr<IOBufferBlock>
+QUICUnknownFrame::to_io_buffer_block(size_t limit) const
 {
-  return 0;
+  Ptr<IOBufferBlock> block;
+  return block;
 }
 
 void
-QUICUnknownFrame::parse(const uint8_t *buf, size_t len)
+QUICUnknownFrame::parse(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
+  this->_packet = packet;
 }
 
 int
@@ -2492,65 +2761,65 @@
 //
 
 QUICFrame *
-QUICFrameFactory::create(uint8_t *buf, const uint8_t *src, size_t len)
+QUICFrameFactory::create(uint8_t *buf, const uint8_t *src, size_t len, const QUICPacket *packet)
 {
   switch (QUICFrame::type(src)) {
   case QUICFrameType::STREAM:
-    new (buf) QUICStreamFrame(src, len);
+    new (buf) QUICStreamFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::CRYPTO:
-    new (buf) QUICCryptoFrame(src, len);
+    new (buf) QUICCryptoFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::ACK:
-    new (buf) QUICAckFrame(src, len);
+    new (buf) QUICAckFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::PADDING:
-    new (buf) QUICPaddingFrame(src, len);
+    new (buf) QUICPaddingFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::RESET_STREAM:
-    new (buf) QUICRstStreamFrame(src, len);
+    new (buf) QUICRstStreamFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::CONNECTION_CLOSE:
-    new (buf) QUICConnectionCloseFrame(src, len);
+    new (buf) QUICConnectionCloseFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::MAX_DATA:
-    new (buf) QUICMaxDataFrame(src, len);
+    new (buf) QUICMaxDataFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::MAX_STREAM_DATA:
-    new (buf) QUICMaxStreamDataFrame(src, len);
+    new (buf) QUICMaxStreamDataFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::MAX_STREAMS:
-    new (buf) QUICMaxStreamsFrame(src, len);
+    new (buf) QUICMaxStreamsFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::PING:
-    new (buf) QUICPingFrame(src, len);
+    new (buf) QUICPingFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::DATA_BLOCKED:
-    new (buf) QUICDataBlockedFrame(src, len);
+    new (buf) QUICDataBlockedFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::STREAM_DATA_BLOCKED:
-    new (buf) QUICStreamDataBlockedFrame(src, len);
+    new (buf) QUICStreamDataBlockedFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::STREAMS_BLOCKED:
-    new (buf) QUICStreamIdBlockedFrame(src, len);
+    new (buf) QUICStreamIdBlockedFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::NEW_CONNECTION_ID:
-    new (buf) QUICNewConnectionIdFrame(src, len);
+    new (buf) QUICNewConnectionIdFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::STOP_SENDING:
-    new (buf) QUICStopSendingFrame(src, len);
+    new (buf) QUICStopSendingFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::PATH_CHALLENGE:
-    new (buf) QUICPathChallengeFrame(src, len);
+    new (buf) QUICPathChallengeFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::PATH_RESPONSE:
-    new (buf) QUICPathResponseFrame(src, len);
+    new (buf) QUICPathResponseFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::NEW_TOKEN:
-    new (buf) QUICNewTokenFrame(src, len);
+    new (buf) QUICNewTokenFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   case QUICFrameType::RETIRE_CONNECTION_ID:
-    new (buf) QUICRetireConnectionIdFrame(src, len);
+    new (buf) QUICRetireConnectionIdFrame(src, len, packet);
     return reinterpret_cast<QUICFrame *>(buf);
   default:
     // Unknown frame
@@ -2560,7 +2829,7 @@
 }
 
 const QUICFrame &
-QUICFrameFactory::fast_create(const uint8_t *buf, size_t len)
+QUICFrameFactory::fast_create(const uint8_t *buf, size_t len, const QUICPacket *packet)
 {
   if (QUICFrame::type(buf) == QUICFrameType::UNKNOWN) {
     return this->_unknown_frame;
@@ -2570,12 +2839,12 @@
   QUICFrame *frame     = this->_reusable_frames[type_index];
 
   if (frame == nullptr) {
-    frame = QUICFrameFactory::create(this->_buf_for_fast_create + (type_index * QUICFrame::MAX_INSTANCE_SIZE), buf, len);
+    frame = QUICFrameFactory::create(this->_buf_for_fast_create + (type_index * QUICFrame::MAX_INSTANCE_SIZE), buf, len, packet);
     if (frame != nullptr) {
       this->_reusable_frames[static_cast<ptrdiff_t>(QUICFrame::type(buf))] = frame;
     }
   } else {
-    frame->parse(buf, len);
+    frame->parse(buf, len, packet);
   }
 
   return *frame;
@@ -2656,6 +2925,13 @@
   return reinterpret_cast<QUICPingFrame *>(buf);
 }
 
+QUICPaddingFrame *
+QUICFrameFactory::create_padding_frame(uint8_t *buf, size_t size, QUICFrameId id, QUICFrameGenerator *owner)
+{
+  new (buf) QUICPaddingFrame(size);
+  return reinterpret_cast<QUICPaddingFrame *>(buf);
+}
+
 QUICPathChallengeFrame *
 QUICFrameFactory::create_path_challenge_frame(uint8_t *buf, const uint8_t *data, QUICFrameId id, QUICFrameGenerator *owner)
 {
@@ -2721,11 +2997,11 @@
 }
 
 QUICNewConnectionIdFrame *
-QUICFrameFactory::create_new_connection_id_frame(uint8_t *buf, uint32_t sequence, QUICConnectionId connectoin_id,
-                                                 QUICStatelessResetToken stateless_reset_token, QUICFrameId id,
-                                                 QUICFrameGenerator *owner)
+QUICFrameFactory::create_new_connection_id_frame(uint8_t *buf, uint64_t sequence, uint64_t retire_prior_to,
+                                                 QUICConnectionId connectoin_id, QUICStatelessResetToken stateless_reset_token,
+                                                 QUICFrameId id, QUICFrameGenerator *owner)
 {
-  new (buf) QUICNewConnectionIdFrame(sequence, connectoin_id, stateless_reset_token, id, owner);
+  new (buf) QUICNewConnectionIdFrame(sequence, retire_prior_to, connectoin_id, stateless_reset_token, id, owner);
   return reinterpret_cast<QUICNewConnectionIdFrame *>(buf);
 }
 
diff --git a/iocore/net/quic/QUICFrame.h b/iocore/net/quic/QUICFrame.h
index 20f1bfe..ab21b17 100644
--- a/iocore/net/quic/QUICFrame.h
+++ b/iocore/net/quic/QUICFrame.h
@@ -55,21 +55,26 @@
   virtual size_t size() const = 0;
   virtual bool is_probing_frame() const;
   virtual bool is_flow_controlled() const;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const = 0;
-  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const = 0;
   virtual int debug_msg(char *msg, size_t msg_len) const;
-  virtual void parse(const uint8_t *buf, size_t len){};
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet){};
   virtual QUICFrameGenerator *generated_by();
   bool valid() const;
+  bool ack_eliciting() const;
+  const QUICPacket *packet() const;
   LINK(QUICFrame, link);
 
 protected:
   virtual void _reset(){};
-  QUICFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : _id(id), _owner(owner) {}
+  QUICFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr, const QUICPacket *packet = nullptr)
+    : _id(id), _owner(owner), _packet(packet)
+  {
+  }
   size_t _size               = 0;
   bool _valid                = false;
   QUICFrameId _id            = 0;
   QUICFrameGenerator *_owner = nullptr;
+  const QUICPacket *_packet  = nullptr;
 };
 
 //
@@ -80,7 +85,7 @@
 {
 public:
   QUICStreamFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICStreamFrame(const uint8_t *buf, size_t len);
+  QUICStreamFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICStreamFrame(Ptr<IOBufferBlock> &block, QUICStreamId streamid, QUICOffset offset, bool last = false,
                   bool has_offset_field = true, bool has_length_field = true, QUICFrameId id = 0,
                   QUICFrameGenerator *owner = nullptr);
@@ -89,12 +94,10 @@
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
   virtual bool is_flow_controlled() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
   virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
 
-  size_t store(uint8_t *buf, size_t *len, size_t limit, bool include_length_field) const;
   QUICStreamId stream_id() const;
   QUICOffset offset() const;
   IOBufferBlock *data() const;
@@ -128,15 +131,15 @@
 {
 public:
   QUICCryptoFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICCryptoFrame(const uint8_t *buf, size_t len);
+  QUICCryptoFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICCryptoFrame(Ptr<IOBufferBlock> &block, QUICOffset offset, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr);
   QUICCryptoFrame(const QUICCryptoFrame &o);
 
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
 
   QUICOffset offset() const;
   uint64_t data_length() const;
@@ -145,8 +148,12 @@
   LINK(QUICCryptoFrame, link);
 
 private:
+  static constexpr uint8_t MAX_HEADER_SIZE = 16;
+
   virtual void _reset() override;
 
+  size_t _store_header(uint8_t *buf, size_t *len) const;
+
   QUICOffset _offset = 0;
   Ptr<IOBufferBlock> _block;
 };
@@ -218,7 +225,7 @@
     AckBlockSection(uint64_t first_ack_block) : _first_ack_block(first_ack_block) {}
     uint8_t count() const;
     size_t size() const;
-    size_t store(uint8_t *buf, size_t *len, size_t limit) const;
+    Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const;
     uint64_t first_ack_block() const;
     void add_ack_block(const AckBlock block);
     const_iterator begin() const;
@@ -250,7 +257,7 @@
   };
 
   QUICAckFrame(QUICFrameId id = 0) : QUICFrame(id) {}
-  QUICAckFrame(const uint8_t *buf, size_t len);
+  QUICAckFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICAckFrame(QUICPacketNumber largest_acknowledged, uint64_t ack_delay, uint64_t first_ack_block, QUICFrameId id = 0,
                QUICFrameGenerator *owner = nullptr);
 
@@ -260,8 +267,8 @@
   virtual ~QUICAckFrame();
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
 
   QUICPacketNumber largest_acknowledged() const;
@@ -289,15 +296,15 @@
 {
 public:
   QUICRstStreamFrame(QUICFrameId id = 0) : QUICFrame(id) {}
-  QUICRstStreamFrame(const uint8_t *buf, size_t len);
+  QUICRstStreamFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICRstStreamFrame(QUICStreamId stream_id, QUICAppErrorCode error_code, QUICOffset final_offset, QUICFrameId id = 0,
                      QUICFrameGenerator *owner = nullptr);
 
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
 
   QUICStreamId stream_id() const;
   QUICAppErrorCode error_code() const;
@@ -319,11 +326,11 @@
 {
 public:
   QUICPingFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICPingFrame(const uint8_t *buf, size_t len);
+  QUICPingFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
 
 private:
 };
@@ -335,13 +342,18 @@
 class QUICPaddingFrame : public QUICFrame
 {
 public:
-  QUICPaddingFrame() {}
-  QUICPaddingFrame(const uint8_t *buf, size_t len);
+  QUICPaddingFrame(size_t size) : _size(size) {}
+  QUICPaddingFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
   virtual bool is_probing_frame() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
+
+private:
+  // padding frame is a resident of padding frames
+  // size indicate how many padding frames in this QUICPaddingFrame
+  size_t _size = 0;
 };
 
 //
@@ -352,18 +364,18 @@
 {
 public:
   QUICConnectionCloseFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICConnectionCloseFrame(const uint8_t *buf, size_t len);
+  QUICConnectionCloseFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   // Constructor for transport error codes
-  QUICConnectionCloseFrame(uint16_t error_code, QUICFrameType frame_type, uint64_t reason_phrase_length, const char *reason_phrase,
+  QUICConnectionCloseFrame(uint64_t error_code, QUICFrameType frame_type, uint64_t reason_phrase_length, const char *reason_phrase,
                            QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr);
   // Constructor for application protocol error codes
-  QUICConnectionCloseFrame(uint16_t error_code, uint64_t reason_phrase_length, const char *reason_phrase, QUICFrameId id = 0,
+  QUICConnectionCloseFrame(uint64_t error_code, uint64_t reason_phrase_length, const char *reason_phrase, QUICFrameId id = 0,
                            QUICFrameGenerator *owner = nullptr);
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
 
   uint16_t error_code() const;
   QUICFrameType frame_type() const;
@@ -374,7 +386,7 @@
   virtual void _reset() override;
 
   uint8_t _type = 0;
-  uint16_t _error_code;
+  uint64_t _error_code;
   QUICFrameType _frame_type      = QUICFrameType::UNKNOWN;
   uint64_t _reason_phrase_length = 0;
   const char *_reason_phrase     = nullptr;
@@ -388,13 +400,13 @@
 {
 public:
   QUICMaxDataFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICMaxDataFrame(const uint8_t *buf, size_t len);
+  QUICMaxDataFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICMaxDataFrame(uint64_t maximum_data, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr);
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
 
   uint64_t maximum_data() const;
 
@@ -412,13 +424,13 @@
 {
 public:
   QUICMaxStreamDataFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICMaxStreamDataFrame(const uint8_t *buf, size_t len);
+  QUICMaxStreamDataFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICMaxStreamDataFrame(QUICStreamId stream_id, uint64_t maximum_stream_data, QUICFrameId id = 0,
                          QUICFrameGenerator *owner = nullptr);
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
 
   QUICStreamId stream_id() const;
@@ -439,12 +451,12 @@
 {
 public:
   QUICMaxStreamsFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICMaxStreamsFrame(const uint8_t *buf, size_t len);
+  QUICMaxStreamsFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICMaxStreamsFrame(QUICStreamId maximum_streams, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr);
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
   uint64_t maximum_streams() const;
 
 private:
@@ -460,15 +472,15 @@
 {
 public:
   QUICDataBlockedFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICDataBlockedFrame(const uint8_t *buf, size_t len);
+  QUICDataBlockedFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICDataBlockedFrame(QUICOffset offset, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr)
     : QUICFrame(id, owner), _offset(offset){};
 
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
 
   QUICOffset offset() const;
 
@@ -486,14 +498,14 @@
 {
 public:
   QUICStreamDataBlockedFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICStreamDataBlockedFrame(const uint8_t *buf, size_t len);
+  QUICStreamDataBlockedFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICStreamDataBlockedFrame(QUICStreamId s, QUICOffset o, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr)
     : QUICFrame(id, owner), _stream_id(s), _offset(o){};
 
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
 
   QUICStreamId stream_id() const;
@@ -513,15 +525,15 @@
 {
 public:
   QUICStreamIdBlockedFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICStreamIdBlockedFrame(const uint8_t *buf, size_t len);
+  QUICStreamIdBlockedFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICStreamIdBlockedFrame(QUICStreamId s, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr)
     : QUICFrame(id, owner), _stream_id(s)
   {
   }
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
 
   QUICStreamId stream_id() const;
 
@@ -539,18 +551,19 @@
 {
 public:
   QUICNewConnectionIdFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICNewConnectionIdFrame(const uint8_t *buf, size_t len);
-  QUICNewConnectionIdFrame(uint64_t seq, const QUICConnectionId &cid, QUICStatelessResetToken token, QUICFrameId id = 0,
-                           QUICFrameGenerator *owner = nullptr)
-    : QUICFrame(id, owner), _sequence(seq), _connection_id(cid), _stateless_reset_token(token){};
+  QUICNewConnectionIdFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
+  QUICNewConnectionIdFrame(uint64_t seq, uint64_t ret, const QUICConnectionId &cid, QUICStatelessResetToken token,
+                           QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr)
+    : QUICFrame(id, owner), _sequence(seq), _retire_prior_to(ret), _connection_id(cid), _stateless_reset_token(token){};
 
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
 
   uint64_t sequence() const;
+  uint64_t retire_prior_to() const;
   QUICConnectionId connection_id() const;
   QUICStatelessResetToken stateless_reset_token() const;
 
@@ -558,6 +571,7 @@
   virtual void _reset() override;
 
   uint64_t _sequence              = 0;
+  uint64_t _retire_prior_to       = 0;
   QUICConnectionId _connection_id = QUICConnectionId::ZERO();
   QUICStatelessResetToken _stateless_reset_token;
 };
@@ -570,14 +584,14 @@
 {
 public:
   QUICStopSendingFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICStopSendingFrame(const uint8_t *buf, size_t len);
+  QUICStopSendingFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICStopSendingFrame(QUICStreamId stream_id, QUICAppErrorCode error_code, QUICFrameId id = 0,
                        QUICFrameGenerator *owner = nullptr);
 
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
 
   QUICStreamId stream_id() const;
   QUICAppErrorCode error_code() const;
@@ -598,7 +612,7 @@
 public:
   static constexpr uint8_t DATA_LEN = 8;
   QUICPathChallengeFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICPathChallengeFrame(const uint8_t *buf, size_t len);
+  QUICPathChallengeFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICPathChallengeFrame(ats_unique_buf data, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr)
     : QUICFrame(id, owner), _data(std::move(data))
   {
@@ -606,8 +620,9 @@
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
   virtual bool is_probing_frame() const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual int debug_msg(char *msg, size_t msg_len) const override;
 
   const uint8_t *data() const;
 
@@ -626,7 +641,7 @@
 public:
   static constexpr uint8_t DATA_LEN = 8;
   QUICPathResponseFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICPathResponseFrame(const uint8_t *buf, size_t len);
+  QUICPathResponseFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICPathResponseFrame(ats_unique_buf data, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr)
     : QUICFrame(id, owner), _data(std::move(data))
   {
@@ -634,8 +649,9 @@
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
   virtual bool is_probing_frame() const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual int debug_msg(char *msg, size_t msg_len) const override;
 
   const uint8_t *data() const;
 
@@ -653,15 +669,15 @@
 {
 public:
   QUICNewTokenFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICNewTokenFrame(const uint8_t *buf, size_t len);
+  QUICNewTokenFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICNewTokenFrame(ats_unique_buf token, size_t token_length, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr)
     : QUICFrame(id, owner), _token_length(token_length), _token(std::move(token))
   {
   }
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
 
   uint64_t token_length() const;
   const uint8_t *token() const;
@@ -681,15 +697,15 @@
 {
 public:
   QUICRetireConnectionIdFrame(QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr) : QUICFrame(id, owner) {}
-  QUICRetireConnectionIdFrame(const uint8_t *buf, size_t len);
+  QUICRetireConnectionIdFrame(const uint8_t *buf, size_t len, const QUICPacket *packet = nullptr);
   QUICRetireConnectionIdFrame(uint64_t seq_num, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr)
     : QUICFrame(id, owner), _seq_num(seq_num)
   {
   }
   virtual QUICFrameType type() const override;
   virtual size_t size() const override;
-  virtual size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  virtual void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  virtual void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
   virtual int debug_msg(char *msg, size_t msg_len) const override;
 
   uint64_t seq_num() const;
@@ -708,8 +724,8 @@
 {
   QUICFrameType type() const override;
   size_t size() const override;
-  size_t store(uint8_t *buf, size_t *len, size_t limit) const override;
-  void parse(const uint8_t *buf, size_t len) override;
+  virtual Ptr<IOBufferBlock> to_io_buffer_block(size_t limit) const override;
+  void parse(const uint8_t *buf, size_t len, const QUICPacket *packet) override;
   int debug_msg(char *msg, size_t msg_len) const override;
 };
 
@@ -722,13 +738,13 @@
   /*
    * This is used for creating a QUICFrame object based on received data.
    */
-  static QUICFrame *create(uint8_t *buf, const uint8_t *src, size_t len);
+  static QUICFrame *create(uint8_t *buf, const uint8_t *src, size_t len, const QUICPacket *packet);
 
   /*
    * This works almost the same as create() but it reuses created objects for performance.
    * If you create a frame object which has the same frame type that you created before, the object will be reset by new data.
    */
-  const QUICFrame &fast_create(const uint8_t *buf, size_t len);
+  const QUICFrame &fast_create(const uint8_t *buf, size_t len, const QUICPacket *packet);
 
   /*
    * Creates a STREAM frame.
@@ -833,7 +849,8 @@
   /*
    * Creates a NEW_CONNECTION_ID frame.
    */
-  static QUICNewConnectionIdFrame *create_new_connection_id_frame(uint8_t *buf, uint32_t sequence, QUICConnectionId connectoin_id,
+  static QUICNewConnectionIdFrame *create_new_connection_id_frame(uint8_t *buf, uint64_t sequence, uint64_t retire_prior_to,
+                                                                  QUICConnectionId connectoin_id,
                                                                   QUICStatelessResetToken stateless_reset_token, QUICFrameId id = 0,
                                                                   QUICFrameGenerator *owner = nullptr);
 
@@ -849,6 +866,11 @@
   static QUICRetireConnectionIdFrame *create_retire_connection_id_frame(uint8_t *buf, uint64_t seq_num, QUICFrameId id = 0,
                                                                         QUICFrameGenerator *owner = nullptr);
 
+  /*
+   * Creates a PADDING frame
+   */
+  static QUICPaddingFrame *create_padding_frame(uint8_t *buf, size_t size, QUICFrameId id = 0, QUICFrameGenerator *owner = nullptr);
+
 private:
   // FIXME Actual number of frame types is several but some of the values are not sequential.
   QUICFrame *_reusable_frames[256] = {nullptr};
diff --git a/iocore/net/quic/QUICFrameDispatcher.cc b/iocore/net/quic/QUICFrameDispatcher.cc
index c2f3d1f..b807ff5 100644
--- a/iocore/net/quic/QUICFrameDispatcher.cc
+++ b/iocore/net/quic/QUICFrameDispatcher.cc
@@ -43,7 +43,7 @@
 
 QUICConnectionErrorUPtr
 QUICFrameDispatcher::receive_frames(QUICEncryptionLevel level, const uint8_t *payload, uint16_t size, bool &ack_only,
-                                    bool &is_flow_controlled, bool *has_non_probing_frame)
+                                    bool &is_flow_controlled, bool *has_non_probing_frame, const QUICPacket *packet)
 {
   uint16_t cursor               = 0;
   ack_only                      = true;
@@ -51,7 +51,7 @@
   QUICConnectionErrorUPtr error = nullptr;
 
   while (cursor < size) {
-    const QUICFrame &frame = this->_frame_factory.fast_create(payload + cursor, size - cursor);
+    const QUICFrame &frame = this->_frame_factory.fast_create(payload + cursor, size - cursor, packet);
     if (frame.type() == QUICFrameType::UNKNOWN) {
       QUICDebug("Failed to create a frame (%u bytes skipped)", size - cursor);
       break;
diff --git a/iocore/net/quic/QUICFrameDispatcher.h b/iocore/net/quic/QUICFrameDispatcher.h
index 79d7131..e7ce785 100644
--- a/iocore/net/quic/QUICFrameDispatcher.h
+++ b/iocore/net/quic/QUICFrameDispatcher.h
@@ -35,7 +35,8 @@
   QUICFrameDispatcher(QUICConnectionInfoProvider *info);
 
   QUICConnectionErrorUPtr receive_frames(QUICEncryptionLevel level, const uint8_t *payload, uint16_t size,
-                                         bool &should_send_ackbool, bool &is_flow_controlled, bool *has_non_probing_frame);
+                                         bool &should_send_ackbool, bool &is_flow_controlled, bool *has_non_probing_frame,
+                                         const QUICPacket *packet);
 
   void add_handler(QUICFrameHandler *handler);
 
diff --git a/iocore/net/quic/QUICFrameGenerator.cc b/iocore/net/quic/QUICFrameGenerator.cc
index 3dce966..908374e 100644
--- a/iocore/net/quic/QUICFrameGenerator.cc
+++ b/iocore/net/quic/QUICFrameGenerator.cc
@@ -23,6 +23,7 @@
 
 #include "QUICFrameGenerator.h"
 
+// QUICFrameGenerator
 void
 QUICFrameGenerator::_records_frame(QUICFrameId id, QUICFrameInformationUPtr info)
 {
@@ -58,3 +59,31 @@
     this->_info.erase(it);
   }
 }
+
+void
+QUICFrameGeneratorManager::add_generator(QUICFrameGenerator &generator, int weight)
+{
+  auto it = this->_inline_vector.begin();
+  for (; it != this->_inline_vector.end(); ++it) {
+    if (it->first >= weight) {
+      break;
+    }
+  }
+  this->_inline_vector.emplace(it, weight, &generator);
+}
+
+const std::vector<QUICFrameGenerator *> &
+QUICFrameGeneratorManager::generators()
+{
+  // Because we don't remove generators. So The size changed means new generators is coming
+  if (!this->_generators.empty() && this->_generators.size() == this->_inline_vector.size()) {
+    return this->_generators;
+  }
+
+  this->_generators.clear();
+  for (auto it : this->_inline_vector) {
+    this->_generators.emplace_back(it.second);
+  }
+
+  return this->_generators;
+}
diff --git a/iocore/net/quic/QUICFrameGenerator.h b/iocore/net/quic/QUICFrameGenerator.h
index 2298de5..f415ff7 100644
--- a/iocore/net/quic/QUICFrameGenerator.h
+++ b/iocore/net/quic/QUICFrameGenerator.h
@@ -30,14 +30,14 @@
 {
 public:
   virtual ~QUICFrameGenerator(){};
-  virtual bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) = 0;
+  virtual bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) = 0;
 
   /*
    * This function constructs an instance of QUICFrame on buf.
    * It returns a pointer for the frame if it succeeded, and returns nullptr if it failed.
    */
   virtual QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit,
-                                    uint16_t maximum_frame_size, ink_hrtime timestamp) = 0;
+                                    uint16_t maximum_frame_size, size_t current_packet_size, uint32_t seq_num) = 0;
 
   void on_frame_acked(QUICFrameId id);
   void on_frame_lost(QUICFrameId id);
@@ -67,3 +67,55 @@
   QUICEncryptionLevel _encryption_level_filter = QUICEncryptionLevel::ONE_RTT;
   std::map<QUICFrameId, QUICFrameInformationUPtr> _info;
 };
+
+// only generate one frame per loop
+class QUICFrameOnceGenerator : public QUICFrameGenerator
+{
+public:
+  bool
+  will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override
+  {
+    if (this->_seq_num == seq_num) {
+      return false;
+    }
+
+    this->_seq_num = seq_num;
+    return this->_will_generate_frame(level, current_packet_size, ack_eliciting);
+  }
+
+  QUICFrame *
+  generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
+                 size_t current_packet_size, uint32_t seq_num) override
+  {
+    this->_seq_num = seq_num;
+    return this->_generate_frame(buf, level, connection_credit, maximum_frame_size, current_packet_size);
+  }
+
+protected:
+  virtual bool _will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting) = 0;
+  virtual QUICFrame *_generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit,
+                                     uint16_t maximum_frame_size, size_t current_packet_size)                  = 0;
+
+private:
+  uint32_t _seq_num = UINT32_MAX;
+};
+
+enum QUICFrameGeneratorWeight {
+  EARLY       = 100,
+  BEFORE_DATA = 200,
+  AFTER_DATA  = 300,
+  LATE        = 400,
+};
+
+class QUICFrameGeneratorManager
+{
+public:
+  void add_generator(QUICFrameGenerator &generator, int weight);
+  const std::vector<QUICFrameGenerator *> &generators();
+
+private:
+  using QUICActiveFrameGenerator = std::pair<int, QUICFrameGenerator *>;
+
+  std::vector<QUICFrameGenerator *> _generators;
+  std::vector<QUICActiveFrameGenerator> _inline_vector;
+};
diff --git a/iocore/net/quic/QUICHandshake.cc b/iocore/net/quic/QUICHandshake.cc
index 6042d26..c88377f 100644
--- a/iocore/net/quic/QUICHandshake.cc
+++ b/iocore/net/quic/QUICHandshake.cc
@@ -166,7 +166,7 @@
     packet_factory->set_version(version);
   } else {
     QUICHSDebug("Version negotiation failed");
-    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::VERSION_NEGOTIATION_ERROR);
+    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::PROTOCOL_VIOLATION);
   }
 
   return nullptr;
@@ -322,24 +322,24 @@
 }
 
 bool
-QUICHandshake::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICHandshake::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num)
 {
   if (!this->_is_level_matched(level)) {
     return false;
   }
 
-  return this->_crypto_streams[static_cast<int>(level)].will_generate_frame(level, timestamp);
+  return this->_crypto_streams[static_cast<int>(level)].will_generate_frame(level, current_packet_size, ack_eliciting, seq_num);
 }
 
 QUICFrame *
 QUICHandshake::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                              ink_hrtime timestamp)
+                              size_t current_packet_size, uint32_t seq_num)
 {
   QUICFrame *frame = nullptr;
 
   if (this->_is_level_matched(level)) {
-    frame =
-      this->_crypto_streams[static_cast<int>(level)].generate_frame(buf, level, connection_credit, maximum_frame_size, timestamp);
+    frame = this->_crypto_streams[static_cast<int>(level)].generate_frame(buf, level, connection_credit, maximum_frame_size,
+                                                                          current_packet_size, seq_num);
   }
 
   return frame;
@@ -382,6 +382,9 @@
     pref_addr->store(pref_addr_buf, len);
     tp->set(QUICTransportParameterId::PREFERRED_ADDRESS, pref_addr_buf, len);
   }
+  if (tp_config.active_cid_limit() != 0) {
+    tp->set(QUICTransportParameterId::ACTIVE_CONNECTION_ID_LIMIT, tp_config.active_cid_limit());
+  }
 
   // MAYs (server)
   tp->set(QUICTransportParameterId::STATELESS_RESET_TOKEN, this->_reset_token.buf(), QUICStatelessResetToken::LEN);
@@ -421,6 +424,9 @@
     tp->set(QUICTransportParameterId::INITIAL_MAX_STREAM_DATA_UNI, tp_config.initial_max_stream_data_uni());
   }
   tp->set(QUICTransportParameterId::ACK_DELAY_EXPONENT, tp_config.ack_delay_exponent());
+  if (tp_config.active_cid_limit() != 0) {
+    tp->set(QUICTransportParameterId::ACTIVE_CONNECTION_ID_LIMIT, tp_config.active_cid_limit());
+  }
 
   this->_local_transport_parameters = std::shared_ptr<QUICTransportParameters>(tp);
   this->_hs_protocol->set_local_transport_parameters(std::unique_ptr<QUICTransportParameters>(tp));
diff --git a/iocore/net/quic/QUICHandshake.h b/iocore/net/quic/QUICHandshake.h
index 4dda103..49ef437 100644
--- a/iocore/net/quic/QUICHandshake.h
+++ b/iocore/net/quic/QUICHandshake.h
@@ -51,9 +51,9 @@
   virtual QUICConnectionErrorUPtr handle_frame(QUICEncryptionLevel level, const QUICFrame &frame) override;
 
   // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
   // for client side
   QUICConnectionErrorUPtr start(const QUICTPConfig &tp_config, QUICPacketFactory *packet_factory, bool vn_exercise_enabled);
diff --git a/iocore/net/quic/QUICIncomingFrameBuffer.cc b/iocore/net/quic/QUICIncomingFrameBuffer.cc
index 154563f..373d009 100644
--- a/iocore/net/quic/QUICIncomingFrameBuffer.cc
+++ b/iocore/net/quic/QUICIncomingFrameBuffer.cc
@@ -113,7 +113,11 @@
     this->_recv_offset = offset + len;
     this->_recv_buffer.push(stream_frame);
   } else {
-    this->_out_of_order_queue.insert(std::make_pair(offset, stream_frame));
+    auto result = this->_out_of_order_queue.insert(std::make_pair(offset, stream_frame));
+    if (!result.second) {
+      // Duplicate frame doesn't need to be inserted
+      delete stream_frame;
+    }
   }
 
   return nullptr;
@@ -134,30 +138,30 @@
   // stream with fin flag {11.3. Stream Final Offset}
   // Once a final offset for a stream is known, it cannot change.
   // If a RESET_STREAM or STREAM frame causes the final offset to change for a stream,
-  // an endpoint SHOULD respond with a FINAL_OFFSET_ERROR error (see Section 12).
+  // an endpoint SHOULD respond with a FINAL_SIZE_ERROR error (see Section 12).
   // A receiver SHOULD treat receipt of data at or beyond the final offset as a
-  // FINAL_OFFSET_ERROR error, even after a stream is closed.
+  // FINAL_SIZE_ERROR error, even after a stream is closed.
 
   // {11.3. Stream Final Offset}
   // A receiver SHOULD treat receipt of data at or beyond the final offset as a
-  // FINAL_OFFSET_ERROR error, even after a stream is closed.
+  // FINAL_SIZE_ERROR error, even after a stream is closed.
   if (fin_flag) {
     if (this->_fin_offset != UINT64_MAX) {
       if (this->_fin_offset == offset + len) {
         // dup fin frame
         return nullptr;
       }
-      return std::make_unique<QUICConnectionError>(QUICTransErrorCode::FINAL_OFFSET_ERROR);
+      return std::make_unique<QUICConnectionError>(QUICTransErrorCode::FINAL_SIZE_ERROR);
     }
 
     this->_fin_offset = offset + len;
 
     if (this->_max_offset > this->_fin_offset) {
-      return std::make_unique<QUICConnectionError>(QUICTransErrorCode::FINAL_OFFSET_ERROR);
+      return std::make_unique<QUICConnectionError>(QUICTransErrorCode::FINAL_SIZE_ERROR);
     }
 
   } else if (this->_fin_offset != UINT64_MAX && this->_fin_offset <= offset) {
-    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::FINAL_OFFSET_ERROR);
+    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::FINAL_SIZE_ERROR);
   }
   this->_max_offset = std::max(offset + len, this->_max_offset);
 
@@ -242,7 +246,11 @@
     this->_recv_offset = offset + len;
     this->_recv_buffer.push(crypto_frame);
   } else {
-    this->_out_of_order_queue.insert(std::make_pair(offset, crypto_frame));
+    auto result = this->_out_of_order_queue.insert(std::make_pair(offset, crypto_frame));
+    if (!result.second) {
+      // Duplicate frame doesn't need to be inserted
+      delete crypto_frame;
+    }
   }
 
   return nullptr;
diff --git a/iocore/net/quic/QUICKeyGenerator.cc b/iocore/net/quic/QUICKeyGenerator.cc
index 05c1796..98d091d 100644
--- a/iocore/net/quic/QUICKeyGenerator.cc
+++ b/iocore/net/quic/QUICKeyGenerator.cc
@@ -34,7 +34,7 @@
 using namespace std::literals;
 
 constexpr static uint8_t QUIC_VERSION_1_SALT[] = {
-  0xef, 0x4f, 0xb0, 0xab, 0xb4, 0x74, 0x70, 0xc4, 0x1b, 0xef, 0xcf, 0x80, 0x31, 0x33, 0x4f, 0xae, 0x48, 0x5e, 0x09, 0xa0,
+  0xc3, 0xee, 0xf7, 0x12, 0xc7, 0x2e, 0xbb, 0x5a, 0x11, 0xa7, 0xd2, 0x43, 0x2b, 0xb4, 0x63, 0x65, 0xbe, 0xf9, 0xf5, 0x02,
 };
 constexpr static std::string_view LABEL_FOR_CLIENT_INITIAL_SECRET("client in"sv);
 constexpr static std::string_view LABEL_FOR_SERVER_INITIAL_SECRET("server in"sv);
diff --git a/iocore/net/quic/QUICLossDetector.cc b/iocore/net/quic/QUICLossDetector.cc
index 7cd94c0..4d6397b 100644
--- a/iocore/net/quic/QUICLossDetector.cc
+++ b/iocore/net/quic/QUICLossDetector.cc
@@ -29,14 +29,20 @@
 #include "QUICEvents.h"
 #include "QUICDebugNames.h"
 #include "QUICFrameGenerator.h"
+#include "QUICPinger.h"
+#include "QUICPadder.h"
+#include "QUICPacketProtectionKeyInfo.h"
 
-#define QUICLDDebug(fmt, ...) Debug("quic_loss_detector", "[%s] " fmt, this->_info->cids().data(), ##__VA_ARGS__)
-#define QUICLDVDebug(fmt, ...) Debug("v_quic_loss_detector", "[%s] " fmt, this->_info->cids().data(), ##__VA_ARGS__)
+#define QUICLDDebug(fmt, ...) \
+  Debug("quic_loss_detector", "[%s] " fmt, this->_context.connection_info()->cids().data(), ##__VA_ARGS__)
+#define QUICLDVDebug(fmt, ...) \
+  Debug("v_quic_loss_detector", "[%s] " fmt, this->_context.connection_info()->cids().data(), ##__VA_ARGS__)
 
-QUICLossDetector::QUICLossDetector(QUICConnectionInfoProvider *info, QUICCongestionController *cc, QUICRTTMeasure *rtt_measure,
-                                   const QUICLDConfig &ld_config)
-  : _info(info), _rtt_measure(rtt_measure), _cc(cc)
+QUICLossDetector::QUICLossDetector(QUICLDContext &context, QUICCongestionController *cc, QUICRTTMeasure *rtt_measure,
+                                   QUICPinger *pinger, QUICPadder *padder)
+  : _rtt_measure(rtt_measure), _pinger(pinger), _padder(padder), _cc(cc), _context(context)
 {
+  auto &ld_config             = _context.ld_config();
   this->mutex                 = new_ProxyMutex();
   this->_loss_detection_mutex = new_ProxyMutex();
 
@@ -133,6 +139,9 @@
   ink_hrtime now                 = packet_info->time_sent;
   size_t sent_bytes              = packet_info->sent_bytes;
 
+  QUICLDDebug("%s packet sent : %" PRIu64 " bytes: %lu ack_eliciting: %d", QUICDebugNames::pn_space(packet_info->pn_space),
+              packet_number, sent_bytes, ack_eliciting);
+
   this->_add_to_sent_packet_list(packet_number, std::move(packet_info));
 
   if (in_flight) {
@@ -178,6 +187,21 @@
   this->_ack_delay_exponent = ack_delay_exponent;
 }
 
+bool
+QUICLossDetector::_include_ack_eliciting(const std::vector<QUICPacketInfo *> &acked_packets, int index) const
+{
+  // Find out ack_elicting packet.
+  // FIXME: this loop is the same as _on_ack_received's loop it would better
+  // to combine it.
+  for (auto packet : acked_packets) {
+    if (packet->ack_eliciting) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void
 QUICLossDetector::_on_ack_received(const QUICAckFrame &ack_frame, QUICPacketNumberSpace pn_space)
 {
@@ -185,10 +209,17 @@
 
   int index                          = static_cast<int>(pn_space);
   this->_largest_acked_packet[index] = std::max(this->_largest_acked_packet[index], ack_frame.largest_acknowledged());
+
+  auto newly_acked_packets = this->_determine_newly_acked_packets(ack_frame, index);
+  if (newly_acked_packets.empty()) {
+    return;
+  }
+
   // If the largest acknowledged is newly acked and
   //  ack-eliciting, update the RTT.
   auto pi = this->_sent_packets[index].find(ack_frame.largest_acknowledged());
-  if (pi != this->_sent_packets[index].end() && pi->second->ack_eliciting) {
+  if (pi != this->_sent_packets[index].end() &&
+      (pi->second->ack_eliciting || this->_include_ack_eliciting(newly_acked_packets, index))) {
     ink_hrtime latest_rtt = Thread::get_hrtime() - pi->second->time_sent;
     // _latest_rtt is nanosecond but ack_frame.ack_delay is microsecond and scaled
     ink_hrtime delay = HRTIME_USECONDS(ack_frame.ack_delay() << this->_ack_delay_exponent);
@@ -205,21 +236,8 @@
   }
 
   // Find all newly acked packets.
-  bool newly_acked_packets = false;
-  for (auto &&range : this->_determine_newly_acked_packets(ack_frame)) {
-    for (auto ite = this->_sent_packets[index].begin(); ite != this->_sent_packets[index].end(); /* no increment here*/) {
-      auto tmp_ite = ite;
-      tmp_ite++;
-      if (range.contains(ite->first)) {
-        newly_acked_packets = true;
-        this->_on_packet_acked(*(ite->second));
-      }
-      ite = tmp_ite;
-    }
-  }
-
-  if (!newly_acked_packets) {
-    return;
+  for (auto info : newly_acked_packets) {
+    this->_on_packet_acked(*info);
   }
 
   QUICLDVDebug("[%s] Unacked packets %lu (retransmittable %u, includes %u handshake packets)", QUICDebugNames::pn_space(pn_space),
@@ -240,9 +258,10 @@
 QUICLossDetector::_on_packet_acked(const QUICPacketInfo &acked_packet)
 {
   SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
-  // QUICLDDebug("Packet number %" PRIu64 " has been acked", acked_packet_number);
+  QUICLDDebug("[%s] Packet number %" PRIu64 " has been acked", QUICDebugNames::pn_space(acked_packet.pn_space),
+              acked_packet.packet_number);
 
-  if (acked_packet.ack_eliciting) {
+  if (acked_packet.in_flight) {
     this->_cc->on_packet_acked(acked_packet);
   }
 
@@ -276,6 +295,31 @@
 void
 QUICLossDetector::_set_loss_detection_timer()
 {
+  std::function<void(ink_hrtime)> update_timer = [this](ink_hrtime time) {
+    this->_loss_detection_alarm_at = time;
+    if (!this->_loss_detection_timer) {
+      this->_loss_detection_timer = eventProcessor.schedule_every(this, HRTIME_MSECONDS(25));
+    }
+  };
+
+  QUICPacketNumberSpace pn_space;
+  ink_hrtime alarm = this->_get_earliest_loss_time(pn_space);
+  if (alarm != 0) {
+    update_timer(alarm);
+    QUICLDDebug("[%s] time threshold loss detection timer: %" PRId64 "ms", QUICDebugNames::pn_space(pn_space),
+                (this->_loss_detection_alarm_at - Thread::get_hrtime()) / HRTIME_MSECOND);
+    return;
+  }
+
+  if (this->_crypto_outstanding > 0 || this->_is_client_without_one_rtt_key()) {
+    // Crypto retransmission timer.
+    alarm = this->_time_of_last_sent_crypto_packet + this->_rtt_measure->handshake_retransmit_timeout();
+    update_timer(alarm);
+    QUICLDDebug("%s crypto packet alarm will be set: %" PRId64 "ms", QUICDebugNames::pn_space(pn_space),
+                (alarm - this->_time_of_last_sent_crypto_packet) / HRTIME_MSECOND);
+    return;
+  }
+
   // Don't arm the alarm if there are no packets with retransmittable data in flight.
   // -- MODIFIED CODE --
   // In psuedocode, `bytes_in_flight` is used, but we're tracking "retransmittable data in flight" by `_ack_eliciting_outstanding`
@@ -291,29 +335,11 @@
   }
   // -- END OF MODIFIED CODE --
 
-  QUICPacketNumberSpace pn_space;
-  ink_hrtime loss_time = this->_get_earliest_loss_time(pn_space);
-  if (loss_time != 0) {
-    // Time threshold loss detection.
-    this->_loss_detection_alarm_at = loss_time;
-    QUICLDDebug("[%s] time threshold loss detection timer: %" PRId64, QUICDebugNames::pn_space(pn_space),
-                this->_loss_detection_alarm_at);
-  } else if (this->_crypto_outstanding) {
-    // Handshake retransmission alarm.
-    this->_loss_detection_alarm_at = this->_time_of_last_sent_crypto_packet + this->_rtt_measure->handshake_retransmit_timeout();
-    QUICLDDebug("%s crypto packet alarm will be set: %" PRId64, QUICDebugNames::pn_space(pn_space), this->_loss_detection_alarm_at);
-    // -- ADDITIONAL CODE --
-    // In psudocode returning here, but we don't do for scheduling _loss_detection_alarm event.
-    // -- END OF ADDITIONAL CODE --
-  } else {
-    // PTO Duration
-    this->_loss_detection_alarm_at = this->_time_of_last_sent_ack_eliciting_packet + this->_rtt_measure->current_pto_period();
-    QUICLDDebug("[%s] PTO timeout will be set: %" PRId64, QUICDebugNames::pn_space(pn_space), this->_loss_detection_alarm_at);
-  }
-
-  if (!this->_loss_detection_timer) {
-    this->_loss_detection_timer = eventProcessor.schedule_every(this, HRTIME_MSECONDS(25));
-  }
+  // PTO Duration
+  alarm = this->_time_of_last_sent_ack_eliciting_packet + this->_rtt_measure->current_pto_period();
+  update_timer(alarm);
+  QUICLDDebug("[%s] PTO timeout will be set: %" PRId64 "ms", QUICDebugNames::pn_space(pn_space),
+              (alarm - this->_time_of_last_sent_ack_eliciting_packet) / HRTIME_MSECOND);
 }
 
 void
@@ -326,11 +352,23 @@
     this->_detect_lost_packets(pn_space);
   } else if (this->_crypto_outstanding) {
     // Handshake retransmission alarm.
+    QUICLDVDebug("Crypto Retranmission");
     this->_retransmit_all_unacked_crypto_data();
     this->_rtt_measure->set_crypto_count(this->_rtt_measure->crypto_count() + 1);
+  } else if (this->_is_client_without_one_rtt_key()) {
+    // Client sends an anti-deadlock packet: Initial is padded
+    // to earn more anti-amplification credit,
+    // a Handshake packet proves address ownership.
+    if (this->_context.key_info()->is_encryption_key_available(QUICKeyPhase::HANDSHAKE)) {
+      this->_send_one_handshake_packets();
+    } else {
+      this->_send_one_padded_packets();
+    }
+
+    this->_rtt_measure->set_crypto_count(this->_rtt_measure->crypto_count() + 1);
   } else {
     QUICLDVDebug("PTO");
-    this->_send_two_packets();
+    this->_send_one_or_two_packet();
     this->_rtt_measure->set_pto_count(this->_rtt_measure->pto_count() + 1);
   }
 
@@ -358,6 +396,8 @@
   SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
   this->_loss_time[static_cast<int>(pn_space)] = 0;
   ink_hrtime loss_delay = this->_k_time_threshold * std::max(this->_rtt_measure->latest_rtt(), this->_rtt_measure->smoothed_rtt());
+  loss_delay            = std::min(loss_delay, this->_rtt_measure->k_granularity());
+
   std::map<QUICPacketNumber, QUICPacketInfo *> lost_packets;
 
   // Packets sent before this time are deemed lost.
@@ -390,12 +430,12 @@
 
       if (unacked->in_flight) {
         lost_packets.insert({it->first, it->second.get()});
-      } else if (this->_loss_time[static_cast<int>(pn_space)] == 0) {
-        this->_loss_time[static_cast<int>(pn_space)] = unacked->time_sent + loss_delay;
-      } else {
-        this->_loss_time[static_cast<int>(pn_space)] =
-          std::min(this->_loss_time[static_cast<int>(pn_space)], unacked->time_sent + loss_delay);
       }
+    } else if (this->_loss_time[static_cast<int>(pn_space)] == 0) {
+      this->_loss_time[static_cast<int>(pn_space)] = unacked->time_sent + loss_delay;
+    } else {
+      this->_loss_time[static_cast<int>(pn_space)] =
+        std::min(this->_loss_time[static_cast<int>(pn_space)], unacked->time_sent + loss_delay);
     }
   }
 
@@ -442,10 +482,38 @@
 }
 
 void
-QUICLossDetector::_send_two_packets()
+QUICLossDetector::_send_packet(QUICEncryptionLevel level, bool padded)
 {
-  SCOPED_MUTEX_LOCK(lock, this->_loss_detection_mutex, this_ethread());
-  // TODO sent ping
+  if (padded) {
+    this->_padder->request(level);
+  } else {
+    this->_pinger->request();
+  }
+  this->_cc->add_extra_credit();
+}
+
+void
+QUICLossDetector::_send_one_or_two_packet()
+{
+  this->_send_packet(QUICEncryptionLevel::ONE_RTT);
+  this->_send_packet(QUICEncryptionLevel::ONE_RTT);
+  ink_assert(this->_pinger->count() >= 2);
+  QUICLDDebug("[%s] send ping frame %" PRIu64, QUICDebugNames::encryption_level(QUICEncryptionLevel::ONE_RTT),
+              this->_pinger->count());
+}
+
+void
+QUICLossDetector::_send_one_handshake_packets()
+{
+  this->_send_packet(QUICEncryptionLevel::HANDSHAKE);
+  QUICLDDebug("[%s] send handshake packet", QUICDebugNames::encryption_level(QUICEncryptionLevel::HANDSHAKE));
+}
+
+void
+QUICLossDetector::_send_one_padded_packets()
+{
+  this->_send_packet(QUICEncryptionLevel::INITIAL, true);
+  QUICLDDebug("[%s] send PADDING frame", QUICDebugNames::encryption_level(QUICEncryptionLevel::INITIAL));
 }
 
 // ===== Functions below are helper functions =====
@@ -466,9 +534,10 @@
   }
 }
 
-std::set<QUICAckFrame::PacketNumberRange>
-QUICLossDetector::_determine_newly_acked_packets(const QUICAckFrame &ack_frame)
+std::vector<QUICPacketInfo *>
+QUICLossDetector::_determine_newly_acked_packets(const QUICAckFrame &ack_frame, int pn_space)
 {
+  std::vector<QUICPacketInfo *> packets;
   std::set<QUICAckFrame::PacketNumberRange> numbers;
   QUICPacketNumber x = ack_frame.largest_acknowledged();
   numbers.insert({x, static_cast<uint64_t>(x) - ack_frame.ack_block_section()->first_ack_block()});
@@ -479,7 +548,15 @@
     x -= block.length() + 1;
   }
 
-  return numbers;
+  for (auto &&range : numbers) {
+    for (auto ite = this->_sent_packets[pn_space].rbegin(); ite != this->_sent_packets[pn_space].rend(); ite++) {
+      if (range.contains(ite->first)) {
+        packets.push_back(ite->second.get());
+      }
+    }
+  }
+
+  return packets;
 }
 
 void
@@ -542,6 +619,16 @@
   }
 }
 
+bool
+QUICLossDetector::_is_client_without_one_rtt_key() const
+{
+  return this->_context.connection_info()->direction() == NET_VCONNECTION_OUT &&
+         !((this->_context.key_info()->is_encryption_key_available(QUICKeyPhase::PHASE_1) &&
+            this->_context.key_info()->is_decryption_key_available(QUICKeyPhase::PHASE_1)) ||
+           (this->_context.key_info()->is_encryption_key_available(QUICKeyPhase::PHASE_0) &&
+            this->_context.key_info()->is_decryption_key_available(QUICKeyPhase::PHASE_0)));
+}
+
 //
 // QUICRTTMeasure
 //
@@ -566,30 +653,28 @@
 void
 QUICRTTMeasure::update_rtt(ink_hrtime latest_rtt, ink_hrtime ack_delay)
 {
-  // additional code
   this->_latest_rtt = latest_rtt;
 
+  if (this->_smoothed_rtt == 0) {
+    this->_min_rtt      = 0;
+    this->_smoothed_rtt = this->_latest_rtt;
+    this->_rttvar       = this->_latest_rtt / 2;
+    return;
+  }
+
   // min_rtt ignores ack delay.
   this->_min_rtt = std::min(this->_min_rtt, latest_rtt);
   // Limit ack_delay by max_ack_delay
   ack_delay = std::min(ack_delay, this->_max_ack_delay);
   // Adjust for ack delay if it's plausible.
-  if (this->_latest_rtt - this->_min_rtt > ack_delay) {
-    this->_latest_rtt -= ack_delay;
+  auto adjusted_rtt = this->_latest_rtt;
+  if (adjusted_rtt > this->_min_rtt + ack_delay) {
+    adjusted_rtt -= ack_delay;
+  }
 
-    // the newest spec has removed the max_ack_delay assignment. but we need to assign it in somewhere
-    // this code is from draft-19
-    this->_max_ack_delay = std::max(ack_delay, this->_max_ack_delay);
-  }
   // Based on {{RFC6298}}.
-  if (this->_smoothed_rtt == 0) {
-    this->_smoothed_rtt = latest_rtt;
-    this->_rttvar       = latest_rtt / 2.0;
-  } else {
-    double rttvar_sample = ABS(this->_smoothed_rtt - latest_rtt);
-    this->_rttvar        = 3.0 / 4.0 * this->_rttvar + 1.0 / 4.0 * rttvar_sample;
-    this->_smoothed_rtt  = 7.0 / 8.0 * this->_smoothed_rtt + 1.0 / 8.0 * latest_rtt;
-  }
+  this->_rttvar       = 3.0 / 4.0 * this->_rttvar + 1.0 / 4.0 * ABS(this->_smoothed_rtt - adjusted_rtt);
+  this->_smoothed_rtt = 7.0 / 8.0 * this->_smoothed_rtt + 1.0 / 8.0 * adjusted_rtt;
 }
 
 ink_hrtime
@@ -607,7 +692,7 @@
 QUICRTTMeasure::congestion_period(uint32_t threshold) const
 {
   ink_hrtime pto = this->_smoothed_rtt + std::max(this->_rttvar * 4, this->_k_granularity);
-  return pto * (1 << (threshold - 1));
+  return pto * threshold;
 }
 
 ink_hrtime
@@ -662,6 +747,12 @@
   return this->_pto_count;
 }
 
+ink_hrtime
+QUICRTTMeasure::k_granularity() const
+{
+  return this->_k_granularity;
+}
+
 void
 QUICRTTMeasure::reset()
 {
@@ -669,5 +760,6 @@
   this->_pto_count    = 0;
   this->_smoothed_rtt = 0;
   this->_rttvar       = 0;
-  this->_min_rtt      = INT64_MAX;
+  this->_min_rtt      = 0;
+  this->_latest_rtt   = 0;
 }
diff --git a/iocore/net/quic/QUICLossDetector.h b/iocore/net/quic/QUICLossDetector.h
index 1b7a536..5e4005b 100644
--- a/iocore/net/quic/QUICLossDetector.h
+++ b/iocore/net/quic/QUICLossDetector.h
@@ -36,26 +36,14 @@
 #include "QUICFrame.h"
 #include "QUICFrameHandler.h"
 #include "QUICConnection.h"
+#include "QUICContext.h"
+#include "QUICCongestionController.h"
 
+class QUICPadder;
+class QUICPinger;
 class QUICLossDetector;
 class QUICRTTMeasure;
 
-struct QUICPacketInfo {
-  // 6.3.1.  Sent Packet Fields
-  QUICPacketNumber packet_number;
-  ink_hrtime time_sent;
-  bool ack_eliciting;
-  bool is_crypto_packet;
-  bool in_flight;
-  size_t sent_bytes;
-
-  // addition
-  QUICPacketType type;
-  std::vector<QUICFrameInfo> frames;
-  QUICPacketNumberSpace pn_space;
-  // end
-};
-
 using QUICPacketInfoUPtr = std::unique_ptr<QUICPacketInfo>;
 
 class QUICRTTProvider
@@ -68,19 +56,18 @@
   virtual ink_hrtime congestion_period(uint32_t threshold) const = 0;
 };
 
-class QUICCongestionController
+class QUICNewRenoCongestionController : public QUICCongestionController
 {
 public:
-  QUICCongestionController(const QUICRTTProvider &rtt_provider, QUICConnectionInfoProvider *info, const QUICCCConfig &cc_config);
-  virtual ~QUICCongestionController() {}
-  void on_packet_sent(size_t bytes_sent);
-  void on_packet_acked(const QUICPacketInfo &acked_packet);
-  virtual void on_packets_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &packets);
-  void on_retransmission_timeout_verified();
-  void process_ecn(const QUICPacketInfo &acked_largest_packet, const QUICAckFrame::EcnSection *ecn_section);
+  QUICNewRenoCongestionController(QUICCCContext &context);
+  virtual ~QUICNewRenoCongestionController() {}
+  void on_packet_sent(size_t bytes_sent) override;
+  void on_packet_acked(const QUICPacketInfo &acked_packet) override;
+  virtual void on_packets_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &packets) override;
+  void process_ecn(const QUICPacketInfo &acked_largest_packet, const QUICAckFrame::EcnSection *ecn_section) override;
   bool check_credit() const;
-  uint32_t open_window() const;
-  void reset();
+  uint32_t credit() const override;
+  void reset() override;
   bool is_app_limited();
 
   // Debug
@@ -88,6 +75,8 @@
   uint32_t congestion_window() const;
   uint32_t current_ssthresh() const;
 
+  void add_extra_credit() override;
+
 private:
   Ptr<ProxyMutex> _cc_mutex;
 
@@ -97,32 +86,33 @@
   bool _in_window_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &lost_packets, QUICPacketInfo *largest_lost_packet,
                        ink_hrtime period) const;
 
+  uint32_t _extra_packets_count = 0;
+
   // [draft-17 recovery] 7.9.1. Constants of interest
   // Values will be loaded from records.config via QUICConfig at constructor
   uint32_t _k_max_datagram_size               = 0;
   uint32_t _k_initial_window                  = 0;
   uint32_t _k_minimum_window                  = 0;
   float _k_loss_reduction_factor              = 0.0;
-  uint32_t _k_persistent_congestion_threshold = 0;
+  uint32_t _k_persistent_congestion_threshold = 3;
 
   // [draft-17 recovery] 7.9.2. Variables of interest
-  uint32_t _ecn_ce_counter        = 0;
-  uint32_t _bytes_in_flight       = 0;
-  uint32_t _congestion_window     = 0;
-  ink_hrtime _recovery_start_time = 0;
-  uint32_t _ssthresh              = UINT32_MAX;
+  uint32_t _ecn_ce_counter                   = 0;
+  uint32_t _bytes_in_flight                  = 0;
+  uint32_t _congestion_window                = 0;
+  ink_hrtime _congestion_recovery_start_time = 0;
+  uint32_t _ssthresh                         = UINT32_MAX;
 
-  QUICConnectionInfoProvider *_info = nullptr;
-  const QUICRTTProvider &_rtt_provider;
+  bool _in_congestion_recovery(ink_hrtime sent_time);
 
-  bool _in_recovery(ink_hrtime sent_time);
+  QUICCCContext &_context;
 };
 
 class QUICLossDetector : public Continuation, public QUICFrameHandler
 {
 public:
-  QUICLossDetector(QUICConnectionInfoProvider *info, QUICCongestionController *cc, QUICRTTMeasure *rtt_measure,
-                   const QUICLDConfig &ld_config);
+  QUICLossDetector(QUICLDContext &context, QUICCongestionController *cc, QUICRTTMeasure *rtt_measure, QUICPinger *pinger,
+                   QUICPadder *padder);
   ~QUICLossDetector();
 
   int event_handler(int event, Event *edata);
@@ -178,15 +168,24 @@
 
   ink_hrtime _get_earliest_loss_time(QUICPacketNumberSpace &pn_space);
 
-  std::set<QUICAckFrame::PacketNumberRange> _determine_newly_acked_packets(const QUICAckFrame &ack_frame);
+  std::vector<QUICPacketInfo *> _determine_newly_acked_packets(const QUICAckFrame &ack_frame, int pn_space);
+  bool _include_ack_eliciting(const std::vector<QUICPacketInfo *> &acked_packets, int index) const;
 
   void _retransmit_all_unacked_crypto_data();
-  void _send_one_packet();
-  void _send_two_packets();
+  void _send_one_or_two_packet();
+  void _send_one_handshake_packets();
+  void _send_one_padded_packets();
 
-  QUICConnectionInfoProvider *_info = nullptr;
-  QUICRTTMeasure *_rtt_measure      = nullptr;
-  QUICCongestionController *_cc     = nullptr;
+  void _send_packet(QUICEncryptionLevel level, bool padded = false);
+
+  bool _is_client_without_one_rtt_key() const;
+
+  QUICRTTMeasure *_rtt_measure  = nullptr;
+  QUICPinger *_pinger           = nullptr;
+  QUICPadder *_padder           = nullptr;
+  QUICCongestionController *_cc = nullptr;
+
+  QUICLDContext &_context;
 };
 
 class QUICRTTMeasure : public QUICRTTProvider
@@ -219,11 +218,14 @@
   void update_rtt(ink_hrtime latest_rtt, ink_hrtime ack_delay);
   void reset();
 
+  ink_hrtime k_granularity() const;
+
 private:
   // related to rtt calculate
-  uint32_t _crypto_count    = 0;
-  uint32_t _pto_count       = 0;
-  ink_hrtime _max_ack_delay = 0;
+  uint32_t _crypto_count = 0;
+  uint32_t _pto_count    = 0;
+  // FIXME should be set by transport parameters
+  ink_hrtime _max_ack_delay = HRTIME_MSECONDS(25);
 
   // rtt vars
   ink_hrtime _latest_rtt   = 0;
@@ -233,5 +235,5 @@
 
   // config
   ink_hrtime _k_granularity = 0;
-  ink_hrtime _k_initial_rtt = 0;
+  ink_hrtime _k_initial_rtt = HRTIME_MSECONDS(500);
 };
diff --git a/iocore/net/quic/QUICCongestionController.cc b/iocore/net/quic/QUICNewRenoCongestionController.cc
similarity index 62%
rename from iocore/net/quic/QUICCongestionController.cc
rename to iocore/net/quic/QUICNewRenoCongestionController.cc
index 79d8fd8..080c910 100644
--- a/iocore/net/quic/QUICCongestionController.cc
+++ b/iocore/net/quic/QUICNewRenoCongestionController.cc
@@ -24,22 +24,24 @@
 #include <tscore/Diags.h>
 #include <QUICLossDetector.h>
 
-#define QUICCCDebug(fmt, ...)                                                \
-  Debug("quic_cc",                                                           \
-        "[%s] "                                                              \
-        "window: %" PRIu32 " bytes: %" PRIu32 " ssthresh: %" PRIu32 " " fmt, \
-        this->_info->cids().data(), this->_congestion_window, this->_bytes_in_flight, this->_ssthresh, ##__VA_ARGS__)
+#define QUICCCDebug(fmt, ...)                                                                                               \
+  Debug("quic_cc",                                                                                                          \
+        "[%s] "                                                                                                             \
+        "window: %" PRIu32 " bytes: %" PRIu32 " ssthresh: %" PRIu32 " extra: %" PRIu32 " " fmt,                             \
+        this->_context.connection_info()->cids().data(), this->_congestion_window, this->_bytes_in_flight, this->_ssthresh, \
+        this->_extra_packets_count, ##__VA_ARGS__)
 
-#define QUICCCError(fmt, ...)                                                \
-  Error("quic_cc",                                                           \
-        "[%s] "                                                              \
-        "window: %" PRIu32 " bytes: %" PRIu32 " ssthresh: %" PRIu32 " " fmt, \
-        this->_info->cids().data(), this->_congestion_window, this->_bytes_in_flight, this->_ssthresh, ##__VA_ARGS__)
+#define QUICCCError(fmt, ...)                                                                                               \
+  Error("quic_cc",                                                                                                          \
+        "[%s] "                                                                                                             \
+        "window: %" PRIu32 " bytes: %" PRIu32 " ssthresh: %" PRIu32 " extra %" PRIu32 " " fmt,                              \
+        this->_context.connection_info()->cids().data(), this->_congestion_window, this->_bytes_in_flight, this->_ssthresh, \
+        this->_extra_packets_count, ##__VA_ARGS__)
 
-QUICCongestionController::QUICCongestionController(const QUICRTTProvider &rtt_provider, QUICConnectionInfoProvider *info,
-                                                   const QUICCCConfig &cc_config)
-  : _cc_mutex(new_ProxyMutex()), _info(info), _rtt_provider(rtt_provider)
+QUICNewRenoCongestionController::QUICNewRenoCongestionController(QUICCCContext &context)
+  : _cc_mutex(new_ProxyMutex()), _context(context)
 {
+  auto &cc_config                          = context.cc_config();
   this->_k_max_datagram_size               = cc_config.max_datagram_size();
   this->_k_initial_window                  = cc_config.initial_window();
   this->_k_minimum_window                  = cc_config.minimum_window();
@@ -50,32 +52,36 @@
 }
 
 void
-QUICCongestionController::on_packet_sent(size_t bytes_sent)
+QUICNewRenoCongestionController::on_packet_sent(size_t bytes_sent)
 {
   SCOPED_MUTEX_LOCK(lock, this->_cc_mutex, this_ethread());
+  if (this->_extra_packets_count > 0) {
+    --this->_extra_packets_count;
+  }
+
   this->_bytes_in_flight += bytes_sent;
 }
 
 bool
-QUICCongestionController::_in_recovery(ink_hrtime sent_time)
+QUICNewRenoCongestionController::_in_congestion_recovery(ink_hrtime sent_time)
 {
-  return sent_time <= this->_recovery_start_time;
+  return sent_time <= this->_congestion_recovery_start_time;
 }
 
 bool
-QUICCongestionController::is_app_limited()
+QUICNewRenoCongestionController::is_app_limited()
 {
   // FIXME : don't known how does app worked here
   return false;
 }
 
 void
-QUICCongestionController::on_packet_acked(const QUICPacketInfo &acked_packet)
+QUICNewRenoCongestionController::on_packet_acked(const QUICPacketInfo &acked_packet)
 {
   // Remove from bytes_in_flight.
   SCOPED_MUTEX_LOCK(lock, this->_cc_mutex, this_ethread());
   this->_bytes_in_flight -= acked_packet.sent_bytes;
-  if (this->_in_recovery(acked_packet.time_sent)) {
+  if (this->_in_congestion_recovery(acked_packet.time_sent)) {
     // Do not increase congestion window in recovery period.
     return;
   }
@@ -101,12 +107,12 @@
 // the original one is:
 //   CongestionEvent(sent_time):
 void
-QUICCongestionController::_congestion_event(ink_hrtime sent_time)
+QUICNewRenoCongestionController::_congestion_event(ink_hrtime sent_time)
 {
-  // Start a new congestion event if the sent time is larger
-  // than the start time of the previous recovery epoch.
-  if (!this->_in_recovery(sent_time)) {
-    this->_recovery_start_time = Thread::get_hrtime();
+  // Start a new congestion event if packet was sent after the
+  // start of the previous congestion recovery period.
+  if (!this->_in_congestion_recovery(sent_time)) {
+    this->_congestion_recovery_start_time = Thread::get_hrtime();
     this->_congestion_window *= this->_k_loss_reduction_factor;
     this->_congestion_window = std::max(this->_congestion_window, this->_k_minimum_window);
     this->_ssthresh          = this->_congestion_window;
@@ -117,7 +123,8 @@
 // the original one is:
 //   ProcessECN(ack):
 void
-QUICCongestionController::process_ecn(const QUICPacketInfo &acked_largest_packet, const QUICAckFrame::EcnSection *ecn_section)
+QUICNewRenoCongestionController::process_ecn(const QUICPacketInfo &acked_largest_packet,
+                                             const QUICAckFrame::EcnSection *ecn_section)
 {
   // If the ECN-CE counter reported by the peer has increased,
   // this could be a new congestion event.
@@ -131,10 +138,10 @@
 }
 
 bool
-QUICCongestionController::_in_persistent_congestion(const std::map<QUICPacketNumber, QUICPacketInfo *> &lost_packets,
-                                                    QUICPacketInfo *largest_lost_packet)
+QUICNewRenoCongestionController::_in_persistent_congestion(const std::map<QUICPacketNumber, QUICPacketInfo *> &lost_packets,
+                                                           QUICPacketInfo *largest_lost_packet)
 {
-  ink_hrtime period = this->_rtt_provider.congestion_period(this->_k_persistent_congestion_threshold);
+  ink_hrtime period = this->_context.rtt_provider()->congestion_period(this->_k_persistent_congestion_threshold);
   // Determine if all packets in the window before the
   // newest lost packet, including the edges, are marked
   // lost
@@ -145,7 +152,7 @@
 // the original one is:
 //   OnPacketsLost(lost_packets):
 void
-QUICCongestionController::on_packets_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &lost_packets)
+QUICNewRenoCongestionController::on_packets_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &lost_packets)
 {
   if (lost_packets.empty()) {
     return;
@@ -157,8 +164,6 @@
     this->_bytes_in_flight -= lost_packet.second->sent_bytes;
   }
   QUICPacketInfo *largest_lost_packet = lost_packets.rbegin()->second;
-  // Start a new recovery epoch if the lost packet is larger
-  // than the end of the previous recovery epoch.
   this->_congestion_event(largest_lost_packet->time_sent);
 
   // Collapse congestion window if persistent congestion
@@ -168,7 +173,7 @@
 }
 
 bool
-QUICCongestionController::check_credit() const
+QUICNewRenoCongestionController::check_credit() const
 {
   if (this->_bytes_in_flight >= this->_congestion_window) {
     QUICCCDebug("Congestion control pending");
@@ -178,8 +183,12 @@
 }
 
 uint32_t
-QUICCongestionController::open_window() const
+QUICNewRenoCongestionController::credit() const
 {
+  if (this->_extra_packets_count) {
+    return UINT32_MAX;
+  }
+
   if (this->check_credit()) {
     return this->_congestion_window - this->_bytes_in_flight;
   } else {
@@ -188,38 +197,38 @@
 }
 
 uint32_t
-QUICCongestionController::bytes_in_flight() const
+QUICNewRenoCongestionController::bytes_in_flight() const
 {
   return this->_bytes_in_flight;
 }
 
 uint32_t
-QUICCongestionController::congestion_window() const
+QUICNewRenoCongestionController::congestion_window() const
 {
   return this->_congestion_window;
 }
 
 uint32_t
-QUICCongestionController::current_ssthresh() const
+QUICNewRenoCongestionController::current_ssthresh() const
 {
   return this->_ssthresh;
 }
 
 // [draft-17 recovery] 7.9.3.  Initialization
 void
-QUICCongestionController::reset()
+QUICNewRenoCongestionController::reset()
 {
   SCOPED_MUTEX_LOCK(lock, this->_cc_mutex, this_ethread());
 
-  this->_bytes_in_flight     = 0;
-  this->_congestion_window   = this->_k_initial_window;
-  this->_recovery_start_time = 0;
-  this->_ssthresh            = UINT32_MAX;
+  this->_bytes_in_flight                = 0;
+  this->_congestion_window              = this->_k_initial_window;
+  this->_congestion_recovery_start_time = 0;
+  this->_ssthresh                       = UINT32_MAX;
 }
 
 bool
-QUICCongestionController::_in_window_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &lost_packets,
-                                          QUICPacketInfo *largest_lost_packet, ink_hrtime period) const
+QUICNewRenoCongestionController::_in_window_lost(const std::map<QUICPacketNumber, QUICPacketInfo *> &lost_packets,
+                                                 QUICPacketInfo *largest_lost_packet, ink_hrtime period) const
 {
   // check whether packets are continuous. return true if all continuous packets are in period
   QUICPacketNumber next_expected = UINT64_MAX;
@@ -240,3 +249,9 @@
 
   return next_expected == UINT64_MAX ? false : true;
 }
+
+void
+QUICNewRenoCongestionController::add_extra_credit()
+{
+  ++this->_extra_packets_count;
+}
diff --git a/iocore/net/quic/QUICPacket.cc b/iocore/net/quic/QUICPacket.cc
index ec8ac37..534ed27 100644
--- a/iocore/net/quic/QUICPacket.cc
+++ b/iocore/net/quic/QUICPacket.cc
@@ -69,6 +69,12 @@
   return this->_from;
 }
 
+const IpEndpoint &
+QUICPacketHeader::to() const
+{
+  return this->_to;
+}
+
 bool
 QUICPacketHeader::is_crypto_packet() const
 {
@@ -82,16 +88,16 @@
 }
 
 QUICPacketHeaderUPtr
-QUICPacketHeader::load(const IpEndpoint from, ats_unique_buf buf, size_t len, QUICPacketNumber base)
+QUICPacketHeader::load(const IpEndpoint from, const IpEndpoint to, ats_unique_buf buf, size_t len, QUICPacketNumber base)
 {
   QUICPacketHeaderUPtr header = QUICPacketHeaderUPtr(nullptr, &QUICPacketHeaderDeleter::delete_null_header);
   if (QUICInvariants::is_long_header(buf.get())) {
     QUICPacketLongHeader *long_header = quicPacketLongHeaderAllocator.alloc();
-    new (long_header) QUICPacketLongHeader(from, std::move(buf), len, base);
+    new (long_header) QUICPacketLongHeader(from, to, std::move(buf), len, base);
     header = QUICPacketHeaderUPtr(long_header, &QUICPacketHeaderDeleter::delete_long_header);
   } else {
     QUICPacketShortHeader *short_header = quicPacketShortHeaderAllocator.alloc();
-    new (short_header) QUICPacketShortHeader(from, std::move(buf), len, base);
+    new (short_header) QUICPacketShortHeader(from, to, std::move(buf), len, base);
     header = QUICPacketHeaderUPtr(short_header, &QUICPacketHeaderDeleter::delete_short_header);
   }
   return header;
@@ -159,8 +165,9 @@
 // QUICPacketLongHeader
 //
 
-QUICPacketLongHeader::QUICPacketLongHeader(const IpEndpoint from, ats_unique_buf buf, size_t len, QUICPacketNumber base)
-  : QUICPacketHeader(from, std::move(buf), len, base)
+QUICPacketLongHeader::QUICPacketLongHeader(const IpEndpoint from, const IpEndpoint to, ats_unique_buf buf, size_t len,
+                                           QUICPacketNumber base)
+  : QUICPacketHeader(from, to, std::move(buf), len, base)
 {
   this->_key_phase = QUICTypeUtil::key_phase(this->type());
   uint8_t *raw_buf = this->_buf.get();
@@ -172,13 +179,15 @@
 
   size_t offset          = LONG_HDR_OFFSET_CONNECTION_ID;
   this->_destination_cid = {raw_buf + offset, dcil};
-  offset += dcil;
+  offset += dcil + 1;
   this->_source_cid = {raw_buf + offset, scil};
   offset += scil;
 
   if (this->type() != QUICPacketType::VERSION_NEGOTIATION) {
     if (this->type() == QUICPacketType::RETRY) {
-      uint8_t odcil        = (raw_buf[0] & 0x0f) + 3;
+      uint8_t odcil = raw_buf[offset];
+      offset += 1;
+
       this->_original_dcid = {raw_buf + offset, odcil};
       offset += odcil;
     } else {
@@ -219,7 +228,7 @@
 {
   if (this->_type == QUICPacketType::VERSION_NEGOTIATION) {
     this->_buf_len =
-      LONG_HDR_OFFSET_CONNECTION_ID + this->_destination_cid.length() + this->_source_cid.length() + this->_payload_length;
+      LONG_HDR_OFFSET_CONNECTION_ID + this->_destination_cid.length() + 1 + this->_source_cid.length() + this->_payload_length;
   } else {
     this->buf();
   }
@@ -289,9 +298,6 @@
 QUICPacketLongHeader::dcil(uint8_t &dcil, const uint8_t *packet, size_t packet_len)
 {
   if (QUICInvariants::dcil(dcil, packet, packet_len)) {
-    if (dcil != 0) {
-      dcil += 3;
-    }
     return true;
   } else {
     return false;
@@ -302,9 +308,6 @@
 QUICPacketLongHeader::scil(uint8_t &scil, const uint8_t *packet, size_t packet_len)
 {
   if (QUICInvariants::scil(scil, packet, packet_len)) {
-    if (scil != 0) {
-      scil += 3;
-    }
     return true;
   } else {
     return false;
@@ -312,16 +315,16 @@
 }
 
 bool
-QUICPacketLongHeader::token_length(size_t &token_length, uint8_t *field_len, const uint8_t *packet, size_t packet_len)
+QUICPacketLongHeader::token_length(size_t &token_length, uint8_t &field_len, size_t &token_length_filed_offset,
+                                   const uint8_t *packet, size_t packet_len)
 {
   QUICPacketType type = QUICPacketType::UNINITIALIZED;
   QUICPacketLongHeader::type(type, packet, packet_len);
 
   if (type != QUICPacketType::INITIAL) {
     token_length = 0;
-    if (field_len) {
-      *field_len = 0;
-    }
+    field_len    = 0;
+
     return true;
   }
 
@@ -329,66 +332,85 @@
   QUICPacketLongHeader::dcil(dcil, packet, packet_len);
   QUICPacketLongHeader::scil(scil, packet, packet_len);
 
-  size_t offset = LONG_HDR_OFFSET_CONNECTION_ID + dcil + scil;
-  if (offset >= packet_len) {
+  token_length_filed_offset = LONG_HDR_OFFSET_CONNECTION_ID + dcil + 1 + scil;
+  if (token_length_filed_offset >= packet_len) {
     return false;
   }
 
-  if (offset > packet_len) {
-    return false;
-  }
-
-  token_length = QUICIntUtil::read_QUICVariableInt(packet + offset);
-  if (field_len) {
-    *field_len = QUICVariableInt::size(packet + offset);
-  }
+  token_length = QUICIntUtil::read_QUICVariableInt(packet + token_length_filed_offset);
+  field_len    = QUICVariableInt::size(packet + token_length_filed_offset);
 
   return true;
 }
 
 bool
-QUICPacketLongHeader::length(size_t &length, uint8_t *field_len, const uint8_t *packet, size_t packet_len)
+QUICPacketLongHeader::length(size_t &length, uint8_t &length_field_len, size_t &length_field_offset, const uint8_t *packet,
+                             size_t packet_len)
 {
-  uint8_t dcil, scil;
-  QUICPacketLongHeader::dcil(dcil, packet, packet_len);
-  QUICPacketLongHeader::scil(scil, packet, packet_len);
+  uint8_t dcil;
+  if (!QUICPacketLongHeader::dcil(dcil, packet, packet_len)) {
+    return false;
+  }
+
+  uint8_t scil;
+  if (!QUICPacketLongHeader::scil(scil, packet, packet_len)) {
+    return false;
+  }
 
   // Token Length (i) + Token (*) (for INITIAL packet)
-  size_t token_length            = 0;
-  uint8_t token_length_field_len = 0;
-  if (!QUICPacketLongHeader::token_length(token_length, &token_length_field_len, packet, packet_len)) {
+  size_t token_length              = 0;
+  uint8_t token_length_field_len   = 0;
+  size_t token_length_field_offset = 0;
+  if (!QUICPacketLongHeader::token_length(token_length, token_length_field_len, token_length_field_offset, packet, packet_len)) {
     return false;
   }
 
   // Length (i)
-  size_t length_offset = LONG_HDR_OFFSET_CONNECTION_ID + dcil + scil + token_length_field_len + token_length;
-  if (length_offset >= packet_len) {
+  length_field_offset = LONG_HDR_OFFSET_CONNECTION_ID + dcil + 1 + scil + token_length_field_len + token_length;
+  if (length_field_offset >= packet_len) {
     return false;
   }
-  length = QUICIntUtil::read_QUICVariableInt(packet + length_offset);
-  if (field_len) {
-    *field_len = QUICVariableInt::size(packet + length_offset);
-  }
+
+  length_field_len = QUICVariableInt::size(packet + length_field_offset);
+  length           = QUICIntUtil::read_QUICVariableInt(packet + length_field_offset);
+
   return true;
 }
 
 bool
-QUICPacketLongHeader::packet_number_offset(uint8_t &pn_offset, const uint8_t *packet, size_t packet_len)
+QUICPacketLongHeader::packet_number_offset(size_t &pn_offset, const uint8_t *packet, size_t packet_len)
 {
-  QUICPacketType type;
-  QUICPacketLongHeader::type(type, packet, packet_len);
-
-  uint8_t dcil, scil;
-  size_t token_length;
-  uint8_t token_length_field_len;
   size_t length;
   uint8_t length_field_len;
-  if (!QUICPacketLongHeader::dcil(dcil, packet, packet_len) || !QUICPacketLongHeader::scil(scil, packet, packet_len) ||
-      !QUICPacketLongHeader::token_length(token_length, &token_length_field_len, packet, packet_len) ||
-      !QUICPacketLongHeader::length(length, &length_field_len, packet, packet_len)) {
+  size_t length_field_offset;
+
+  if (!QUICPacketLongHeader::length(length, length_field_len, length_field_offset, packet, packet_len)) {
     return false;
   }
-  pn_offset = 6 + dcil + scil + token_length_field_len + token_length + length_field_len;
+  pn_offset = length_field_offset + length_field_len;
+
+  if (pn_offset >= packet_len) {
+    return false;
+  }
+
+  return true;
+}
+
+bool
+QUICPacketLongHeader::packet_length(size_t &packet_len, const uint8_t *buf, size_t buf_len)
+{
+  size_t length;
+  uint8_t length_field_len;
+  size_t length_field_offset;
+
+  if (!QUICPacketLongHeader::length(length, length_field_len, length_field_offset, buf, buf_len)) {
+    return false;
+  }
+  packet_len = length + length_field_offset + length_field_len;
+
+  if (packet_len > buf_len) {
+    return false;
+  }
 
   return true;
 }
@@ -521,28 +543,49 @@
   QUICTypeUtil::write_QUICVersion(this->_version, buf + *len, &n);
   *len += n;
 
-  buf[*len] = this->_destination_cid == QUICConnectionId::ZERO() ? 0 : (this->_destination_cid.length() - 3) << 4;
-  buf[*len] += this->_source_cid == QUICConnectionId::ZERO() ? 0 : this->_source_cid.length() - 3;
-  *len += 1;
-
+  // DICD
   if (this->_destination_cid != QUICConnectionId::ZERO()) {
+    // Len
+    buf[*len] = this->_destination_cid.length();
+    *len += 1;
+
+    // ID
     QUICTypeUtil::write_QUICConnectionId(this->_destination_cid, buf + *len, &n);
     *len += n;
+  } else {
+    buf[*len] = 0;
+    *len += 1;
   }
+
+  // SCID
   if (this->_source_cid != QUICConnectionId::ZERO()) {
+    // Len
+    buf[*len] = this->_source_cid.length();
+    *len += 1;
+
+    // ID
     QUICTypeUtil::write_QUICConnectionId(this->_source_cid, buf + *len, &n);
     *len += n;
+  } else {
+    buf[*len] = 0;
+    *len += 1;
   }
 
   if (this->_type != QUICPacketType::VERSION_NEGOTIATION) {
     if (this->_type == QUICPacketType::RETRY) {
       // Original Destination Connection ID
       if (this->_original_dcid != QUICConnectionId::ZERO()) {
+        // Len
+        buf[*len] = this->_original_dcid.length();
+        *len += 1;
+
+        // ID
         QUICTypeUtil::write_QUICConnectionId(this->_original_dcid, buf + *len, &n);
         *len += n;
+      } else {
+        buf[*len] = 0;
+        *len += 1;
       }
-      // ODCIL
-      buf[0] |= this->_original_dcid.length() - 3;
     } else {
       if (this->_type == QUICPacketType::INITIAL) {
         // Token Length Field
@@ -590,8 +633,9 @@
 // QUICPacketShortHeader
 //
 
-QUICPacketShortHeader::QUICPacketShortHeader(const IpEndpoint from, ats_unique_buf buf, size_t len, QUICPacketNumber base)
-  : QUICPacketHeader(from, std::move(buf), len, base)
+QUICPacketShortHeader::QUICPacketShortHeader(const IpEndpoint from, const IpEndpoint to, ats_unique_buf buf, size_t len,
+                                             QUICPacketNumber base)
+  : QUICPacketHeader(from, to, std::move(buf), len, base)
 {
   QUICInvariants::dcid(this->_connection_id, this->_buf.get(), len);
 
@@ -718,7 +762,7 @@
 }
 
 bool
-QUICPacketShortHeader::packet_number_offset(uint8_t &pn_offset, const uint8_t *packet, size_t packet_len, int dcil)
+QUICPacketShortHeader::packet_number_offset(size_t &pn_offset, const uint8_t *packet, size_t packet_len, int dcil)
 {
   pn_offset = 1 + dcil;
   return true;
@@ -795,6 +839,12 @@
   return this->_header->from();
 }
 
+const IpEndpoint &
+QUICPacket::to() const
+{
+  return this->_header->to();
+}
+
 UDPConnection *
 QUICPacket::udp_con() const
 {
diff --git a/iocore/net/quic/QUICPacket.h b/iocore/net/quic/QUICPacket.h
index dd9c9bc..5fc834f 100644
--- a/iocore/net/quic/QUICPacket.h
+++ b/iocore/net/quic/QUICPacket.h
@@ -55,8 +55,8 @@
 class QUICPacketHeader
 {
 public:
-  QUICPacketHeader(const IpEndpoint from, ats_unique_buf buf, size_t len, QUICPacketNumber base)
-    : _from(from), _buf(std::move(buf)), _buf_len(len), _base_packet_number(base)
+  QUICPacketHeader(const IpEndpoint from, const IpEndpoint to, ats_unique_buf buf, size_t len, QUICPacketNumber base)
+    : _from(from), _to(to), _buf(std::move(buf)), _buf_len(len), _base_packet_number(base)
   {
   }
   ~QUICPacketHeader() {}
@@ -65,6 +65,7 @@
   virtual bool is_crypto_packet() const;
 
   const IpEndpoint &from() const;
+  const IpEndpoint &to() const;
 
   virtual QUICPacketType type() const = 0;
 
@@ -121,7 +122,8 @@
    *
    * This creates either a QUICPacketShortHeader or a QUICPacketLongHeader.
    */
-  static QUICPacketHeaderUPtr load(const IpEndpoint from, ats_unique_buf buf, size_t len, QUICPacketNumber base);
+  static QUICPacketHeaderUPtr load(const IpEndpoint from, const IpEndpoint to, ats_unique_buf buf, size_t len,
+                                   QUICPacketNumber base);
 
   /*
    * Build a QUICPacketHeader
@@ -185,6 +187,7 @@
   static constexpr size_t MAX_PACKET_HEADER_LEN = 256;
 
   const IpEndpoint _from = {};
+  const IpEndpoint _to   = {};
 
   // These two are used only if the instance was created with a buffer
   ats_unique_buf _buf = {nullptr};
@@ -208,7 +211,7 @@
 public:
   QUICPacketLongHeader() : QUICPacketHeader(){};
   virtual ~QUICPacketLongHeader(){};
-  QUICPacketLongHeader(const IpEndpoint from, ats_unique_buf buf, size_t len, QUICPacketNumber base);
+  QUICPacketLongHeader(const IpEndpoint from, const IpEndpoint to, ats_unique_buf buf, size_t len, QUICPacketNumber base);
   QUICPacketLongHeader(QUICPacketType type, QUICKeyPhase key_phase, const QUICConnectionId &destination_cid,
                        const QUICConnectionId &source_cid, QUICPacketNumber packet_number, QUICPacketNumber base_packet_number,
                        QUICVersion version, bool crypto, ats_unique_buf buf, size_t len,
@@ -235,18 +238,15 @@
 
   static bool type(QUICPacketType &type, const uint8_t *packet, size_t packet_len);
   static bool version(QUICVersion &version, const uint8_t *packet, size_t packet_len);
-  /**
-   * Unlike QUICInvariants::dcil(), this returns actual connection id length
-   */
   static bool dcil(uint8_t &dcil, const uint8_t *packet, size_t packet_len);
-  /**
-   * Unlike QUICInvariants::scil(), this returns actual connection id length
-   */
   static bool scil(uint8_t &scil, const uint8_t *packet, size_t packet_len);
-  static bool token_length(size_t &token_length, uint8_t *field_len, const uint8_t *packet, size_t packet_len);
-  static bool length(size_t &length, uint8_t *field_len, const uint8_t *packet, size_t packet_len);
+  static bool token_length(size_t &token_length, uint8_t &field_len, size_t &token_length_filed_offset, const uint8_t *packet,
+                           size_t packet_len);
+  static bool length(size_t &length, uint8_t &length_field_len, size_t &length_field_offset, const uint8_t *packet,
+                     size_t packet_len);
   static bool key_phase(QUICKeyPhase &key_phase, const uint8_t *packet, size_t packet_len);
-  static bool packet_number_offset(uint8_t &pn_offset, const uint8_t *packet, size_t packet_len);
+  static bool packet_number_offset(size_t &pn_offset, const uint8_t *packet, size_t packet_len);
+  static bool packet_length(size_t &length, const uint8_t *buf, size_t buf_len);
 
 private:
   QUICConnectionId _destination_cid = QUICConnectionId::ZERO();
@@ -264,7 +264,7 @@
 public:
   QUICPacketShortHeader() : QUICPacketHeader(){};
   virtual ~QUICPacketShortHeader(){};
-  QUICPacketShortHeader(const IpEndpoint from, ats_unique_buf buf, size_t len, QUICPacketNumber base);
+  QUICPacketShortHeader(const IpEndpoint from, const IpEndpoint to, ats_unique_buf buf, size_t len, QUICPacketNumber base);
   QUICPacketShortHeader(QUICPacketType type, QUICKeyPhase key_phase, QUICPacketNumber packet_number,
                         QUICPacketNumber base_packet_number, ats_unique_buf buf, size_t len);
   QUICPacketShortHeader(QUICPacketType type, QUICKeyPhase key_phase, const QUICConnectionId &connection_id,
@@ -286,7 +286,7 @@
   void store(uint8_t *buf, size_t *len) const override;
 
   static bool key_phase(QUICKeyPhase &key_phase, const uint8_t *packet, size_t packet_len);
-  static bool packet_number_offset(uint8_t &pn_offset, const uint8_t *packet, size_t packet_len, int dcil);
+  static bool packet_number_offset(size_t &pn_offset, const uint8_t *packet, size_t packet_len, int dcil);
 
 private:
   int _packet_number_len;
@@ -347,10 +347,11 @@
   QUICPacket(QUICPacketHeaderUPtr header, ats_unique_buf payload, size_t payload_len, bool ack_eliciting, bool probing,
              std::vector<QUICFrameInfo> &frames);
 
-  ~QUICPacket();
+  virtual ~QUICPacket();
 
   UDPConnection *udp_con() const;
-  const IpEndpoint &from() const;
+  virtual const IpEndpoint &from() const;
+  virtual const IpEndpoint &to() const;
   QUICPacketType type() const;
   QUICConnectionId destination_cid() const;
   QUICConnectionId source_cid() const;
diff --git a/iocore/net/quic/QUICPacketFactory.cc b/iocore/net/quic/QUICPacketFactory.cc
index 4c88c1b..ea82f44 100644
--- a/iocore/net/quic/QUICPacketFactory.cc
+++ b/iocore/net/quic/QUICPacketFactory.cc
@@ -62,14 +62,14 @@
 }
 
 QUICPacketUPtr
-QUICPacketFactory::create(UDPConnection *udp_con, IpEndpoint from, ats_unique_buf buf, size_t len,
+QUICPacketFactory::create(UDPConnection *udp_con, IpEndpoint from, IpEndpoint to, ats_unique_buf buf, size_t len,
                           QUICPacketNumber base_packet_number, QUICPacketCreationResult &result)
 {
   size_t max_plain_txt_len = 2048;
   ats_unique_buf plain_txt = ats_unique_malloc(max_plain_txt_len);
   size_t plain_txt_len     = 0;
 
-  QUICPacketHeaderUPtr header = QUICPacketHeader::load(from, std::move(buf), len, base_packet_number);
+  QUICPacketHeaderUPtr header = QUICPacketHeader::load(from, to, std::move(buf), len, base_packet_number);
 
   QUICConnectionId dcid = header->destination_cid();
   QUICConnectionId scid = header->source_cid();
@@ -238,7 +238,7 @@
                                            QUICPacketNumber base_packet_number, ats_unique_buf payload, size_t len,
                                            bool retransmittable, bool probing, bool crypto)
 {
-  QUICPacketNumberSpace index = QUICTypeUtil::pn_space(QUICEncryptionLevel::INITIAL);
+  QUICPacketNumberSpace index = QUICTypeUtil::pn_space(QUICEncryptionLevel::HANDSHAKE);
   QUICPacketNumber pn         = this->_packet_number_generator[static_cast<int>(index)].next();
   QUICPacketHeaderUPtr header =
     QUICPacketHeader::build(QUICPacketType::HANDSHAKE, QUICKeyPhase::HANDSHAKE, destination_cid, source_cid, pn, base_packet_number,
@@ -251,7 +251,7 @@
                                           QUICPacketNumber base_packet_number, ats_unique_buf payload, size_t len,
                                           bool retransmittable, bool probing)
 {
-  QUICPacketNumberSpace index = QUICTypeUtil::pn_space(QUICEncryptionLevel::INITIAL);
+  QUICPacketNumberSpace index = QUICTypeUtil::pn_space(QUICEncryptionLevel::ZERO_RTT);
   QUICPacketNumber pn         = this->_packet_number_generator[static_cast<int>(index)].next();
   QUICPacketHeaderUPtr header =
     QUICPacketHeader::build(QUICPacketType::ZERO_RTT_PROTECTED, QUICKeyPhase::ZERO_RTT, destination_cid, source_cid, pn,
@@ -263,7 +263,7 @@
 QUICPacketFactory::create_protected_packet(QUICConnectionId connection_id, QUICPacketNumber base_packet_number,
                                            ats_unique_buf payload, size_t len, bool retransmittable, bool probing)
 {
-  QUICPacketNumberSpace index = QUICTypeUtil::pn_space(QUICEncryptionLevel::INITIAL);
+  QUICPacketNumberSpace index = QUICTypeUtil::pn_space(QUICEncryptionLevel::ONE_RTT);
   QUICPacketNumber pn         = this->_packet_number_generator[static_cast<int>(index)].next();
   // TODO Key phase should be picked up from QUICHandshakeProtocol, probably
   QUICPacketHeaderUPtr header = QUICPacketHeader::build(QUICPacketType::PROTECTED, QUICKeyPhase::PHASE_0, connection_id, pn,
@@ -274,19 +274,20 @@
 QUICPacketUPtr
 QUICPacketFactory::create_stateless_reset_packet(QUICConnectionId connection_id, QUICStatelessResetToken stateless_reset_token)
 {
+  constexpr uint8_t MIN_UNPREDICTABLE_FIELD_LEN = 5;
   std::random_device rnd;
 
   uint8_t random_packet_number = static_cast<uint8_t>(rnd() & 0xFF);
-  size_t payload_len           = static_cast<uint8_t>((rnd() & 0xFF) | 16); // Mimimum length has to be 16
-  ats_unique_buf payload       = ats_unique_malloc(payload_len + 16);
-  uint8_t *naked_payload       = payload.get();
+  size_t payload_len     = static_cast<uint8_t>((rnd() & 0xFF) | (MIN_UNPREDICTABLE_FIELD_LEN + QUICStatelessResetToken::LEN));
+  ats_unique_buf payload = ats_unique_malloc(payload_len);
+  uint8_t *naked_payload = payload.get();
 
   // Generate random octets
   for (int i = payload_len - 1; i >= 0; --i) {
     naked_payload[i] = static_cast<uint8_t>(rnd() & 0xFF);
   }
   // Copy stateless reset token into payload
-  memcpy(naked_payload + payload_len - 16, stateless_reset_token.buf(), 16);
+  memcpy(naked_payload + payload_len - QUICStatelessResetToken::LEN, stateless_reset_token.buf(), QUICStatelessResetToken::LEN);
 
   // KeyPhase won't be used
   QUICPacketHeaderUPtr header = QUICPacketHeader::build(QUICPacketType::STATELESS_RESET, QUICKeyPhase::INITIAL, connection_id,
diff --git a/iocore/net/quic/QUICPacketFactory.h b/iocore/net/quic/QUICPacketFactory.h
index a00639d..732ad35 100644
--- a/iocore/net/quic/QUICPacketFactory.h
+++ b/iocore/net/quic/QUICPacketFactory.h
@@ -52,7 +52,7 @@
 
   QUICPacketFactory(const QUICPacketProtectionKeyInfo &pp_key_info) : _pp_key_info(pp_key_info), _pp_protector(pp_key_info) {}
 
-  QUICPacketUPtr create(UDPConnection *udp_con, IpEndpoint from, ats_unique_buf buf, size_t len,
+  QUICPacketUPtr create(UDPConnection *udp_con, IpEndpoint from, IpEndpoint to, ats_unique_buf buf, size_t len,
                         QUICPacketNumber base_packet_number, QUICPacketCreationResult &result);
   QUICPacketUPtr create_initial_packet(QUICConnectionId destination_cid, QUICConnectionId source_cid,
                                        QUICPacketNumber base_packet_number, ats_unique_buf payload, size_t len, bool ack_eliciting,
diff --git a/iocore/net/quic/QUICPacketHeaderProtector.cc b/iocore/net/quic/QUICPacketHeaderProtector.cc
index 49a29ad..0dbfe8d 100644
--- a/iocore/net/quic/QUICPacketHeaderProtector.cc
+++ b/iocore/net/quic/QUICPacketHeaderProtector.cc
@@ -152,25 +152,16 @@
                                                int dcil) const
 {
   if (QUICInvariants::is_long_header(protected_packet)) {
-    uint8_t dcil;
-    uint8_t scil;
     size_t dummy;
     uint8_t length_len;
-    QUICPacketLongHeader::dcil(dcil, protected_packet, protected_packet_len);
-    QUICPacketLongHeader::scil(scil, protected_packet, protected_packet_len);
-    QUICPacketLongHeader::length(dummy, &length_len, protected_packet, protected_packet_len);
-    *sample_offset = 6 + dcil + scil + length_len + 4;
-
-    QUICPacketType type;
-    QUICPacketLongHeader::type(type, protected_packet, protected_packet_len);
-    if (type == QUICPacketType::INITIAL) {
-      size_t token_len;
-      uint8_t token_length_len;
-      QUICPacketLongHeader::token_length(token_len, &token_length_len, protected_packet, protected_packet_len);
-      *sample_offset += token_len + token_length_len;
+    size_t length_offset;
+    if (!QUICPacketLongHeader::length(dummy, length_len, length_offset, protected_packet, protected_packet_len)) {
+      return false;
     }
+
+    *sample_offset = length_offset + length_len + 4;
   } else {
-    *sample_offset = 1 + dcil + 4;
+    *sample_offset = QUICInvariants::SH_DCID_OFFSET + dcil + 4;
   }
 
   return static_cast<size_t>(*sample_offset + 16) <= protected_packet_len;
@@ -179,7 +170,7 @@
 bool
 QUICPacketHeaderProtector::_unprotect(uint8_t *protected_packet, size_t protected_packet_len, const uint8_t *mask) const
 {
-  uint8_t pn_offset;
+  size_t pn_offset;
 
   // Unprotect packet number
   if (QUICInvariants::is_long_header(protected_packet)) {
@@ -201,7 +192,7 @@
 bool
 QUICPacketHeaderProtector::_protect(uint8_t *protected_packet, size_t protected_packet_len, const uint8_t *mask, int dcil) const
 {
-  uint8_t pn_offset;
+  size_t pn_offset;
 
   uint8_t pn_length = QUICTypeUtil::read_QUICPacketNumberLen(protected_packet);
 
diff --git a/iocore/net/quic/QUICPacketProtectionKeyInfo.h b/iocore/net/quic/QUICPacketProtectionKeyInfo.h
index 32a38d4..71d077d 100644
--- a/iocore/net/quic/QUICPacketProtectionKeyInfo.h
+++ b/iocore/net/quic/QUICPacketProtectionKeyInfo.h
@@ -26,11 +26,43 @@
 #include "QUICTypes.h"
 #include "QUICKeyGenerator.h"
 
-class QUICPacketProtectionKeyInfo
+class QUICPacketProtectionKeyInfoProvider
+{
+public:
+  virtual ~QUICPacketProtectionKeyInfoProvider() {}
+  // Payload Protection (common)
+  virtual const EVP_CIPHER *get_cipher(QUICKeyPhase phase) const = 0;
+  virtual size_t get_tag_len(QUICKeyPhase phase) const           = 0;
+
+  // Payload Protection (encryption)
+  virtual bool is_encryption_key_available(QUICKeyPhase phase) const = 0;
+  virtual const uint8_t *encryption_key(QUICKeyPhase phase) const    = 0;
+  virtual size_t encryption_key_len(QUICKeyPhase phase) const        = 0;
+  virtual const uint8_t *encryption_iv(QUICKeyPhase phase) const     = 0;
+  virtual const size_t *encryption_iv_len(QUICKeyPhase phase) const  = 0;
+
+  // Payload Protection (decryption)
+  virtual bool is_decryption_key_available(QUICKeyPhase phase) const = 0;
+  virtual const uint8_t *decryption_key(QUICKeyPhase phase) const    = 0;
+  virtual size_t decryption_key_len(QUICKeyPhase phase) const        = 0;
+  virtual const uint8_t *decryption_iv(QUICKeyPhase phase) const     = 0;
+  virtual const size_t *decryption_iv_len(QUICKeyPhase phase) const  = 0;
+
+  // Header Protection
+  virtual const EVP_CIPHER *get_cipher_for_hp(QUICKeyPhase phase) const  = 0;
+  virtual const uint8_t *encryption_key_for_hp(QUICKeyPhase phase) const = 0;
+  virtual size_t encryption_key_for_hp_len(QUICKeyPhase phase) const     = 0;
+  virtual const uint8_t *decryption_key_for_hp(QUICKeyPhase phase) const = 0;
+  virtual size_t decryption_key_for_hp_len(QUICKeyPhase phase) const     = 0;
+};
+
+class QUICPacketProtectionKeyInfo : public QUICPacketProtectionKeyInfoProvider
 {
 public:
   enum class Context { SERVER, CLIENT };
 
+  virtual ~QUICPacketProtectionKeyInfo() {}
+
   // FIXME This should be passed to the constructor but NetVC cannot pass it because it has set_context too.
   void set_context(Context ctx);
 
@@ -38,58 +70,58 @@
 
   // Payload Protection (common)
 
-  virtual const EVP_CIPHER *get_cipher(QUICKeyPhase phase) const;
-  virtual size_t get_tag_len(QUICKeyPhase phase) const;
+  virtual const EVP_CIPHER *get_cipher(QUICKeyPhase phase) const override;
+  virtual size_t get_tag_len(QUICKeyPhase phase) const override;
   virtual void set_cipher_initial(const EVP_CIPHER *cipher);
   virtual void set_cipher(const EVP_CIPHER *cipher, size_t tag_len);
 
   // Payload Protection (encryption)
 
-  virtual bool is_encryption_key_available(QUICKeyPhase phase) const;
+  virtual bool is_encryption_key_available(QUICKeyPhase phase) const override;
   virtual void set_encryption_key_available(QUICKeyPhase phase);
 
-  virtual const uint8_t *encryption_key(QUICKeyPhase phase) const;
+  virtual const uint8_t *encryption_key(QUICKeyPhase phase) const override;
   virtual uint8_t *encryption_key(QUICKeyPhase phase);
 
-  virtual size_t encryption_key_len(QUICKeyPhase phase) const;
+  virtual size_t encryption_key_len(QUICKeyPhase phase) const override;
 
-  virtual const uint8_t *encryption_iv(QUICKeyPhase phase) const;
+  virtual const uint8_t *encryption_iv(QUICKeyPhase phase) const override;
   virtual uint8_t *encryption_iv(QUICKeyPhase phase);
 
-  virtual const size_t *encryption_iv_len(QUICKeyPhase phase) const;
+  virtual const size_t *encryption_iv_len(QUICKeyPhase phase) const override;
   virtual size_t *encryption_iv_len(QUICKeyPhase phase);
 
   // Payload Protection (decryption)
 
-  virtual bool is_decryption_key_available(QUICKeyPhase phase) const;
+  virtual bool is_decryption_key_available(QUICKeyPhase phase) const override;
   virtual void set_decryption_key_available(QUICKeyPhase phase);
 
-  virtual const uint8_t *decryption_key(QUICKeyPhase phase) const;
+  virtual const uint8_t *decryption_key(QUICKeyPhase phase) const override;
   virtual uint8_t *decryption_key(QUICKeyPhase phase);
 
-  virtual size_t decryption_key_len(QUICKeyPhase phase) const;
+  virtual size_t decryption_key_len(QUICKeyPhase phase) const override;
 
-  virtual const uint8_t *decryption_iv(QUICKeyPhase phase) const;
+  virtual const uint8_t *decryption_iv(QUICKeyPhase phase) const override;
   virtual uint8_t *decryption_iv(QUICKeyPhase phase);
 
-  virtual const size_t *decryption_iv_len(QUICKeyPhase phase) const;
+  virtual const size_t *decryption_iv_len(QUICKeyPhase phase) const override;
   virtual size_t *decryption_iv_len(QUICKeyPhase phase);
 
   // Header Protection
 
-  virtual const EVP_CIPHER *get_cipher_for_hp(QUICKeyPhase phase) const;
+  virtual const EVP_CIPHER *get_cipher_for_hp(QUICKeyPhase phase) const override;
   virtual void set_cipher_for_hp_initial(const EVP_CIPHER *cipher);
   virtual void set_cipher_for_hp(const EVP_CIPHER *cipher);
 
-  virtual const uint8_t *encryption_key_for_hp(QUICKeyPhase phase) const;
+  virtual const uint8_t *encryption_key_for_hp(QUICKeyPhase phase) const override;
   virtual uint8_t *encryption_key_for_hp(QUICKeyPhase phase);
 
-  virtual size_t encryption_key_for_hp_len(QUICKeyPhase phase) const;
+  virtual size_t encryption_key_for_hp_len(QUICKeyPhase phase) const override;
 
-  virtual const uint8_t *decryption_key_for_hp(QUICKeyPhase phase) const;
+  virtual const uint8_t *decryption_key_for_hp(QUICKeyPhase phase) const override;
   virtual uint8_t *decryption_key_for_hp(QUICKeyPhase phase);
 
-  virtual size_t decryption_key_for_hp_len(QUICKeyPhase phase) const;
+  virtual size_t decryption_key_for_hp_len(QUICKeyPhase phase) const override;
 
 private:
   Context _ctx = Context::SERVER;
diff --git a/iocore/net/quic/QUICPacketReceiveQueue.cc b/iocore/net/quic/QUICPacketReceiveQueue.cc
index 405c295..c90385b 100644
--- a/iocore/net/quic/QUICPacketReceiveQueue.cc
+++ b/iocore/net/quic/QUICPacketReceiveQueue.cc
@@ -26,42 +26,12 @@
 
 #include "QUICIntUtil.h"
 
-// FIXME: workaround for coalescing packets
-static constexpr int LONG_HDR_OFFSET_CONNECTION_ID = 6;
-
 static bool
 is_vn(QUICVersion v)
 {
   return v == 0x0;
 }
 
-static bool
-long_hdr_pkt_len(size_t &pkt_len, uint8_t *buf, size_t len)
-{
-  uint8_t dcil, scil;
-  QUICPacketLongHeader::dcil(dcil, buf, len);
-  QUICPacketLongHeader::scil(scil, buf, len);
-
-  size_t offset = LONG_HDR_OFFSET_CONNECTION_ID + dcil + scil;
-
-  // token_length and token_length_field_len should be 0 except INITIAL packet
-  size_t token_length            = 0;
-  uint8_t token_length_field_len = 0;
-  if (!QUICPacketLongHeader::token_length(token_length, &token_length_field_len, buf, len)) {
-    return false;
-  }
-
-  size_t length            = 0;
-  uint8_t length_field_len = 0;
-  if (!QUICPacketLongHeader::length(length, &length_field_len, buf, len)) {
-    return false;
-  }
-
-  pkt_len = offset + token_length + token_length_field_len + length_field_len + length;
-
-  return true;
-}
-
 QUICPacketReceiveQueue::QUICPacketReceiveQueue(QUICPacketFactory &packet_factory, QUICPacketHeaderProtector &ph_protector)
   : _packet_factory(packet_factory), _ph_protector(ph_protector)
 {
@@ -91,6 +61,7 @@
     // Create a QUIC packet
     this->_udp_con     = udp_packet->getConnection();
     this->_from        = udp_packet->from;
+    this->_to          = udp_packet->to;
     this->_payload_len = udp_packet->getPktLength();
     this->_payload     = ats_unique_malloc(this->_payload_len);
     IOBufferBlock *b   = udp_packet->getIOBlockChain();
@@ -124,7 +95,7 @@
         if (type == QUICPacketType::RETRY) {
           pkt_len = remaining_len;
         } else {
-          if (!long_hdr_pkt_len(pkt_len, this->_payload.get() + this->_offset, remaining_len)) {
+          if (!QUICPacketLongHeader::packet_length(pkt_len, this->_payload.get() + this->_offset, remaining_len)) {
             this->_payload.release();
             this->_payload     = nullptr;
             this->_payload_len = 0;
@@ -177,7 +148,7 @@
   }
 
   if (this->_ph_protector.unprotect(pkt.get(), pkt_len)) {
-    quic_packet = this->_packet_factory.create(this->_udp_con, this->_from, std::move(pkt), pkt_len,
+    quic_packet = this->_packet_factory.create(this->_udp_con, this->_from, this->_to, std::move(pkt), pkt_len,
                                                this->_largest_received_packet_number, result);
   } else {
     // ZERO_RTT might be rejected
diff --git a/iocore/net/quic/QUICPacketReceiveQueue.h b/iocore/net/quic/QUICPacketReceiveQueue.h
index 5027df3..e4e3e29 100644
--- a/iocore/net/quic/QUICPacketReceiveQueue.h
+++ b/iocore/net/quic/QUICPacketReceiveQueue.h
@@ -51,4 +51,5 @@
   size_t _offset          = 0;
   UDPConnection *_udp_con;
   IpEndpoint _from;
+  IpEndpoint _to;
 };
diff --git a/iocore/net/quic/QUICPadder.cc b/iocore/net/quic/QUICPadder.cc
new file mode 100644
index 0000000..0ae913e
--- /dev/null
+++ b/iocore/net/quic/QUICPadder.cc
@@ -0,0 +1,109 @@
+/** @file
+
+  A brief file description
+
+  @section license License
+
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you 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
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+#include "QUICIntUtil.h"
+#include "QUICPadder.h"
+
+static constexpr uint32_t MINIMUM_INITIAL_PACKET_SIZE = 1200;
+static constexpr uint32_t MIN_PKT_PAYLOAD_LEN         = 3; ///< Minimum payload length for sampling for header protection
+
+void
+QUICPadder::request(QUICEncryptionLevel level)
+{
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  ++this->_need_to_fire[static_cast<int>(level)];
+}
+
+void
+QUICPadder::cancel(QUICEncryptionLevel level)
+{
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  this->_need_to_fire[static_cast<int>(level)] = 0;
+}
+
+uint64_t
+QUICPadder::count(QUICEncryptionLevel level)
+{
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  return this->_need_to_fire[static_cast<int>(level)];
+}
+
+bool
+QUICPadder::_will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting)
+{
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  // no extre padding packet
+  if (current_packet_size == 0 && this->_need_to_fire[static_cast<int>(level)] == 0) {
+    return false;
+  }
+
+  // every packets need to be padded
+  return true;
+}
+
+QUICFrame *
+QUICPadder::_generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
+                            size_t current_packet_size)
+{
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  QUICFrame *frame = nullptr;
+
+  uint64_t min_size = 0;
+  if (level == QUICEncryptionLevel::INITIAL && this->_context == NET_VCONNECTION_OUT) {
+    min_size = this->_minimum_quic_packet_size();
+    if (this->_av_token_len && min_size > (QUICVariableInt::size(this->_av_token_len) + this->_av_token_len)) {
+      min_size -= (QUICVariableInt::size(this->_av_token_len) + this->_av_token_len);
+    }
+  } else {
+    min_size = MIN_PKT_PAYLOAD_LEN;
+  }
+
+  if (min_size > current_packet_size) { // ignore if we don't need to pad.
+    frame = QUICFrameFactory::create_padding_frame(
+      buf, std::min(min_size - current_packet_size, static_cast<uint64_t>(maximum_frame_size)));
+  }
+
+  this->_need_to_fire[static_cast<int>(level)] = 0;
+  return frame;
+}
+
+uint32_t
+QUICPadder::_minimum_quic_packet_size()
+{
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  if (this->_context == NET_VCONNECTION_OUT) {
+    // FIXME Only the first packet need to be 1200 bytes at least
+    return MINIMUM_INITIAL_PACKET_SIZE;
+  } else {
+    // FIXME This size should be configurable and should have some randomness
+    // This is just for providing protection against packet analysis for protected packets
+    return 32 + (this->_rnd() & 0x3f); // 32 to 96
+  }
+}
+
+void
+QUICPadder::set_av_token_len(uint32_t len)
+{
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  this->_av_token_len = len;
+}
diff --git a/iocore/net/quic/QUICPadder.h b/iocore/net/quic/QUICPadder.h
new file mode 100644
index 0000000..bba8dfc
--- /dev/null
+++ b/iocore/net/quic/QUICPadder.h
@@ -0,0 +1,57 @@
+/** @file
+ *
+ *  A brief file description
+ *
+ *  @section license License
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include "QUICTypes.h"
+#include "QUICFrameHandler.h"
+#include "QUICFrameGenerator.h"
+
+#include "I_Lock.h"
+
+class QUICPadder : public QUICFrameOnceGenerator
+{
+public:
+  QUICPadder(NetVConnectionContext_t context) : _mutex(new_ProxyMutex()), _context(context) {}
+
+  void request(QUICEncryptionLevel level);
+  void cancel(QUICEncryptionLevel level);
+  uint64_t count(QUICEncryptionLevel level);
+  void set_av_token_len(uint32_t len);
+
+private:
+  uint32_t _minimum_quic_packet_size();
+
+  // QUICFrameGenerator
+  bool _will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting) override;
+  QUICFrame *_generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
+                             size_t current_packet_size) override;
+
+  Ptr<ProxyMutex> _mutex;
+  std::random_device _rnd;
+
+  uint32_t _av_token_len = 0;
+  // Initial, 0/1-RTT, and Handshake
+  uint64_t _need_to_fire[4]        = {0};
+  NetVConnectionContext_t _context = NET_VCONNECTION_OUT;
+};
diff --git a/iocore/net/quic/QUICPathManager.cc b/iocore/net/quic/QUICPathManager.cc
new file mode 100644
index 0000000..613efec
--- /dev/null
+++ b/iocore/net/quic/QUICPathManager.cc
@@ -0,0 +1,84 @@
+/** @file
+ *
+ *  A brief file description
+ *
+ *  @section license License
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "QUICPathManager.h"
+#include "QUICPathValidator.h"
+#include "QUICConnection.h"
+
+#define QUICDebug(fmt, ...) Debug("quic_path", "[%s] " fmt, this->_cinfo.cids().data(), ##__VA_ARGS__)
+
+void
+QUICPathManager::open_new_path(const QUICPath &path, ink_hrtime timeout_in)
+{
+  if (this->_verify_timeout_at == 0) {
+    // Overwrite _previous_path only if _current_path is verified
+    // _previous_path should always have a verified path if available
+    this->_previous_path = this->_current_path;
+  }
+  this->_current_path = path;
+  this->_path_validator.validate(path);
+  this->_verify_timeout_at = Thread::get_hrtime() + timeout_in;
+}
+
+void
+QUICPathManager::set_trusted_path(const QUICPath &path)
+{
+  this->_current_path  = path;
+  this->_previous_path = path;
+}
+
+void
+QUICPathManager::_check_verify_timeout()
+{
+  if (this->_verify_timeout_at != 0) {
+    if (this->_path_validator.is_validated(this->_current_path)) {
+      // Address validation succeeded
+      this->_verify_timeout_at = 0;
+      this->_previous_path     = {{}, {}};
+    } else if (this->_verify_timeout_at < Thread::get_hrtime()) {
+      // Address validation failed
+      QUICDebug("Switching back to the previous path");
+      this->_current_path      = this->_previous_path;
+      this->_verify_timeout_at = 0;
+      this->_previous_path     = {{}, {}};
+    }
+  }
+}
+
+const QUICPath &
+QUICPathManager::get_current_path()
+{
+  this->_check_verify_timeout();
+  return this->_current_path;
+}
+
+const QUICPath &
+QUICPathManager::get_verified_path()
+{
+  this->_check_verify_timeout();
+  if (this->_verify_timeout_at != 0) {
+    return this->_previous_path;
+  } else {
+    return this->_current_path;
+  }
+}
diff --git a/iocore/net/quic/QUICPathManager.h b/iocore/net/quic/QUICPathManager.h
new file mode 100644
index 0000000..9f9eb37
--- /dev/null
+++ b/iocore/net/quic/QUICPathManager.h
@@ -0,0 +1,53 @@
+/** @file
+ *
+ *  A brief file description
+ *
+ *  @section license License
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include "QUICTypes.h"
+
+class QUICConnectionInfoProvider;
+class QUICPathValidator;
+
+class QUICPathManager
+{
+public:
+  QUICPathManager(const QUICConnectionInfoProvider &info, QUICPathValidator &path_validator)
+    : _cinfo(info), _path_validator(path_validator)
+  {
+  }
+
+  const QUICPath &get_current_path();
+  const QUICPath &get_verified_path();
+  void open_new_path(const QUICPath &path, ink_hrtime timeout_in);
+  void set_trusted_path(const QUICPath &path);
+
+private:
+  const QUICConnectionInfoProvider &_cinfo;
+  QUICPathValidator &_path_validator;
+
+  ink_hrtime _verify_timeout_at = 0;
+  QUICPath _current_path        = {{}, {}};
+  QUICPath _previous_path       = {{}, {}};
+
+  void _check_verify_timeout();
+};
diff --git a/iocore/net/quic/QUICPathValidator.cc b/iocore/net/quic/QUICPathValidator.cc
index 40a2390..21a97c9 100644
--- a/iocore/net/quic/QUICPathValidator.cc
+++ b/iocore/net/quic/QUICPathValidator.cc
@@ -23,32 +23,85 @@
 
 #include <chrono>
 #include "QUICPathValidator.h"
+#include "QUICPacket.h"
+
+#define QUICDebug(fmt, ...) Debug("quic_path", "[%s] " fmt, this->_cinfo.cids().data(), ##__VA_ARGS__)
 
 bool
-QUICPathValidator::is_validating()
+QUICPathValidator::ValidationJob::has_more_challenges() const
+{
+  return this->_has_outgoing_challenge;
+}
+
+const uint8_t *
+QUICPathValidator::ValidationJob::get_next_challenge() const
+{
+  if (this->_has_outgoing_challenge) {
+    return this->_outgoing_challenge + ((this->_has_outgoing_challenge - 1) * 8);
+  } else {
+    return nullptr;
+  }
+}
+
+void
+QUICPathValidator::ValidationJob::consume_challenge()
+{
+  --(this->_has_outgoing_challenge);
+}
+
+bool
+QUICPathValidator::is_validating(const QUICPath &path)
+{
+  if (auto j = this->_jobs.find(path); j != this->_jobs.end()) {
+    return j->second.is_validating();
+  } else {
+    return false;
+  }
+}
+
+bool
+QUICPathValidator::is_validated(const QUICPath &path)
+{
+  if (auto j = this->_jobs.find(path); j != this->_jobs.end()) {
+    return j->second.is_validated();
+  } else {
+    return false;
+  }
+}
+
+void
+QUICPathValidator::validate(const QUICPath &path)
+{
+  if (this->_jobs.find(path) != this->_jobs.end()) {
+    // Do nothing
+  } else {
+    auto result = this->_jobs.emplace(std::piecewise_construct, std::forward_as_tuple(path), std::forward_as_tuple());
+    result.first->second.start();
+    // QUICDebug("Validating a path between %s and %s", path.local_ep(), path.remote_ep());
+  }
+}
+
+bool
+QUICPathValidator::ValidationJob::is_validating()
 {
   return this->_state == ValidationState::VALIDATING;
 }
 
 bool
-QUICPathValidator::is_validated()
+QUICPathValidator::ValidationJob::is_validated()
 {
   return this->_state == ValidationState::VALIDATED;
 }
 
 void
-QUICPathValidator::validate()
+QUICPathValidator::ValidationJob::start()
 {
-  if (this->_state == ValidationState::VALIDATING) {
-    // Do nothing
-  } else {
-    this->_state = ValidationState::VALIDATING;
-    this->_generate_challenge();
-  }
+  this->_state = ValidationState::VALIDATING;
+  this->_generate_challenge();
 }
 
 void
-QUICPathValidator::_generate_challenge()
+QUICPathValidator::ValidationJob::_generate_challenge()
 {
   size_t seed =
     std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
@@ -60,29 +113,17 @@
   this->_has_outgoing_challenge = 3;
 }
 
-void
-QUICPathValidator::_generate_response(const QUICPathChallengeFrame &frame)
+bool
+QUICPathValidator::ValidationJob::validate_response(const uint8_t *data)
 {
-  memcpy(this->_incoming_challenge, frame.data(), QUICPathChallengeFrame::DATA_LEN);
-  this->_has_outgoing_response = true;
-}
-
-QUICConnectionErrorUPtr
-QUICPathValidator::_validate_response(const QUICPathResponseFrame &frame)
-{
-  QUICConnectionErrorUPtr error = std::make_unique<QUICConnectionError>(QUICTransErrorCode::PROTOCOL_VIOLATION);
-
   for (int i = 0; i < 3; ++i) {
-    if (memcmp(this->_outgoing_challenge + (QUICPathChallengeFrame::DATA_LEN * i), frame.data(),
-               QUICPathChallengeFrame::DATA_LEN) == 0) {
+    if (memcmp(this->_outgoing_challenge + (QUICPathChallengeFrame::DATA_LEN * i), data, QUICPathChallengeFrame::DATA_LEN) == 0) {
       this->_state                  = ValidationState::VALIDATED;
       this->_has_outgoing_challenge = 0;
-      error                         = nullptr;
-      break;
+      return true;
     }
   }
-
-  return error;
+  return false;
 }
 
 //
@@ -101,10 +142,21 @@
 
   switch (frame.type()) {
   case QUICFrameType::PATH_CHALLENGE:
-    this->_generate_response(static_cast<const QUICPathChallengeFrame &>(frame));
+    this->_incoming_challenges.emplace(this->_incoming_challenges.begin(),
+                                       static_cast<const QUICPathChallengeFrame &>(frame).data());
     break;
   case QUICFrameType::PATH_RESPONSE:
-    error = this->_validate_response(static_cast<const QUICPathResponseFrame &>(frame));
+    if (auto item = this->_jobs.find({frame.packet()->to(), frame.packet()->from()}); item != this->_jobs.end()) {
+      if (item->second.validate_response(static_cast<const QUICPathResponseFrame &>(frame).data())) {
+        QUICDebug("validation succeeded");
+        this->_on_validation_callback(true);
+      } else {
+        QUICDebug("validation failed");
+        this->_on_validation_callback(false);
+      }
+    } else {
+      error = std::make_unique<QUICConnectionError>(QUICTransErrorCode::PROTOCOL_VIOLATION);
+    }
     break;
   default:
     ink_assert(!"Can't happen");
@@ -117,17 +169,30 @@
 // QUICFrameGenerator
 //
 bool
-QUICPathValidator::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICPathValidator::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num)
 {
   if (!this->_is_level_matched(level)) {
     return false;
   }
 
-  if (this->_last_sent_at == timestamp) {
+  if (this->_latest_seq_num == seq_num) {
     return false;
   }
 
-  return (this->_has_outgoing_challenge || this->_has_outgoing_response);
+  // Check challenges
+  for (auto &&item : this->_jobs) {
+    auto &j = item.second;
+    if (!j.is_validating() && !j.is_validated()) {
+      j.start();
+      return true;
+    }
+    if (j.has_more_challenges()) {
+      return true;
+    }
+  }
+
+  // Check responses
+  return !this->_incoming_challenges.empty();
 }
 
 /**
@@ -135,7 +200,7 @@
  */
 QUICFrame *
 QUICPathValidator::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t /* connection_credit */,
-                                  uint16_t maximum_frame_size, ink_hrtime timestamp)
+                                  uint16_t maximum_frame_size, size_t current_packet_size, uint32_t seq_num)
 {
   QUICFrame *frame = nullptr;
 
@@ -143,27 +208,31 @@
     return frame;
   }
 
-  if (this->_has_outgoing_response) {
-    frame = QUICFrameFactory::create_path_response_frame(buf, this->_incoming_challenge);
+  if (!this->_incoming_challenges.empty()) {
+    frame = QUICFrameFactory::create_path_response_frame(buf, this->_incoming_challenges.back());
     if (frame && frame->size() > maximum_frame_size) {
       // Cancel generating frame
       frame = nullptr;
     } else {
-      this->_has_outgoing_response = false;
+      this->_incoming_challenges.pop_back();
     }
-  } else if (this->_has_outgoing_challenge) {
-    frame = QUICFrameFactory::create_path_challenge_frame(
-      buf, this->_outgoing_challenge + (QUICPathChallengeFrame::DATA_LEN * (this->_has_outgoing_challenge - 1)));
-    if (frame && frame->size() > maximum_frame_size) {
-      // Cancel generating frame
-      frame = nullptr;
-    } else {
-      --this->_has_outgoing_challenge;
-      ink_assert(this->_has_outgoing_challenge >= 0);
+  } else {
+    for (auto &&item : this->_jobs) {
+      auto &j = item.second;
+      if (j.has_more_challenges()) {
+        frame = QUICFrameFactory::create_path_challenge_frame(buf, j.get_next_challenge());
+        if (frame && frame->size() > maximum_frame_size) {
+          // Cancel generating frame
+          frame = nullptr;
+        } else {
+          j.consume_challenge();
+        }
+        break;
+      }
     }
   }
 
-  this->_last_sent_at = timestamp;
+  this->_latest_seq_num = seq_num;
 
   return frame;
 }
diff --git a/iocore/net/quic/QUICPathValidator.h b/iocore/net/quic/QUICPathValidator.h
index 47a2975..c575f5a 100644
--- a/iocore/net/quic/QUICPathValidator.h
+++ b/iocore/net/quic/QUICPathValidator.h
@@ -24,26 +24,31 @@
 #pragma once
 
 #include <vector>
+#include <unordered_map>
 #include "QUICTypes.h"
 #include "QUICFrameHandler.h"
 #include "QUICFrameGenerator.h"
+#include "QUICConnection.h"
 
 class QUICPathValidator : public QUICFrameHandler, public QUICFrameGenerator
 {
 public:
-  QUICPathValidator() {}
-  bool is_validating();
-  bool is_validated();
-  void validate();
+  QUICPathValidator(const QUICConnectionInfoProvider &info, std::function<void(bool)> callback)
+    : _cinfo(info), _on_validation_callback(callback)
+  {
+  }
+  bool is_validating(const QUICPath &path);
+  bool is_validated(const QUICPath &path);
+  void validate(const QUICPath &path);
 
   // QUICFrameHandler
   std::vector<QUICFrameType> interests() override;
   QUICConnectionErrorUPtr handle_frame(QUICEncryptionLevel level, const QUICFrame &frame) override;
 
   // QUICFrameGeneratro
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
 private:
   enum class ValidationState : int {
@@ -51,14 +56,33 @@
     VALIDATING,
     VALIDATED,
   };
-  ValidationState _state      = ValidationState::NOT_VALIDATED;
-  int _has_outgoing_challenge = 0;
-  bool _has_outgoing_response = false;
-  ink_hrtime _last_sent_at    = 0;
-  uint8_t _incoming_challenge[QUICPathChallengeFrame::DATA_LEN];
-  uint8_t _outgoing_challenge[QUICPathChallengeFrame::DATA_LEN * 3];
 
-  void _generate_challenge();
-  void _generate_response(const QUICPathChallengeFrame &frame);
-  QUICConnectionErrorUPtr _validate_response(const QUICPathResponseFrame &frame);
+  class ValidationJob
+  {
+  public:
+    ValidationJob(){};
+    ~ValidationJob(){};
+    bool is_validating();
+    bool is_validated();
+    void start();
+    bool validate_response(const uint8_t *data);
+    bool has_more_challenges() const;
+    const uint8_t *get_next_challenge() const;
+    void consume_challenge();
+
+  private:
+    ValidationState _state = ValidationState::NOT_VALIDATED;
+    uint8_t _outgoing_challenge[QUICPathChallengeFrame::DATA_LEN * 3];
+    int _has_outgoing_challenge = 0;
+
+    void _generate_challenge();
+  };
+
+  const QUICConnectionInfoProvider &_cinfo;
+  std::unordered_map<QUICPath, ValidationJob, QUICPathHasher> _jobs;
+
+  std::function<void(bool)> _on_validation_callback;
+
+  uint32_t _latest_seq_num = 0;
+  std::vector<QUICPathValidationData> _incoming_challenges;
 };
diff --git a/iocore/net/quic/QUICPinger.cc b/iocore/net/quic/QUICPinger.cc
index e6f69c6..84454c8 100644
--- a/iocore/net/quic/QUICPinger.cc
+++ b/iocore/net/quic/QUICPinger.cc
@@ -24,54 +24,72 @@
 #include "QUICPinger.h"
 
 void
-QUICPinger::request(QUICEncryptionLevel level)
+QUICPinger::request()
 {
-  if (!this->_is_level_matched(level)) {
-    return;
-  }
-  ++this->_need_to_fire[static_cast<int>(level)];
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  ++this->_need_to_fire;
 }
 
 void
-QUICPinger::cancel(QUICEncryptionLevel level)
+QUICPinger::cancel()
 {
-  if (!this->_is_level_matched(level)) {
-    return;
-  }
-
-  if (this->_need_to_fire[static_cast<int>(level)] > 0) {
-    --this->_need_to_fire[static_cast<int>(level)];
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  if (this->_need_to_fire > 0) {
+    --this->_need_to_fire;
   }
 }
 
 bool
-QUICPinger::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICPinger::_will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting)
 {
-  if (!this->_is_level_matched(level)) {
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+
+  if (level != QUICEncryptionLevel::ONE_RTT) {
     return false;
   }
 
-  return this->_need_to_fire[static_cast<int>(QUICTypeUtil::pn_space(level))] > 0;
+  // PING Frame is meaningless for ack_eliciting packet. Cancel it.
+  if (ack_eliciting) {
+    this->_ack_eliciting_packet_out = true;
+    this->cancel();
+    return false;
+  }
+
+  if (this->_ack_eliciting_packet_out == false && !ack_eliciting && current_packet_size > 0 && this->_need_to_fire == 0) {
+    // force to send an PING Frame
+    this->request();
+  }
+
+  // only update `_ack_eliciting_packet_out` when we has something to send.
+  if (current_packet_size) {
+    this->_ack_eliciting_packet_out = ack_eliciting;
+  }
+  return this->_need_to_fire > 0;
 }
 
 /**
  * @param connection_credit This is not used. Because PING frame is not flow-controlled
  */
 QUICFrame *
-QUICPinger::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t /* connection_credit */, uint16_t maximum_frame_size,
-                           ink_hrtime timestamp)
+QUICPinger::_generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t /* connection_credit */, uint16_t maximum_frame_size,
+                            size_t current_packet_size)
 {
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
   QUICFrame *frame = nullptr;
 
-  if (!this->_is_level_matched(level)) {
-    return frame;
-  }
-
-  if (this->_need_to_fire[static_cast<int>(level)] > 0 && maximum_frame_size > 0) {
+  if (level == QUICEncryptionLevel::ONE_RTT && this->_need_to_fire > 0 && maximum_frame_size > 0) {
     // don't care ping frame lost or acked
-    frame                                        = QUICFrameFactory::create_ping_frame(buf, 0, nullptr);
-    this->_need_to_fire[static_cast<int>(level)] = 0;
+    frame = QUICFrameFactory::create_ping_frame(buf, 0, nullptr);
+    --this->_need_to_fire;
+    this->_ack_eliciting_packet_out = true;
   }
 
   return frame;
 }
+
+uint64_t
+QUICPinger::count()
+{
+  SCOPED_MUTEX_LOCK(lock, this->_mutex, this_ethread());
+  return this->_need_to_fire;
+}
diff --git a/iocore/net/quic/QUICPinger.h b/iocore/net/quic/QUICPinger.h
index efa59a3..483cfb2 100644
--- a/iocore/net/quic/QUICPinger.h
+++ b/iocore/net/quic/QUICPinger.h
@@ -28,20 +28,25 @@
 #include "QUICFrameHandler.h"
 #include "QUICFrameGenerator.h"
 
-class QUICPinger : public QUICFrameGenerator
+#include "I_Lock.h"
+
+class QUICPinger : public QUICFrameOnceGenerator
 {
 public:
-  QUICPinger() {}
+  QUICPinger() : _mutex(new_ProxyMutex()) {}
 
-  void request(QUICEncryptionLevel level);
-  void cancel(QUICEncryptionLevel level);
-
-  // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
-  QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+  void request();
+  void cancel();
+  uint64_t count();
 
 private:
-  // Initial, 0/1-RTT, and Handshake
-  uint64_t _need_to_fire[4] = {0};
+  // QUICFrameGenerator
+  bool _will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting) override;
+  QUICFrame *_generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
+                             size_t current_packet_size) override;
+
+  bool _ack_eliciting_packet_out = false;
+
+  Ptr<ProxyMutex> _mutex;
+  uint64_t _need_to_fire = 0;
 };
diff --git a/iocore/net/quic/QUICStreamManager.cc b/iocore/net/quic/QUICStreamManager.cc
index 91edd1b..de4ffb9 100644
--- a/iocore/net/quic/QUICStreamManager.cc
+++ b/iocore/net/quic/QUICStreamManager.cc
@@ -29,8 +29,6 @@
 static constexpr char tag[]                     = "quic_stream_manager";
 static constexpr QUICStreamId QUIC_STREAM_TYPES = 4;
 
-ClassAllocator<QUICStreamManager> quicStreamManagerAllocator("quicStreamManagerAllocator");
-
 QUICStreamManager::QUICStreamManager(QUICConnectionInfoProvider *info, QUICRTTProvider *rtt_provider, QUICApplicationMap *app_map)
   : _stream_factory(rtt_provider, info), _info(info), _app_map(app_map)
 {
@@ -92,7 +90,7 @@
   QUICConnectionErrorUPtr error    = nullptr;
   QUICStreamVConnection *stream_vc = this->_find_or_create_stream_vc(stream_id);
   if (!stream_vc) {
-    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_ID_ERROR);
+    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_LIMIT_ERROR);
   }
 
   QUICApplication *application = this->_app_map->get(stream_id);
@@ -176,7 +174,7 @@
   if (stream) {
     return stream->recv(frame);
   } else {
-    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_ID_ERROR);
+    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_LIMIT_ERROR);
   }
 }
 
@@ -187,7 +185,7 @@
   if (stream) {
     return stream->recv(frame);
   } else {
-    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_ID_ERROR);
+    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_LIMIT_ERROR);
   }
 }
 
@@ -196,7 +194,7 @@
 {
   QUICStreamVConnection *stream = this->_find_or_create_stream_vc(frame.stream_id());
   if (!stream) {
-    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_ID_ERROR);
+    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_LIMIT_ERROR);
   }
 
   QUICApplication *application = this->_app_map->get(frame.stream_id());
@@ -215,7 +213,7 @@
   if (stream) {
     return stream->recv(frame);
   } else {
-    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_ID_ERROR);
+    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_LIMIT_ERROR);
   }
 }
 
@@ -226,7 +224,7 @@
   if (stream) {
     return stream->recv(frame);
   } else {
-    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_ID_ERROR);
+    return std::make_unique<QUICConnectionError>(QUICTransErrorCode::STREAM_LIMIT_ERROR);
   }
 }
 
@@ -407,7 +405,7 @@
 }
 
 bool
-QUICStreamManager::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICStreamManager::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num)
 {
   if (!this->_is_level_matched(level)) {
     return false;
@@ -419,7 +417,7 @@
   }
 
   for (QUICStreamVConnection *s = this->stream_list.head; s; s = s->link.next) {
-    if (s->will_generate_frame(level, timestamp)) {
+    if (s->will_generate_frame(level, current_packet_size, ack_eliciting, seq_num)) {
       return true;
     }
   }
@@ -429,7 +427,7 @@
 
 QUICFrame *
 QUICStreamManager::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                                  ink_hrtime timestamp)
+                                  size_t current_packet_size, uint32_t seq_num)
 {
   QUICFrame *frame = nullptr;
 
@@ -444,7 +442,7 @@
 
   // FIXME We should pick a stream based on priority
   for (QUICStreamVConnection *s = this->stream_list.head; s; s = s->link.next) {
-    frame = s->generate_frame(buf, level, connection_credit, maximum_frame_size, timestamp);
+    frame = s->generate_frame(buf, level, connection_credit, maximum_frame_size, current_packet_size, seq_num);
     if (frame) {
       break;
     }
diff --git a/iocore/net/quic/QUICStreamManager.h b/iocore/net/quic/QUICStreamManager.h
index fbdc49d..fb38ecc 100644
--- a/iocore/net/quic/QUICStreamManager.h
+++ b/iocore/net/quic/QUICStreamManager.h
@@ -37,7 +37,6 @@
 class QUICStreamManager : public QUICFrameHandler, public QUICFrameGenerator
 {
 public:
-  QUICStreamManager() : _stream_factory(nullptr, nullptr){};
   QUICStreamManager(QUICConnectionInfoProvider *info, QUICRTTProvider *rtt_provider, QUICApplicationMap *app_map);
 
   void init_flow_control_params(const std::shared_ptr<const QUICTransportParameters> &local_tp,
@@ -63,9 +62,9 @@
   virtual QUICConnectionErrorUPtr handle_frame(QUICEncryptionLevel level, const QUICFrame &frame) override;
 
   // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t timestamp) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t timestamp) override;
 
 protected:
   virtual bool _is_level_matched(QUICEncryptionLevel level) override;
diff --git a/iocore/net/quic/QUICTokenCreator.cc b/iocore/net/quic/QUICTokenCreator.cc
new file mode 100644
index 0000000..9d1ef62
--- /dev/null
+++ b/iocore/net/quic/QUICTokenCreator.cc
@@ -0,0 +1,71 @@
+/** @file
+ *
+ *  A brief file description
+ *
+ *  @section license License
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#include "QUICTokenCreator.h"
+
+bool
+QUICTokenCreator::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num)
+{
+  if (!this->_is_level_matched(level)) {
+    return false;
+  }
+
+  return !this->_is_resumption_token_sent;
+}
+
+QUICFrame *
+QUICTokenCreator::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
+                                 size_t current_packet_size, uint32_t seq_num)
+{
+  QUICFrame *frame = nullptr;
+
+  if (!this->_is_level_matched(level)) {
+    return frame;
+  }
+
+  if (this->_is_resumption_token_sent) {
+    return frame;
+  }
+
+  if (this->_context->connection_info()->direction() == NET_VCONNECTION_IN) {
+    // TODO Make expiration period configurable
+    QUICResumptionToken token(this->_context->connection_info()->five_tuple().source(),
+                              this->_context->connection_info()->connection_id(), Thread::get_hrtime() + HRTIME_HOURS(24));
+    frame = QUICFrameFactory::create_new_token_frame(buf, token, this->_issue_frame_id(), this);
+    if (frame) {
+      if (frame->size() < maximum_frame_size) {
+        this->_is_resumption_token_sent = true;
+      } else {
+        // Cancel generating frame
+        frame = nullptr;
+      }
+    }
+  }
+
+  return frame;
+}
+
+void
+QUICTokenCreator::_on_frame_lost(QUICFrameInformationUPtr &info)
+{
+  this->_is_resumption_token_sent = false;
+}
diff --git a/iocore/net/quic/QUICTokenCreator.h b/iocore/net/quic/QUICTokenCreator.h
new file mode 100644
index 0000000..e107fb9
--- /dev/null
+++ b/iocore/net/quic/QUICTokenCreator.h
@@ -0,0 +1,42 @@
+/** @file
+ *
+ *  A brief file description
+ *
+ *  @section license License
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#pragma once
+
+#include "QUICFrameGenerator.h"
+#include "QUICContext.h"
+
+class QUICTokenCreator final : public QUICFrameGenerator
+{
+public:
+  QUICTokenCreator(QUICContext *context) : _context(context) {}
+
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
+  QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
+                            size_t current_packet_size, uint32_t seq_num) override;
+
+private:
+  void _on_frame_lost(QUICFrameInformationUPtr &info) override;
+
+  bool _is_resumption_token_sent = false;
+  QUICContext *_context          = nullptr;
+};
diff --git a/iocore/net/quic/QUICTransportParameters.cc b/iocore/net/quic/QUICTransportParameters.cc
index 04f0009..248cfcb 100644
--- a/iocore/net/quic/QUICTransportParameters.cc
+++ b/iocore/net/quic/QUICTransportParameters.cc
@@ -183,7 +183,7 @@
   if ((ite = this->_parameters.find(QUICTransportParameterId::INITIAL_MAX_STREAM_DATA_UNI)) != this->_parameters.end()) {
   }
 
-  if ((ite = this->_parameters.find(QUICTransportParameterId::DISABLE_MIGRATION)) != this->_parameters.end()) {
+  if ((ite = this->_parameters.find(QUICTransportParameterId::DISABLE_ACTIVE_MIGRATION)) != this->_parameters.end()) {
   }
 
   if ((ite = this->_parameters.find(QUICTransportParameterId::MAX_ACK_DELAY)) != this->_parameters.end()) {
@@ -290,11 +290,12 @@
       uint64_t int_value;
       size_t int_value_len;
       QUICVariableInt::decode(int_value, int_value_len, p.second->data(), p.second->len());
-      Debug(tag, "%s: 0x%" PRIx64 " (%" PRIu64 ")", QUICDebugNames::transport_parameter_id(p.first), int_value, int_value);
+      Debug(tag, "%s (%" PRIu32 "): 0x%" PRIx64 " (%" PRIu64 ")", QUICDebugNames::transport_parameter_id(p.first),
+            static_cast<uint16_t>(p.first), int_value, int_value);
     } else if (p.second->len() <= 24) {
       char hex_str[65];
       to_hex_str(hex_str, sizeof(hex_str), p.second->data(), p.second->len());
-      Debug(tag, "%s: %s", QUICDebugNames::transport_parameter_id(p.first), hex_str);
+      Debug(tag, "%s (%" PRIu32 "): %s", QUICDebugNames::transport_parameter_id(p.first), static_cast<uint16_t>(p.first), hex_str);
     } else if (QUICTransportParameterId::PREFERRED_ADDRESS == p.first) {
       QUICPreferredAddress pref_addr(p.second->data(), p.second->len());
       char cid_hex_str[QUICConnectionId::MAX_HEX_STR_LENGTH];
diff --git a/iocore/net/quic/QUICTransportParameters.h b/iocore/net/quic/QUICTransportParameters.h
index 6886bd0..df46d9d 100644
--- a/iocore/net/quic/QUICTransportParameters.h
+++ b/iocore/net/quic/QUICTransportParameters.h
@@ -46,8 +46,9 @@
     INITIAL_MAX_STREAMS_UNI,
     ACK_DELAY_EXPONENT,
     MAX_ACK_DELAY,
-    DISABLE_MIGRATION,
+    DISABLE_ACTIVE_MIGRATION,
     PREFERRED_ADDRESS,
+    ACTIVE_CONNECTION_ID_LIMIT,
   };
 
   explicit operator bool() const { return true; }
diff --git a/iocore/net/quic/QUICTypes.cc b/iocore/net/quic/QUICTypes.cc
index 29e09d2..5c354a9 100644
--- a/iocore/net/quic/QUICTypes.cc
+++ b/iocore/net/quic/QUICTypes.cc
@@ -252,15 +252,15 @@
 }
 
 void
-QUICTypeUtil::write_QUICTransErrorCode(uint16_t error_code, uint8_t *buf, size_t *len)
+QUICTypeUtil::write_QUICTransErrorCode(uint64_t error_code, uint8_t *buf, size_t *len)
 {
-  QUICIntUtil::write_uint_as_nbytes(static_cast<uint64_t>(error_code), 2, buf, len);
+  QUICIntUtil::write_QUICVariableInt(static_cast<uint64_t>(error_code), buf, len);
 }
 
 void
 QUICTypeUtil::write_QUICAppErrorCode(QUICAppErrorCode error_code, uint8_t *buf, size_t *len)
 {
-  QUICIntUtil::write_uint_as_nbytes(static_cast<uint64_t>(error_code), 2, buf, len);
+  QUICIntUtil::write_QUICVariableInt(static_cast<uint64_t>(error_code), buf, len);
 }
 
 void
@@ -553,6 +553,24 @@
 }
 
 //
+// QUICPath
+//
+
+QUICPath::QUICPath(IpEndpoint local_ep, IpEndpoint remote_ep) : _local_ep(local_ep), _remote_ep(remote_ep) {}
+
+const IpEndpoint &
+QUICPath::local_ep() const
+{
+  return this->_local_ep;
+}
+
+const IpEndpoint &
+QUICPath::remote_ep() const
+{
+  return this->_remote_ep;
+}
+
+//
 // QUICConnectionId
 //
 QUICConnectionId
@@ -660,7 +678,7 @@
     return false;
   }
 
-  dst = buf[QUICInvariants::LH_CIL_OFFSET] >> 4;
+  dst = buf[QUICInvariants::LH_CIL_OFFSET];
 
   return true;
 }
@@ -670,11 +688,12 @@
 {
   ink_assert(QUICInvariants::is_long_header(buf));
 
-  if (buf_len < QUICInvariants::LH_CIL_OFFSET) {
+  uint8_t dcil = 0;
+  if (!QUICInvariants::dcil(dcil, buf, buf_len)) {
     return false;
   }
 
-  dst = buf[QUICInvariants::LH_CIL_OFFSET] & 0x0F;
+  dst = buf[QUICInvariants::LH_CIL_OFFSET + 1 + dcil];
 
   return true;
 }
@@ -691,13 +710,12 @@
       return false;
     }
 
-    if (dcil) {
-      dcid_len = dcil + QUICInvariants::CIL_BASE;
-    } else {
+    if (dcil == 0) {
       dst = QUICConnectionId::ZERO();
       return true;
     }
 
+    dcid_len    = dcil;
     dcid_offset = QUICInvariants::LH_DCID_OFFSET;
   } else {
     // remote dcil is local scil
@@ -724,34 +742,30 @@
   }
 
   uint8_t scid_offset = QUICInvariants::LH_DCID_OFFSET;
-  uint8_t scid_len    = 0;
 
   uint8_t dcil = 0;
   if (!QUICInvariants::dcil(dcil, buf, buf_len)) {
     return false;
   }
 
-  if (dcil) {
-    scid_offset += (dcil + QUICInvariants::CIL_BASE);
-  }
+  scid_offset += dcil;
 
   uint8_t scil = 0;
   if (!QUICInvariants::scil(scil, buf, buf_len)) {
     return false;
   }
+  scid_offset += 1;
 
-  if (scil) {
-    scid_len = scil + QUICInvariants::CIL_BASE;
-  } else {
+  if (scil == 0) {
     dst = QUICConnectionId::ZERO();
     return true;
   }
 
-  if (scid_offset + scid_len > buf_len) {
+  if (scid_offset + scil > buf_len) {
     return false;
   }
 
-  dst = QUICTypeUtil::read_QUICConnectionId(buf + scid_offset, scid_len);
+  dst = QUICTypeUtil::read_QUICConnectionId(buf + scid_offset, scil);
 
   return true;
 }
diff --git a/iocore/net/quic/QUICTypes.h b/iocore/net/quic/QUICTypes.h
index ee19ab0..7c3a537 100644
--- a/iocore/net/quic/QUICTypes.h
+++ b/iocore/net/quic/QUICTypes.h
@@ -51,7 +51,7 @@
 // Note: Fix QUIC_ALPN_PROTO_LIST in QUICConfig.cc
 // Note: Change ExtensionType (QUICTransportParametersHandler::TRANSPORT_PARAMETER_ID) if it's changed
 constexpr QUICVersion QUIC_SUPPORTED_VERSIONS[] = {
-  0xff000014,
+  0xff000017,
 };
 constexpr QUICVersion QUIC_EXERCISE_VERSION = 0x1a2a3a4a;
 
@@ -75,9 +75,10 @@
 
 // introduce by draft-19 kPacketNumberSpace
 enum class QUICPacketNumberSpace {
-  Initial,
-  Handshake,
-  ApplicationData,
+  None            = -1,
+  Initial         = 0,
+  Handshake       = 1,
+  ApplicationData = 2,
 };
 
 // Devide to QUICPacketType and QUICPacketLongHeaderType ?
@@ -147,24 +148,23 @@
   APPLICATION,
 };
 
-enum class QUICTransErrorCode : uint16_t {
+enum class QUICTransErrorCode : uint64_t {
   NO_ERROR = 0x00,
   INTERNAL_ERROR,
   SERVER_BUSY,
   FLOW_CONTROL_ERROR,
-  STREAM_ID_ERROR,
+  STREAM_LIMIT_ERROR,
   STREAM_STATE_ERROR,
-  FINAL_OFFSET_ERROR,
+  FINAL_SIZE_ERROR,
   FRAME_ENCODING_ERROR,
   TRANSPORT_PARAMETER_ERROR,
-  VERSION_NEGOTIATION_ERROR,
-  PROTOCOL_VIOLATION,
-  INVALID_MIGRATION = 0x0C,
-  CRYPTO_ERROR      = 0x0100, // 0x100 - 0x1FF
+  PROTOCOL_VIOLATION     = 0x0A,
+  CRYPTO_BUFFER_EXCEEDED = 0x0D,
+  CRYPTO_ERROR           = 0x0100, // 0x100 - 0x1FF
 };
 
 // Application Protocol Error Codes defined in application
-using QUICAppErrorCode                          = uint16_t;
+using QUICAppErrorCode                          = uint64_t;
 constexpr uint16_t QUIC_APP_ERROR_CODE_STOPPING = 0;
 
 class QUICError
@@ -225,7 +225,7 @@
   static uint8_t SCID_LEN;
 
   static const int MIN_LENGTH_FOR_INITIAL = 8;
-  static const int MAX_LENGTH             = 18;
+  static const int MAX_LENGTH             = 20;
   static const size_t MAX_HEX_STR_LENGTH  = MAX_LENGTH * 2 + 1;
   static QUICConnectionId ZERO();
   QUICConnectionId();
@@ -398,8 +398,8 @@
 class QUICPreferredAddress
 {
 public:
-  constexpr static int16_t MIN_LEN = 26;
-  constexpr static int16_t MAX_LEN = 295;
+  constexpr static int16_t MIN_LEN = 41;
+  constexpr static int16_t MAX_LEN = 61;
 
   QUICPreferredAddress(IpEndpoint endpoint_ipv4, IpEndpoint endpoint_ipv6, const QUICConnectionId &cid,
                        QUICStatelessResetToken token)
@@ -419,8 +419,8 @@
   void store(uint8_t *buf, uint16_t &len) const;
 
 private:
-  IpEndpoint _endpoint_ipv4;
-  IpEndpoint _endpoint_ipv6;
+  IpEndpoint _endpoint_ipv4 = {};
+  IpEndpoint _endpoint_ipv6 = {};
   QUICConnectionId _cid;
   QUICStatelessResetToken _token;
   bool _valid = false;
@@ -457,6 +457,61 @@
   uint64_t _hash_code = 0;
 };
 
+class QUICPath
+{
+public:
+  QUICPath(IpEndpoint local_ep, IpEndpoint remote_ep);
+  const IpEndpoint &local_ep() const;
+  const IpEndpoint &remote_ep() const;
+
+  inline bool
+  operator==(const QUICPath &x) const
+  {
+    if ((this->_local_ep.port() != 0 && x._local_ep.port() != 0) && this->_local_ep.port() != x._local_ep.port()) {
+      return false;
+    }
+
+    if ((this->_remote_ep.port() != 0 && x._remote_ep.port() != 0) && this->_remote_ep.port() != x._remote_ep.port()) {
+      return false;
+    }
+
+    if ((!IpAddr(this->_local_ep).isAnyAddr() && !IpAddr(x._local_ep).isAnyAddr()) && this->_local_ep != x._local_ep) {
+      return false;
+    }
+
+    if ((!IpAddr(this->_remote_ep).isAnyAddr() || !IpAddr(x._remote_ep).isAnyAddr()) && this->_remote_ep != x._remote_ep) {
+      return false;
+    }
+
+    return true;
+  }
+
+private:
+  IpEndpoint _local_ep;
+  IpEndpoint _remote_ep;
+};
+
+class QUICPathHasher
+{
+public:
+  std::size_t
+  operator()(const QUICPath &k) const
+  {
+    return k.remote_ep().port();
+  }
+};
+
+class QUICPathValidationData
+{
+public:
+  QUICPathValidationData(const uint8_t *data) { memcpy(this->_data, data, sizeof(this->_data)); }
+
+  inline operator const uint8_t *() const { return this->_data; }
+
+private:
+  uint8_t _data[8];
+};
+
 class QUICTPConfig
 {
 public:
@@ -471,11 +526,13 @@
   virtual uint64_t initial_max_streams_uni() const             = 0;
   virtual uint8_t ack_delay_exponent() const                   = 0;
   virtual uint8_t max_ack_delay() const                        = 0;
+  virtual uint8_t active_cid_limit() const                     = 0;
 };
 
 class QUICLDConfig
 {
 public:
+  virtual ~QUICLDConfig() {}
   virtual uint32_t packet_threshold() const = 0;
   virtual float time_threshold() const      = 0;
   virtual ink_hrtime granularity() const    = 0;
@@ -485,6 +542,7 @@
 class QUICCCConfig
 {
 public:
+  virtual ~QUICCCConfig() {}
   virtual uint32_t max_datagram_size() const               = 0;
   virtual uint32_t initial_window() const                  = 0;
   virtual uint32_t minimum_window() const                  = 0;
@@ -520,7 +578,7 @@
   static void write_QUICVersion(QUICVersion version, uint8_t *buf, size_t *len);
   static void write_QUICStreamId(QUICStreamId stream_id, uint8_t *buf, size_t *len);
   static void write_QUICOffset(QUICOffset offset, uint8_t *buf, size_t *len);
-  static void write_QUICTransErrorCode(uint16_t error_code, uint8_t *buf, size_t *len);
+  static void write_QUICTransErrorCode(uint64_t error_code, uint8_t *buf, size_t *len);
   static void write_QUICAppErrorCode(QUICAppErrorCode error_code, uint8_t *buf, size_t *len);
   static void write_QUICMaxData(uint64_t max_data, uint8_t *buf, size_t *len);
 
@@ -533,18 +591,11 @@
   static bool is_long_header(const uint8_t *buf);
   static bool is_version_negotiation(QUICVersion v);
   static bool version(QUICVersion &dst, const uint8_t *buf, uint64_t buf_len);
-  /**
-   * This function returns the raw value. You'll need to add 3 to the returned value to get the actual connection id length.
-   */
   static bool dcil(uint8_t &dst, const uint8_t *buf, uint64_t buf_len);
-  /**
-   * This function returns the raw value. You'll need to add 3 to the returned value to get the actual connection id length.
-   */
   static bool scil(uint8_t &dst, const uint8_t *buf, uint64_t buf_len);
   static bool dcid(QUICConnectionId &dst, const uint8_t *buf, uint64_t buf_len);
   static bool scid(QUICConnectionId &dst, const uint8_t *buf, uint64_t buf_len);
 
-  static const size_t CIL_BASE          = 3;
   static const size_t LH_VERSION_OFFSET = 1;
   static const size_t LH_CIL_OFFSET     = 5;
   static const size_t LH_DCID_OFFSET    = 6;
diff --git a/iocore/net/quic/QUICUnidirectionalStream.cc b/iocore/net/quic/QUICUnidirectionalStream.cc
index b6dae8f..90bd1dd 100644
--- a/iocore/net/quic/QUICUnidirectionalStream.cc
+++ b/iocore/net/quic/QUICUnidirectionalStream.cc
@@ -125,14 +125,14 @@
 }
 
 bool
-QUICSendStream::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICSendStream::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num)
 {
   return !this->is_retransmited_frame_queue_empty() || this->_write_vio.get_reader()->is_read_avail_more_than(0);
 }
 
 QUICFrame *
 QUICSendStream::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                               ink_hrtime timestamp)
+                               size_t current_packet_size, uint32_t seq_num)
 {
   SCOPED_MUTEX_LOCK(lock, this->_write_vio.mutex, this_ethread());
 
@@ -183,7 +183,8 @@
     uint64_t stream_credit = this->_remote_flow_controller.credit();
     if (stream_credit == 0) {
       // STREAM_DATA_BLOCKED
-      frame = this->_remote_flow_controller.generate_frame(buf, level, UINT16_MAX, maximum_frame_size, timestamp);
+      frame =
+        this->_remote_flow_controller.generate_frame(buf, level, UINT16_MAX, maximum_frame_size, current_packet_size, seq_num);
       return frame;
     }
 
@@ -526,15 +527,15 @@
 }
 
 bool
-QUICReceiveStream::will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp)
+QUICReceiveStream::will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num)
 {
-  return this->_local_flow_controller.will_generate_frame(level, timestamp) ||
+  return this->_local_flow_controller.will_generate_frame(level, current_packet_size, ack_eliciting, seq_num) ||
          (this->_stop_sending_reason != nullptr && this->_is_stop_sending_sent == false);
 }
 
 QUICFrame *
 QUICReceiveStream::generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                                  ink_hrtime timestamp)
+                                  size_t current_packet_size, uint32_t seq_num)
 {
   QUICFrame *frame = nullptr;
   // STOP_SENDING
@@ -548,7 +549,7 @@
   }
 
   // MAX_STREAM_DATA
-  frame = this->_local_flow_controller.generate_frame(buf, level, UINT16_MAX, maximum_frame_size, timestamp);
+  frame = this->_local_flow_controller.generate_frame(buf, level, UINT16_MAX, maximum_frame_size, current_packet_size, seq_num);
   return frame;
 }
 
diff --git a/iocore/net/quic/QUICUnidirectionalStream.h b/iocore/net/quic/QUICUnidirectionalStream.h
index 0c71627..5ebe552 100644
--- a/iocore/net/quic/QUICUnidirectionalStream.h
+++ b/iocore/net/quic/QUICUnidirectionalStream.h
@@ -37,9 +37,9 @@
   int state_stream_closed(int event, void *data);
 
   // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
   virtual QUICConnectionErrorUPtr recv(const QUICMaxStreamDataFrame &frame) override;
   virtual QUICConnectionErrorUPtr recv(const QUICStopSendingFrame &frame) override;
@@ -86,9 +86,9 @@
   int state_stream_closed(int event, void *data);
 
   // QUICFrameGenerator
-  bool will_generate_frame(QUICEncryptionLevel level, ink_hrtime timestamp) override;
+  bool will_generate_frame(QUICEncryptionLevel level, size_t current_packet_size, bool ack_eliciting, uint32_t seq_num) override;
   QUICFrame *generate_frame(uint8_t *buf, QUICEncryptionLevel level, uint64_t connection_credit, uint16_t maximum_frame_size,
-                            ink_hrtime timestamp) override;
+                            size_t current_packet_size, uint32_t seq_num) override;
 
   virtual QUICConnectionErrorUPtr recv(const QUICStreamFrame &frame) override;
   virtual QUICConnectionErrorUPtr recv(const QUICStreamDataBlockedFrame &frame) override;
diff --git a/iocore/net/quic/test/test_QUICAckFrameCreator.cc b/iocore/net/quic/test/test_QUICAckFrameCreator.cc
index 99b40e7..39b7bc9 100644
--- a/iocore/net/quic/test/test_QUICAckFrameCreator.cc
+++ b/iocore/net/quic/test/test_QUICAckFrameCreator.cc
@@ -32,63 +32,67 @@
   uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
 
   // Initial state
-  QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   QUICAckFrame *frame  = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame == nullptr);
 
   // One packet
   ack_manager.update(level, 1, 1, false);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 0);
   CHECK(frame->largest_acknowledged() == 1);
   CHECK(frame->ack_block_section()->first_ack_block() == 0);
+  ack_frame->~QUICFrame();
 
   // retry
-  CHECK(ack_manager.will_generate_frame(level, 0) == false);
+  CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
 
   // Not sequential
   ack_manager.update(level, 2, 1, false);
   ack_manager.update(level, 5, 1, false);
   ack_manager.update(level, 3, 1, false);
   ack_manager.update(level, 4, 1, false);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 0);
   CHECK(frame->largest_acknowledged() == 5);
   CHECK(frame->ack_block_section()->first_ack_block() == 4);
+  ack_frame->~QUICFrame();
 
   // Loss
   ack_manager.update(level, 6, 1, false);
   ack_manager.update(level, 7, 1, false);
   ack_manager.update(level, 10, 1, false);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 1);
   CHECK(frame->largest_acknowledged() == 10);
   CHECK(frame->ack_block_section()->first_ack_block() == 0);
   CHECK(frame->ack_block_section()->begin()->gap() == 1);
+  ack_frame->~QUICFrame();
 
   // on frame acked
   ack_manager.on_frame_acked(frame->id());
 
-  CHECK(ack_manager.will_generate_frame(level, 0) == false);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   CHECK(ack_frame == nullptr);
 
   ack_manager.update(level, 11, 1, false);
   ack_manager.update(level, 12, 1, false);
   ack_manager.update(level, 13, 1, false);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 0);
   CHECK(frame->largest_acknowledged() == 13);
   CHECK(frame->ack_block_section()->first_ack_block() == 2);
   CHECK(frame->ack_block_section()->begin()->gap() == 0);
+  ack_frame->~QUICFrame();
 
   ack_manager.on_frame_acked(frame->id());
 
@@ -96,17 +100,18 @@
   ack_manager.update(level, 14, 1, true);
   ack_manager.update(level, 15, 1, true);
   ack_manager.update(level, 16, 1, true);
-  CHECK(ack_manager.will_generate_frame(level, 0) == false);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
 
   ack_manager.update(level, 17, 1, false);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 0);
   CHECK(frame->largest_acknowledged() == 17);
   CHECK(frame->ack_block_section()->first_ack_block() == 3);
   CHECK(frame->ack_block_section()->begin()->gap() == 0);
+  ack_frame->~QUICFrame();
 }
 
 TEST_CASE("QUICAckFrameManager should send", "[quic]")
@@ -117,7 +122,7 @@
 
     QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
     ack_manager.update(level, 2, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
   }
 
   SECTION("QUIC delay ack and unorder packet", "[quic]")
@@ -126,13 +131,13 @@
 
     QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
     ack_manager.update(level, 0, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == false);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
 
     ack_manager.update(level, 1, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == false);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
 
     ack_manager.update(level, 3, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
   }
 
   SECTION("QUIC delay too much time", "[quic]")
@@ -142,12 +147,12 @@
 
     QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
     ack_manager.update(level, 0, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == false);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
 
     sleep(1);
     Thread::get_hrtime_updated();
     ack_manager.update(level, 1, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
   }
 
   SECTION("QUIC intial packet", "[quic]")
@@ -156,7 +161,7 @@
 
     QUICEncryptionLevel level = QUICEncryptionLevel::INITIAL;
     ack_manager.update(level, 0, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
   }
 
   SECTION("QUIC handshake packet", "[quic]")
@@ -165,7 +170,7 @@
 
     QUICEncryptionLevel level = QUICEncryptionLevel::HANDSHAKE;
     ack_manager.update(level, 0, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
   }
 
   SECTION("QUIC frame fired", "[quic]")
@@ -174,11 +179,11 @@
     QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
 
     ack_manager.update(level, 0, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == false);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
 
     sleep(1);
     Thread::get_hrtime_updated();
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
   }
 
   SECTION("QUIC refresh frame", "[quic]")
@@ -187,27 +192,28 @@
     QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
 
     uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
-    QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+    QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
     QUICAckFrame *frame  = static_cast<QUICAckFrame *>(ack_frame);
     CHECK(frame == nullptr);
 
     // unorder frame should sent immediately
     ack_manager.update(level, 1, 1, false);
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
 
     ack_manager.update(level, 2, 1, false);
 
     // Delay due to some reason, the frame is not valued any more, but still valued
     sleep(1);
     Thread::get_hrtime_updated();
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
-    ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
+    ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
     frame     = static_cast<QUICAckFrame *>(ack_frame);
 
     CHECK(frame->ack_block_count() == 0);
     CHECK(frame->largest_acknowledged() == 2);
     CHECK(frame->ack_block_section()->first_ack_block() == 1);
     CHECK(frame->ack_block_section()->begin()->gap() == 0);
+    ack_frame->~QUICFrame();
   }
 }
 
@@ -218,7 +224,7 @@
 
   // Initial state
   uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
-  QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   QUICAckFrame *frame  = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame == nullptr);
 
@@ -228,25 +234,27 @@
   ack_manager.update(level, 8, 1, false);
   ack_manager.update(level, 9, 1, false);
 
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 2);
   CHECK(frame->largest_acknowledged() == 9);
   CHECK(frame->ack_block_section()->first_ack_block() == 1);
   CHECK(frame->ack_block_section()->begin()->gap() == 0);
+  ack_frame->~QUICFrame();
 
-  CHECK(ack_manager.will_generate_frame(level, 0) == false);
+  CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
 
   ack_manager.update(level, 7, 1, false);
   ack_manager.update(level, 4, 1, false);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 1);
   CHECK(frame->largest_acknowledged() == 9);
   CHECK(frame->ack_block_section()->first_ack_block() == 5);
   CHECK(frame->ack_block_section()->begin()->gap() == 0);
+  ack_frame->~QUICFrame();
 }
 
 TEST_CASE("QUICAckFrameManager_QUICAckFrameCreator", "[quic]")
@@ -296,7 +304,7 @@
   uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
 
   // Initial state
-  QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   QUICAckFrame *frame  = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame == nullptr);
 
@@ -306,39 +314,42 @@
   ack_manager.update(level, 8, 1, false);
   ack_manager.update(level, 9, 1, false);
 
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 2);
   CHECK(frame->largest_acknowledged() == 9);
   CHECK(frame->ack_block_section()->first_ack_block() == 1);
   CHECK(frame->ack_block_section()->begin()->gap() == 0);
+  ack_frame->~QUICFrame();
 
   ack_manager.on_frame_lost(frame->id());
-  CHECK(ack_manager.will_generate_frame(level, 0) == true);
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 2);
   CHECK(frame->largest_acknowledged() == 9);
   CHECK(frame->ack_block_section()->first_ack_block() == 1);
   CHECK(frame->ack_block_section()->begin()->gap() == 0);
+  ack_frame->~QUICFrame();
 
-  CHECK(ack_manager.will_generate_frame(level, 0) == false);
+  CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
   ack_manager.on_frame_lost(frame->id());
-  CHECK(ack_manager.will_generate_frame(level, 0) == true);
+  CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
   ack_manager.update(level, 7, 1, false);
   ack_manager.update(level, 4, 1, false);
 
-  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+  ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
   frame     = static_cast<QUICAckFrame *>(ack_frame);
   CHECK(frame != nullptr);
   CHECK(frame->ack_block_count() == 1);
   CHECK(frame->largest_acknowledged() == 9);
   CHECK(frame->ack_block_section()->first_ack_block() == 5);
   CHECK(frame->ack_block_section()->begin()->gap() == 0);
+  ack_frame->~QUICFrame();
 
-  CHECK(ack_manager.will_generate_frame(level, 0) == false);
+  CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
 }
 
 TEST_CASE("QUICAckFrameManager ack only packet", "[quic]")
@@ -350,7 +361,7 @@
     uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
 
     // Initial state
-    QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+    QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
     QUICAckFrame *frame  = static_cast<QUICAckFrame *>(ack_frame);
     CHECK(frame == nullptr);
 
@@ -360,19 +371,20 @@
     ack_manager.update(level, 4, 1, false);
     ack_manager.update(level, 5, 1, false);
 
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
 
-    ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+    ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
     frame     = static_cast<QUICAckFrame *>(ack_frame);
     CHECK(frame != nullptr);
     CHECK(frame->ack_block_count() == 0);
     CHECK(frame->largest_acknowledged() == 5);
     CHECK(frame->ack_block_section()->first_ack_block() == 4);
     CHECK(frame->ack_block_section()->begin()->gap() == 0);
+    ack_frame->~QUICFrame();
 
     ack_manager.update(level, 6, 1, true);
     ack_manager.update(level, 7, 1, true);
-    CHECK(ack_manager.will_generate_frame(level, 0) == false);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
   }
 
   SECTION("ONE_RTT")
@@ -382,7 +394,7 @@
     uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
 
     // Initial state
-    QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+    QUICFrame *ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
     QUICAckFrame *frame  = static_cast<QUICAckFrame *>(ack_frame);
     CHECK(frame == nullptr);
 
@@ -392,18 +404,19 @@
     ack_manager.update(level, 4, 1, false);
     ack_manager.update(level, 5, 1, false);
 
-    CHECK(ack_manager.will_generate_frame(level, 0) == true);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == true);
 
-    ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0);
+    ack_frame = ack_manager.generate_frame(frame_buf, level, UINT16_MAX, UINT16_MAX, 0, 0);
     frame     = static_cast<QUICAckFrame *>(ack_frame);
     CHECK(frame != nullptr);
     CHECK(frame->ack_block_count() == 0);
     CHECK(frame->largest_acknowledged() == 5);
     CHECK(frame->ack_block_section()->first_ack_block() == 4);
     CHECK(frame->ack_block_section()->begin()->gap() == 0);
+    ack_frame->~QUICFrame();
 
     ack_manager.update(level, 6, 1, true);
     ack_manager.update(level, 7, 1, true);
-    CHECK(ack_manager.will_generate_frame(level, 0) == false);
+    CHECK(ack_manager.will_generate_frame(level, 0, true, 0) == false);
   }
 }
diff --git a/iocore/net/quic/test/test_QUICAltConnectionManager.cc b/iocore/net/quic/test/test_QUICAltConnectionManager.cc
index d30da7b..298f21b 100644
--- a/iocore/net/quic/test/test_QUICAltConnectionManager.cc
+++ b/iocore/net/quic/test/test_QUICAltConnectionManager.cc
@@ -58,6 +58,7 @@
     CHECK(memcmp(pref_addr->endpoint_ipv6().sin6.sin6_addr.s6_addr, ipv6_addr.s6_addr, 16) == 0);
     CHECK(pref_addr->cid() == cid55);
     CHECK(memcmp(pref_addr->token().buf(), buf + 26, 16) == 0);
+    delete pref_addr;
   }
 
   SECTION("store")
@@ -85,6 +86,7 @@
     pref_addr->store(actual, len);
     CHECK(sizeof(buf) == len);
     CHECK(memcmp(buf, actual, sizeof(buf)) == 0);
+    delete pref_addr;
   }
 
   SECTION("unavailable")
@@ -93,5 +95,6 @@
     CHECK(!pref_addr->is_available());
     CHECK(!pref_addr->has_ipv4());
     CHECK(!pref_addr->has_ipv6());
+    delete pref_addr;
   }
 }
diff --git a/iocore/net/quic/test/test_QUICFlowController.cc b/iocore/net/quic/test/test_QUICFlowController.cc
index d58a311..61bb652 100644
--- a/iocore/net/quic/test/test_QUICFlowController.cc
+++ b/iocore/net/quic/test/test_QUICFlowController.cc
@@ -116,7 +116,7 @@
   fc.forward_limit(2048);
   CHECK(fc.current_offset() == 1024);
   CHECK(fc.current_limit() == 2048);
-  QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0);
+  QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0, 0);
   CHECK(frame);
   CHECK(frame->type() == QUICFrameType::MAX_DATA);
 
@@ -168,7 +168,7 @@
   CHECK(fc.current_offset() == 1000);
   CHECK(fc.current_limit() == 1024);
   CHECK(ret != 0);
-  QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0);
+  QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0, 0);
   CHECK(frame);
   CHECK(frame->type() == QUICFrameType::DATA_BLOCKED);
 
@@ -199,9 +199,9 @@
   CHECK(fc.current_limit() == 1024);
   CHECK(ret == 0);
 
-  CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0));
+  CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0, true, 0));
   // if there're anything to send
-  QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0);
+  QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0, 0);
   CHECK(frame);
   CHECK(frame->type() == QUICFrameType::DATA_BLOCKED);
 
@@ -265,7 +265,7 @@
   fc.forward_limit(2048);
   CHECK(fc.current_offset() == 1024);
   CHECK(fc.current_limit() == 2048);
-  QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0);
+  QUICFrame *frame = fc.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 0, 1024, 0, 0);
   CHECK(frame);
   CHECK(frame->type() == QUICFrameType::MAX_STREAM_DATA);
 
@@ -306,7 +306,7 @@
   CHECK(ret == 0);
 
   CHECK(fc.credit() == 0);
-  CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0));
+  CHECK(fc.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0, true, 0));
 
   // Delay
   ret = fc.update(512);
@@ -342,23 +342,23 @@
     QUICRemoteConnectionFlowController fc(1024);
 
     // Check initial state
-    auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     CHECK(!frame);
 
     ret = fc.update(1024);
     CHECK(ret == 0);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 1024);
     QUICFrameId id = frame->id();
 
     // Don't retransmit unless the frame is lost
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(!frame);
 
     // Retransmit
     fc.on_frame_lost(id);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 1024);
 
@@ -366,12 +366,12 @@
     fc.on_frame_lost(frame->id());
     fc.forward_limit(2048);
     ret   = fc.update(1536);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     CHECK(!frame);
 
     // This should not be retransmition
     ret   = fc.update(2048);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICDataBlockedFrame *>(frame)->offset() == 2048);
   }
@@ -383,23 +383,23 @@
     QUICRemoteStreamFlowController fc(1024, 0);
 
     // Check initial state
-    auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     CHECK(!frame);
 
     ret = fc.update(1024);
     CHECK(ret == 0);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 1024);
     QUICFrameId id = frame->id();
 
     // Don't retransmit unless the frame is lost
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(!frame);
 
     // Retransmit
     fc.on_frame_lost(id);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 1024);
 
@@ -407,12 +407,12 @@
     fc.on_frame_lost(frame->id());
     fc.forward_limit(2048);
     ret   = fc.update(1536);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     CHECK(!frame);
 
     // This should not be retransmition
     ret   = fc.update(2048);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICStreamDataBlockedFrame *>(frame)->offset() == 2048);
   }
@@ -424,23 +424,23 @@
     QUICLocalConnectionFlowController fc(&rp, 1024);
 
     // Check initial state
-    auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     CHECK(!frame);
 
     fc.update(1024);
     fc.forward_limit(1024);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 1024);
     QUICFrameId id = frame->id();
 
     // Don't retransmit unless the frame is lost
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(!frame);
 
     // Retransmit
     fc.on_frame_lost(id);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 1024);
 
@@ -448,7 +448,7 @@
     fc.on_frame_lost(id);
     fc.forward_limit(2048);
     fc.update(2048);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICMaxDataFrame *>(frame)->maximum_data() == 2048);
   }
@@ -460,23 +460,23 @@
     QUICLocalStreamFlowController fc(&rp, 1024, 0);
 
     // Check initial state
-    auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    auto frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     CHECK(!frame);
 
     fc.update(1024);
     fc.forward_limit(1024);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data() == 1024);
     QUICFrameId id = frame->id();
 
     // Don't retransmit unless the frame is lost
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(!frame);
 
     // Retransmit
     fc.on_frame_lost(id);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data() == 1024);
 
@@ -484,7 +484,7 @@
     fc.on_frame_lost(id);
     fc.forward_limit(2048);
     fc.update(2048);
-    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0);
+    frame = fc.generate_frame(frame_buf, level, 1024, 1024, 0, 0);
     REQUIRE(frame);
     CHECK(static_cast<QUICMaxStreamDataFrame *>(frame)->maximum_stream_data() == 2048);
   }
diff --git a/iocore/net/quic/test/test_QUICFrame.cc b/iocore/net/quic/test/test_QUICFrame.cc
index a8f81fd..58f68e4 100644
--- a/iocore/net/quic/test/test_QUICFrame.cc
+++ b/iocore/net/quic/test/test_QUICFrame.cc
@@ -84,7 +84,7 @@
       0x01,                   // Stream ID
       0x01, 0x02, 0x03, 0x04, // Stream Data
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAM);
     CHECK(frame1->size() == 6);
     const QUICStreamFrame *stream_frame = static_cast<const QUICStreamFrame *>(frame1);
@@ -103,7 +103,7 @@
       0x05,                         // Data Length
       0x01, 0x02, 0x03, 0x04, 0x05, // Stream Data
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAM);
     CHECK(frame1->size() == 8);
     const QUICStreamFrame *stream_frame = static_cast<const QUICStreamFrame *>(frame1);
@@ -123,7 +123,7 @@
       0x05,                         // Data Length
       0x01, 0x02, 0x03, 0x04, 0x05, // Stream Data
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAM);
     CHECK(frame1->size() == 9);
 
@@ -144,7 +144,7 @@
       0x05,                         // Data Length
       0x01, 0x02, 0x03, 0x04, 0x05, // Stream Data
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAM);
     CHECK(frame1->size() == 9);
 
@@ -165,7 +165,7 @@
       0x05,                   // Data Length
       0x01, 0x02, 0x03, 0x04, // BAD Stream Data
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAM);
     CHECK(frame1->valid() == false);
   }
@@ -176,7 +176,7 @@
       0x0e, // 0b00001OLF (OLF=110)
       0x01, // Stream ID
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAM);
     CHECK(frame1->valid() == false);
   }
@@ -428,7 +428,7 @@
       0x05,                         // Length
       0x01, 0x02, 0x03, 0x04, 0x05, // Crypto Data
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::CRYPTO);
     CHECK(frame->size() == sizeof(buf));
 
@@ -444,15 +444,15 @@
       0x06,                   // Type
       0x80, 0x01, 0x00, 0x00, // Offset
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::CRYPTO);
     CHECK(frame->valid() == false);
   }
 
   SECTION("Storing")
   {
-    uint8_t buf[32] = {0};
-    size_t len;
+    uint8_t buf[32]    = {0};
+    size_t len         = 0;
     uint8_t expected[] = {
       0x06,                         // Typr
       0x80, 0x01, 0x00, 0x00,       // Offset
@@ -468,7 +468,11 @@
     QUICCryptoFrame crypto_frame(block, 0x010000);
     CHECK(crypto_frame.size() == sizeof(expected));
 
-    crypto_frame.store(buf, &len, 32);
+    Ptr<IOBufferBlock> ibb = crypto_frame.to_io_buffer_block(sizeof(buf));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(buf + len, b->start(), b->size());
+      len += b->size();
+    }
     CHECK(len == sizeof(expected));
     CHECK(memcmp(buf, expected, sizeof(expected)) == 0);
   }
@@ -486,7 +490,7 @@
       0x00,       // Ack Block Count
       0x00,       // Ack Block Section
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::ACK);
     CHECK(frame1->size() == 6);
     const QUICAckFrame *ack_frame1 = static_cast<const QUICAckFrame *>(frame1);
@@ -494,6 +498,7 @@
     CHECK(ack_frame1->ack_block_count() == 0);
     CHECK(ack_frame1->largest_acknowledged() == 0x12);
     CHECK(ack_frame1->ack_delay() == 0x3456);
+    frame1->~QUICFrame();
   }
 
   SECTION("0 Ack Block, 8 bit packet number length, 8 bit block length")
@@ -505,7 +510,7 @@
       0x00,                   // Ack Block Count
       0x80, 0x00, 0x00, 0x01, // Ack Block Section (First ACK Block Length)
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::ACK);
     CHECK(frame1->size() == 12);
 
@@ -518,6 +523,7 @@
 
     const QUICAckFrame::AckBlockSection *section = ack_frame1->ack_block_section();
     CHECK(section->first_ack_block() == 0x01);
+    frame1->~QUICFrame();
   }
 
   SECTION("2 Ack Block, 8 bit packet number length, 8 bit block length")
@@ -534,7 +540,7 @@
       0xc9, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, // Ack Block Section (ACK Block 2 Length)
     };
 
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::ACK);
     CHECK(frame1->size() == 21);
     const QUICAckFrame *ack_frame1 = static_cast<const QUICAckFrame *>(frame1);
@@ -556,6 +562,7 @@
     CHECK(ite->length() == 0x090a0b0c0d0e0f10);
     ++ite;
     CHECK(ite == section->end());
+    frame1->~QUICFrame();
   }
 
   SECTION("load bad frame")
@@ -565,9 +572,10 @@
       0x12, // Largest Acknowledged
     };
 
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::ACK);
     CHECK(frame1->valid() == false);
+    frame1->~QUICFrame();
   }
 
   SECTION("load bad block")
@@ -583,9 +591,10 @@
       0x85, 0x06, 0x07, 0x08, // Ack Block Section (Gap 2)
     };
 
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::ACK);
     CHECK(frame1->valid() == false);
+    frame1->~QUICFrame();
   }
 
   SECTION("0 Ack Block, 8 bit packet number length, 8 bit block length with ECN section")
@@ -601,7 +610,7 @@
       0x02, // ECT1
       0x03, // ECN-CE
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::ACK);
     CHECK(frame1->size() == 9);
     const QUICAckFrame *ack_frame1 = static_cast<const QUICAckFrame *>(frame1);
@@ -613,6 +622,7 @@
     CHECK(ack_frame1->ecn_section()->ect0_count() == 1);
     CHECK(ack_frame1->ecn_section()->ect1_count() == 2);
     CHECK(ack_frame1->ecn_section()->ecn_ce_count() == 3);
+    frame1->~QUICFrame();
   }
 
   SECTION("0 Ack Block, 8 bit packet number length, 8 bit block length with ECN section")
@@ -627,9 +637,10 @@
       0x01, // ECT0
       0x02, // ECT1
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::ACK);
     CHECK(frame1->valid() == false);
+    frame1->~QUICFrame();
   }
 }
 
@@ -638,7 +649,7 @@
   SECTION("0 Ack Block, 8 bit packet number length, 8 bit block length")
   {
     uint8_t buf[32] = {0};
-    size_t len;
+    size_t len      = 0;
 
     uint8_t expected[] = {
       0x02,       // Type
@@ -651,7 +662,11 @@
     QUICAckFrame ack_frame(0x12, 0x3456, 0);
     CHECK(ack_frame.size() == 6);
 
-    ack_frame.store(buf, &len, 32);
+    Ptr<IOBufferBlock> ibb = ack_frame.to_io_buffer_block(sizeof(buf));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(buf + len, b->start(), b->size());
+      len += b->size();
+    }
     CHECK(len == 6);
     CHECK(memcmp(buf, expected, len) == 0);
   }
@@ -659,7 +674,7 @@
   SECTION("2 Ack Block, 8 bit packet number length, 8 bit block length")
   {
     uint8_t buf[32] = {0};
-    size_t len;
+    size_t len      = 0;
 
     uint8_t expected[] = {
       0x02,                                           // Type
@@ -678,7 +693,11 @@
     section->add_ack_block({0x05060708, 0x090a0b0c0d0e0f10});
     CHECK(ack_frame.size() == 21);
 
-    ack_frame.store(buf, &len, 32);
+    Ptr<IOBufferBlock> ibb = ack_frame.to_io_buffer_block(sizeof(buf));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(buf + len, b->start(), b->size());
+      len += b->size();
+    }
     CHECK(len == 21);
     CHECK(memcmp(buf, expected, len) == 0);
   }
@@ -692,12 +711,12 @@
     uint8_t buf1[] = {
       0x04,                                          // Type
       0x92, 0x34, 0x56, 0x78,                        // Stream ID
-      0x00, 0x01,                                    // Error Code
+      0x01,                                          // Error Code
       0xd1, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 // Final Offset
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::RESET_STREAM);
-    CHECK(frame1->size() == 15);
+    CHECK(frame1->size() == 14);
     const QUICRstStreamFrame *rst_stream_frame1 = static_cast<const QUICRstStreamFrame *>(frame1);
     CHECK(rst_stream_frame1 != nullptr);
     CHECK(rst_stream_frame1->error_code() == 0x0001);
@@ -710,9 +729,9 @@
     uint8_t buf1[] = {
       0x04,                   // Type
       0x92, 0x34, 0x56, 0x78, // Stream ID
-      0x00, 0x01,             // Error Code
+      0x01,                   // Error Code
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::RESET_STREAM);
     CHECK(frame1->valid() == false);
   }
@@ -721,19 +740,23 @@
 TEST_CASE("Store RESET_STREAM Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x04,                                          // Type
     0x92, 0x34, 0x56, 0x78,                        // Stream ID
-    0x00, 0x01,                                    // Error Code
+    0x01,                                          // Error Code
     0xd1, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 // Final Offset
   };
   QUICRstStreamFrame rst_stream_frame(0x12345678, 0x0001, 0x1122334455667788);
-  CHECK(rst_stream_frame.size() == 15);
+  CHECK(rst_stream_frame.size() == 14);
 
-  rst_stream_frame.store(buf, &len, 65535);
-  CHECK(len == 15);
+  Ptr<IOBufferBlock> ibb = rst_stream_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
+  CHECK(len == 14);
   CHECK(memcmp(buf, expected, len) == 0);
 }
 
@@ -743,7 +766,7 @@
   uint8_t buf[] = {
     0x01, // Type
   };
-  const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+  const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
   CHECK(frame->type() == QUICFrameType::PING);
   CHECK(frame->size() == 1);
 
@@ -754,7 +777,7 @@
 TEST_CASE("Store Ping Frame", "[quic]")
 {
   uint8_t buf[16];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x01, // Type
@@ -763,7 +786,11 @@
   QUICPingFrame frame;
   CHECK(frame.size() == 1);
 
-  frame.store(buf, &len, 16);
+  Ptr<IOBufferBlock> ibb = frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 1);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -772,11 +799,11 @@
 {
   uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
   uint8_t buf1[] = {
-    0x00, // Type
+    0x00, 0x00, 0x00 // Type
   };
-  const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+  const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
   CHECK(frame1->type() == QUICFrameType::PADDING);
-  CHECK(frame1->size() == 1);
+  CHECK(frame1->size() == 3);
   const QUICPaddingFrame *paddingFrame1 = static_cast<const QUICPaddingFrame *>(frame1);
   CHECK(paddingFrame1 != nullptr);
 }
@@ -784,14 +811,18 @@
 TEST_CASE("Store Padding Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
-    0x00, // Type
+    0x00, 0x00, 0x00, // Type
   };
-  QUICPaddingFrame padding_frame;
-  padding_frame.store(buf, &len, 65535);
-  CHECK(len == 1);
+  QUICPaddingFrame padding_frame(3);
+  Ptr<IOBufferBlock> ibb = padding_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
+  CHECK(len == 3);
   CHECK(memcmp(buf, expected, len) == 0);
 }
 
@@ -805,13 +836,13 @@
   {
     uint8_t buf[] = {
       0x1c,                        // Type
-      0x00, 0x0A,                  // Error Code
+      0x0A,                        // Error Code
       0x00,                        // Frame Type
       0x05,                        // Reason Phrase Length
       0x41, 0x42, 0x43, 0x44, 0x45 // Reason Phrase ("ABCDE");
     };
 
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::CONNECTION_CLOSE);
     CHECK(frame->size() == sizeof(buf));
 
@@ -826,13 +857,13 @@
   SECTION("Bad loading")
   {
     uint8_t buf[] = {
-      0x1c,       // Type
-      0x00, 0x0A, // Error Code
-      0x00,       // Frame Type
-      0x05,       // Reason Phrase Length
+      0x1c, // Type
+      0x0A, // Error Code
+      0x00, // Frame Type
+      0x05, // Reason Phrase Length
     };
 
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::CONNECTION_CLOSE);
     CHECK(frame->valid() == false);
   }
@@ -840,12 +871,12 @@
   SECTION("loading w/o reason phrase")
   {
     uint8_t buf[] = {
-      0x1c,       // Type
-      0x00, 0x0A, // Error Code
-      0x04,       // Frame Type
-      0x00,       // Reason Phrase Length
+      0x1c, // Type
+      0x0A, // Error Code
+      0x04, // Frame Type
+      0x00, // Reason Phrase Length
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::CONNECTION_CLOSE);
     CHECK(frame->size() == sizeof(buf));
 
@@ -859,11 +890,11 @@
   SECTION("storing w/ reason phrase")
   {
     uint8_t buf[32];
-    size_t len;
+    size_t len = 0;
 
     uint8_t expected[] = {
       0x1c,                        // Type
-      0x00, 0x0A,                  // Error Code
+      0x0A,                        // Error Code
       0x08,                        // Frame Type
       0x05,                        // Reason Phrase Length
       0x41, 0x42, 0x43, 0x44, 0x45 // Reason Phrase ("ABCDE");
@@ -872,7 +903,11 @@
                                                     QUICFrameType::STREAM, 5, "ABCDE");
     CHECK(connection_close_frame.size() == sizeof(expected));
 
-    connection_close_frame.store(buf, &len, 32);
+    Ptr<IOBufferBlock> ibb = connection_close_frame.to_io_buffer_block(sizeof(buf));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(buf + len, b->start(), b->size());
+      len += b->size();
+    }
     CHECK(len == sizeof(expected));
     CHECK(memcmp(buf, expected, len) == 0);
   }
@@ -880,17 +915,21 @@
   SECTION("storing w/o reason phrase")
   {
     uint8_t buf[32];
-    size_t len;
+    size_t len = 0;
 
     uint8_t expected[] = {
-      0x1c,       // Type
-      0x00, 0x0A, // Error Code
-      0x00,       // Frame Type
-      0x00,       // Reason Phrase Length
+      0x1c, // Type
+      0x0A, // Error Code
+      0x00, // Frame Type
+      0x00, // Reason Phrase Length
     };
     QUICConnectionCloseFrame connection_close_frame(static_cast<uint16_t>(QUICTransErrorCode::PROTOCOL_VIOLATION),
                                                     QUICFrameType::UNKNOWN, 0, nullptr);
-    connection_close_frame.store(buf, &len, 32);
+    Ptr<IOBufferBlock> ibb = connection_close_frame.to_io_buffer_block(sizeof(buf));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(buf + len, b->start(), b->size());
+      len += b->size();
+    }
     CHECK(len == sizeof(expected));
     CHECK(memcmp(buf, expected, len) == 0);
   }
@@ -905,7 +944,7 @@
       0x10,                                          // Type
       0xd1, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 // Maximum Data
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::MAX_DATA);
     CHECK(frame1->size() == 9);
     const QUICMaxDataFrame *max_data_frame = static_cast<const QUICMaxDataFrame *>(frame1);
@@ -918,7 +957,7 @@
     uint8_t buf1[] = {
       0x10, // Type
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::MAX_DATA);
     CHECK(frame1->valid() == false);
   }
@@ -927,7 +966,7 @@
 TEST_CASE("Store MaxData Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x10,                                          // Type
@@ -936,7 +975,11 @@
   QUICMaxDataFrame max_data_frame(0x1122334455667788, 0, nullptr);
   CHECK(max_data_frame.size() == 9);
 
-  max_data_frame.store(buf, &len, 65535);
+  Ptr<IOBufferBlock> ibb = max_data_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 9);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -951,7 +994,7 @@
       0x81, 0x02, 0x03, 0x04,                        // Stream ID
       0xd1, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 // Maximum Stream Data
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::MAX_STREAM_DATA);
     CHECK(frame1->size() == 13);
     const QUICMaxStreamDataFrame *maxStreamDataFrame1 = static_cast<const QUICMaxStreamDataFrame *>(frame1);
@@ -966,7 +1009,7 @@
       0x11,                   // Type
       0x81, 0x02, 0x03, 0x04, // Stream ID
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::MAX_STREAM_DATA);
     CHECK(frame1->valid() == false);
   }
@@ -975,7 +1018,7 @@
 TEST_CASE("Store MaxStreamData Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x11,                                          // Type
@@ -985,7 +1028,11 @@
   QUICMaxStreamDataFrame max_stream_data_frame(0x01020304, 0x1122334455667788ULL);
   CHECK(max_stream_data_frame.size() == 13);
 
-  max_stream_data_frame.store(buf, &len, 65535);
+  Ptr<IOBufferBlock> ibb = max_stream_data_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 13);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -999,7 +1046,7 @@
       0x12,                   // Type
       0x81, 0x02, 0x03, 0x04, // Stream ID
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::MAX_STREAMS);
     CHECK(frame1->size() == 5);
     const QUICMaxStreamsFrame *max_streams_frame = static_cast<const QUICMaxStreamsFrame *>(frame1);
@@ -1011,7 +1058,7 @@
     uint8_t buf1[] = {
       0x12, // Type
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::MAX_STREAMS);
     CHECK(frame1->valid() == false);
   }
@@ -1020,7 +1067,7 @@
 TEST_CASE("Store MaxStreams Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x12,                   // Type
@@ -1029,7 +1076,11 @@
   QUICMaxStreamsFrame max_streams_frame(0x01020304, 0, nullptr);
   CHECK(max_streams_frame.size() == 5);
 
-  max_streams_frame.store(buf, &len, 65535);
+  Ptr<IOBufferBlock> ibb = max_streams_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 5);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -1043,7 +1094,7 @@
       0x14, // Type
       0x07, // Offset
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::DATA_BLOCKED);
     CHECK(frame1->size() == 2);
     const QUICDataBlockedFrame *blocked_stream_frame = static_cast<const QUICDataBlockedFrame *>(frame1);
@@ -1056,7 +1107,7 @@
     uint8_t buf1[] = {
       0x14, // Type
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::DATA_BLOCKED);
     CHECK(frame1->valid() == false);
   }
@@ -1065,7 +1116,7 @@
 TEST_CASE("Store DataBlocked Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x14, // Type
@@ -1074,7 +1125,11 @@
   QUICDataBlockedFrame blocked_stream_frame(0x07, 0, nullptr);
   CHECK(blocked_stream_frame.size() == 2);
 
-  blocked_stream_frame.store(buf, &len, 65535);
+  Ptr<IOBufferBlock> ibb = blocked_stream_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 2);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -1089,7 +1144,7 @@
       0x81, 0x02, 0x03, 0x04, // Stream ID
       0x07,                   // Offset
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAM_DATA_BLOCKED);
     CHECK(frame1->size() == 6);
     const QUICStreamDataBlockedFrame *stream_blocked_frame = static_cast<const QUICStreamDataBlockedFrame *>(frame1);
@@ -1104,7 +1159,7 @@
       0x15,                   // Type
       0x81, 0x02, 0x03, 0x04, // Stream ID
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAM_DATA_BLOCKED);
     CHECK(frame1->valid() == false);
   }
@@ -1113,7 +1168,7 @@
 TEST_CASE("Store StreamDataBlocked Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x15,                   // Type
@@ -1123,7 +1178,11 @@
   QUICStreamDataBlockedFrame stream_blocked_frame(0x01020304, 0x07);
   CHECK(stream_blocked_frame.size() == 6);
 
-  stream_blocked_frame.store(buf, &len, 65535);
+  Ptr<IOBufferBlock> ibb = stream_blocked_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 6);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -1137,7 +1196,7 @@
       0x16,       // Type
       0x41, 0x02, // Stream ID
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAMS_BLOCKED);
     CHECK(frame1->size() == 3);
     const QUICStreamIdBlockedFrame *stream_id_blocked_frame = static_cast<const QUICStreamIdBlockedFrame *>(frame1);
@@ -1150,7 +1209,7 @@
     uint8_t buf1[] = {
       0x16, // Type
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
     CHECK(frame1->type() == QUICFrameType::STREAMS_BLOCKED);
     CHECK(frame1->valid() == false);
   }
@@ -1159,7 +1218,7 @@
 TEST_CASE("Store StreamsBlocked Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x16,       // Type
@@ -1168,7 +1227,11 @@
   QUICStreamIdBlockedFrame stream_id_blocked_frame(0x0102, 0, nullptr);
   CHECK(stream_id_blocked_frame.size() == 3);
 
-  stream_id_blocked_frame.store(buf, &len, 65535);
+  Ptr<IOBufferBlock> ibb = stream_id_blocked_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 3);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -1176,61 +1239,74 @@
 TEST_CASE("Load NewConnectionId Frame", "[quic]")
 {
   uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
+
   SECTION("load")
   {
-    uint8_t buf1[] = {
+    uint8_t buf[] = {
       0x18,                                           // Type
       0x41, 0x02,                                     // Sequence
+      0x41, 0x00,                                     // Retire Prior To
       0x08,                                           // Length
       0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, // Connection ID
       0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, // Stateless Reset Token
       0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
-    CHECK(frame1->type() == QUICFrameType::NEW_CONNECTION_ID);
-    CHECK(frame1->size() == 28);
-    const QUICNewConnectionIdFrame *new_con_id_frame = static_cast<const QUICNewConnectionIdFrame *>(frame1);
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
+    CHECK(frame->type() == QUICFrameType::NEW_CONNECTION_ID);
+    CHECK(frame->size() == sizeof(buf));
+    CHECK(frame->valid() == true);
+
+    const QUICNewConnectionIdFrame *new_con_id_frame = static_cast<const QUICNewConnectionIdFrame *>(frame);
     CHECK(new_con_id_frame != nullptr);
     CHECK(new_con_id_frame->sequence() == 0x0102);
+    CHECK(new_con_id_frame->retire_prior_to() == 0x0100);
     CHECK((new_con_id_frame->connection_id() ==
            QUICConnectionId(reinterpret_cast<const uint8_t *>("\x11\x22\x33\x44\x55\x66\x77\x88"), 8)));
-    CHECK(memcmp(new_con_id_frame->stateless_reset_token().buf(), buf1 + 12, 16) == 0);
+    CHECK(memcmp(new_con_id_frame->stateless_reset_token().buf(), buf + sizeof(buf) - QUICStatelessResetToken::LEN,
+                 QUICStatelessResetToken::LEN) == 0);
   }
 
   SECTION("Bad Load")
   {
-    uint8_t buf1[] = {
+    uint8_t buf[] = {
       0x18,                                           // Type
       0x41, 0x02,                                     // Sequence
+      0x41, 0x00,                                     // Retire Prior To
       0x08,                                           // Length
       0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, // Connection ID
       0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, // Stateless Reset Token
     };
-    const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
-    CHECK(frame1->type() == QUICFrameType::NEW_CONNECTION_ID);
-    CHECK(frame1->valid() == false);
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
+    CHECK(frame->type() == QUICFrameType::NEW_CONNECTION_ID);
+    CHECK(frame->valid() == false);
   }
 }
 
 TEST_CASE("Store NewConnectionId Frame", "[quic]")
 {
   uint8_t buf[32];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x18,                                           // Type
-    0x41, 0x02,                                     // Sequence
+    0x41, 0x02,                                     // Sequence Number
+    0x41, 0x00,                                     // Retire Prior To
     0x08,                                           // Length
     0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, // Connection ID
     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, // Stateless Reset Token
     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
   };
-  QUICNewConnectionIdFrame new_con_id_frame(0x0102, {reinterpret_cast<const uint8_t *>("\x11\x22\x33\x44\x55\x66\x77\x88"), 8},
-                                            {expected + 12});
-  CHECK(new_con_id_frame.size() == 28);
+  QUICNewConnectionIdFrame new_con_id_frame(0x0102, 0x0100,
+                                            {reinterpret_cast<const uint8_t *>("\x11\x22\x33\x44\x55\x66\x77\x88"), 8},
+                                            {expected + sizeof(expected) - QUICStatelessResetToken::LEN});
+  CHECK(new_con_id_frame.size() == sizeof(expected));
 
-  new_con_id_frame.store(buf, &len, 32);
-  CHECK(len == 28);
+  Ptr<IOBufferBlock> ibb = new_con_id_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
+  CHECK(len == sizeof(expected));
   CHECK(memcmp(buf, expected, len) == 0);
 }
 
@@ -1242,16 +1318,16 @@
     uint8_t buf[] = {
       0x05,                   // Type
       0x92, 0x34, 0x56, 0x78, // Stream ID
-      0x00, 0x01,             // Error Code
+      0x01,                   // Error Code
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::STOP_SENDING);
-    CHECK(frame->size() == 7);
+    CHECK(frame->size() == 6);
 
     const QUICStopSendingFrame *stop_sending_frame = static_cast<const QUICStopSendingFrame *>(frame);
     CHECK(stop_sending_frame != nullptr);
     CHECK(stop_sending_frame->stream_id() == 0x12345678);
-    CHECK(stop_sending_frame->error_code() == 0x0001);
+    CHECK(stop_sending_frame->error_code() == 0x01);
   }
 
   SECTION("Bad LOAD")
@@ -1260,7 +1336,7 @@
       0x05,                   // Type
       0x92, 0x34, 0x56, 0x78, // Stream ID
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::STOP_SENDING);
     CHECK(frame->valid() == false);
   }
@@ -1269,18 +1345,22 @@
 TEST_CASE("Store STOP_SENDING Frame", "[quic]")
 {
   uint8_t buf[65535];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x05,                   // Type
     0x92, 0x34, 0x56, 0x78, // Stream ID
-    0x00, 0x01,             // Error Code
+    0x01,                   // Error Code
   };
   QUICStopSendingFrame stop_sending_frame(0x12345678, static_cast<QUICAppErrorCode>(0x01));
-  CHECK(stop_sending_frame.size() == 7);
+  CHECK(stop_sending_frame.size() == 6);
 
-  stop_sending_frame.store(buf, &len, 65535);
-  CHECK(len == 7);
+  Ptr<IOBufferBlock> ibb = stop_sending_frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
+  CHECK(len == 6);
   CHECK(memcmp(buf, expected, len) == 0);
 }
 
@@ -1293,13 +1373,14 @@
       0x1a,                                           // Type
       0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, // Data
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::PATH_CHALLENGE);
     CHECK(frame->size() == 9);
 
     const QUICPathChallengeFrame *path_challenge_frame = static_cast<const QUICPathChallengeFrame *>(frame);
     CHECK(path_challenge_frame != nullptr);
     CHECK(memcmp(path_challenge_frame->data(), "\x01\x23\x45\x67\x89\xab\xcd\xef", QUICPathChallengeFrame::DATA_LEN) == 0);
+    frame->~QUICFrame();
   }
 
   SECTION("Load")
@@ -1308,16 +1389,17 @@
       0x1a,                                     // Type
       0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xef, // Data
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::PATH_CHALLENGE);
     CHECK(frame->valid() == false);
+    frame->~QUICFrame();
   }
 }
 
 TEST_CASE("Store PATH_CHALLENGE Frame", "[quic]")
 {
   uint8_t buf[16];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x1a,                                           // Type
@@ -1332,7 +1414,11 @@
   QUICPathChallengeFrame frame(std::move(data));
   CHECK(frame.size() == 9);
 
-  frame.store(buf, &len, 16);
+  Ptr<IOBufferBlock> ibb = frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 9);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -1346,13 +1432,14 @@
       0x1b,                                           // Type
       0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, // Data
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::PATH_RESPONSE);
     CHECK(frame->size() == 9);
 
     const QUICPathResponseFrame *path_response_frame = static_cast<const QUICPathResponseFrame *>(frame);
     CHECK(path_response_frame != nullptr);
     CHECK(memcmp(path_response_frame->data(), "\x01\x23\x45\x67\x89\xab\xcd\xef", QUICPathResponseFrame::DATA_LEN) == 0);
+    frame->~QUICFrame();
   }
 
   SECTION("Load")
@@ -1361,16 +1448,17 @@
       0x1b,                                     // Type
       0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, // Data
     };
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf));
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, buf, sizeof(buf), nullptr);
     CHECK(frame->type() == QUICFrameType::PATH_RESPONSE);
     CHECK(frame->valid() == false);
+    frame->~QUICFrame();
   }
 }
 
 TEST_CASE("Store PATH_RESPONSE Frame", "[quic]")
 {
   uint8_t buf[16];
-  size_t len;
+  size_t len = 0;
 
   uint8_t expected[] = {
     0x1b,                                           // Type
@@ -1385,7 +1473,11 @@
   QUICPathResponseFrame frame(std::move(data));
   CHECK(frame.size() == 9);
 
-  frame.store(buf, &len, 16);
+  Ptr<IOBufferBlock> ibb = frame.to_io_buffer_block(sizeof(buf));
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
   CHECK(len == 9);
   CHECK(memcmp(buf, expected, len) == 0);
 }
@@ -1405,7 +1497,7 @@
 
   SECTION("load")
   {
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, raw_new_token_frame, raw_new_token_frame_len);
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, raw_new_token_frame, raw_new_token_frame_len, nullptr);
     CHECK(frame->type() == QUICFrameType::NEW_TOKEN);
     CHECK(frame->size() == raw_new_token_frame_len);
 
@@ -1413,19 +1505,21 @@
     CHECK(new_token_frame != nullptr);
     CHECK(new_token_frame->token_length() == raw_token_len);
     CHECK(memcmp(new_token_frame->token(), raw_token, raw_token_len) == 0);
+    frame->~QUICFrame();
   }
 
   SECTION("bad load")
   {
-    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, raw_new_token_frame, raw_new_token_frame_len - 5);
+    const QUICFrame *frame = QUICFrameFactory::create(frame_buf, raw_new_token_frame, raw_new_token_frame_len - 5, nullptr);
     CHECK(frame->type() == QUICFrameType::NEW_TOKEN);
     CHECK(frame->valid() == false);
+    frame->~QUICFrame();
   }
 
   SECTION("store")
   {
     uint8_t buf[32];
-    size_t len;
+    size_t len = 0;
 
     ats_unique_buf token = ats_unique_malloc(raw_token_len);
     memcpy(token.get(), raw_token, raw_token_len);
@@ -1433,7 +1527,11 @@
     QUICNewTokenFrame frame(std::move(token), raw_token_len);
     CHECK(frame.size() == raw_new_token_frame_len);
 
-    frame.store(buf, &len, 16);
+    Ptr<IOBufferBlock> ibb = frame.to_io_buffer_block(sizeof(buf));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(buf + len, b->start(), b->size());
+      len += b->size();
+    }
     CHECK(len == raw_new_token_frame_len);
     CHECK(memcmp(buf, raw_new_token_frame, len) == 0);
   }
@@ -1452,7 +1550,7 @@
   SECTION("load")
   {
     const QUICFrame *frame =
-      QUICFrameFactory::create(frame_buf, raw_retire_connection_id_frame, raw_retire_connection_id_frame_len);
+      QUICFrameFactory::create(frame_buf, raw_retire_connection_id_frame, raw_retire_connection_id_frame_len, nullptr);
     CHECK(frame->type() == QUICFrameType::RETIRE_CONNECTION_ID);
     CHECK(frame->size() == raw_retire_connection_id_frame_len);
 
@@ -1464,7 +1562,7 @@
   SECTION("bad load")
   {
     const QUICFrame *frame =
-      QUICFrameFactory::create(frame_buf, raw_retire_connection_id_frame, raw_retire_connection_id_frame_len - 1);
+      QUICFrameFactory::create(frame_buf, raw_retire_connection_id_frame, raw_retire_connection_id_frame_len - 1, nullptr);
     CHECK(frame->type() == QUICFrameType::RETIRE_CONNECTION_ID);
     CHECK(frame->valid() == false);
   }
@@ -1472,12 +1570,16 @@
   SECTION("store")
   {
     uint8_t buf[32];
-    size_t len;
+    size_t len = 0;
 
     QUICRetireConnectionIdFrame frame(seq_num, 0, nullptr);
     CHECK(frame.size() == raw_retire_connection_id_frame_len);
 
-    frame.store(buf, &len, 16);
+    Ptr<IOBufferBlock> ibb = frame.to_io_buffer_block(sizeof(buf));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(buf + len, b->start(), b->size());
+      len += b->size();
+    }
     CHECK(len == raw_retire_connection_id_frame_len);
     CHECK(memcmp(buf, raw_retire_connection_id_frame, len) == 0);
   }
@@ -1489,7 +1591,7 @@
   uint8_t buf1[] = {
     0x20, // Type
   };
-  const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1));
+  const QUICFrame *frame1 = QUICFrameFactory::create(frame_buf, buf1, sizeof(buf1), nullptr);
   CHECK(frame1 == nullptr);
 }
 
@@ -1505,13 +1607,13 @@
     0x12,                   // Type
     0x85, 0x06, 0x07, 0x08, // Stream Data
   };
-  const QUICFrame &frame1 = factory.fast_create(buf1, sizeof(buf1));
+  const QUICFrame &frame1 = factory.fast_create(buf1, sizeof(buf1), nullptr);
   CHECK(frame1.type() == QUICFrameType::MAX_STREAMS);
 
   const QUICMaxStreamsFrame &max_streams_frame1 = static_cast<const QUICMaxStreamsFrame &>(frame1);
   CHECK(max_streams_frame1.maximum_streams() == 0x01020304);
 
-  const QUICFrame &frame2 = factory.fast_create(buf2, sizeof(buf2));
+  const QUICFrame &frame2 = factory.fast_create(buf2, sizeof(buf2), nullptr);
   CHECK(frame2.type() == QUICFrameType::MAX_STREAMS);
 
   const QUICMaxStreamsFrame &max_streams_frame2 = static_cast<const QUICMaxStreamsFrame &>(frame2);
@@ -1527,7 +1629,7 @@
   uint8_t buf1[] = {
     0x20, // Type
   };
-  const QUICFrame &frame1 = factory.fast_create(buf1, sizeof(buf1));
+  const QUICFrame &frame1 = factory.fast_create(buf1, sizeof(buf1), nullptr);
   CHECK(frame1.type() == QUICFrameType::UNKNOWN);
 }
 
diff --git a/iocore/net/quic/test/test_QUICFrameDispatcher.cc b/iocore/net/quic/test/test_QUICFrameDispatcher.cc
index be81c2e..eb89aa7 100644
--- a/iocore/net/quic/test/test_QUICFrameDispatcher.cc
+++ b/iocore/net/quic/test/test_QUICFrameDispatcher.cc
@@ -36,14 +36,12 @@
 
   QUICStreamFrame streamFrame(block, 0x03, 0);
 
-  MockQUICLDConfig ld_config;
-  MockQUICCCConfig cc_config;
+  MockQUICContext context;
+
   MockQUICConnection connection;
-  MockQUICStreamManager streamManager;
+  MockQUICStreamManager streamManager = {&connection};
   MockQUICConnectionInfoProvider info;
-  MockQUICCongestionController cc(&info, cc_config);
-  QUICRTTMeasure rtt_measure;
-  MockQUICLossDetector lossDetector(&info, &cc, &rtt_measure, ld_config);
+  MockQUICLossDetector lossDetector(context);
 
   QUICFrameDispatcher quicFrameDispatcher(&info);
   quicFrameDispatcher.add_handler(&connection);
@@ -64,14 +62,19 @@
   }
   bool should_send_ack;
   bool is_flow_controlled;
-  quicFrameDispatcher.receive_frames(QUICEncryptionLevel::INITIAL, buf, len, should_send_ack, is_flow_controlled, nullptr);
+  quicFrameDispatcher.receive_frames(QUICEncryptionLevel::INITIAL, buf, len, should_send_ack, is_flow_controlled, nullptr, nullptr);
   CHECK(connection.getTotalFrameCount() == 0);
   CHECK(streamManager.getTotalFrameCount() == 1);
 
   // CONNECTION_CLOSE frame
   QUICConnectionCloseFrame connectionCloseFrame(0, 0, "", 0, nullptr);
-  connectionCloseFrame.store(buf, &len, 4096);
-  quicFrameDispatcher.receive_frames(QUICEncryptionLevel::INITIAL, buf, len, should_send_ack, is_flow_controlled, nullptr);
+  ibb = connectionCloseFrame.to_io_buffer_block(sizeof(buf));
+  len = 0;
+  for (auto b = ibb; b; b = b->next) {
+    memcpy(buf + len, b->start(), b->size());
+    len += b->size();
+  }
+  quicFrameDispatcher.receive_frames(QUICEncryptionLevel::INITIAL, buf, len, should_send_ack, is_flow_controlled, nullptr, nullptr);
   CHECK(connection.getTotalFrameCount() == 1);
   CHECK(streamManager.getTotalFrameCount() == 1);
 }
diff --git a/iocore/net/quic/test/test_QUICIncomingFrameBuffer.cc b/iocore/net/quic/test/test_QUICIncomingFrameBuffer.cc
index 50a3dfa..3b4e8a9 100644
--- a/iocore/net/quic/test/test_QUICIncomingFrameBuffer.cc
+++ b/iocore/net/quic/test/test_QUICIncomingFrameBuffer.cc
@@ -71,7 +71,7 @@
     buffer.insert(new QUICStreamFrame(*stream1_frame_2_r));
     err = buffer.insert(new QUICStreamFrame(*stream1_frame_3_r));
     CHECK(err->cls == QUICErrorClass::TRANSPORT);
-    CHECK(err->code == static_cast<uint16_t>(QUICTransErrorCode::FINAL_OFFSET_ERROR));
+    CHECK(err->code == static_cast<uint16_t>(QUICTransErrorCode::FINAL_SIZE_ERROR));
 
     buffer.clear();
 
@@ -82,7 +82,7 @@
     buffer2.insert(new QUICStreamFrame(*stream1_frame_1_r));
     err = buffer2.insert(new QUICStreamFrame(*stream1_frame_2_r));
     CHECK(err->cls == QUICErrorClass::TRANSPORT);
-    CHECK(err->code == static_cast<uint16_t>(QUICTransErrorCode::FINAL_OFFSET_ERROR));
+    CHECK(err->code == static_cast<uint16_t>(QUICTransErrorCode::FINAL_SIZE_ERROR));
 
     buffer2.clear();
 
@@ -91,7 +91,7 @@
     buffer3.insert(new QUICStreamFrame(*stream1_frame_4_r));
     err = buffer3.insert(new QUICStreamFrame(*stream1_frame_3_r));
     CHECK(err->cls == QUICErrorClass::TRANSPORT);
-    CHECK(err->code == static_cast<uint16_t>(QUICTransErrorCode::FINAL_OFFSET_ERROR));
+    CHECK(err->code == static_cast<uint16_t>(QUICTransErrorCode::FINAL_SIZE_ERROR));
 
     buffer3.clear();
   }
@@ -158,14 +158,19 @@
 
   auto frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 0);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 1024);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 2048);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 3072);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 4096);
+  delete frame;
   CHECK(buffer.empty());
 
   buffer.clear();
@@ -179,14 +184,19 @@
 
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 0);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 1024);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 2048);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 3072);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 4096);
+  delete frame;
   CHECK(buffer.empty());
 
   delete stream;
@@ -228,12 +238,16 @@
 
   auto frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 0);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 1024);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 2048);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame == nullptr);
+  delete frame;
   CHECK(buffer.empty());
 
   buffer.clear();
@@ -251,10 +265,13 @@
 
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 0);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 1024);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame->offset() == 2048);
+  delete frame;
   frame = static_cast<const QUICStreamFrame *>(buffer.pop());
   CHECK(frame == nullptr);
   CHECK(buffer.empty());
diff --git a/iocore/net/quic/test/test_QUICInvariants.cc b/iocore/net/quic/test/test_QUICInvariants.cc
index 5cdbc28..e57aab1 100644
--- a/iocore/net/quic/test/test_QUICInvariants.cc
+++ b/iocore/net/quic/test/test_QUICInvariants.cc
@@ -37,8 +37,9 @@
     const uint8_t buf[] = {
       0x80,                                           // Long header, Type: NONE
       0x11, 0x22, 0x33, 0x44,                         // Version
-      0x55,                                           // DCIL/SCIL
+      0x08,                                           // DCID Len
       0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
       0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
     };
     uint64_t buf_len = sizeof(buf);
@@ -53,12 +54,12 @@
     CHECK(version == 0x11223344);
 
     CHECK(QUICInvariants::dcil(dcil, buf, buf_len));
-    CHECK(dcil == 5);
+    CHECK(dcil == sizeof(raw_dcid));
     CHECK(QUICInvariants::dcid(dcid, buf, buf_len));
     CHECK(dcid == expected_dcid);
 
     CHECK(QUICInvariants::scil(scil, buf, buf_len));
-    CHECK(scil == 5);
+    CHECK(scil == sizeof(raw_scid));
     CHECK(QUICInvariants::scid(scid, buf, buf_len));
     CHECK(scid == expected_scid);
   }
@@ -68,7 +69,8 @@
     const uint8_t buf[] = {
       0x80,                                           // Long header, Type: NONE
       0x11, 0x22, 0x33, 0x44,                         // Version
-      0x05,                                           // DCIL/SCIL
+      0x00,                                           // DCID Len
+      0x08,                                           // SCID Len
       0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
     };
     uint64_t buf_len = sizeof(buf);
@@ -88,7 +90,7 @@
     CHECK(dcid == QUICConnectionId::ZERO());
 
     CHECK(QUICInvariants::scil(scil, buf, buf_len));
-    CHECK(scil == 5);
+    CHECK(scil == sizeof(raw_scid));
     CHECK(QUICInvariants::scid(scid, buf, buf_len));
     CHECK(scid == expected_scid);
   }
@@ -98,8 +100,9 @@
     const uint8_t buf[] = {
       0x80,                                           // Long header, Type: NONE
       0x11, 0x22, 0x33, 0x44,                         // Version
-      0x50,                                           // DCIL/SCIL
+      0x08,                                           // DCID Len
       0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x00,                                           // SCID Len
     };
     uint64_t buf_len = sizeof(buf);
 
@@ -113,7 +116,7 @@
     CHECK(version == 0x11223344);
 
     CHECK(QUICInvariants::dcil(dcil, buf, buf_len));
-    CHECK(dcil == 5);
+    CHECK(dcil == sizeof(raw_dcid));
     CHECK(QUICInvariants::dcid(dcid, buf, buf_len));
     CHECK(dcid == expected_dcid);
 
@@ -143,8 +146,9 @@
     const uint8_t buf[] = {
       0x80,                   // Long header, Type: NONE
       0x11, 0x22, 0x33, 0x44, // Version
-      0x55,                   // DCIL/SCIL
+      0x08,                   // DCID Len
       0x01, 0x02, 0x03, 0x04, // Invalid Destination Connection ID
+      0x00,                   // SCID Len
     };
     uint64_t buf_len = sizeof(buf);
 
@@ -164,8 +168,9 @@
     const uint8_t buf[] = {
       0x80,                                           // Long header, Type: NONE
       0x11, 0x22, 0x33, 0x44,                         // Version
-      0x55,                                           // DCIL/SCIL
+      0x08,                                           // DCID Len
       0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
       0x11, 0x12, 0x13, 0x14,                         // Invalid Source Connection ID
     };
     uint64_t buf_len = sizeof(buf);
diff --git a/iocore/net/quic/test/test_QUICKeyGenerator.cc b/iocore/net/quic/test/test_QUICKeyGenerator.cc
index e24d3db..4c1858a 100644
--- a/iocore/net/quic/test/test_QUICKeyGenerator.cc
+++ b/iocore/net/quic/test/test_QUICKeyGenerator.cc
@@ -36,7 +36,7 @@
 #include "QUICPacketProtectionKeyInfo.h"
 
 // https://github.com/quicwg/base-drafts/wiki/Test-Vector-for-the-Clear-Text-AEAD-key-derivation
-TEST_CASE("draft-17 Test Vectors", "[quic]")
+TEST_CASE("draft-23 Test Vectors", "[quic]")
 {
   SECTION("CLIENT Initial")
   {
@@ -44,15 +44,9 @@
 
     QUICConnectionId cid = {reinterpret_cast<const uint8_t *>("\xc6\x54\xef\xd8\xa3\x1b\x47\x92"), 8};
 
-    uint8_t expected_client_key[] = {
-      0x86, 0xd1, 0x83, 0x04, 0x80, 0xb4, 0x0f, 0x86, 0xcf, 0x9d, 0x68, 0xdc, 0xad, 0xf3, 0x5d, 0xfe,
-    };
-    uint8_t expected_client_iv[] = {
-      0x12, 0xf3, 0x93, 0x8a, 0xca, 0x34, 0xaa, 0x02, 0x54, 0x31, 0x63, 0xd4,
-    };
-    uint8_t expected_client_hp[] = {
-      0xcd, 0x25, 0x3a, 0x36, 0xff, 0x93, 0x93, 0x7c, 0x46, 0x93, 0x84, 0xa8, 0x23, 0xaf, 0x6c, 0x56,
-    };
+    uint8_t expected_client_key[] = {0xfc, 0x4a, 0x14, 0x7a, 0x7e, 0xe9, 0x70, 0x29, 0x1b, 0x8f, 0x1c, 0x3, 0x2d, 0x2c, 0x40, 0xf9};
+    uint8_t expected_client_iv[]  = {0x1e, 0x6a, 0x5d, 0xdb, 0x7c, 0x1d, 0x1a, 0xa7, 0xa0, 0xfd, 0x70, 0x5};
+    uint8_t expected_client_hp[] = {0x43, 0x1d, 0x22, 0x82, 0xb4, 0x7b, 0xb9, 0x3f, 0xeb, 0xd2, 0xcf, 0x19, 0x85, 0x21, 0xe2, 0xbe};
 
     QUICPacketProtectionKeyInfo pp_key_info;
     pp_key_info.set_cipher_initial(EVP_aes_128_gcm());
@@ -74,15 +68,10 @@
 
     QUICConnectionId cid = {reinterpret_cast<const uint8_t *>("\xc6\x54\xef\xd8\xa3\x1b\x47\x92"), 8};
 
-    uint8_t expected_server_key[] = {
-      0x2c, 0x78, 0x63, 0x3e, 0x20, 0x6e, 0x99, 0xad, 0x25, 0x19, 0x64, 0xf1, 0x9f, 0x6d, 0xcd, 0x6d,
-    };
-    uint8_t expected_server_iv[] = {
-      0x7b, 0x50, 0xbf, 0x36, 0x98, 0xa0, 0x6d, 0xfa, 0xbf, 0x75, 0xf2, 0x87,
-    };
-    uint8_t expected_server_hp[] = {
-      0x25, 0x79, 0xd8, 0x69, 0x6f, 0x85, 0xed, 0xa6, 0x8d, 0x35, 0x02, 0xb6, 0x55, 0x96, 0x58, 0x6b,
-    };
+    uint8_t expected_server_key[] = {0x60, 0xc0, 0x2f, 0xa6, 0x12, 0x1e, 0xb1, 0xab,
+                                     0xa4, 0x35, 0x1f, 0x2a, 0x63, 0xb0, 0xac, 0xf8};
+    uint8_t expected_server_iv[]  = {0x38, 0xd, 0xf3, 0xc0, 0xf2, 0x8d, 0x94, 0x7, 0x76, 0x5c, 0x55, 0xa1};
+    uint8_t expected_server_hp[] = {0x92, 0xe8, 0x67, 0xb1, 0x20, 0xb1, 0x3f, 0x40, 0x9c, 0x1a, 0xa8, 0xef, 0x54, 0x30, 0x53, 0x51};
 
     QUICPacketProtectionKeyInfo pp_key_info;
     pp_key_info.set_cipher_initial(EVP_aes_128_gcm());
diff --git a/iocore/net/quic/test/test_QUICLossDetector.cc b/iocore/net/quic/test/test_QUICLossDetector.cc
index 0016724..6c3604f 100644
--- a/iocore/net/quic/test/test_QUICLossDetector.cc
+++ b/iocore/net/quic/test/test_QUICLossDetector.cc
@@ -38,11 +38,11 @@
 
   QUICAckFrameManager afm;
   QUICConnectionId connection_id = {reinterpret_cast<const uint8_t *>("\x01"), 1};
-  MockQUICCCConfig cc_config;
-  MockQUICLDConfig ld_config;
-  MockQUICConnectionInfoProvider info;
-  MockQUICCongestionController cc(&info, cc_config);
-  QUICLossDetector detector(&info, &cc, &rtt_measure, ld_config);
+  MockQUICContext context;
+  QUICPinger pinger;
+  QUICPadder padder(NetVConnectionContext_t::NET_VCONNECTION_IN);
+  MockQUICCongestionController cc;
+  QUICLossDetector detector(context, &cc, &rtt_measure, &pinger, &padder);
   ats_unique_buf payload = ats_unique_malloc(512);
   size_t payload_len     = 512;
   QUICPacketUPtr packet  = QUICPacketFactory::create_null_packet();
@@ -54,11 +54,16 @@
     // Check initial state
     uint8_t frame_buffer[1024] = {0};
     CHECK(g.lost_frame_count == 0);
-    QUICFrame *ping_frame = g.generate_frame(frame_buffer, QUICEncryptionLevel::HANDSHAKE, 4, UINT16_MAX, 0);
+    QUICFrame *ping_frame = g.generate_frame(frame_buffer, QUICEncryptionLevel::HANDSHAKE, 4, UINT16_MAX, 0, 0);
 
     uint8_t raw[4];
-    size_t len;
-    CHECK(ping_frame->store(raw, &len, 10240) < 4);
+    size_t len             = 0;
+    Ptr<IOBufferBlock> ibb = ping_frame->to_io_buffer_block(sizeof(raw));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(raw + len, b->start(), b->size());
+      len += b->size();
+    }
+    CHECK(len < 4);
 
     // Send SERVER_CLEARTEXT (Handshake message)
     ats_unique_buf payload = ats_unique_malloc(sizeof(raw));
@@ -245,7 +250,7 @@
     afm.update(level, pn9, payload_len, false);
     afm.update(level, pn10, payload_len, false);
     uint8_t buf[QUICFrame::MAX_INSTANCE_SIZE];
-    QUICFrame *x = afm.generate_frame(buf, level, 2048, 2048, 0);
+    QUICFrame *x = afm.generate_frame(buf, level, 2048, 2048, 0, 0);
     frame        = static_cast<QUICAckFrame *>(x);
     ink_hrtime_sleep(HRTIME_MSECONDS(1000));
     detector.handle_frame(level, *frame);
@@ -263,18 +268,19 @@
     CHECK(cc.lost_packets.find(pn8) == cc.lost_packets.end());
     CHECK(cc.lost_packets.find(pn9) == cc.lost_packets.end());
     CHECK(cc.lost_packets.find(pn9) == cc.lost_packets.end());
+    x->~QUICFrame();
   }
 }
 
 TEST_CASE("QUICLossDetector_HugeGap", "[quic]")
 {
   uint8_t frame_buf[QUICFrame::MAX_INSTANCE_SIZE];
-  MockQUICConnectionInfoProvider info;
-  MockQUICCCConfig cc_config;
-  MockQUICLDConfig ld_config;
-  MockQUICCongestionController cc(&info, cc_config);
   QUICRTTMeasure rtt_measure;
-  QUICLossDetector detector(&info, &cc, &rtt_measure, ld_config);
+  MockQUICContext context;
+  QUICPinger pinger;
+  QUICPadder padder(NetVConnectionContext_t::NET_VCONNECTION_IN);
+  MockQUICCongestionController cc;
+  QUICLossDetector detector(context, &cc, &rtt_measure, &pinger, &padder);
 
   auto t1           = Thread::get_hrtime();
   QUICAckFrame *ack = QUICFrameFactory::create_ack_frame(frame_buf, 100000000, 100, 10000000);
@@ -282,4 +288,5 @@
   detector.handle_frame(QUICEncryptionLevel::INITIAL, *ack);
   auto t2 = Thread::get_hrtime();
   CHECK(t2 - t1 < HRTIME_MSECONDS(100));
+  ack->~QUICAckFrame();
 }
diff --git a/iocore/net/quic/test/test_QUICPacket.cc b/iocore/net/quic/test/test_QUICPacket.cc
index f50d156..573e1a8 100644
--- a/iocore/net/quic/test/test_QUICPacket.cc
+++ b/iocore/net/quic/test/test_QUICPacket.cc
@@ -32,8 +32,9 @@
     const uint8_t input[] = {
       0xc0,                                           // Long header, Type: NONE
       0x00, 0x00, 0x00, 0x00,                         // Version
-      0x55,                                           // DCIL/SCIL
+      0x08,                                           // DCID Len
       0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
       0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
       0x00, 0x00, 0x00, 0x08,                         // Supported Version 1
       0x00, 0x00, 0x00, 0x09,                         // Supported Version 1
@@ -41,9 +42,9 @@
     ats_unique_buf uinput = ats_unique_malloc(sizeof(input));
     memcpy(uinput.get(), input, sizeof(input));
 
-    QUICPacketHeaderUPtr header = QUICPacketHeader::load({}, std::move(uinput), sizeof(input), 0);
-    CHECK(header->size() == 22);
-    CHECK(header->packet_size() == 30);
+    QUICPacketHeaderUPtr header = QUICPacketHeader::load({}, {}, std::move(uinput), sizeof(input), 0);
+    CHECK(header->size() == sizeof(input) - 8);
+    CHECK(header->packet_size() == sizeof(input));
     CHECK(header->type() == QUICPacketType::VERSION_NEGOTIATION);
     CHECK(
       (header->destination_cid() == QUICConnectionId(reinterpret_cast<const uint8_t *>("\x01\x02\x03\x04\x05\x06\x07\x08"), 8)));
@@ -57,18 +58,19 @@
     const uint8_t input[] = {
       0xc3,                                           // Long header, Type: INITIAL
       0x11, 0x22, 0x33, 0x44,                         // Version
-      0x55,                                           // DCIL/SCIL
+      0x08,                                           // DCID Len
       0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
       0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
       0x00,                                           // Token Length (i), Token (*)
-      0x02,                                           // Payload length
+      0x06,                                           // Length
       0x01, 0x23, 0x45, 0x67,                         // Packet number
       0xff, 0xff,                                     // Payload (dummy)
     };
     ats_unique_buf uinput = ats_unique_malloc(sizeof(input));
     memcpy(uinput.get(), input, sizeof(input));
 
-    QUICPacketHeaderUPtr header = QUICPacketHeader::load({}, std::move(uinput), sizeof(input), 0);
+    QUICPacketHeaderUPtr header = QUICPacketHeader::load({}, {}, std::move(uinput), sizeof(input), 0);
     CHECK(header->size() == sizeof(input) - 2); // Packet Length - Payload Length
     CHECK(header->packet_size() == sizeof(input));
     CHECK(header->type() == QUICPacketType::INITIAL);
@@ -85,9 +87,11 @@
     const uint8_t input[] = {
       0xf5,                                           // Long header, Type: RETRY
       0x11, 0x22, 0x33, 0x44,                         // Version
-      0x55,                                           // DCIL/SCIL
+      0x08,                                           // DCID Len
       0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
       0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
+      0x08,                                           // ODCID Len
       0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, // Original Destination Connection ID
       0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, // Retry Token
       0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
@@ -97,7 +101,7 @@
 
     const uint8_t retry_token[] = {0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0};
 
-    QUICPacketHeaderUPtr header = QUICPacketHeader::load({}, std::move(uinput), sizeof(input), 0);
+    QUICPacketHeaderUPtr header = QUICPacketHeader::load({}, {}, std::move(uinput), sizeof(input), 0);
     CHECK(header->size() == sizeof(input) - 16); // Packet Length - Payload Length (Retry Token)
     CHECK(header->packet_size() == sizeof(input));
     CHECK(header->type() == QUICPacketType::RETRY);
@@ -114,6 +118,62 @@
     CHECK(header->version() == 0x11223344);
   }
 
+  SECTION("Long Header (parse) INITIAL Packet")
+  {
+    const uint8_t buf[] = {
+      0xc3,                                           // Long header, Type: INITIAL
+      0x11, 0x22, 0x33, 0x44,                         // Version
+      0x08,                                           // DCID Len
+      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
+      0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
+      0x00,                                           // Token Length (i), Token (*)
+      0x06,                                           // Length
+      0x01, 0x23, 0x45, 0x67,                         // Packet number
+      0xff, 0xff,                                     // Payload (dummy)
+    };
+
+    QUICPacketType type;
+    REQUIRE(QUICPacketLongHeader::type(type, buf, sizeof(buf)));
+    CHECK(type == QUICPacketType::INITIAL);
+
+    QUICVersion version;
+    REQUIRE(QUICPacketLongHeader::version(version, buf, sizeof(buf)));
+    CHECK(version == 0x11223344);
+
+    uint8_t dcil;
+    REQUIRE(QUICPacketLongHeader::dcil(dcil, buf, sizeof(buf)));
+    CHECK(dcil == 8);
+
+    uint8_t scil;
+    REQUIRE(QUICPacketLongHeader::scil(scil, buf, sizeof(buf)));
+    CHECK(dcil == 8);
+
+    size_t token_length;
+    uint8_t token_length_field_len;
+    size_t token_length_field_offset;
+    REQUIRE(QUICPacketLongHeader::token_length(token_length, token_length_field_len, token_length_field_offset, buf, sizeof(buf)));
+    CHECK(token_length == 0);
+    CHECK(token_length_field_len == 1);
+    CHECK(token_length_field_offset == 23);
+
+    size_t length;
+    uint8_t length_field_len;
+    size_t length_field_offset;
+    REQUIRE(QUICPacketLongHeader::length(length, length_field_len, length_field_offset, buf, sizeof(buf)));
+    CHECK(length == 6);
+    CHECK(length_field_len == 1);
+    CHECK(length_field_offset == 24);
+
+    size_t pn_offset;
+    REQUIRE(QUICPacketLongHeader::packet_number_offset(pn_offset, buf, sizeof(buf)));
+    CHECK(pn_offset == 25);
+
+    size_t packet_length;
+    REQUIRE(QUICPacketLongHeader::packet_length(packet_length, buf, sizeof(buf)));
+    CHECK(packet_length == sizeof(buf));
+  }
+
   SECTION("Long Header (store) INITIAL Packet")
   {
     uint8_t buf[64] = {0};
@@ -122,8 +182,9 @@
     const uint8_t expected[] = {
       0xc3,                                           // Long header, Type: INITIAL
       0x11, 0x22, 0x33, 0x44,                         // Version
-      0x55,                                           // DCIL/SCIL
+      0x08,                                           // DCID Len
       0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
       0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
       0x00,                                           // Token Length (i), Token (*)
       0x19,                                           // Length (Not 0x09 because it will have 16 bytes of AEAD tag)
@@ -160,11 +221,13 @@
     size_t len      = 0;
 
     const uint8_t expected[] = {
-      0xf5,                                           // Long header, Type: RETRY
+      0xf0,                                           // Long header, Type: RETRY
       0x11, 0x22, 0x33, 0x44,                         // Version
-      0x55,                                           // DCIL/SCIL
+      0x08,                                           // DCID Len
       0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
       0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
+      0x08,                                           // ODCID Len
       0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, // Original Destination Connection ID
       0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, // Retry Token
       0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
@@ -220,7 +283,7 @@
     ats_unique_buf uinput = ats_unique_malloc(sizeof(input));
     memcpy(uinput.get(), input, sizeof(input));
 
-    QUICPacketHeaderUPtr header = QUICPacketHeader::load({}, std::move(uinput), sizeof(input), 0);
+    QUICPacketHeaderUPtr header = QUICPacketHeader::load({}, {}, std::move(uinput), sizeof(input), 0);
     CHECK(header->size() == 23);
     CHECK(header->packet_size() == 25);
     CHECK(header->key_phase() == QUICKeyPhase::PHASE_0);
diff --git a/iocore/net/quic/test/test_QUICPacketFactory.cc b/iocore/net/quic/test/test_QUICPacketFactory.cc
index 08d94b4..dc01765 100644
--- a/iocore/net/quic/test/test_QUICPacketFactory.cc
+++ b/iocore/net/quic/test/test_QUICPacketFactory.cc
@@ -50,10 +50,11 @@
   uint8_t expected[] = {
     0xa7,                                           // Long header, Type: NONE
     0x00, 0x00, 0x00, 0x00,                         // Version
-    0x55,                                           // DCIL/SCIL
+    0x08,                                           // DCID Len
     0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Destination Connection ID
+    0x08,                                           // SCID Len
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Source Connection ID
-    0xff, 0x00, 0x00, 0x14,                         // Supported Version
+    0xff, 0x00, 0x00, 0x17,                         // Supported Version
     0x1a, 0x2a, 0x3a, 0x4a,                         // Excercise Version
   };
   uint8_t buf[1024] = {0};
diff --git a/iocore/net/quic/test/test_QUICPacketHeaderProtector.cc b/iocore/net/quic/test/test_QUICPacketHeaderProtector.cc
index dc754a4..5cb69af 100644
--- a/iocore/net/quic/test/test_QUICPacketHeaderProtector.cc
+++ b/iocore/net/quic/test/test_QUICPacketHeaderProtector.cc
@@ -70,13 +70,19 @@
   SECTION("Long header", "[quic]")
   {
     uint8_t original[] = {
-      0xC3, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-      0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-      0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+      0xc3,                                           // Long header, Type: INITIAL
+      0x11, 0x22, 0x33, 0x44,                         // Version
+      0x08,                                           // DCID Len
+      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // Destination Connection ID
+      0x08,                                           // SCID Len
+      0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, // Source Connection ID
+      0x00,                                           // Token Length (i), Token (*)
+      0x19,                                           // Length (Not 0x09 because it will have 16 bytes of AEAD tag)
+      0x01, 0x23, 0x45, 0x67,                         // Packet number
+      0x11, 0x22, 0x33, 0x44, 0x55,                   // Payload (dummy)
     };
     uint8_t tmp[64];
-    memcpy(tmp, original, sizeof(tmp));
+    memcpy(tmp, original, sizeof(original));
 
     QUICPacketProtectionKeyInfo pp_key_info_client;
     QUICPacketProtectionKeyInfo pp_key_info_server;
@@ -91,15 +97,18 @@
     QUICPacketHeaderProtector server_ph_protector(pp_key_info_server);
 
     // ## Client -> Server
-    client_ph_protector.protect(tmp, sizeof(tmp), 18);
+    REQUIRE(client_ph_protector.protect(tmp, sizeof(tmp), 18));
     CHECK(memcmp(original, tmp, sizeof(original)) != 0);
-    server_ph_protector.unprotect(tmp, sizeof(tmp));
+    REQUIRE(server_ph_protector.unprotect(tmp, sizeof(tmp)));
     CHECK(memcmp(original, tmp, sizeof(original)) == 0);
     // ## Server -> Client
-    server_ph_protector.protect(tmp, sizeof(tmp), 18);
+    REQUIRE(server_ph_protector.protect(tmp, sizeof(tmp), 18));
     CHECK(memcmp(original, tmp, sizeof(original)) != 0);
-    client_ph_protector.unprotect(tmp, sizeof(tmp));
+    REQUIRE(client_ph_protector.unprotect(tmp, sizeof(tmp)));
     CHECK(memcmp(original, tmp, sizeof(original)) == 0);
+
+    delete client;
+    delete server;
   }
 
   SECTION("Short header", "[quic]")
@@ -197,14 +206,24 @@
     REQUIRE(client->handshake(&msg5, &msg4) == 1);
 
     // ## Client -> Server
-    client_ph_protector.protect(tmp, sizeof(tmp), 18);
+    REQUIRE(client_ph_protector.protect(tmp, sizeof(tmp), 18));
     CHECK(memcmp(original, tmp, sizeof(original)) != 0);
-    server_ph_protector.unprotect(tmp, sizeof(tmp));
+    REQUIRE(server_ph_protector.unprotect(tmp, sizeof(tmp)));
     CHECK(memcmp(original, tmp, sizeof(original)) == 0);
     // ## Server -> Client
-    server_ph_protector.protect(tmp, sizeof(tmp), 18);
+    REQUIRE(server_ph_protector.protect(tmp, sizeof(tmp), 18));
     CHECK(memcmp(original, tmp, sizeof(original)) != 0);
-    client_ph_protector.unprotect(tmp, sizeof(tmp));
+    REQUIRE(client_ph_protector.unprotect(tmp, sizeof(tmp)));
     CHECK(memcmp(original, tmp, sizeof(original)) == 0);
+
+    delete client;
+    delete server;
   }
+
+  SSL_CTX_free(client_ssl_ctx);
+  SSL_CTX_free(server_ssl_ctx);
+  BIO_free(crt_bio);
+  BIO_free(key_bio);
+  X509_free(x509);
+  EVP_PKEY_free(pkey);
 }
diff --git a/iocore/net/quic/test/test_QUICPathValidator.cc b/iocore/net/quic/test/test_QUICPathValidator.cc
new file mode 100644
index 0000000..78c51f2
--- /dev/null
+++ b/iocore/net/quic/test/test_QUICPathValidator.cc
@@ -0,0 +1,112 @@
+/** @file
+ *
+ *  A brief file description
+ *
+ *  @section license License
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "catch.hpp"
+
+#include "quic/QUICPathValidator.h"
+#include "quic/Mock.h"
+#include "stdio.h"
+#include "stdlib.h"
+
+TEST_CASE("QUICPathValidator", "[quic]")
+{
+  MockQUICConnectionInfoProvider cinfo_provider;
+  QUICPathValidator pv_c(cinfo_provider, [](bool x) {});
+  QUICPathValidator pv_s(cinfo_provider, [](bool x) {});
+
+  SECTION("interests")
+  {
+    auto interests = pv_c.interests();
+    CHECK(std::find_if(interests.begin(), interests.end(), [](QUICFrameType t) { return t == QUICFrameType::PATH_CHALLENGE; }) !=
+          interests.end());
+    CHECK(std::find_if(interests.begin(), interests.end(), [](QUICFrameType t) { return t == QUICFrameType::PATH_RESPONSE; }) !=
+          interests.end());
+    CHECK(std::find_if(interests.begin(), interests.end(), [](QUICFrameType t) {
+            return t != QUICFrameType::PATH_CHALLENGE && t != QUICFrameType::PATH_RESPONSE;
+          }) == interests.end());
+  }
+
+  SECTION("basic scenario")
+  {
+    uint8_t frame_buf[1024];
+    uint32_t seq_num = 1;
+    IpEndpoint local, remote;
+    ats_ip_pton("127.0.0.1:4433", &local);
+    ats_ip_pton("127.0.0.1:12345", &remote);
+    QUICPath path = {local, remote};
+
+    // Send a challenge
+    CHECK(!pv_c.is_validating(path));
+    CHECK(!pv_c.is_validated(path));
+    REQUIRE(!pv_c.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0, false, seq_num));
+    pv_c.validate(path);
+    CHECK(pv_c.is_validating(path));
+    CHECK(!pv_c.is_validated(path));
+    REQUIRE(pv_c.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0, false, seq_num));
+    auto frame = pv_c.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 1024, 1024, 0, seq_num);
+    REQUIRE(frame);
+    CHECK(frame->type() == QUICFrameType::PATH_CHALLENGE);
+    CHECK(pv_c.is_validating(path));
+    CHECK(!pv_c.is_validated(path));
+    ++seq_num;
+
+    // Receive the challenge and respond
+    CHECK(!pv_s.is_validating(path));
+    CHECK(!pv_s.is_validated(path));
+    REQUIRE(!pv_s.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0, false, seq_num));
+    auto error = pv_s.handle_frame(QUICEncryptionLevel::ONE_RTT, *frame);
+    REQUIRE(!error);
+    CHECK(!pv_s.is_validating(path));
+    CHECK(!pv_s.is_validated(path));
+    REQUIRE(pv_s.will_generate_frame(QUICEncryptionLevel::ONE_RTT, 0, false, seq_num));
+    frame->~QUICFrame();
+    frame = pv_s.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 1024, 1024, 0, seq_num);
+    REQUIRE(frame);
+    CHECK(frame->type() == QUICFrameType::PATH_RESPONSE);
+    CHECK(!pv_s.is_validating(path));
+    CHECK(!pv_s.is_validated(path));
+    ++seq_num;
+
+    uint8_t buf[1024];
+    size_t len = 0;
+    uint8_t received_frame_buf[1024];
+    Ptr<IOBufferBlock> ibb = frame->to_io_buffer_block(sizeof(buf));
+    for (auto b = ibb; b; b = b->next) {
+      memcpy(buf + len, b->start(), b->size());
+      len += b->size();
+    }
+    MockQUICPacket mock_packet;
+    auto received_frame = QUICFrameFactory::create(received_frame_buf, buf, len, &mock_packet);
+    mock_packet.set_from(remote);
+    mock_packet.set_to(local);
+
+    // Receive the response
+    error = pv_c.handle_frame(QUICEncryptionLevel::ONE_RTT, *received_frame);
+    REQUIRE(!error);
+    CHECK(!pv_c.is_validating(path));
+    CHECK(pv_c.is_validated(path));
+
+    frame->~QUICFrame();
+    received_frame->~QUICFrame();
+  }
+}
diff --git a/iocore/net/quic/test/test_QUICPinger.cc b/iocore/net/quic/test/test_QUICPinger.cc
new file mode 100644
index 0000000..fce04c6
--- /dev/null
+++ b/iocore/net/quic/test/test_QUICPinger.cc
@@ -0,0 +1,101 @@
+/** @file
+ *
+ *  A brief file description
+ *
+ *  @section license License
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "catch.hpp"
+
+#include "QUICPinger.h"
+
+static constexpr QUICEncryptionLevel level = QUICEncryptionLevel::ONE_RTT;
+static uint8_t frame[1024]                 = {0};
+
+TEST_CASE("QUICPinger", "[quic]")
+{
+  SECTION("request and cancel")
+  {
+    QUICPinger pinger;
+    pinger.request();
+    REQUIRE(pinger.count() == 1);
+    pinger.request();
+    REQUIRE(pinger.count() == 2);
+    pinger.cancel();
+    REQUIRE(pinger.count() == 1);
+    REQUIRE(pinger.generate_frame(frame, level, UINT64_MAX, UINT16_MAX, 0, 0) != nullptr);
+    REQUIRE(pinger.count() == 0);
+  }
+
+  SECTION("generate PING Frame twice")
+  {
+    QUICPinger pinger;
+    pinger.request();
+    REQUIRE(pinger.count() == 1);
+    pinger.request();
+    REQUIRE(pinger.count() == 2);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, false, 0) == true);
+    REQUIRE(pinger.count() == 2);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, false, 0) == false);
+    REQUIRE(pinger.count() == 2);
+  }
+
+  SECTION("don't generate frame when packet is ack_elicting")
+  {
+    QUICPinger pinger;
+    pinger.request();
+    REQUIRE(pinger.count() == 1);
+    pinger.request();
+    REQUIRE(pinger.count() == 2);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, true, 0) == false);
+    REQUIRE(pinger.count() == 1);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, true, 1) == false);
+    REQUIRE(pinger.count() == 0);
+  }
+
+  SECTION("generating PING Frame for next continuos un-ack-eliciting packets")
+  {
+    QUICPinger pinger;
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, false, 0) == true);
+    REQUIRE(pinger.count() == 1);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, true, 1) == false);
+    REQUIRE(pinger.count() == 0);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, false, 2) == false);
+    REQUIRE(pinger.count() == 0);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, false, 3) == true);
+    REQUIRE(pinger.count() == 1);
+  }
+
+  SECTION("don't send PING Frame for empty packet")
+  {
+    QUICPinger pinger;
+    REQUIRE(pinger.will_generate_frame(level, 0, false, 0) == false);
+    REQUIRE(pinger.count() == 0);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, false, 1) == true);
+    REQUIRE(pinger.count() == 1);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, true, 2) == false);
+    REQUIRE(pinger.count() == 0);
+    REQUIRE(pinger.will_generate_frame(level, UINT64_MAX, false, 3) == false);
+    REQUIRE(pinger.count() == 0);
+    REQUIRE(pinger.will_generate_frame(level, 0, false, 4) == false);
+    REQUIRE(pinger.count() == 0);
+    REQUIRE(pinger.will_generate_frame(level, 1, false, 5) == true);
+    REQUIRE(pinger.count() == 1);
+  }
+}
diff --git a/iocore/net/quic/test/test_QUICStream.cc b/iocore/net/quic/test/test_QUICStream.cc
index aefc488..1ed2356 100644
--- a/iocore/net/quic/test/test_QUICStream.cc
+++ b/iocore/net/quic/test/test_QUICStream.cc
@@ -229,50 +229,50 @@
 
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     // This should not send a frame because of flow control
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame);
     CHECK(frame->type() == QUICFrameType::STREAM_DATA_BLOCKED);
-    CHECK(stream->will_generate_frame(level, 0) == true);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
 
     // Update window
     stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 5120));
 
     // This should send a frame
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     // Update window
     stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 5632));
@@ -280,24 +280,24 @@
     // This should send a frame
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == true);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
 
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM_DATA_BLOCKED);
 
     // Update window
     stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 6144));
 
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
   }
 
   /*
@@ -329,13 +329,13 @@
     write_buffer->write(data1, sizeof(data1));
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
     // Generate STREAM frame
-    frame  = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame  = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     frame1 = static_cast<QUICStreamFrame *>(frame);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0) == nullptr);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
     stream->on_frame_lost(frame->id());
-    CHECK(stream->will_generate_frame(level, 0) == true);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
 
     // Write data2
     write_buffer->write(data2, sizeof(data2));
@@ -343,7 +343,7 @@
     // Lost the frame
     stream->on_frame_lost(frame->id());
     // Regenerate a frame
-    frame = stream->generate_frame(frame_buf2, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf2, level, 4096, 4096, 0, 0);
     // Lost data should be resent first
     frame2 = static_cast<QUICStreamFrame *>(frame);
     CHECK(frame->type() == QUICFrameType::STREAM);
@@ -370,15 +370,15 @@
     QUICFrame *frame          = nullptr;
 
     stream->reset(QUICStreamErrorUPtr(new QUICStreamError(stream.get(), QUIC_APP_ERROR_CODE_STOPPING)));
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     REQUIRE(frame);
     CHECK(frame->type() == QUICFrameType::RESET_STREAM);
     // Don't send it again untill it is considers as lost
-    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr);
+    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0) == nullptr);
     // Loss the frame
     stream->on_frame_lost(frame->id());
     // After the loss the frame should be regenerated
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     REQUIRE(frame);
     CHECK(frame->type() == QUICFrameType::RESET_STREAM);
   }
@@ -401,15 +401,15 @@
     QUICFrame *frame          = nullptr;
 
     stream->stop_sending(QUICStreamErrorUPtr(new QUICStreamError(stream.get(), QUIC_APP_ERROR_CODE_STOPPING)));
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     REQUIRE(frame);
     CHECK(frame->type() == QUICFrameType::STOP_SENDING);
     // Don't send it again untill it is considers as lost
-    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr);
+    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0) == nullptr);
     // Loss the frame
     stream->on_frame_lost(frame->id());
     // After the loss the frame should be regenerated
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     REQUIRE(frame);
     CHECK(frame->type() == QUICFrameType::STOP_SENDING);
   }
@@ -599,15 +599,15 @@
     QUICFrame *frame          = nullptr;
 
     stream->stop_sending(QUICStreamErrorUPtr(new QUICStreamError(stream.get(), QUIC_APP_ERROR_CODE_STOPPING)));
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     REQUIRE(frame);
     CHECK(frame->type() == QUICFrameType::STOP_SENDING);
     // Don't send it again untill it is considers as lost
-    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr);
+    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0) == nullptr);
     // Loss the frame
     stream->on_frame_lost(frame->id());
     // After the loss the frame should be regenerated
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     REQUIRE(frame);
     CHECK(frame->type() == QUICFrameType::STOP_SENDING);
   }
@@ -687,50 +687,50 @@
 
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     // This should not send a frame because of flow control
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame);
     CHECK(frame->type() == QUICFrameType::STREAM_DATA_BLOCKED);
-    CHECK(stream->will_generate_frame(level, 0) == true);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
 
     // Update window
     stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 5120));
 
     // This should send a frame
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
 
     // Update window
     stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 5632));
@@ -738,24 +738,24 @@
     // This should send a frame
     write_buffer->write(data, 1024);
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == true);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
 
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM_DATA_BLOCKED);
 
     // Update window
     stream->recv(*std::make_shared<QUICMaxStreamDataFrame>(stream_id, 6144));
 
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == true);
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
   }
 
   /*
@@ -786,13 +786,13 @@
     write_buffer->write(data1, sizeof(data1));
     stream->handleEvent(VC_EVENT_WRITE_READY, nullptr);
     // Generate STREAM frame
-    frame  = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame  = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     frame1 = static_cast<QUICStreamFrame *>(frame);
     CHECK(frame->type() == QUICFrameType::STREAM);
-    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr);
-    CHECK(stream->will_generate_frame(level, 0) == false);
+    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0) == nullptr);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == false);
     stream->on_frame_lost(frame->id());
-    CHECK(stream->will_generate_frame(level, 0) == true);
+    CHECK(stream->will_generate_frame(level, 0, false, 0) == true);
 
     // Write data2
     write_buffer->write(data2, sizeof(data2));
@@ -800,7 +800,7 @@
     // Lost the frame
     stream->on_frame_lost(frame->id());
     // Regenerate a frame
-    frame = stream->generate_frame(frame_buf2, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf2, level, 4096, 4096, 0, 0);
     // Lost data should be resent first
     frame2 = static_cast<QUICStreamFrame *>(frame);
     CHECK(frame->type() == QUICFrameType::STREAM);
@@ -826,15 +826,15 @@
     QUICFrame *frame          = nullptr;
 
     stream->reset(QUICStreamErrorUPtr(new QUICStreamError(stream.get(), QUIC_APP_ERROR_CODE_STOPPING)));
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     REQUIRE(frame);
     CHECK(frame->type() == QUICFrameType::RESET_STREAM);
     // Don't send it again untill it is considers as lost
-    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0) == nullptr);
+    CHECK(stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0) == nullptr);
     // Loss the frame
     stream->on_frame_lost(frame->id());
     // After the loss the frame should be regenerated
-    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0);
+    frame = stream->generate_frame(frame_buf, level, 4096, 4096, 0, 0);
     REQUIRE(frame);
     CHECK(frame->type() == QUICFrameType::RESET_STREAM);
   }
diff --git a/iocore/net/quic/test/test_QUICStreamManager.cc b/iocore/net/quic/test/test_QUICStreamManager.cc
index ced351a..74a37cc 100644
--- a/iocore/net/quic/test/test_QUICStreamManager.cc
+++ b/iocore/net/quic/test/test_QUICStreamManager.cc
@@ -247,12 +247,12 @@
   // total_offset should be a integer in unit of octets
   uint8_t frame_buf[4096];
   mock_app.send(reinterpret_cast<uint8_t *>(block_1024->buf()), 1024, 0);
-  sm.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 16384, 16384, 0);
+  sm.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 16384, 16384, 0, 0);
   CHECK(sm.total_offset_sent() == 1024);
 
   // total_offset should be a integer in unit of octets
   mock_app.send(reinterpret_cast<uint8_t *>(block_1024->buf()), 1024, 4);
-  sm.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 16384, 16384, 0);
+  sm.generate_frame(frame_buf, QUICEncryptionLevel::ONE_RTT, 16384, 16384, 0, 0);
   CHECK(sm.total_offset_sent() == 2048);
 
   // Wait for event processing
diff --git a/iocore/net/quic/test/test_QUICTransportParameters.cc b/iocore/net/quic/test/test_QUICTransportParameters.cc
index d60e260..95fb0ae 100644
--- a/iocore/net/quic/test/test_QUICTransportParameters.cc
+++ b/iocore/net/quic/test/test_QUICTransportParameters.cc
@@ -167,7 +167,7 @@
     CHECK(len == 16);
     CHECK(memcmp(data, buf + 12, 16) == 0);
 
-    CHECK(!params_in_ee.contains(QUICTransportParameterId::DISABLE_MIGRATION));
+    CHECK(!params_in_ee.contains(QUICTransportParameterId::DISABLE_ACTIVE_MIGRATION));
   }
 
   SECTION("OK case - zero length value")
@@ -205,7 +205,7 @@
     CHECK(len == 2);
     CHECK(memcmp(data, "\x51\x23", 2) == 0);
 
-    CHECK(params_in_ee.contains(QUICTransportParameterId::DISABLE_MIGRATION));
+    CHECK(params_in_ee.contains(QUICTransportParameterId::DISABLE_ACTIVE_MIGRATION));
   }
 
   SECTION("Duplicate parameters")
@@ -281,7 +281,7 @@
 
     uint16_t max_packet_size = 0x1bcd;
     params_in_ee.set(QUICTransportParameterId::MAX_PACKET_SIZE, max_packet_size);
-    params_in_ee.set(QUICTransportParameterId::DISABLE_MIGRATION, nullptr, 0);
+    params_in_ee.set(QUICTransportParameterId::DISABLE_ACTIVE_MIGRATION, nullptr, 0);
 
     params_in_ee.add_version(0x01020304);
     params_in_ee.add_version(0x05060708);
diff --git a/iocore/net/quic/test/test_QUICType.cc b/iocore/net/quic/test/test_QUICType.cc
index aff8247..fb45c44 100644
--- a/iocore/net/quic/test/test_QUICType.cc
+++ b/iocore/net/quic/test/test_QUICType.cc
@@ -30,6 +30,74 @@
 
 TEST_CASE("QUICType", "[quic]")
 {
+  SECTION("QUICPath")
+  {
+    IpEndpoint local_a, local_b, remote_a, remote_b;
+    QUICPath path_a = {{}, {}}, path_b = {{}, {}};
+
+    // The same addresses and ports -> TRUE
+    ats_ip_pton("192.168.0.1:4433", &local_a);
+    ats_ip_pton("192.168.1.1:12345", &remote_a);
+    ats_ip_pton("192.168.0.1:4433", &local_b);
+    ats_ip_pton("192.168.1.1:12345", &remote_b);
+    path_a = {local_a, remote_a};
+    path_b = {local_b, remote_b};
+    CHECK(path_a == path_b);
+    CHECK(path_b == path_a);
+    path_a = {remote_a, local_a};
+    path_b = {remote_b, local_b};
+    CHECK(path_a == path_b);
+    CHECK(path_b == path_a);
+
+    // Different ports -> FALSE
+    ats_ip_pton("192.168.0.1:4433", &local_a);
+    ats_ip_pton("192.168.1.1:12345", &remote_a);
+    ats_ip_pton("192.168.0.1:4433", &local_b);
+    ats_ip_pton("192.168.1.1:54321", &remote_b);
+    path_a = {local_a, remote_a};
+    path_b = {local_b, remote_b};
+    CHECK(!(path_a == path_b));
+    CHECK(!(path_b == path_a));
+    path_a = {remote_a, local_a};
+    path_b = {remote_b, local_b};
+    CHECK(!(path_a == path_b));
+    CHECK(!(path_b == path_a));
+
+    // Different addresses but the same ports -> FALSE
+    ats_ip_pton("192.168.0.1:4433", &local_a);
+    ats_ip_pton("192.168.1.1:12345", &remote_a);
+    ats_ip_pton("192.168.0.1:4433", &local_b);
+    ats_ip_pton("192.168.2.1:12345", &remote_b);
+    path_a = {local_a, remote_a};
+    path_b = {local_b, remote_b};
+    CHECK(!(path_a == path_b));
+    CHECK(!(path_b == path_a));
+    path_a = {remote_a, local_a};
+    path_b = {remote_b, local_b};
+    CHECK(!(path_a == path_b));
+    CHECK(!(path_b == path_a));
+
+    // Server local address is any -> TRUE
+    ats_ip_pton("0.0.0.0:4433", &local_a);
+    ats_ip_pton("192.168.1.1:12345", &remote_a);
+    ats_ip_pton("192.168.0.1:4433", &local_b);
+    ats_ip_pton("192.168.1.1:12345", &remote_b);
+    path_a = {local_a, remote_a};
+    path_b = {local_b, remote_b};
+    CHECK(path_a == path_b);
+    CHECK(path_b == path_a);
+
+    // Client local address and port are any -> TRUE
+    ats_ip_pton("0.0.0.0:0", &local_a);
+    ats_ip_pton("192.168.1.1:12345", &remote_a);
+    ats_ip_pton("192.168.0.1:4433", &local_b);
+    ats_ip_pton("192.168.1.1:12345", &remote_b);
+    path_a = {local_a, remote_a};
+    path_b = {local_b, remote_b};
+    CHECK(path_a == path_b);
+    CHECK(path_b == path_a);
+  }
+
   SECTION("QUICRetryToken")
   {
     IpEndpoint ep;
diff --git a/mgmt/RecordsConfig.cc b/mgmt/RecordsConfig.cc
index 080d9f2..e31cdbb 100644
--- a/mgmt/RecordsConfig.cc
+++ b/mgmt/RecordsConfig.cc
@@ -1372,7 +1372,7 @@
   ,
   {RECT_CONFIG, "proxy.config.quic.initial_max_stream_data_uni_in", RECD_INT, "4096", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
   ,
-  {RECT_CONFIG, "proxy.config.quic.initial_max_stream_data_uni_out", RECD_INT, "0", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
+  {RECT_CONFIG, "proxy.config.quic.initial_max_stream_data_uni_out", RECD_INT, "4096", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
   ,
   {RECT_CONFIG, "proxy.config.quic.initial_max_streams_bidi_in", RECD_INT, "100", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
   ,
@@ -1390,6 +1390,10 @@
   ,
   {RECT_CONFIG, "proxy.config.quic.max_ack_delay_out", RECD_INT, "25", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
   ,
+  {RECT_CONFIG, "proxy.config.quic.active_cid_limit_in", RECD_INT, "4", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
+  ,
+  {RECT_CONFIG, "proxy.config.quic.active_cid_limit_out", RECD_INT, "8", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
+  ,
   // Constants of Loss Detection
   {RECT_CONFIG, "proxy.config.quic.loss_detection.packet_threshold", RECD_INT, "3", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
   ,
@@ -1397,7 +1401,7 @@
   ,
   {RECT_CONFIG, "proxy.config.quic.loss_detection.granularity", RECD_INT, "1", RECU_DYNAMIC, RR_NULL, RECC_STR, "[0-1]", RECA_NULL}
   ,
-  {RECT_CONFIG, "proxy.config.quic.loss_detection.initial_rtt", RECD_INT, "100", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
+  {RECT_CONFIG, "proxy.config.quic.loss_detection.initial_rtt", RECD_INT, "500", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[0-9]+$", RECA_NULL}
   ,
 
   // Constatns of Congestion Control
@@ -1409,7 +1413,7 @@
   ,
   {RECT_CONFIG, "proxy.config.quic.congestion_control.loss_reduction_factor", RECD_FLOAT, "0.5", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[\\.0-9]+$", RECA_NULL}
   ,
-  {RECT_CONFIG, "proxy.config.quic.congestion_control.persistent_congestion_threshold", RECD_INT, "2", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[\\.0-9]+$", RECA_NULL}
+  {RECT_CONFIG, "proxy.config.quic.congestion_control.persistent_congestion_threshold", RECD_INT, "3", RECU_DYNAMIC, RR_NULL, RECC_STR, "^-?[\\.0-9]+$", RECA_NULL}
   ,
 
   //# Add LOCAL Records Here
diff --git a/proxy/http3/QPACK.h b/proxy/http3/QPACK.h
index 85bd710..feb1068 100644
--- a/proxy/http3/QPACK.h
+++ b/proxy/http3/QPACK.h
@@ -151,12 +151,12 @@
   {
   public:
     DecodeRequest(uint16_t largest_reference, EThread *thread, Continuation *continuation, uint64_t stream_id,
-                  const uint8_t *header_blcok, size_t header_block_len, HTTPHdr &hdr)
+                  const uint8_t *header_block, size_t header_block_len, HTTPHdr &hdr)
       : _largest_reference(largest_reference),
         _thread(thread),
         _continuation(continuation),
         _stream_id(stream_id),
-        _header_block(header_blcok),
+        _header_block(header_block),
         _header_block_len(header_block_len),
         _hdr(hdr)
     {
diff --git a/src/traffic_quic/quic_client.cc b/src/traffic_quic/quic_client.cc
index 007c20a..7f3ec64 100644
--- a/src/traffic_quic/quic_client.cc
+++ b/src/traffic_quic/quic_client.cc
@@ -33,8 +33,8 @@
 // https://www.openssl.org/docs/manmaster/man3/SSL_CTX_set_alpn_protos.html
 // Should be integrate with IP_PROTO_TAG_HTTP_QUIC in ts/ink_inet.h ?
 using namespace std::literals;
-static constexpr std::string_view HQ_ALPN_PROTO_LIST("\5hq-20"sv);
-static constexpr std::string_view H3_ALPN_PROTO_LIST("\5h3-20"sv);
+static constexpr std::string_view HQ_ALPN_PROTO_LIST("\5hq-23"sv);
+static constexpr std::string_view H3_ALPN_PROTO_LIST("\5h3-23"sv);
 
 QUICClient::QUICClient(const QUICClientConfig *config) : Continuation(new_ProxyMutex()), _config(config)
 {
diff --git a/src/tscore/ink_inet.cc b/src/tscore/ink_inet.cc
index 6483850..9f36ce9 100644
--- a/src/tscore/ink_inet.cc
+++ b/src/tscore/ink_inet.cc
@@ -50,8 +50,8 @@
 const std::string_view IP_PROTO_TAG_HTTP_1_0("http/1.0"sv);
 const std::string_view IP_PROTO_TAG_HTTP_1_1("http/1.1"sv);
 const std::string_view IP_PROTO_TAG_HTTP_2_0("h2"sv);     // HTTP/2 over TLS
-const std::string_view IP_PROTO_TAG_HTTP_QUIC("hq-20"sv); // HTTP/0.9 over QUIC
-const std::string_view IP_PROTO_TAG_HTTP_3("h3-20"sv);    // HTTP/3 over QUIC
+const std::string_view IP_PROTO_TAG_HTTP_QUIC("hq-23"sv); // HTTP/0.9 over QUIC
+const std::string_view IP_PROTO_TAG_HTTP_3("h3-23"sv);    // HTTP/3 over QUIC
 
 const std::string_view UNIX_PROTO_TAG{"unix"sv};