Fix H3 quiche traffic handling

# Overview
This patch extends the HTTP/3 autest coverage, using curl, golang, and
Proxy Verifier HTTP/3 clients to generate their implementations of h3
traffic. It also adds request and response bodies of various sizes,
including "large" 300k bodies to exercise multiple packet, buffer, and
flow control ATS HTTP/3 implementations. It also exercises some
interesting requests, such as HEAD and 204 responses. This patch also
includes the various production fixes needed for these tests.

# Issues Found and their Fixes

## UDP batches could stall large H3 transfers
Large request and response bodies exposed a UDP receive starvation bug
in the UDP read path. On systems using `recvmmsg()` with
edge-triggered readiness, ATS could read one full batch of datagrams
and then leave the rest queued in the kernel without another readable
event to wake the QUIC stack.

This changes
`UDPNetProcessorInternal::read_multiple_messages_from_net()` in
`src/iocore/net/UnixUDPNet.cc` to return whether the kernel supplied a
full batch. `udp_read_from_net()` now loops while full batches are
returned, draining the socket before handing packets to QUIC and
avoiding large-transfer stalls caused by unread UDP bursts.

## QUIC stream writes consumed data before quiche accepted it
The stream write path consumed the `QUICStreamVCAdapter` write reader
inside `_read()`, before `QUICStream::send_data()` knew whether
`quiche_conn_stream_send()` had accepted the bytes. When quiche accepted
only a partial write or returned a flow-control error, ATS could lose
stream data and report write progress too early.

This makes `QUICStream::send_data()` keep a pending
`IOBufferBlock`/FIN pair until quiche reports successful consumption,
and only then calls the new `QUICStreamAdapter::consume()` hook. The
concrete reader accounting lives in `QUICStreamVCAdapter::_consume()`,
while `QUICStream::has_data_to_send()`, `QUICStream::on_write()`, and
`QUICNetVConnection::on_stream_updated()` make newly writable stream
data schedule packet writes again. This also treats completed finite
writes with only FIN left as writable stream state, so empty bodies and
fully consumed bodies still close the H3 stream cleanly.

## H3 transaction cleanup raced with stream closure
The timeout and stream lifetime tests exposed cases where an
`HQTransaction` could be deleted while an event handler was still
active, or while the QUIC stream adapter still had read/write cleanup to
finish. That left later stream-close and timeout paths touching state
that had already been torn down.

This adds explicit transaction lifetime state in `HQTransaction`:
`_closed`, `_stream_closed`, `_event_handler_active`, and
`_is_write_buffer_flushed()`. `Http3App::on_stream_close()` now calls
`HQTransaction::stream_closed()`, and
`HQTransaction::_delete_if_possible()` waits until the transaction is
done, the stream is closed or no longer readable, and pending writes
have flushed before deleting the transaction.

## H3 read completion could run before headers and DATA were settled
The H3 request read path could signal completion before asynchronous
QPACK header decode and buffered DATA delivery had finished updating the
sink VIO. That showed up around HEAD, 204, and stream-close timing
because the HTTP state machine needed a stable view of whether headers
were decoded and whether a request body existed.

This updates `Http3HeaderVIOAdaptor::_on_qpack_decode_complete()` to add
the printed header length to the sink VIO and notify
`Http3Transaction::on_header_decode_complete()`, which schedules the
appropriate read event. `Http3StreamDataVIOAdaptor::finalize()` now uses
a persistent reader, writes buffered DATA into the sink VIO exactly
once, and updates `ndone`/`nbytes` consistently before the transaction
is signaled.

## The QPACK static table had drifted from the standard table
The HEAD, 204, and quic-go coverage exposed that ATS's static QPACK
table was not the table used by external HTTP/3 implementations. The
extra zstd entry and modified `accept-encoding` value in
`src/proxy/http3/QPACK.cc` shifted later static indexes, so an
externally encoded `:status 204` could decode as a different status.

This restores the standard static table entries by using
`accept-encoding: gzip, deflate, br` and removing the non-standard
`content-encoding: zstd` entry. The new 204 cases in
`tests/gold_tests/h3/replays/h3_proxy_verifier.replay.yaml` and
`tests/gold_tests/h3/replays/h3_server_for_go_client.replay.yaml` cover
this interoperability point with Proxy Verifier and quic-go.

Author: bneradt

ci/rat-exclude.txt

@@ -24,6 +24,8 @@ blib/**
 **/*.default.in
 **/*.config
 **/*.gold
+**/go.mod
+**/go.sum
 **/*.hrw4u
 **/.gitignore
 **/.gitmodules

include/iocore/net/quic/Mock.h

