quiche: implement Envoy Quic stream and connection

bazel/external/quiche.BUILD

@@ -59,6 +59,8 @@ quiche_copt = [
     "-Wno-type-limits",
     # quic_inlined_frame.h uses offsetof() to optimize memory usage in frames.
     "-Wno-invalid-offsetof",
+    "-Wno-type-limits",
+    "-Wno-return-type",
 ]
 
 envoy_cc_test_library(
@@ -2014,6 +2016,7 @@ envoy_cc_library(
     copts = quiche_copt,
     repository = "@envoy",
     tags = ["nofips"],
+    visibility = ["//visibility:public"],
     deps = [
         ":quic_core_packets_lib",
         ":quic_platform_base",

include/envoy/api/io_error.h

@@ -31,6 +31,8 @@ class IoError {
     Interrupt,
     // Requested a nonexistent interface or a non-local source address.
     AddressNotAvailable,
+    // Bad file descriptor.
+    BadFd,
     // Other error codes cannot be mapped to any one above in getErrorCode().
     UnknownError
   };

source/common/network/io_socket_error_impl.cc

@@ -25,6 +25,8 @@ Api::IoError::IoErrorCode IoSocketError::getErrorCode() const {
     return IoErrorCode::Interrupt;
   case EADDRNOTAVAIL:
     return IoErrorCode::AddressNotAvailable;
+  case EBADF:
+    return IoErrorCode::BadFd;
   default:
     ENVOY_LOG_MISC(debug, "Unknown error code {} details {}", errno_, ::strerror(errno_));
     return IoErrorCode::UnknownError;

source/extensions/quic_listeners/quiche/BUILD

@@ -35,6 +35,18 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "envoy_quic_connection_helper_lib",
+    hdrs = ["envoy_quic_connection_helper.h"],
+    tags = ["nofips"],
+    deps = [
+        "//source/extensions/quic_listeners/quiche/platform:envoy_quic_clock_lib",
+        "@com_googlesource_quiche//:quic_core_buffer_allocator_lib",
+        "@com_googlesource_quiche//:quic_core_connection_lib",
+        "@com_googlesource_quiche//:quic_core_crypto_random_lib",
+    ],
+)
+
 envoy_cc_library(
     name = "envoy_quic_packet_writer_lib",
     srcs = ["envoy_quic_packet_writer.cc"],
@@ -80,10 +92,114 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "envoy_quic_stream_lib",
+    hdrs = ["envoy_quic_stream.h"],
+    tags = ["nofips"],
+    deps = [
+        "//include/envoy/http:codec_interface",
+        "//source/common/http:codec_helper_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "envoy_quic_server_stream_lib",
+    srcs = ["envoy_quic_server_stream.cc"],
+    hdrs = ["envoy_quic_server_stream.h"],
+    tags = ["nofips"],
+    deps = [
+        ":envoy_quic_stream_lib",
+        ":envoy_quic_utils_lib",
+        "//source/common/buffer:buffer_lib",
+        "//source/common/common:assert_lib",
+        "//source/common/http:header_map_lib",
+        "@com_googlesource_quiche//:quic_core_http_spdy_session_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "codec_impl_lib",
+    srcs = ["codec_impl.cc"],
+    hdrs = ["codec_impl.h"],
+    tags = ["nofips"],
+    deps = [
+        ":envoy_quic_server_session_lib",
+        "//include/envoy/http:codec_interface",
+        "@com_googlesource_quiche//:quic_core_http_spdy_session_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "envoy_quic_server_session_lib",
+    srcs = ["envoy_quic_server_session.cc"],
+    hdrs = ["envoy_quic_server_session.h"],
+    tags = ["nofips"],
+    deps = [
+        ":envoy_quic_connection_lib",
+        ":envoy_quic_server_stream_lib",
+        "//include/envoy/event:dispatcher_interface",
+        "//include/envoy/network:connection_interface",
+        "//source/common/common:empty_string",
+        "//source/common/network:filter_manager_lib",
+        "//source/common/stream_info:stream_info_lib",
+        "@com_googlesource_quiche//:quic_core_http_spdy_session_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "quic_io_handle_wrapper_lib",
+    hdrs = ["quic_io_handle_wrapper.h"],
+    deps = [
+        "//include/envoy/network:io_handle_interface",
+        "//source/common/network:io_socket_error_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "envoy_quic_connection_lib",
+    srcs = ["envoy_quic_connection.cc"],
+    hdrs = ["envoy_quic_connection.h"],
+    tags = ["nofips"],
+    deps = [
+        ":quic_io_handle_wrapper_lib",
+        "//include/envoy/network:connection_interface",
+        "//source/common/network:listen_socket_lib",
+        "//source/extensions/quic_listeners/quiche:envoy_quic_utils_lib",
+        "//source/server:connection_handler_lib",
+        "@com_googlesource_quiche//:quic_core_connection_lib",
+    ],
+)
+
+envoy_cc_library(
+    name = "envoy_quic_dispatcher_lib",
+    srcs = [
+        "envoy_quic_dispatcher.cc",
+    ],
+    hdrs = [
+        "envoy_quic_dispatcher.h",
+    ],
+    tags = ["nofips"],
+    deps = [
+        ":envoy_quic_connection_lib",
+        ":envoy_quic_proof_source_lib",
+        ":envoy_quic_server_session_lib",
+        "//include/envoy/network:listener_interface",
+        "//source/server:connection_handler_lib",
+        "@com_googlesource_quiche//:quic_core_server_lib",
+        "@com_googlesource_quiche//:quic_core_utils_lib",
+    ],
+)
+
 envoy_cc_library(
     name = "envoy_quic_utils_lib",
+    srcs = ["envoy_quic_utils.cc"],
     hdrs = ["envoy_quic_utils.h"],
     external_deps = ["quiche_quic_platform"],
     tags = ["nofips"],
-    deps = ["//source/common/network:address_lib"],
+    deps = [
+        "//include/envoy/http:codec_interface",
+        "//source/common/http:header_map_lib",
+        "//source/common/network:address_lib",
+        "@com_googlesource_quiche//:quic_core_http_header_list_lib",
+    ],
 )

source/extensions/quic_listeners/quiche/codec_impl.cc

@@ -0,0 +1,23 @@
+#include "extensions/quic_listeners/quiche/codec_impl.h"
+
+namespace Envoy {
+namespace Quic {
+
+void QuicHttpConnectionImplBase::goAway() {
+  quic_session_.SendGoAway(quic::QUIC_PEER_GOING_AWAY, "server shutdown imminent");
+}
+
+bool QuicHttpConnectionImplBase::wantsToWrite() { return quic_session_.HasDataToWrite(); }
+
+// TODO(danzh): modify QUIC stack to react based on aggregated bytes across all
+// the streams. And call StreamCallbackHelper::runHighWatermarkCallbacks() for each stream.
+void QuicHttpConnectionImplBase::onUnderlyingConnectionAboveWriteBufferHighWatermark() {
+  NOT_IMPLEMENTED_GCOVR_EXCL_LINE;
+}
+
+void QuicHttpConnectionImplBase::onUnderlyingConnectionBelowWriteBufferLowWatermark() {
+  NOT_IMPLEMENTED_GCOVR_EXCL_LINE;
+}
+
+} // namespace Quic
+} // namespace Envoy

source/extensions/quic_listeners/quiche/codec_impl.h

@@ -0,0 +1,58 @@
+#include "envoy/http/codec.h"
+
+#include "common/common/assert.h"
+#include "common/common/logger.h"
+
+#include "extensions/quic_listeners/quiche/envoy_quic_server_session.h"
+
+namespace Envoy {
+namespace Quic {
+
+// QuicHttpConnectionImplBase instance is a thin QUIC codec just providing quic interface to HCM.
+// Owned by HCM and created during onNewConnection() if the network connection
+// is a QUIC connection.
+class QuicHttpConnectionImplBase : public virtual Http::Connection,
+                                   protected Logger::Loggable<Logger::Id::quic> {
+public:
+  QuicHttpConnectionImplBase(EnvoyQuicServerSession& quic_session) : quic_session_(quic_session) {}
+
+  // Http::Connection
+  void dispatch(Buffer::Instance& /*data*/) override {
+    // Bypassed. QUIC connection already hands all data to streams.
+    NOT_REACHED_GCOVR_EXCL_LINE;
+  }
+  Http::Protocol protocol() override {
+    // From HCM's view, QUIC should behave the same as Http2, only the stats
+    // should be different.
+    // TODO(danzh) add Http3 enum value for QUIC.
+    return Http::Protocol::Http2;
+  }
+  void goAway() override;
+  // Returns true if the session has data to send but queued in connection or
+  // stream send buffer.
+  bool wantsToWrite() override;
+  void onUnderlyingConnectionAboveWriteBufferHighWatermark() override;
+  void onUnderlyingConnectionBelowWriteBufferLowWatermark() override;
+
+protected:
+  EnvoyQuicServerSession& quic_session_;
+};
+
+class QuicHttpServerConnectionImpl : public QuicHttpConnectionImplBase,
+                                     public Http::ServerConnection {
+public:
+  QuicHttpServerConnectionImpl(EnvoyQuicServerSession& quic_session,
+                               Http::ServerConnectionCallbacks& callbacks)
+      : QuicHttpConnectionImplBase(quic_session) {
+    quic_session.setHttpConnectionCallbacks(callbacks);
+  }
+
+  // Http::Connection
+  void shutdownNotice() override {
+    // TODO(danzh): Add double-GOAWAY support in QUIC.
+    ENVOY_CONN_LOG(error, "Shutdown notice is not propagated to QUIC.", quic_session_);
+  }
+};
+
+} // namespace Quic
+} // namespace Envoy

source/extensions/quic_listeners/quiche/envoy_quic_connection.cc

@@ -0,0 +1,59 @@
+#include "extensions/quic_listeners/quiche/envoy_quic_connection.h"
+
+#include "common/network/listen_socket_impl.h"
+
+#include "extensions/quic_listeners/quiche/envoy_quic_utils.h"
+#include "extensions/quic_listeners/quiche/quic_io_handle_wrapper.h"
+#include "extensions/transport_sockets/well_known_names.h"
+
+namespace Envoy {
+namespace Quic {
+
+EnvoyQuicConnection::EnvoyQuicConnection(
+    const quic::QuicConnectionId& server_connection_id,
+    quic::QuicSocketAddress initial_peer_address, quic::QuicConnectionHelperInterface& helper,
+    quic::QuicAlarmFactory& alarm_factory, quic::QuicPacketWriter& writer, bool owns_writer,
+    quic::Perspective perspective, const quic::ParsedQuicVersionVector& supported_versions,
+    Network::ListenerConfig& listener_config, Server::ListenerStats& listener_stats)
+    : quic::QuicConnection(server_connection_id, initial_peer_address, &helper, &alarm_factory,
+                           &writer, owns_writer, perspective, supported_versions),
+      listener_config_(listener_config), listener_stats_(listener_stats) {}
+
+bool EnvoyQuicConnection::OnPacketHeader(const quic::QuicPacketHeader& header) {
+  if (quic::QuicConnection::OnPacketHeader(header) && connection_socket_ == nullptr) {
+    ASSERT(self_address().IsInitialized());
+    // Self address should be initialized by now. It's time to install filters.
+    Network::Address::InstanceConstSharedPtr local_addr =
+        quicAddressToEnvoyAddressInstance(self_address());
+
+    Network::Address::InstanceConstSharedPtr remote_addr =
+        quicAddressToEnvoyAddressInstance(peer_address());
+    connection_socket_ = std::make_unique<Network::ConnectionSocketImpl>(
+        // Wraps the real IoHandle instance so that if this socket gets closed,
+        // the real IoHandle won't be affected.
+        std::make_unique<QuicIoHandleWrapper>(listener_config_.socket().ioHandle()),
+        std::move(local_addr), std::move(remote_addr));
+    connection_socket_->setDetectedTransportProtocol(
+        Extensions::TransportSockets::TransportSocketNames::get().Quic);
+
+    filter_chain_ = listener_config_.filterChainManager().findFilterChain(*connection_socket_);
+    if (filter_chain_ == nullptr) {
+      listener_stats_.no_filter_chain_match_.inc();
+      CloseConnection(quic::QUIC_CRYPTO_INTERNAL_ERROR,
+                      "closing connection: no matching filter chain found for handshake",
+                      quic::ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+      return false;
+    }
+    const bool empty_filter_chain = !listener_config_.filterChainFactory().createNetworkFilterChain(
+        *envoy_connection_, filter_chain_->networkFilterFactories());
+    if (empty_filter_chain) {
+      CloseConnection(quic::QUIC_CRYPTO_INTERNAL_ERROR, "closing connection: filter chain is empty",
+                      quic::ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace Quic
+} // namespace Envoy

source/extensions/quic_listeners/quiche/envoy_quic_connection.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#pragma GCC diagnostic push
+// QUICHE allows unused parameters.
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+// QUICHE uses offsetof().
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+
+#include "quiche/quic/core/quic_connection.h"
+
+#pragma GCC diagnostic pop
+
+#include <memory>
+
+#include "common/common/logger.h"
+#include "envoy/network/connection.h"
+#include "envoy/network/listener.h"
+#include "server/connection_handler_impl.h"
+
+namespace Envoy {
+namespace Quic {
+
+// Derived for network filter chain, stats and QoS. This is used on both client
+// and server side.
+class EnvoyQuicConnection : public quic::QuicConnection,
+                            protected Logger::Loggable<Logger::Id::connection> {
+public:
+  EnvoyQuicConnection(const quic::QuicConnectionId& server_connection_id,
+                      quic::QuicSocketAddress initial_peer_address,
+                      quic::QuicConnectionHelperInterface& helper,
+                      quic::QuicAlarmFactory& alarm_factory, quic::QuicPacketWriter& writer,
+                      bool owns_writer, quic::Perspective perspective,
+                      const quic::ParsedQuicVersionVector& supported_versions,
+                      Network::ListenerConfig& listener_config,
+                      Server::ListenerStats& listener_stats);
+
+  ~EnvoyQuicConnection() override = default;
+
+  // Called by EnvoyQuicSession::setConnectionStats().
+  void setConnectionStats(const Network::Connection::ConnectionStats& stats) {
+    connection_stats_ = std::make_unique<Network::Connection::ConnectionStats>(stats);
+  }
+
+  // quic::QuicConnection
+  // Overridden to retrieve filter chain with initialized self address.
+  bool OnPacketHeader(const quic::QuicPacketHeader& header) override;
+
+  // Called in session Initialize().
+  void setEnvoyConnection(Network::Connection& connection) { envoy_connection_ = &connection; }
+
+  const Network::ConnectionSocketPtr& connectionSocket() const { return connection_socket_; }
+
+protected:
+  Network::Connection::ConnectionStats& connectionStats() const { return *connection_stats_; }
+
+private:
+  // TODO(danzh): populate stats.
+  std::unique_ptr<Network::Connection::ConnectionStats> connection_stats_;
+  // Only initialized after self address is known. Must not own the underlying
+  // socket because UDP socket is shared among all connections.
+  Network::ConnectionSocketPtr connection_socket_;
+  Network::Connection* envoy_connection_{nullptr};
+  Network::ListenerConfig& listener_config_;
+  Server::ListenerStats& listener_stats_;
+  // Latched to the corresponding quic FilterChain after connection_socket_ is
+  // initialized.
+  const Network::FilterChain* filter_chain_{nullptr};
+};
+
+} // namespace Quic
+} // namespace Envoy