QUIC: cleaned up quic encryption state tracking.

The patch removes remnants of the old state tracking mechanism, which did
not take into account assimetry of read/write states and was not very
useful.

The encryption state now is entirely tracked using SSL_quic_read/write_level().

QUIC: added ALPN checks.

quic-transport draft 29:

    section 7:

    *  authenticated negotiation of an application protocol (TLS uses
       ALPN [RFC7301] for this purpose)

    ...

    Endpoints MUST explicitly negotiate an application protocol.  This
    avoids situations where there is a disagreement about the protocol
    that is in use.

    section 8.1:

    When using ALPN, endpoints MUST immediately close a connection (see
    Section 10.3 of [QUIC-TRANSPORT]) with a no_application_protocol TLS
    alert (QUIC error code 0x178; see Section 4.10) if an application
    protocol is not negotiated.

Changes in ngx_quic_close_quic() function are required to avoid attempts
to generated and send packets without proper keys, what happens in case
of failed ALPN check.

QUIC: fixed off-by-one in frame range handler.

The ctx->pnum is incremented after the packet is sent, thus pointing to the
next packet number, which should not be used in comparison.

QUIC: further limiting maximum QUIC packet size.

quic-transport draft 29, section 14:

    QUIC depends upon a minimum IP packet size of at least 1280 bytes.
    This is the IPv6 minimum size [RFC8200] and is also supported by most
    modern IPv4 networks.  Assuming the minimum IP header size, this
    results in a QUIC maximum packet size of 1232 bytes for IPv6 and 1252
    bytes for IPv4.

Since the packet size can change during connection lifetime, the
ngx_quic_max_udp_payload() function is introduced that currently
returns minimal allowed size, depending on address family.

QUIC: raise error on missing transport parameters.

quic-tls, 8.2:

    The quic_transport_parameters extension is carried in the ClientHello
    and the EncryptedExtensions messages during the handshake.  Endpoints
    MUST send the quic_transport_parameters extension; endpoints that
    receive ClientHello or EncryptedExtensions messages without the
    quic_transport_parameters extension MUST close the connection with an
    error of type 0x16d (equivalent to a fatal TLS missing_extension
    alert, see Section 4.10).

QUIC: Fixed connection cleanup.

A posted event need to be deleted during the connection close.

Style.

Limited max udp payload size for outgoing packets.

This allows to avoid problems with packet fragmentation in real networks.
This is a temporary workaround.

Increased default initial retransmit timeout.

This is a temporary workaround, proper retransmission mechanism based on
quic-recovery rfc draft is yet to be implemented.

Currently hardcoded value is too small for real networks.  The patch
sets static PTO, considering rtt of ~333ms, what gives about 1s.

Fixed usage of own/client transport parameters.

Stream ID handling in MAX_STREAM_DATA and STREAM_DATA_BLOCKED.

Stream ID handling in RESET_STREAM and STOP_SENDING frames.

Reject invalid STREAM ID with STREAM_STATE_ERROR connection error.

Introduced connection error APPLICATION_ERROR from draft-28.

Receipt of CONNECTION_CLOSE in 0-RTT is permitted in draft-28.

Treat receipt of NEW_TOKEN as connection error PROTOCOL_VIOLATION.

Decoupled validation of Host and :authority for HTTP/2 and HTTP/3.

Previously an error was triggered for HTTP/2 when host with port was passed
by client.

Compatibility with BoringSSL master branch.

Recently BoringSSL introduced SSL_set_quic_early_data_context()
that serves as an additional constrain to enable 0-RTT in QUIC.

Relevant changes:
 * https://boringssl.googlesource.com/boringssl/+/7c52299%5E!/
 * https://boringssl.googlesource.com/boringssl/+/8519432%5E!/

Fixed transport parameters on a new connection with a valid token.

Previously, the retry transport parameter was sent regardless.

Require ":authority" or "Host" in HTTP/3 and HTTP/2 requests.

