trafficserver-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mas...@apache.org
Subject [trafficserver] 01/03: Handle CONNECTION_CLOSE frame on QUICNetVConnection
Date Mon, 14 Aug 2017 08:34:32 GMT
This is an automated email from the ASF dual-hosted git repository.

maskit pushed a commit to branch quic-latest
in repository https://gitbox.apache.org/repos/asf/trafficserver.git

commit c4a8ea6adaf59b234f299f38935aa68362dc8617
Author: Masakazu Kitajo <maskit@apache.org>
AuthorDate: Mon Aug 14 16:55:05 2017 +0900

    Handle CONNECTION_CLOSE frame on QUICNetVConnection
    
    Integrate QUICConnectionManager into QUICNetVConnection.
---
 iocore/net/P_QUICNetVConnection.h                  |  29 +++--
 iocore/net/QUICNetVConnection.cc                   | 117 ++++++++++++++-------
 iocore/net/quic/Makefile.am                        |   1 -
 iocore/net/quic/Mock.h                             |  87 +++++++--------
 .../{QUICConnectionManager.h => QUICConnection.h}  |  14 +--
 iocore/net/quic/QUICConnectionManager.cc           |  42 --------
 iocore/net/quic/QUICFrameDispatcher.cc             |  11 +-
 iocore/net/quic/QUICFrameDispatcher.h              |   6 +-
 iocore/net/quic/QUICFrameHandler.h                 |   1 +
 iocore/net/quic/QUICPacket.cc                      |   4 +-
 iocore/net/quic/test/Makefile.am                   |   2 -
 iocore/net/quic/test/test_QUICFrameDispatcher.cc   |   8 +-
 12 files changed, 162 insertions(+), 160 deletions(-)

diff --git a/iocore/net/P_QUICNetVConnection.h b/iocore/net/P_QUICNetVConnection.h
index 09caae2..3bba2e8 100644
--- a/iocore/net/P_QUICNetVConnection.h
+++ b/iocore/net/P_QUICNetVConnection.h
@@ -42,6 +42,7 @@
 #include "ts/apidefs.h"
 #include "ts/List.h"
 
+#include "quic/QUICConnection.h"
 #include "quic/QUICVersionNegotiator.h"
 #include "quic/QUICPacket.h"
 #include "quic/QUICFrame.h"
@@ -52,10 +53,7 @@
 #include "quic/QUICCrypto.h"
 #include "quic/QUICAckFrameCreator.h"
 #include "quic/QUICLossDetector.h"
-#include "quic/QUICPacketTransmitter.h"
-#include "quic/QUICFrameTransmitter.h"
 #include "quic/QUICStreamManager.h"
-#include "quic/QUICConnectionManager.h"
 #include "quic/QUICFlowController.h"
 #include "quic/QUICCongestionController.h"
 
@@ -134,13 +132,19 @@ class QUICLossDetector;
  *  | WRITE:
  *  |   _state_common_send_packet()
  *  v
+ * state_connection_closing() (If closing actively)
+ *  | READ:
+ *  |   _state_connection_established_process_packet()
+ *  | WRITE:
+ *  |   _state_common_send_packet()
+ *  v
  * state_connection_close()
  *    READ:
  *      Do nothing
  *    WRITE:
  *      _state_common_send_packet()
  **/
