HTTP/3: split header parser in two functions.

The first one parses pseudo-headers and is analagous to the request line
parser in HTTP/1.  The second one parses regular headers and is analogous to
the header parser in HTTP/1.

Additionally, error handling of client passing malformed uri is now fixed.

HTTP/3: move body parser call out of ngx_http_parse_chunked().

The function ngx_http_parse_chunked() is also called from the proxy module to
parse the upstream response.  It should always parse HTTP/1 body in this case.

HTTP/3: prevent array access by negative index for unknown streams.

Currently there are no such streams, but the function
ngx_http_v3_get_uni_stream() supports them.

README: documented Retry, 0-RTT, TLSv1.3 configuration.

Style.

Rephrased error message and removed trailing space.  Long comments were
shortened/rephrased.

Added sending of extra CONNECTION_CLOSE frames.

According to quic-transport draft 28 section 10.3.1:

   When sending CONNECTION_CLOSE, the goal is to ensure that the peer
   will process the frame.  Generally, this means sending the frame in a
   packet with the highest level of packet protection to avoid the
   packet being discarded.  After the handshake is confirmed (see
   Section 4.1.2 of [QUIC-TLS]), an endpoint MUST send any
   CONNECTION_CLOSE frames in a 1-RTT packet.  However, prior to
   confirming the handshake, it is possible that more advanced packet
   protection keys are not available to the peer, so another
   CONNECTION_CLOSE frame MAY be sent in a packet that uses a lower
   packet protection level.

Added more context to CONNECTION CLOSE frames.

Now it is possible to specify frame type that caused an error
and a human-readable reason phrase.

Fixed retransmission of frames after closing connection.

Frames in sent queues are discarded, as no acknowledgment is expected
if the connection is closing.

Avoided excessive definitions for connection state.

There is no need in a separate type for the QUIC connection state.
The only state not found in the SSL library is NGX_QUIC_ST_UNAVAILABLE,
which is actually a flag used by the ngx_quic_close_quic() function
to prevent cleanup of uninitialized connection.

README: pointed out Alt-Svc "ma" parameter useful with curl.

Fixed a typo.

Assorted fixes.

Found by Clang Static Analyzer.

Avoid retransmitting of packets with discarded keys.

Sections 4.10.1 and 4.10.2 of quic transport describe discarding of initial
and handshake keys.  Since the keys are discarded, we no longer need
to retransmit packets and corresponding queues should be emptied.

This patch removes previously added workaround that did not require
acknowledgement for initial packets, resulting in avoiding retransmission,
which is wrong because a packet could be lost and we have to retransmit it.

Fixed frame retransmissions.

It was possible that retransmit timer was not set after the first
retransmission attempt, due to ngx_quic_retransmit() did not set
wait time properly, and the condition in retransmit handler was incorrect.

Removed outdated debug.

Fixed a typo.

README: Retry support, protocol error messages implemented.

Fixed time comparison.

Added tests for connection id lengths in initial packet.

Discard packets without fixed bit or reserved bits set.

Section 17.2 and 17.3 of QUIC transport:

Fixed bit: Packets containing a zero value for this bit are not
valid packets in this version and MUST be discarded.

Reserved bit: An endpoint MUST treat receipt of a packet that has
a non-zero value for these bits, after removing both packet and
header protection, as a connection error of type PROTOCOL_VIOLATION.

Added generation of CC frames with error on connection termination.

When an error occurs, then c->quic->error field may be populated
with an appropriate error code, and the CONNECTION CLOSE frame will be
sent to the peer before the connection is closed.  Otherwise, the error
treated as internal and INTERNAL_ERROR code is sent.

The pkt->error field is populated by functions processing packets to
indicate an error when it does not fit into pass/fail return status.

Address validation using NEW_TOKEN frame.

Address validation using Retry packets.

The behaviour is toggled with the new directive "quic_retry on|off".
QUIC token construction is made suitable for issuing with NEW_TOKEN.

