HTTP/3: fixed encoding variable-length integers.

Fixed memory leak with reordered stream frames.

Fixed includes in quic headers.

Added MAX_STREAM_DATA stub handler.

Currently sending code is ignoring this.

Respecting maximum packet size.

The header size macros for long and short packets were fixed to provide
correct values in bytes.

Currently the sending code limits frames so they don't exceed max_packet_size.
But it does not account the case when a single frame can exceed the limit.

As a result of this patch, big payload (CRYPTO and STREAM) will be split
into a number of smaller frames that fit into advertised max_packet_size
(which specifies final packet size, after encryption).

Removed source/destination swap from the function creating header.

The function now creates a header according to fileds provided in the "pkt"
argument without applying any logic regarding sending side.

Revert "Rejecting new connections with non-zero Initial packet."

chrome-unstable 83.0.4103.7 starts with Initial packet number 1.

I couldn't find a proper explanation besides this text in quic-transport:
    An endpoint MAY skip packet numbers when sending
    packets to detect this (Optimistic ACK Attack) behavior.

Fixed error descriptions.

The check for array bound is done inside function that returns error
description.  Missing initialization element is added.

Removed outdated TODO.

If required, frame handler can invoke output itself.  There is no need to
call output directly in the payload handler, queuing is enough.

Added handling of incorrect values in TP configuration.

Some parameters have minimal/maximum values defined by standard.

Parsing of truncated packet numbers.

For sample decoding algorithm, see quic-transport-27#appendix-A.

Added primitive flow control mechanisms.

 + MAX_STREAM_DATA frame is sent when recv() is performed on stream
   The new value is a sum of total bytes received by stream + free
   space in a buffer;

   The sending of MAX_STREM_DATA frame in response to STREAM_DATA_BLOCKED
   frame is adjusted to follow the same logic as above.

 + MAX_DATA frame is sent when total amount of received data is 2x
   of current limit.  The limit is doubled.

 + Default values of transport parameters are adjusted to more meaningful
   values:

   initial stream limits are set to quic buffer size instead of
   unrealistically small 255.

   initial max data is decreased to 16 buffer sizes, in an assumption that
   this is enough for a relatively short connection, instead of randomly
   chosen big number.

All this allows to initiate a stable flow of streams that does not block
on stream/connection limits (tested with FF 77.0a1 and 100K requests)

Create new stream immediately on receiving new stream id.

Before the patch, full STREAM frame handling was delayed until the frame with
zero offset is received.  Only node in the streams tree was created.

This lead to problems when such stream was deleted, in particular, it had no
handlers set for read events.

This patch creates new stream immediately, but delays data delivery until
the proper offset will arrive. This is somewhat similar to how accept()
operation works.

The ngx_quic_add_stream() function is no longer needed and merged into stream
handler.  The ngx_quic_stream_input() now only handles frames for existing
streams and does not deal with stream creation.

Free remaining frames on connection close.

Frames can still float in the following queues:

 - crypto frames reordering queues (one per encryption level)
 - moved crypto frames cleanup to the moment where all streams are closed
 - stream frames reordering queues (one per packet number namespace)
 - frames retransmit queues (one per packet number namespace)

Sorted functions and functions declarations.

Added reordering support for STREAM frames.

Each stream node now includes incoming frames queue and sent/received counters
for tracking offset. The sent counter is not used, c->sent is used, not like
in crypto buffers, which have no connections.

Crypto buffer frames reordering.

If offset in CRYPTO frame doesn't match expected, following actions are taken:
    a) Duplicate frames or frames within [0...current offset] are ignored
    b) New data from intersecting ranges (starts before current_offset, ends
       after) is consumed
    c) "Future" frames are stored in a sorted queue (min offset .. max offset)

Once a frame is consumed, current offset is updated and the queue is inspected:
    we iterate the queue until the gap is found and act as described
    above for each frame.

The amount of data in buffered frames is limited by corresponding macro.

The CRYPTO and STREAM frame structures are now compatible: they share
the same set of initial fields.  This allows to have code that deals with
both of this frames.

The ordering layer now processes the frame with offset and invokes the
handler when it can organise an ordered stream of data.

Cleaned up magic numbers in ngx_quic_output_frames().

Rename types and variables used for packet number space.

Quote: Conceptually, a packet number space is the context in which a packet
       can be processed and acknowledged.

ngx_quic_namespace_t => ngx_quic_send_ctx_t
qc->ns               => qc->send_ctx
ns->largest          => send_ctx->largest_ack

The ngx_quic_ns(level) macro now returns pointer, not just index:
    ngx_quic_get_send_ctx(c->quic, level)

ngx_quic_retransmit_ns() => ngx_quic_retransmit()
ngx_quic_output_ns() => ngx_quic_output_frames()