-class QUICNetVConnection : public UnixNetVConnection, public QUICPacketTransmitter, public
QUICFrameTransmitter
+class QUICNetVConnection : public UnixNetVConnection, public QUICConnection
 {
   typedef UnixNetVConnection super; ///< Parent type.
 
@@ -155,15 +159,12 @@ public:
   int startEvent(int event, Event *e);
   int state_handshake(int event, Event *data);
   int state_connection_established(int event, Event *data);
+  int state_connection_closing(int event, Event *data);
   int state_connection_closed(int event, Event *data);
   void start(SSL_CTX *);
   uint32_t maximum_quic_packet_size();
   uint32_t minimum_quic_packet_size();
-  virtual void transmit_packet(std::unique_ptr<const QUICPacket> packet) override;
-  virtual void retransmit_packet(const QUICPacket &packet) override;
-  virtual Ptr<ProxyMutex> get_transmitter_mutex() override;
   void push_packet(std::unique_ptr<const QUICPacket> packet);
-  virtual void transmit_frame(std::unique_ptr<QUICFrame, QUICFrameDeleterFunc> frame)
override;
   void close(QUICError error);
   void free(EThread *t) override;
 
@@ -174,6 +175,17 @@ public:
   virtual void net_read_io(NetHandler *nh, EThread *lthread) override;
   virtual int64_t load_buffer_and_write(int64_t towrite, MIOBufferAccessor &buf, int64_t
&total_written, int &needs) override;
 
+  // QUICConnection (QUICPacketTransmitter)
+  virtual void transmit_packet(std::unique_ptr<const QUICPacket> packet) override;
+  virtual void retransmit_packet(const QUICPacket &packet) override;
+  virtual Ptr<ProxyMutex> get_transmitter_mutex() override;
+
+  // QUICConnection (QUICFrameTransmitter)
+  virtual void transmit_frame(std::unique_ptr<QUICFrame, QUICFrameDeleterFunc> frame)
override;
+
+  // QUICConnection (QUICFrameHandler)
+  void handle_frame(std::shared_ptr<const QUICFrame> frame) override;
+
 private:
   QUICConnectionId _quic_connection_id;
   UDPConnection *_udp_con            = nullptr;
@@ -209,6 +221,7 @@ private:
   QUICError _state_handshake_process_client_cleartext_packet(std::unique_ptr<const QUICPacket>
packet);
   QUICError _state_handshake_process_zero_rtt_protected_packet(std::unique_ptr<const QUICPacket>
packet);
   QUICError _state_connection_established_process_packet(std::unique_ptr<const QUICPacket>
packet);
+  QUICError _state_common_receive_packet();
   QUICError _state_common_send_packet();
 
   Ptr<ProxyMutex> _transmitter_mutex;
diff --git a/iocore/net/QUICNetVConnection.cc b/iocore/net/QUICNetVConnection.cc
index 08477fe..da12ede 100644
--- a/iocore/net/QUICNetVConnection.cc
+++ b/iocore/net/QUICNetVConnection.cc
@@ -97,11 +97,10 @@ QUICNetVConnection::start(SSL_CTX *ssl_ctx)
   this->_stream_manager->init(this);
   this->_stream_manager->set_connection(this); // FIXME Want to remove;
 
-  std::shared_ptr<QUICConnectionManager> connectionManager       = std::make_shared<QUICConnectionManager>(this);
   std::shared_ptr<QUICFlowController> flowController             = std::make_shared<QUICFlowController>();
   std::shared_ptr<QUICCongestionController> congestionController = std::make_shared<QUICCongestionController>();
   this->_frame_dispatcher =
-    new QUICFrameDispatcher(connectionManager, this->_stream_manager, flowController,
congestionController, this->_loss_detector);
+    new QUICFrameDispatcher(this, this->_stream_manager, flowController, congestionController,
this->_loss_detector);
 }
 
 void