Also, if both are present, require that they have the same value.  These
requirements are specified in HTTP/3 draft 28.

Current implementation of HTTP/2 treats ":authority" and "Host"
interchangeably.  New checks only make sure at least one of these values is
present in the request.  A similar check existed earlier and was limited only
to HTTP/1.1 in 38c0898b6df7.

Added propagation of the "wildcard" flag to c->listening.

The flags was originally added by 8f038068f4bc, and is propagated correctly
in the stream module.  With QUIC introduction, http module now uses datagram
sockets as well, thus the fix.

Made NGX_QUIC_DRAFT_VERSION tunable from configure parameters.

Now it can be switched using --with-cc-opt='-DNGX_QUIC_DRAFT_VERSION=28'.

QUIC draft-28 transport parameters support.

Draft-27 and draft-28 support can now be enabled interchangeably,
it's based on the compile-time macro NGX_QUIC_DRAFT_VERSION.

Introduced macros for building length-value transport parameters.

Renamed max_packet_size to max_udp_payload_size, from draft-28.

No functional changes.

Rejected forbidden transport parameters with TRANSPORT_PARAMETER_ERROR.

Fixed return codes in ngx_quic_add_handshake_data() callback.

README: update after merging 1.19.0.

Merged with the default branch.

release-1.19.0 tag

nginx-1.19.0-RELEASE

Updated OpenSSL used for win32 builds.

Updated README with "Contributing" section and draft details.

HTTP/2: invalid connection preface logging (ticket #1981).

Previously, invalid connection preface errors were only logged at debug
level, providing no visible feedback, in particular, when a plain text
HTTP/2 listening socket is erroneously used for HTTP/1.x connections.
Now these are explicitly logged at the info level, much like other
client-related errors.

Fixed format specifiers.

OCSP: certificate status cache.

When enabled, certificate status is stored in cache and is used to validate
the certificate in future requests.

New directive ssl_ocsp_cache is added to configure the cache.

SSL: client certificate validation with OCSP (ticket #1534).

OCSP validation for client certificates is enabled by the "ssl_ocsp" directive.
OCSP responder can be optionally specified by "ssl_ocsp_responder".

When session is reused, peer chain is not available for validation.
If the verified chain contains certificates from the peer chain not available
at the server, validation will fail.

OCSP stapling: iterate over all responder addresses.

Previously only the first responder address was used per each stapling update.
Now, in case of a network or parsing error, next address is used.

This also fixes the issue with unsupported responder address families
(ticket #1330).

OCSP stapling: keep extra chain in the staple object.

HTTP/3: reallocate strings inserted into the dynamic table.

They should always be allocated from the main QUIC connection pool.

Fixed client buffer reallocation for HTTP/3.

Preserving pointers within the client buffer is not needed for HTTP/3 because
all data is either allocated from pool or static.  Unlike with HTTP/1, data
typically cannot be referenced directly within the client buffer.  Trying to
preserve NULLs or external pointers lead to broken pointers.

Also, reverted changes in ngx_http_alloc_large_header_buffer() not relevant
for HTTP/3 to minimize diff to mainstream.

Fixed $request_length for HTTP/3.

New field r->parse_start is introduced to substitute r->request_start and
r->header_name_start for request length accounting.  These fields only work for
this purpose in HTTP/1 because HTTP/1 request line and header line start with
these values.

Also, error logging is now fixed to output the right part of the request.

HTTP/3: restricted symbols in header names.

As per HTTP/3 draft 27, a request or response containing uppercase header
field names MUST be treated as malformed.  Also, existing rules applied
when parsing HTTP/1 header names are also applied to HTTP/3 header names:

- null character is not allowed
- underscore character may or may not be treated as invalid depending on the
  value of "underscores_in_headers"
- all non-alphanumeric characters with the exception of '-' are treated as
  invalid

Also, the r->locase_header field is now filled while parsing an HTTP/3
header.

Error logging for invalid headers is fixed as well.

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.