@@ -28,6 +28,8 @@
 #include "iocore/net/quic/QUICStreamAdapter.h"
 #include "iocore/net/quic/QUICStream.h"
 
+#include <algorithm>
+
 class MockQUICContext;
 
 using namespace std::literals;
@@ -191,6 +193,11 @@ class MockQUICConnectionInfoProvider : public QUICConnectionInfoProvider
   {
     return negotiated_application_name_sv;
   }
+
+  void
+  on_stream_updated() override
+  {
+  }
 };
 
 class MockQUICStreamManager : public QUICStreamManager
@@ -431,6 +438,11 @@ class MockQUICConnection : public QUICConnection
     return negotiated_application_name_sv;
   }
 
+  void
+  on_stream_updated() override
+  {
+  }
+
   int             _transmit_count   = 0;
   int             _retransmit_count = 0;
   Ptr<ProxyMutex> _mutex;
@@ -519,13 +531,19 @@ class MockQUICStreamAdapter : public QUICStreamAdapter
   Ptr<IOBufferBlock>
   _read(size_t len) override
   {
-    this->_sending_data_len  -= len;
-    Ptr<IOBufferBlock> block  = make_ptr<IOBufferBlock>(new_IOBufferBlock());
+    len                      = std::min(len, this->_sending_data_len);
+    Ptr<IOBufferBlock> block = make_ptr<IOBufferBlock>(new_IOBufferBlock());
     block->alloc(iobuffer_size_to_index(len, BUFFER_SIZE_INDEX_32K));
     block->fill(len);
     return block;
   }
 
+  void
+  _consume(size_t len) override
+  {
+    this->_sending_data_len -= std::min(len, this->_sending_data_len);
+  }
+
 private:
   size_t _sending_data_len         = 0;
   size_t _total_sending_data_len   = 0;

include/iocore/net/quic/QUICConnection.h

@@ -60,6 +60,7 @@ class QUICConnectionInfoProvider
   virtual bool                    is_handshake_completed() const          = 0;
   virtual QUICVersion             negotiated_version() const              = 0;
   virtual std::string_view        negotiated_application_name() const     = 0;
+  virtual void                    on_stream_updated()                     = 0;
 };
 
 class QUICConnection : public QUICConnectionInfoProvider

include/iocore/net/quic/QUICStream.h

@@ -26,6 +26,7 @@
 #include "tscore/List.h"
 
 #include "iocore/eventsystem/Event.h"
+#include "iocore/eventsystem/IOBuffer.h"
 
 #include "iocore/net/quic/QUICConnection.h"
 #include "iocore/net/quic/QUICDebugNames.h"
@@ -53,6 +54,7 @@ class QUICStream
   QUICStreamDirection               direction() const;
   bool                              is_bidirectional() const;
   bool                              has_no_more_data() const;
+  bool                              has_data_to_send();
 
   QUICOffset final_offset() const;
 
@@ -66,6 +68,7 @@ class QUICStream
    * QUICApplication need to call one of these functions when it process VC_EVENT_*
    */
   void on_read();