Merged with the default branch.

release-1.17.10 tag

nginx-1.17.10-RELEASE

Updated OpenSSL used for win32 builds.

HTTP/3: fixed reading request body.

The new auth_delay directive for delaying unauthorized requests.

The request processing is delayed by a timer.  Since nginx updates
internal time once at the start of each event loop iteration, this
normally ensures constant time delay, adding a mitigation from
time-based attacks.

A notable exception to this is the case when there are no additional
events before the timer expires.  To ensure constant-time processing
in this case as well, we trigger an additional event loop iteration
by posting a dummy event for the next event loop iteration.

Added basic offset support in client CRYPTO frames.

The offset in client CRYPTO frames is tracked in c->quic->crypto_offset_in.
This means that CRYPTO frames with non-zero offset are now accepted making
possible to finish handshake with client certificates that exceed max packet
size (if no reordering happens).

The c->quic->crypto_offset field is renamed to crypto_offset_out to avoid
confusion with tracking of incoming CRYPTO stream.

Fixed build with OpenSSL using old callbacks API.

ACK ranges processing.

 + since number of ranges in unknown, provide a function to parse them once
   again in handler to avoid memory allocation

 + ack handler now processes all ranges, not only the first

 + ECN counters are parsed and saved into frame if present

Ignore non-yet-implemented frames.

Such frames are grouped together in a switch and just ignored, instead of
closing the connection  This may improve test coverage.  All such frames
require acknowledgment.

Added check for SSL_get_current_cipher() results.

The function may return NULL and result need to be checked before use.

Added a bit more debugging in STREAM frame parser.

Do not set timers after the connection is closed.

The qc->closing flag is set when a connection close is initiated for the first
time.

No timers will be set if the flag is active.