@@ -212,7 +211,29 @@ QUICNetVConnection::transmit_frame(std::unique_ptr<QUICFrame, QUICFrameDeleterFu
 void
 QUICNetVConnection::close(QUICError error)
 {
-  this->transmit_frame(QUICFrameFactory::create_connection_close_frame(error.code, 0,
""));
+  if (this->handler == reinterpret_cast<ContinuationHandler>(&QUICNetVConnection::state_connection_closed)
||
+      this->handler == reinterpret_cast<ContinuationHandler>(&QUICNetVConnection::state_connection_closing))
{
+    // do nothing
+  } else {
+    DebugQUICCon("Enter state_connection_closing");
+    SET_HANDLER((NetVConnHandler)&QUICNetVConnection::state_connection_closing);
+    this->transmit_frame(QUICFrameFactory::create_connection_close_frame(error.code, 0,
""));
+  }
+}
+
+void
+QUICNetVConnection::handle_frame(std::shared_ptr<const QUICFrame> frame)
+{
+  switch (frame->type()) {
+  case QUICFrameType::CONNECTION_CLOSE:
+    DebugQUICCon("Enter state_connection_closed");
+    SET_HANDLER((NetVConnHandler)&QUICNetVConnection::state_connection_closed);
+    break;
+  default:
+    DebugQUICCon("Unexpected frame type: %02x", static_cast<unsigned int>(frame->type()));
+    ink_assert(false);
+    break;
+  }
 }
 
 // TODO: Timeout by active_timeout / inactive_timeout
@@ -286,18 +307,7 @@ QUICNetVConnection::state_connection_established(int event, Event *data)
   QUICError error;
   switch (event) {
   case QUIC_EVENT_PACKET_READ_READY: {
-    std::unique_ptr<const QUICPacket> p = std::unique_ptr<const QUICPacket>(this->_packet_recv_queue.dequeue());
-    net_activity(this, this_ethread());
-
-    switch (p->type()) {
-    case QUICPacketType::ONE_RTT_PROTECTED_KEY_PHASE_0:
-    case QUICPacketType::ONE_RTT_PROTECTED_KEY_PHASE_1:
-      error = this->_state_connection_established_process_packet(std::move(p));
-      break;
-    default:
-      error = QUICError(QUICErrorClass::QUIC_TRANSPORT, QUICErrorCode::QUIC_INTERNAL_ERROR);
-      break;
-    }
+    error = this->_state_common_receive_packet();
     break;
   }
   case QUIC_EVENT_PACKET_WRITE_READY: {
@@ -306,16 +316,11 @@ QUICNetVConnection::state_connection_established(int event, Event *data)
   }
 
   case EVENT_IMMEDIATE: {
-    // Start Implicit Shutdown. Because no network activity for the duration of the idle
timeout.
+    // Start Implicit Shutdown. Because of no network activity for the duration of the idle
timeout.
     this->remove_from_active_queue();
+    this->close({});
 
     // TODO: signal VC_EVENT_ACTIVE_TIMEOUT/VC_EVENT_INACTIVITY_TIMEOUT to application
-    DebugQUICCon("Enter state_connection_close");
-    this->_state = QUICConnectionState::Closing;
-    SET_HANDLER((NetVConnHandler)&QUICNetVConnection::state_connection_closed);
-
-    this->close({QUICErrorClass::NONE, QUICErrorCode::QUIC_TRANSPORT_ERROR});
-
     break;
   }
   default:
@@ -331,6 +336,32 @@ QUICNetVConnection::state_connection_established(int event, Event *data)
 }
 
 int
+QUICNetVConnection::state_connection_closing(int event, Event *data)
+{
+  QUICError error;
+  switch (event) {
+  case QUIC_EVENT_PACKET_READ_READY: {
+    error = this->_state_common_receive_packet();
+    break;
+  }
+  case QUIC_EVENT_PACKET_WRITE_READY: {
+    this->_state_common_send_packet();
+    break;
+  }
+  default:
+    DebugQUICCon("Unexpected event: %u", event);
+  }
+
+  // FIXME Enter closed state if CONNECTION_CLOSE was ACKed
+  if (true) {
+    DebugQUICCon("Enter state_connection_closed");
+    SET_HANDLER((NetVConnHandler)&QUICNetVConnection::state_connection_closed);
+  }
+
+  return EVENT_DONE;
+}
+
+int
 QUICNetVConnection::state_connection_closed(int event, Event *data)
 {
   switch (event) {
@@ -339,24 +370,17 @@ QUICNetVConnection::state_connection_closed(int event, Event *data)
     break;
   }
   case QUIC_EVENT_PACKET_WRITE_READY: {
-    // TODO: Retransmit CONNECTION_CLOSE when Explicit Shutdown (Out of scope from first
implementation)
-    // Inplicit Shutdown
-    if (this->_state == QUICConnectionState::Closing) {
-      this->_state_common_send_packet();
-      this->_state = QUICConnectionState::Closed;
-
-      this->next_inactivity_timeout_at = 0;
-      this->next_activity_timeout_at   = 0;
+    this->next_inactivity_timeout_at = 0;
+    this->next_activity_timeout_at   = 0;
 
-      this->inactivity_timeout_in = 0;
-      this->active_timeout_in     = 0;
+    this->inactivity_timeout_in = 0;
+    this->active_timeout_in     = 0;
 
-      // TODO: Drop record from Connection-ID - QUICNetVConnection table in QUICPacketHandler
-      // Shutdown loss detector
-      this->_loss_detector->handleEvent(QUIC_EVENT_LD_SHUTDOWN, nullptr);
+    // TODO: Drop record from Connection-ID - QUICNetVConnection table in QUICPacketHandler
+    // Shutdown loss detector
+    this->_loss_detector->handleEvent(QUIC_EVENT_LD_SHUTDOWN, nullptr);
 
-      this->free(this_ethread());
-    }
+    this->free(this_ethread());
 
     break;
   }
@@ -493,6 +517,25 @@ QUICNetVConnection::_state_connection_established_process_packet(std::unique_ptr
 }
 
 QUICError
+QUICNetVConnection::_state_common_receive_packet()
+{
+  QUICError error;
+  std::unique_ptr<const QUICPacket> p = std::unique_ptr<const QUICPacket>(this->_packet_recv_queue.dequeue());
+  net_activity(this, this_ethread());
+
+  switch (p->type()) {
+  case QUICPacketType::ONE_RTT_PROTECTED_KEY_PHASE_0:
+  case QUICPacketType::ONE_RTT_PROTECTED_KEY_PHASE_1:
+    error = this->_state_connection_established_process_packet(std::move(p));
+    break;
+  default:
+    error = QUICError(QUICErrorClass::QUIC_TRANSPORT, QUICErrorCode::QUIC_INTERNAL_ERROR);
+    break;
+  }
+  return error;
+}
+
+QUICError
 QUICNetVConnection::_state_common_send_packet()
 {
   this->_packetize_frames();
diff --git a/iocore/net/quic/Makefile.am b/iocore/net/quic/Makefile.am
index 714874c..21e1fca 100644
--- a/iocore/net/quic/Makefile.am
+++ b/iocore/net/quic/Makefile.am
@@ -45,7 +45,6 @@ libquic_a_SOURCES = \
   QUICFrame.cc \
   QUICFrameDispatcher.cc \
   QUICVersionNegotiator.cc \
-  QUICConnectionManager.cc \
   QUICLossDetector.cc \
   QUICStreamManager.cc \
   QUICFlowController.cc \
diff --git a/iocore/net/quic/Mock.h b/iocore/net/quic/Mock.h
index 9483ce3..164b808 100644
--- a/iocore/net/quic/Mock.h
+++ b/iocore/net/quic/Mock.h
@@ -1,4 +1,3 @@
-#include "QUICConnectionManager.h"
 #include "QUICStreamManager.h"
 #include "QUICFlowController.h"
 #include "QUICCongestionController.h"
@@ -6,10 +5,10 @@
 #include "QUICEvents.h"
 #include "QUICPacketTransmitter.h"
 
-class MockQUICPacketTransmitter : public QUICPacketTransmitter
+class MockQUICConnection : public QUICConnection
 {
 public:
-  MockQUICPacketTransmitter() : QUICPacketTransmitter() { this->_mutex = new_ProxyMutex();
};
+  MockQUICConnection() : QUICConnection() { this->_mutex = new_ProxyMutex(); };
 
   void
   transmit_packet(std::unique_ptr<const QUICPacket> packet) override
@@ -29,76 +28,78 @@ public:
     return this->_mutex;
   }
 
-  int _transmit_count   = 0;
-  int _retransmit_count = 0;
-  Ptr<ProxyMutex> _mutex;
-};
-
-class MockQUICFrameTransmitter : public QUICFrameTransmitter
-{
   void
-  transmit_frame(std::unique_ptr<QUICFrame, QUICFrameDeleterFunc> frame)
+  transmit_frame(std::unique_ptr<QUICFrame, QUICFrameDeleterFunc> frame) override
   {
   }
-};
-
-class MockQUICLossDetector : public QUICLossDetector
-{
-public:
-  MockQUICLossDetector() : QUICLossDetector(new MockQUICPacketTransmitter()) {}
 
   void
-  rcv_frame(std::shared_ptr<const QUICFrame>)
+  handle_frame(std::shared_ptr<const QUICFrame> f) override
   {
   }
 
-  void
-  on_packet_sent(std::unique_ptr<const QUICPacket> packet)
+  int
+  getTotalFrameCount()
   {
+    return _totalFrameCount;
   }
+
+  int _transmit_count   = 0;
+  int _retransmit_count = 0;
+  Ptr<ProxyMutex> _mutex;
+  int _totalFrameCount = 0;
 };
 
-class MockQUICConnectionManager : public QUICConnectionManager
+class MockQUICPacketTransmitter : public QUICPacketTransmitter
 {
 public:
-  MockQUICConnectionManager() : QUICConnectionManager(new MockQUICFrameTransmitter()) {}
+  MockQUICPacketTransmitter() : QUICPacketTransmitter() { this->_mutex = new_ProxyMutex();
};
 
-  // Override
-  virtual void
-  handle_frame(std::shared_ptr<const QUICFrame> f) override
+  void
+  transmit_packet(std::unique_ptr<const QUICPacket> packet) override
   {
-    ++_frameCount[static_cast<int>(f->type())];
-    ++_totalFrameCount;
+    ++_transmit_count;
   }
 
-  // for Test
-  int
-  getStreamFrameCount()
+  void
+  retransmit_packet(const QUICPacket &packet) override
   {
-    return _frameCount[static_cast<int>(QUICFrameType::STREAM)];
+    ++_retransmit_count;
   }
 
-  int
-  getAckFrameCount()
+  Ptr<ProxyMutex>
+  get_transmitter_mutex() override
   {
-    return _frameCount[static_cast<int>(QUICFrameType::ACK)];
+    return this->_mutex;
   }
 
-  int
-  getPingFrameCount()
+  int _transmit_count   = 0;
+  int _retransmit_count = 0;
+  Ptr<ProxyMutex> _mutex;
+};
+
+class MockQUICFrameTransmitter : public QUICFrameTransmitter
+{
+  void
+  transmit_frame(std::unique_ptr<QUICFrame, QUICFrameDeleterFunc> frame)
   {
-    return _frameCount[static_cast<int>(QUICFrameType::PING)];
   }
+};
 
-  int
-  getTotalFrameCount()
+class MockQUICLossDetector : public QUICLossDetector
+{
+public:
+  MockQUICLossDetector() : QUICLossDetector(new MockQUICPacketTransmitter()) {}
+
+  void
+  rcv_frame(std::shared_ptr<const QUICFrame>)
   {
-    return _totalFrameCount;
   }
 
-private:
-  int _totalFrameCount = 0;
-  int _frameCount[256] = {0};
+  void
+  on_packet_sent(std::unique_ptr<const QUICPacket> packet)
+  {
+  }
 };
 
 class MockQUICStreamManager : public QUICStreamManager
diff --git a/iocore/net/quic/QUICConnectionManager.h b/iocore/net/quic/QUICConnection.h
similarity index 72%
rename from iocore/net/quic/QUICConnectionManager.h
rename to iocore/net/quic/QUICConnection.h
index 3a67734..bf71ba8 100644
--- a/iocore/net/quic/QUICConnectionManager.h
+++ b/iocore/net/quic/QUICConnection.h
@@ -23,18 +23,10 @@
 
 #pragma once
 
-#include <QUICFrameHandler.h>
-#include <QUICFrame.h>
+#include "QUICPacketTransmitter.h"
 #include "QUICFrameTransmitter.h"
+#include "QUICFrameHandler.h"
 
-class QUICConnectionManager : public QUICFrameHandler
+class QUICConnection : public QUICPacketTransmitter, public QUICFrameTransmitter, public
QUICFrameHandler
 {
-public:
-  QUICConnectionManager(QUICFrameTransmitter *tx) : _tx(tx){};
-  virtual void handle_frame(std::shared_ptr<const QUICFrame> frame) override;
-
-private:
-  QUICFrameTransmitter *_tx = nullptr;
-
-  void _handle_ping_frame(const QUICPingFrame *);
 };
diff --git a/iocore/net/quic/QUICConnectionManager.cc b/iocore/net/quic/QUICConnectionManager.cc
deleted file mode 100644
index 85654f2..0000000
--- a/iocore/net/quic/QUICConnectionManager.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-/** @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 <QUICConnectionManager.h>
-
-const static char *tag = "quic_connection_manager";
-
-void
-QUICConnectionManager::handle_frame(std::shared_ptr<const QUICFrame> frame)
-{
-  switch (frame->type()) {
-  case QUICFrameType::CONNECTION_CLOSE:
-  case QUICFrameType::STREAM:
-  case QUICFrameType::GOAWAY:
-  case QUICFrameType::PING:
-    break;
-  default:
-    Debug(tag, "Unexpected frame type: %02x", static_cast<unsigned int>(frame->type()));
-    ink_assert(false);
-    break;
-  }
-}
diff --git a/iocore/net/quic/QUICFrameDispatcher.cc b/iocore/net/quic/QUICFrameDispatcher.cc
index faf664a..724e04f 100644
--- a/iocore/net/quic/QUICFrameDispatcher.cc
+++ b/iocore/net/quic/QUICFrameDispatcher.cc
@@ -22,7 +22,7 @@
  */
 
 #include "QUICFrameDispatcher.h"
-#include "QUICConnectionManager.h"
+#include "QUICConnection.h"
 #include "QUICStreamManager.h"
 #include "QUICFlowController.h"
 #include "QUICCongestionController.h"
@@ -34,13 +34,12 @@ const static char *tag = "quic_frame_handler";
 //
 // Frame Dispatcher
 //
-QUICFrameDispatcher::QUICFrameDispatcher(const std::shared_ptr<QUICConnectionManager>
cmgr,
-                                         const std::shared_ptr<QUICStreamManager> smgr,
+QUICFrameDispatcher::QUICFrameDispatcher(QUICConnection *connection, const std::shared_ptr<QUICStreamManager>
smgr,
                                          const std::shared_ptr<QUICFlowController>
fctlr,
                                          const std::shared_ptr<QUICCongestionController>
cctlr,
                                          const std::shared_ptr<QUICLossDetector> ld)
 {
-  connectionManager    = cmgr;
+  this->_connection    = connection;
   streamManager        = smgr;
   flowController       = fctlr;
   congestionController = cctlr;
@@ -79,12 +78,11 @@ QUICFrameDispatcher::receive_frames(const uint8_t *payload, uint16_t size)
       break;
     }
     case QUICFrameType::CONNECTION_CLOSE: {
-      connectionManager->handle_frame(frame);
+      this->_connection->handle_frame(frame);
       should_send_ack = true;
       break;
     }
     case QUICFrameType::GOAWAY: {
-      connectionManager->handle_frame(frame);
       should_send_ack = true;
       break;
     }
@@ -103,7 +101,6 @@ QUICFrameDispatcher::receive_frames(const uint8_t *payload, uint16_t size)
       break;
     }
     case QUICFrameType::PING: {
-      connectionManager->handle_frame(frame);
       should_send_ack = true;
       break;
     }
diff --git a/iocore/net/quic/QUICFrameDispatcher.h b/iocore/net/quic/QUICFrameDispatcher.h
index c16316b..2fd7f34 100644
--- a/iocore/net/quic/QUICFrameDispatcher.h
+++ b/iocore/net/quic/QUICFrameDispatcher.h
@@ -25,16 +25,16 @@
 
 #include "QUICFrame.h"
 
+class QUICConnection;
 class QUICStreamManager;
 class QUICFlowController;
-class QUICConnectionManager;
 class QUICCongestionController;
 class QUICLossDetector;
 
 class QUICFrameDispatcher
 {
 public:
-  QUICFrameDispatcher(const std::shared_ptr<QUICConnectionManager> cmgr, const std::shared_ptr<QUICStreamManager>
smgr,
+  QUICFrameDispatcher(QUICConnection *connection, const std::shared_ptr<QUICStreamManager>
smgr,
                       const std::shared_ptr<QUICFlowController> fctlr, const std::shared_ptr<QUICCongestionController>
cctlr,
                       const std::shared_ptr<QUICLossDetector> ld);
   /*
@@ -42,12 +42,12 @@ public:
    */
   bool receive_frames(const uint8_t *payload, uint16_t size);
 
-  std::shared_ptr<QUICConnectionManager> connectionManager       = nullptr;
   std::shared_ptr<QUICStreamManager> streamManager               = nullptr;
   std::shared_ptr<QUICFlowController> flowController             = nullptr;
   std::shared_ptr<QUICCongestionController> congestionController = nullptr;
   std::shared_ptr<QUICLossDetector> lossDetector                 = nullptr;
 
 private:
+  QUICConnection *_connection = nullptr;
   QUICFrameFactory _frame_factory;
 };
diff --git a/iocore/net/quic/QUICFrameHandler.h b/iocore/net/quic/QUICFrameHandler.h
index 6a99bac..d4554fe 100644
--- a/iocore/net/quic/QUICFrameHandler.h
+++ b/iocore/net/quic/QUICFrameHandler.h
@@ -27,5 +27,6 @@
 
 class QUICFrameHandler
 {
+public:
   virtual void handle_frame(std::shared_ptr<const QUICFrame> frame) = 0;
 };
diff --git a/iocore/net/quic/QUICPacket.cc b/iocore/net/quic/QUICPacket.cc
index 8b41218..cb45080 100644
--- a/iocore/net/quic/QUICPacket.cc
+++ b/iocore/net/quic/QUICPacket.cc
@@ -636,8 +636,8 @@ QUICPacketFactory::create_server_protected_packet(QUICConnectionId connection_id
   if (this->_crypto->encrypt(cipher_txt.get(), cipher_txt_len, max_cipher_txt_len,
packet->payload(), packet->payload_size(),
                              packet->packet_number(), ad, ad_len, packet->key_phase()))
{
     packet->set_protected_payload(std::move(cipher_txt), cipher_txt_len);
-    Debug("quic_packet_factory", "Encrypt Packet, pkt_num: %" PRIu64 ", header_len: %zu payload:
%zu", packet->packet_number(), ad_len,
-          cipher_txt_len);
+    Debug("quic_packet_factory", "Encrypt Packet, pkt_num: %" PRIu64 ", header_len: %zu payload:
%zu", packet->packet_number(),
+          ad_len, cipher_txt_len);
     return packet;
   } else {
     Debug("quic_packet_factory", "CRYPTOGRAPHIC Error");
diff --git a/iocore/net/quic/test/Makefile.am b/iocore/net/quic/test/Makefile.am
index 1216cda..5837352 100644
--- a/iocore/net/quic/test/Makefile.am
+++ b/iocore/net/quic/test/Makefile.am
@@ -143,7 +143,6 @@ test_QUICFrameDispatcher_SOURCES = \
   main.cc \
   test_QUICFrameDispatcher.cc \
   ../QUICFrameDispatcher.cc \
-  ../QUICConnectionManager.cc \
   ../QUICStreamManager.cc \
   ../QUICFlowController.cc \
   ../QUICCongestionController.cc \
@@ -210,7 +209,6 @@ test_QUICStream_SOURCES = \
   test_QUICStream.cc \
   ../QUICStream.cc \
   ../QUICFrameDispatcher.cc \
-  ../QUICConnectionManager.cc \
   ../QUICStreamManager.cc \
   ../QUICFlowController.cc \
   ../QUICCongestionController.cc
diff --git a/iocore/net/quic/test/test_QUICFrameDispatcher.cc b/iocore/net/quic/test/test_QUICFrameDispatcher.cc
index a406a45..6f5f052 100644
--- a/iocore/net/quic/test/test_QUICFrameDispatcher.cc
+++ b/iocore/net/quic/test/test_QUICFrameDispatcher.cc
@@ -32,15 +32,15 @@ TEST_CASE("QUICFrameHandler", "[quic]")
   uint8_t payload[] = {0x01};
   QUICStreamFrame streamFrame(payload, 1, 0x03, 0);
 
-  auto connectionManager    = std::make_shared<MockQUICConnectionManager>();
+  auto connection           = new MockQUICConnection();
   auto streamManager        = std::make_shared<MockQUICStreamManager>();
   auto flowController       = std::make_shared<MockQUICFlowController>();
   auto congestionController = std::make_shared<MockQUICCongestionController>();
   auto lossDetector         = std::make_shared<MockQUICLossDetector>();
-  QUICFrameDispatcher quicFrameDispatcher(connectionManager, streamManager, flowController,
congestionController, lossDetector);
+  QUICFrameDispatcher quicFrameDispatcher(connection, streamManager, flowController, congestionController,
lossDetector);
 
   // Initial state
-  CHECK(connectionManager->getTotalFrameCount() == 0);
+  CHECK(connection->getTotalFrameCount() == 0);
   CHECK(streamManager->getTotalFrameCount() == 0);
   CHECK(flowController->getTotalFrameCount() == 0);
   CHECK(congestionController->getTotalFrameCount() == 0);
@@ -50,7 +50,7 @@ TEST_CASE("QUICFrameHandler", "[quic]")
   size_t len        = 0;
   streamFrame.store(buf, &len);
   quicFrameDispatcher.receive_frames(buf, len);
-  CHECK(connectionManager->getTotalFrameCount() == 0);
+  CHECK(connection->getTotalFrameCount() == 0);
   CHECK(streamManager->getTotalFrameCount() == 1);
   CHECK(flowController->getTotalFrameCount() == 1);
   CHECK(congestionController->getTotalFrameCount() == 1);

-- 
To stop receiving notification emails like this one, please contact
"commits@trafficserver.apache.org" <commits@trafficserver.apache.org>.

Mime
View raw message