+  void on_write();
   void on_eos();
 
   /**
@@ -85,6 +88,9 @@ class QUICStream
   uint64_t                    _received_bytes   = 0;
   uint64_t                    _sent_bytes       = 0;
   bool                        _has_no_more_data = false;
+  Ptr<IOBufferBlock>          _pending_send_block;
+  bool                        _pending_send_fin = false;
+  bool                        _sent_fin         = false;
 };
 
 class QUICStreamStateListener

include/iocore/net/quic/QUICStreamAdapter.h

@@ -39,6 +39,7 @@ class QUICStreamAdapter
 
   virtual int64_t    write(QUICOffset offset, const uint8_t *data, uint64_t data_length, bool fin) = 0;
   Ptr<IOBufferBlock> read(size_t len);
+  void               consume(size_t len);
   virtual bool       is_eos()     = 0;
   virtual uint64_t   unread_len() = 0;
   virtual uint64_t   read_len()   = 0;
@@ -60,6 +61,7 @@ class QUICStreamAdapter
   virtual void notify_eos() = 0;
 
 protected:
-  virtual Ptr<IOBufferBlock> _read(size_t len) = 0;
+  virtual Ptr<IOBufferBlock> _read(size_t len)    = 0;
+  virtual void               _consume(size_t len) = 0;
   QUICStream                &_stream;
 };

include/iocore/net/quic/QUICStreamVCAdapter.h

@@ -65,6 +65,7 @@ class QUICStreamVCAdapter : public VConnection, public QUICStreamAdapter
 
 protected:
   Ptr<IOBufferBlock> _read(size_t len) override;
+  void               _consume(size_t len) override;
 
   VIO _read_vio;
   VIO _write_vio;

include/iocore/net/quic/QUICTypes.h

@@ -455,9 +455,9 @@ class QUICFiveTuple
   int        protocol() const;
 
 private:
-  IpEndpoint _source;
-  IpEndpoint _destination;
-  int        _protocol;
+  IpEndpoint _source{};
+  IpEndpoint _destination{};
+  int        _protocol  = 0;
   uint64_t   _hash_code = 0;
 };
 

include/proxy/http3/Http3StreamDataVIOAdaptor.h

@@ -42,7 +42,9 @@ class Http3StreamDataVIOAdaptor : public Http3FrameHandler
   bool has_data();
 
 private:
-  VIO       *_sink_vio          = nullptr;
-  int64_t    _total_data_length = 0;
-  MIOBuffer *_buffer;
+  VIO            *_sink_vio          = nullptr;
+  int64_t         _total_data_length = 0;
+  MIOBuffer      *_buffer            = nullptr;
+  IOBufferReader *_reader            = nullptr;
+  bool            _finalized         = false;
 };

include/proxy/http3/Http3Transaction.h

@@ -53,6 +53,7 @@ class HQTransaction : public ProxyTransaction
   void transaction_done() override;
   void release() override;
   int  get_transaction_id() const override;
+  void stream_closed();
   void increment_transactions_stat() override;
   void decrement_transactions_stat() override;
 
@@ -81,6 +82,7 @@ class HQTransaction : public ProxyTransaction
   void            _schedule_read_complete_event();
   void            _unschedule_read_complete_event();
   void            _close_read_complete_event(Event *e);
+  void            _schedule_read_event();
   void            _schedule_write_ready_event();
   void            _unschedule_write_ready_event();
   void            _close_write_ready_event(Event *e);
@@ -90,12 +92,14 @@ class HQTransaction : public ProxyTransaction
   void            _signal_event(int event, Event *e);
   void            _signal_read_event();
   void            _signal_write_event();
+  bool            _is_write_buffer_flushed();
   void            _delete_if_possible();
 
   EThread *_thread = nullptr;
 
   MIOBuffer                    _read_vio_buf{BUFFER_SIZE_INDEX_4K};
   QUICStreamVCAdapter::IOInfo &_info;
+  QUICStreamId                 _stream_id = 0;
 
   size_t _sent_bytes = 0;
 
@@ -106,7 +110,10 @@ class HQTransaction : public ProxyTransaction
   Event *_write_ready_event    = nullptr;
   Event *_write_complete_event = nullptr;
 
-  bool _transaction_done = false;
+  bool _transaction_done     = false;
+  bool _event_handler_active = false;
+  bool _closed               = false;
+  bool _stream_closed        = false;
 };
 
 class Http3Transaction : public HQTransaction
@@ -121,6 +128,7 @@ class Http3Transaction : public HQTransaction
   int state_stream_closed(int event, Event *data) override;
 
   void do_io_close(int lerrno = -1) override;
+  void on_header_decode_complete();
 
   bool is_response_header_sent() const;
   bool is_response_body_sent() const;

include/proxy/logging/TransactionLogData.h

@@ -27,6 +27,8 @@
 #include "proxy/hdrs/HTTP.h"
 #include "tscore/ink_inet.h"
 
+#include <cstddef>
+#include <cstdint>
 #include <optional>
 #include <string_view>
 
@@ -99,13 +101,16 @@ class TransactionLogData
   SquidHierarchyCode get_hier_code() const;
 
   // ===== Byte counters =====
-  int64_t get_client_request_body_bytes() const;
-  int64_t get_client_response_hdr_bytes() const;
-  int64_t get_client_response_body_bytes() const;
-  int64_t get_server_request_body_bytes() const;
-  int64_t get_server_response_body_bytes() const;
-  int64_t get_cache_response_body_bytes() const;
-  int64_t get_cache_response_hdr_bytes() const;
+  int64_t  get_client_request_body_bytes() const;
+  int64_t  get_client_response_hdr_bytes() const;
+  int64_t  get_client_response_body_bytes() const;
+  int64_t  get_server_request_body_bytes() const;
+  int64_t  get_server_response_body_bytes() const;
+  int64_t  get_cache_response_body_bytes() const;
+  int64_t  get_cache_response_hdr_bytes() const;
+  uint64_t get_client_tls_handshake_bytes_rx() const;
+  uint64_t get_client_tls_handshake_bytes_tx() const;
+  size_t   get_client_tls_early_data_len() const;
 
   // ===== Transaction identifiers =====
   int64_t get_sm_id() const;