Server CID change refactored.

Preserve original DCID and unbreak parsing 0-RTT packets.

As per QUIC transport, the first flight of 0-RTT packets obviously uses same
Destination and Source Connection ID values as the client's first Initial.

The fix is to match 0-RTT against original DCID after it has been switched.

Removed redundant long packet type checks.

Removed redundant SSL_do_handshake call before any handshake data.

Cleaned up reordering code.

The ordered frame handler is always called for the existing stream, as it is
allocated from this stream.  Instead of searching stream by id, pointer to the
stream node is passed.

Cleaned up firefox workaround.

The idea is to skip any zeroes that follow valid QUIC packet.  Currently such
behavior can be only observed with Firefox which sends zero-padded initial
packets.

OCSP stapling: moved response verification to a separate function.

Upstream: jump out of loop after matching the status code.

Variables: fixed buffer over-read when evaluating "$arg_".

Restored ngx_quic_encrypt return type.

It was inadvertently changed while working on removing memory allocations.

Store clearflags in pkt->flags after decryption.

It doesn't make sense to store protected flags.

Configure: fixed static compilation with OpenSSL 1.1.1 / BoringSSL.

See 7246:04ebf29eaf5b for details.

Mention quic branch in README.

Configure: unbreak with old OpenSSL, --with-http_v3_module added.

Removed outdated/incorrect comments and fixed style.

 - we need transport parameters early to get packet size limits at least.

Reworked macros for parsing/assembling packet types.

Previously, macros checking a packet type with the long header also checked
whether this is a long header.  Now it requires a separate preceding check.

Renamed retransmit event object in preparation for retry support.

Server CID change.

Factored out sending ACK from payload handler.

Now there's no need to annotate every frame in ACK-eliciting packet.
Sending ACK was moved to the first place, so that queueing ACK frame
no longer postponed up to the next packet after pushing STREAM frames.

Added README.

Respect MAX_DATA and MAX_STREAM_DATA from QUIC client.

QUIC basic congestion control.

Fixed packet retransmission.

Previously frames in ctx->sent queue could be lost.

Assign connection number to every QUIC stream log.

Error messages cleanup.

 + added "quic" prefix to all error messages
 + rephrased some messages
 + removed excessive error logging from frame parser
 + added ngx_quic_check_peer() function to check proper source/destination
   match and do it one place

Cleaned up hexdumps in debug output.

 - the ngx_quic_hexdump0() macro is renamed to ngx_quic_hexdump();
   the original ngx_quic_hexdump() macro with variable argument is
   removed, extra information is logged normally, with ngx_log_debug()

 - all labels in hex dumps are prefixed with "quic"

 - the hexdump format is simplified, length is moved forward to avoid
   situations when the dump is truncated, and length is not shown

 - ngx_quic_flush_flight() function contents is debug-only, placed under
   NGX_DEBUG macro to avoid "unused variable" warnings from compiler

 - frame names in labels are capitalized, similar to other places

Debug cleanup.

 + all dumps are moved under one of the following macros (undefined by default):
    NGX_QUIC_DEBUG_PACKETS
    NGX_QUIC_DEBUG_FRAMES
    NGX_QUIC_DEBUG_FRAMES_ALLOC
    NGX_QUIC_DEBUG_CRYPTO

 + all QUIC debug messages got "quic " prefix

 + all input frames are reported as "quic frame in FOO_FRAME bar:1 baz:2"

 + all outgoing frames re reported as "quic frame out foo bar baz"

 + all stream operations are prefixed with id, like: "quic stream id 0x33 recv"

 + all transport parameters are prefixed with "quic tp"
   (hex dump is moved to caller, to avoid using ngx_cycle->log)

 + packet flags and some other debug messages are updated to
   include packet type

