quiche: quic client codec and setup integration test

bazel/external/quiche.BUILD

@@ -2006,6 +2006,7 @@ envoy_cc_library(
     copts = quiche_copts,
     repository = "@envoy",
     tags = ["nofips"],
+    visibility = ["//visibility:public"],
     deps = [
         ":quic_core_alarm_interface_lib",
         ":quic_core_crypto_encryption_lib",

source/common/http/BUILD

@@ -48,8 +48,11 @@ envoy_cc_library(
         "//source/common/common:enum_to_int",
         "//source/common/common:linked_object",
         "//source/common/common:minimal_logger_lib",
+        "//source/common/config:utility_lib",
         "//source/common/http/http1:codec_lib",
         "//source/common/http/http2:codec_lib",
+        "//source/common/http/http3:quic_codec_factory_lib",
+        "//source/common/http/http3:well_known_names",
         "//source/common/network:filter_lib",
     ],
 )
@@ -180,8 +183,11 @@ envoy_cc_library(
         "//source/common/common:regex_lib",
         "//source/common/common:scope_tracker",
         "//source/common/common:utility_lib",
+        "//source/common/config:utility_lib",
         "//source/common/http/http1:codec_lib",
         "//source/common/http/http2:codec_lib",
+        "//source/common/http/http3:quic_codec_factory_lib",
+        "//source/common/http/http3:well_known_names",
         "//source/common/network:utility_lib",
         "//source/common/router:config_lib",
         "//source/common/runtime:uuid_util_lib",

source/common/http/codec_client.cc

@@ -6,9 +6,12 @@
 #include "envoy/http/codec.h"
 
 #include "common/common/enum_to_int.h"
+#include "common/config/utility.h"
 #include "common/http/exception.h"
 #include "common/http/http1/codec_impl.h"
 #include "common/http/http2/codec_impl.h"
+#include "common/http/http3/quic_codec_factory.h"
+#include "common/http/http3/well_known_names.h"
 #include "common/http/utility.h"
 
 namespace Envoy {
@@ -158,8 +161,10 @@ CodecClientProd::CodecClientProd(Type type, Network::ClientConnectionPtr&& conne
     break;
   }
   case Type::HTTP3: {
-    // TODO(danzh) Add QUIC codec;
-    NOT_IMPLEMENTED_GCOVR_EXCL_LINE;
+    codec_ = std::unique_ptr<ClientConnection>(
+        Config::Utility::getAndCheckFactory<Http::QuicHttpClientConnectionFactory>(
+            Http::QuicCodecNames::get().Quiche)
+            .createQuicClientConnection(*connection_, *this));
   }
   }
 }

source/common/http/http3/BUILD

@@ -0,0 +1,21 @@
+licenses(["notice"])  # Apache 2
+
+load(
+    "//bazel:envoy_build_system.bzl",
+    "envoy_cc_library",
+    "envoy_package",
+)
+
+envoy_package()
+
+envoy_cc_library(
+    name = "quic_codec_factory_lib",
+    hdrs = ["quic_codec_factory.h"],
+    deps = ["//include/envoy/http:codec_interface"],
+)
+
+envoy_cc_library(
+    name = "well_known_names",
+    hdrs = ["well_known_names.h"],
+    deps = ["//source/common/singleton:const_singleton"],
+)

source/common/http/http3/quic_codec_factory.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <string>
+
+#include "envoy/http/codec.h"
+#include "envoy/network/connection.h"
+
+namespace Envoy {
+namespace Http {
+
+// A factory to create Http::ServerConnection instance for QUIC.
+class QuicHttpServerConnectionFactory {
+public:
+  virtual ~QuicHttpServerConnectionFactory() {}
+
+  virtual std::string name() const PURE;
+
+  virtual std::unique_ptr<ServerConnection>
+  createQuicServerConnection(Network::Connection& connection, ConnectionCallbacks& callbacks) PURE;
+
+  static std::string category() { return "quic_client_codec"; }
+};
+
+// A factory to create Http::ClientConnection instance for QUIC.
+class QuicHttpClientConnectionFactory {
+public:
+  virtual ~QuicHttpClientConnectionFactory() {}
+
+  virtual std::string name() const PURE;
+
+  virtual std::unique_ptr<ClientConnection>
+  createQuicClientConnection(Network::Connection& connection, ConnectionCallbacks& callbacks) PURE;
+
+  static std::string category() { return "quic_server_codec"; }
+};
+
+} // namespace Http
+} // namespace Envoy

source/common/http/http3/well_known_names.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+
+#include "common/singleton/const_singleton.h"
+
+namespace Envoy {
+namespace Http {
+
+class QuicCodecNameValues {
+public:
+  // QUICHE is the only QUIC implementation for now.
+  const std::string Quiche = "quiche";
+};
+
+using QuicCodecNames = ConstSingleton<QuicCodecNameValues>;
+
+} // namespace Http
+} // namespace Envoy

source/extensions/filters/network/http_connection_manager/config.cc

@@ -18,6 +18,8 @@
 #include "common/http/default_server_string.h"
 #include "common/http/http1/codec_impl.h"
 #include "common/http/http2/codec_impl.h"
+#include "common/http/http3/quic_codec_factory.h"
+#include "common/http/http3/well_known_names.h"
 #include "common/http/utility.h"
 #include "common/protobuf/utility.h"
 #include "common/router/rds_impl.h"
@@ -415,8 +417,14 @@ HttpConnectionManagerConfig::createCodec(Network::Connection& connection,
         connection, callbacks, context_.scope(), http2_settings_, maxRequestHeadersKb(),
         maxRequestHeadersCount());
   case CodecType::HTTP3:
-    // TODO(danzh) create QUIC specific codec.
-    NOT_IMPLEMENTED_GCOVR_EXCL_LINE;
+    // Hard code Quiche factory name here to instantiate a QUIC codec implemented.
+    // TODO(danzh) Add support to get the factory name from config, possibly
+    // from HttpConnectionManager protobuf. This is not essential till there are multiple
+    // implementations of QUIC.
+    return std::unique_ptr<Http::ServerConnection>(
+        Config::Utility::getAndCheckFactory<Http::QuicHttpServerConnectionFactory>(
+            Http::QuicCodecNames::get().Quiche)
+            .createQuicServerConnection(connection, callbacks));
   case CodecType::AUTO:
     return Http::ConnectionManagerUtility::autoCreateCodec(
         connection, data, callbacks, context_.scope(), http1_settings_, http2_settings_,

source/extensions/quic_listeners/quiche/BUILD

@@ -111,8 +111,12 @@ envoy_cc_library(
     hdrs = ["codec_impl.h"],
     tags = ["nofips"],
     deps = [
+        ":envoy_quic_client_session_lib",
         ":envoy_quic_server_session_lib",
         "//include/envoy/http:codec_interface",
+        "//include/envoy/registry",
+        "//source/common/http/http3:quic_codec_factory_lib",
+        "//source/common/http/http3:well_known_names",
         "@com_googlesource_quiche//:quic_core_http_spdy_session_lib",
     ],
 )
@@ -159,6 +163,30 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "envoy_quic_client_session_lib",
+    srcs = [
+        "envoy_quic_client_session.cc",
+        "envoy_quic_client_stream.cc",
+    ],
+    hdrs = [
+        "envoy_quic_client_session.h",
+        "envoy_quic_client_stream.h",
+    ],
+    tags = ["nofips"],
+    deps = [
+        ":envoy_quic_client_connection_lib",
+        ":envoy_quic_stream_lib",
+        ":envoy_quic_utils_lib",
+        ":quic_filter_manager_connection_lib",
+        "//source/common/buffer:buffer_lib",
+        "//source/common/common:assert_lib",
+        "//source/common/http:header_map_lib",
+        "//source/extensions/quic_listeners/quiche/platform:quic_platform_mem_slice_storage_impl_lib",
+        "@com_googlesource_quiche//:quic_core_http_client_lib",
+    ],
+)
+
 envoy_cc_library(
     name = "quic_io_handle_wrapper_lib",
     hdrs = ["quic_io_handle_wrapper.h"],
@@ -194,6 +222,19 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "envoy_quic_client_connection_lib",
+    srcs = ["envoy_quic_client_connection.cc"],
+    hdrs = ["envoy_quic_client_connection.h"],
+    tags = ["nofips"],
+    deps = [
+        ":envoy_quic_connection_lib",
+        ":envoy_quic_packet_writer_lib",
+        "//include/envoy/event:dispatcher_interface",
+        "//source/common/network:socket_option_factory_lib",
+    ],
+)
+
 envoy_cc_library(
     name = "envoy_quic_dispatcher_lib",
     srcs = ["envoy_quic_dispatcher.cc"],
@@ -258,6 +299,8 @@ envoy_cc_library(
         "//include/envoy/http:codec_interface",
         "//source/common/http:header_map_lib",
         "//source/common/network:address_lib",
+        "//source/common/network:listen_socket_lib",
+        "//source/common/network:socket_option_factory_lib",
         "@com_googlesource_quiche//:quic_core_http_header_list_lib",
     ],
 )

source/extensions/quic_listeners/quiche/active_quic_listener.cc

@@ -34,6 +34,8 @@ ActiveQuicListener::ActiveQuicListener(Event::Dispatcher& dispatcher,
       quic::QuicRandom::GetInstance(), std::make_unique<EnvoyQuicFakeProofSource>(),
       quic::KeyExchangeSource::Default());
   auto connection_helper = std::make_unique<EnvoyQuicConnectionHelper>(dispatcher_);
+  crypto_config_->AddDefaultConfig(random, connection_helper->GetClock(),
+                                   quic::QuicCryptoServerConfig::ConfigOptions());
   auto alarm_factory =
       std::make_unique<EnvoyQuicAlarmFactory>(dispatcher_, *connection_helper->GetClock());
   quic_dispatcher_ = std::make_unique<EnvoyQuicDispatcher>(
@@ -43,6 +45,8 @@ ActiveQuicListener::ActiveQuicListener(Event::Dispatcher& dispatcher,
   quic_dispatcher_->InitializeWithWriter(new EnvoyQuicPacketWriter(listen_socket_));
 }
 
+ActiveQuicListener::~ActiveQuicListener() { onListenerShutdown(); }
+
 void ActiveQuicListener::onListenerShutdown() {
   ENVOY_LOG(info, "Quic listener {} shutdown.", config_.name());
   quic_dispatcher_->Shutdown();
@@ -55,7 +59,7 @@ void ActiveQuicListener::onData(Network::UdpRecvData& data) {
       envoyAddressInstanceToQuicSocketAddress(data.addresses_.local_));
   quic::QuicTime timestamp =
       quic::QuicTime::Zero() +
-      quic::QuicTime::Delta::FromMilliseconds(std::chrono::duration_cast<std::chrono::milliseconds>(
+      quic::QuicTime::Delta::FromMicroseconds(std::chrono::duration_cast<std::chrono::microseconds>(
                                                   data.receive_time_.time_since_epoch())
                                                   .count());
   uint64_t num_slice = data.buffer_->getRawSlices(nullptr, 0);
@@ -64,7 +68,7 @@ void ActiveQuicListener::onData(Network::UdpRecvData& data) {
   data.buffer_->getRawSlices(&slice, 1);
   // TODO(danzh): pass in TTL and UDP header.
   quic::QuicReceivedPacket packet(reinterpret_cast<char*>(slice.mem_), slice.len_, timestamp,
-                                  /*owns_buffer=*/false, /*ttl=*/0, /*ttl_valid=*/true,
+                                  /*owns_buffer=*/false, /*ttl=*/0, /*ttl_valid=*/false,
                                   /*packet_headers=*/nullptr, /*headers_length=*/0,
                                   /*owns_header_buffer*/ false);
   quic_dispatcher_->ProcessPacket(self_address, peer_address, packet);

source/extensions/quic_listeners/quiche/active_quic_listener.h

@@ -26,6 +26,8 @@ class ActiveQuicListener : public Network::UdpListenerCallbacks,
                      Network::SocketSharedPtr listen_socket,
                      Network::ListenerConfig& listener_config, const quic::QuicConfig& quic_config);
 
+  ~ActiveQuicListener() override;
+
   // TODO(#7465): Make this a callback.
   void onListenerShutdown();