TODO: this is a temporary solution to avoid running timer handlers after
connection (and it's pool) was destroyed.  It looks like currently we have
no clear policy of connection closing in regard to timers.

Discarding Handshake packets if no Handshake keys yet.

Found with a previously received Initial packet with ACK only, which
instantiates a new connection but do not produce the handshake keys.

This can be triggered by a fairly well behaving client, if the server
stands behind a load balancer that stripped Initial packets exchange.

Found by F5 test suite.

Rejecting new connections with non-zero Initial packet.

TLS Key Update in QUIC.

Old keys retention is yet to be implemented.

Removed excessive debugging in QUIC packet creation.

While here, eliminated further difference in between.

Logging of packet numbers in QUIC packet creation.

Removed unneccesary milliseconds conversion.

Proper handling of packet number in header.

 - fixed setting of largest received packet number.
 - sending properly truncated packet number
 - added support for multi-byte packet number

Advertizing MAX_STREAMS (0x12) credit in advance.

This makes sending large number of bidirectional stream work within ngtcp2,
which doesn't bother sending optional STREAMS_BLOCKED when exhausted.

This also introduces tracking currently opened and maximum allowed streams.

Fixed computing nonce again, by properly shifting packet number.

Fixed missing propagation of need_ack flag from frames to packet.

Fixed excessive push timer firing.

The timer is set when an output frame is generated; there is no need to arm
it after it was fired.

Fixed computing nonce by xoring all packet number bytes.

Previously, the stub worked only with pnl=0.

Output buffering.

Currently, the output is called periodically, each 200 ms to invoke
ngx_quic_output() that will push all pending frames into packets.

TODO: implement flags a-là Nagle & co (NO_DELAY/NO_PUSH...)

Implemented retransmission and retransmit queue.

All frames collected to packet are moved into a per-namespace send queue.
QUIC connection has a timer which fires on the closest max_ack_delay time.
The frame is deleted from the queue when a corresponding packet is acknowledged.

The NGX_QUIC_MAX_RETRANSMISSION is a timeout that defines maximum length
of retransmission of a frame.

Introduced packet namespace in QUIC connection.

The structure contains all data that is related to the namespace:
packet number and output queue (next patch).

Refactored QUIC secrets storage.

The quic->keys[4] array now contains secrets related to the corresponding
encryption level.  All protection-level functions get proper keys and do
not need to switch manually between levels.

Added missing debug description.

TLS Early Data support.

TLS Early Data key derivation support.

Sending HANDSHAKE_DONE just once with BoringSSL.

If early data is accepted, SSL_do_handshake() completes as soon as ClientHello
is processed.  SSL_in_init() will report the handshake is still in progress.

QUIC packet padding to fulfil header protection sample demands.

Improved SSL_do_handshake() error handling in QUIC.

It can either return a recoverable SSL_ERROR_WANT_READ or fatal errors.

Style.

Removed unused field from ngx_quic_header_t.

HTTP/3: http3 variable.

HTTP/3: static table cleanup.

Parsing HTTP/3 request body.

Fixed handling QUIC stream eof.

Set r->pending_eof flag for a new QUIC stream with the fin bit.  Also, keep
r->ready set when r->pending_eof is set and buffer is empty.

Push QUIC stream frames in send() and cleanup handler.

Chunked response body in HTTP/3.

Fixed buffer overflow.

Unbreak sending CONNECTION_CLOSE from the send_alert callback.

Merged ngx_quic_send_packet() into ngx_quic_send_frames().

This allows to avoid extra allocation and use two static buffers instead.
Adjusted maximum paket size calculation: need to account a tag.

Got rid of memory allocation in decryption.

Static buffers are used instead in functions where decryption takes place.

The pkt->plaintext points to the beginning of a static buffer.
The pkt->payload.data points to decrypted data actual start.

Logging cleanup.

pool->log is replaced with pkt->log or explicit argument passing where
possible.

QUIC frames reuse.

Removed memory allocations from encryption code.

 + ngx_quic_encrypt():
     - no longer accepts pool as argument
     - pkt is 1st arg
     - payload is passed as pkt->payload
     - performs encryption to the specified static buffer

 + ngx_quic_create_long/short_packet() functions:
    - single buffer for everything, allocated by caller
    - buffer layout is: [ ad | payload | TAG ]
      the result is in the beginning of buffer with proper length
    - nonce is calculated on stack
    - log is passed explicitly, pkt is 1st arg
    - no more allocations inside

 + ngx_quic_create_long_header():
    - args changed: no need to pass str_t

 + added ngx_quic_create_short_header()

Fixed QUIC stream insert and find.

Simplifed handling HTTP/3 streams.

Safe QUIC stream creation.

When closing a QUIC connection, wait for all streams to finish.

Additionally, streams are now removed from the tree in cleanup handler.

Removed ngx_quic_stream_node_t.

Now ngx_quic_stream_t is directly inserted into the tree.

Implemented eof in QUIC streams.

Fixed log initialization.

Should be done after memzero.

Advertise our max_idle_timeout in transport parameters.

So we can easily tune how soon client would decide to close a connection.

QUIC streams don't need filter_need_in_memory after 7f0981be07c4.

Now they inherit c->ssl always enabled from the main connection,
which makes r->main_filter_need_in_memory set for them.

Logging cleanup.

 + Client-related errors (i.e. parsing) are done at INFO level
 + c->log->action is updated through the process of receiving, parsing.
   handling packet/payload and generating frames/output.

Added QUIC version check for sending HANDSHAKE_DONE frame.

Implemented sending HANDSHAKE_DONE frame after handshake.

This makes it possible to switch to draft 27 by default.

Fixed client certificate verification.

For ngx_http_process_request() part to work, this required to set both
r->http_connection->ssl and c->ssl on a QUIC stream.  To avoid damaging
global SSL object, ngx_ssl_shutdown() is managed to ignore QUIC streams.

Respect QUIC max_idle_timeout.

Allow ngx_queue_frame() to insert frame in the front.

Previously a frame could only be inserted after the first element of the list.

Support for HTTP/3 ALPN.

This is required by Chrome.

Put zero in 'First ACK Range' when acknowledging one packet.

This fixes Chrome CONNECTION_ID_LIMIT_ERROR with the reason:
"Underflow with first ack block length 2 largest acked is 1".

Avoid using QUIC connection after CONNECTION_CLOSE.

Better flow control and buffering for QUIC streams.

Limit output QUIC packets with client max_packet_size.

Additionally, receive larger packets than 512 bytes.

Fixed received ACK fields order in debug logging.

Connection states code cleanup.

 + ngx_quic_init_ssl_methods() is no longer there, we setup methods on SSL
   connection directly.

 + the handshake_handler is actually a generic quic input handler

 + updated c->log->action and debug to reflect changes and be more informative

 + c->quic is always set in ngx_quic_input()

 + the quic connection state is set by the results of SSL_do_handshake();

Skip unknown transport parameters.

Add unsupported version into log.

This makes it easier to understand what client wants.

Added processing of client transport parameters.

note:
 + parameters are available in SSL connection since they are obtained by ssl
   stack

quote:
   During connection establishment, both endpoints make authenticated
   declarations of their transport parameters.  These declarations are
   made unilaterally by each endpoint.

and really, we send our parameters before we read client's.

no handling of incoming parameters is made by this patch.

Fixed CRYPTO offset generation.

Closing connection on NGX_QUIC_FT_CONNECTION_CLOSE.

Implemented parsing of remaining frame types.

Fixed parsing NGX_QUIC_FT_CONNECTION_CLOSE.

Fixed buffer overrun in create_transport_params() with -24.

It writes 16-bit prefix as designed, but length calculation assumed varint.

Fixed build with macOS's long long abomination.