gRPC: WINDOW_UPDATE after END_STREAM handling (ticket #1797).

As per https://tools.ietf.org/html/rfc7540#section-6.9,
WINDOW_UPDATE received after a frame with the END_STREAM flag
should be handled and not treated as an error.

gRPC: RST_STREAM(NO_ERROR) handling (ticket #1792).

As per https://tools.ietf.org/html/rfc7540#section-8.1,

: A server can send a complete response prior to the client
: sending an entire request if the response does not depend on
: any portion of the request that has not been sent and
: received.  When this is true, a server MAY request that the
: client abort transmission of a request without error by
: sending a RST_STREAM with an error code of NO_ERROR after
: sending a complete response (i.e., a frame with the
: END_STREAM flag).  Clients MUST NOT discard responses as a
: result of receiving such a RST_STREAM, though clients can
: always discard responses at their discretion for other
: reasons.

Previously, RST_STREAM(NO_ERROR) received from upstream after
a frame with the END_STREAM flag was incorrectly treated as an
error.  Now, a single RST_STREAM(NO_ERROR) is properly handled.

This fixes problems observed with modern grpc-c [1], as well
as with the Go gRPC module.

[1] https://github.com/grpc/grpc/pull/1661

Version bump.

TODOs cleanup in transport.

We always generate stream frames that have length. The 'len' member is used
during parsing incoming frames and can be safely ignored when generating
output.

Retired the ngx_quic_parse_int_multi() function.

It used variable-length arguments what is not really necessary.

Removed support of drafts older than currently latest 27.

Added proper handling of connection close phases.

There are following flags in quic connection:

closing  - true, when a connection close is initiated, for whatever reason
draining - true, when a CC frame is received from peer

The following state machine is used for closing:

 +------------------+
 |       I/HS/AD    |
 +------------------+
 |        |       |
 |        |       V
 |        |   immediate close initiated:
 |        |     reasons: close by top-level protocol, fatal error
 |        |     + sends CC (probably with app-level message)
 |        |     + starts close_timer: 3 * PTO (current probe timeout)
 |        |       |
 |        |       V
 |        |   +---------+  - Reply to input with CC (rate-limited)
 |        |   | CLOSING |  - Close/Reset all streams
 |        |   +---------+
 |        |       |    |
 |        V       V    |
 |       receives CC   |
 |          |          |
idle        |          |
timer       |          |
 |          V          |
 |      +----------+   |  - MUST NOT send anything (MAY send a single CC)
 |      | DRAINING |   |  - if not already started, starts close_timer: 3 * PTO
 |      +----------+   |  - if not already done, close all streams
 |          |          |
 |          |          |
 |       close_timer fires
 |          |
 V          V
 +------------------------+
 |       CLOSED           | - clean up all the resources, drop connection
 +------------------------+   state completely

The ngx_quic_close_connection() function gets an "rc" argument, that signals
reason of connection closing:
    NGX_OK    - initiated by application (i.e. http/3), follow state machine
    NGX_DONE  - timedout (while idle or draining)
    NGX_ERROR - fatal error, destroy connection immediately

The PTO calculations are not yet implemented, hardcoded value of 5s is used.

Refactored ngx_quic_close_connection().

The function is split into three:
    ngx_quic_close_connection() itself cleans up all core nginx things
    ngx_quic_close_quic()  deals with everything inside c->quic
    ngx_quic_close_streams() deals with streams cleanup

The quic and streams cleanup functions may return NGX_AGAIN, thus signalling
that cleanup is not ready yet, and the close cannot continue to next step.

HTTP/3: directives with limited values converted to post handler.

The purpose is to show a precise line number with an invalid value.

HTTP/3: bytes holding directives changed to ngx_conf_set_size_slot.

This allows to specify directive values with measurement units.

Improved ngx_quic_build_int() code and readability.

The function now generates somewhat shorter assembler after inlining.

Fixed QUIC buffer consumption in send_chain().

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)

release-1.17.10 tag

nginx-1.17.10-RELEASE

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.

Updated OpenSSL used for win32 builds.

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.

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.