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.

Removed unused variable.

Removed unused variable.

Added checks for permitted frame types.

 + cleanup in macros for packet types
 + some style fixes in quic_transport.h (case, indentation)

Fixed parsing of CONNECTION CLOSE2 frames.

The "frame_type" field is not passed in case of 0x1d frame.

Added parsing of CONNECTION_CLOSE2 frame (0x1D).

The difference is that error code refers to application namespace, i.e.
quic error names cannot be used to convert it to string.

Adedd the http "quic" variable.

The value is literal "quic" for requests passed over HTTP/3, and empty string
otherwise.

Configurable transport parameters.

 - integer parameters can be configured using the following directives:

    quic_max_idle_timeout
    quic_max_ack_delay
    quic_max_packet_size
    quic_initial_max_data
    quic_initial_max_stream_data_bidi_local
    quic_initial_max_stream_data_bidi_remote
    quic_initial_max_stream_data_uni
    quic_initial_max_streams_bidi
    quic_initial_max_streams_uni
    quic_ack_delay_exponent
    quic_active_migration
    quic_active_connection_id_limit

 - only following parameters are actually sent:

    active_connection_id_limit
    initial_max_streams_uni
    initial_max_streams_bidi
    initial_max_stream_data_bidi_local
    initial_max_stream_data_bidi_remote
    initial_max_stream_data_uni

 (other parameters are to be added into ngx_quic_create_transport_params()
  function as needed, should be easy now)

 - draft 24 and draft 27 are now supported
   (at compile-time using quic_version macro)

Reset QUIC timeout on every datagram.

Double MAX_STREAMS on STREAMS_BLOCKED.

Fixed ACKs to packet numbers greater than 63.

Fixed specifiers in "quic packet length" logging.

Fixed build.

The ngx_quic_frame_len() function is not really needed.

Added boundaries checks into frame parser.

The ngx_quic_parse_frame() functions now has new 'pkt' argument: the packet
header of a currently processed frame.  This allows to log errors/debug
closer to reasons and perform additional checks regarding possible frame
types.  The handler only performs processing of good frames.

A number of functions like read_uint32(), parse_int[_multi] probably should
be implemented as a macro, but currently it is better to have them as
functions for simpler debugging.

Send a FIN frame when QUIC stream is closed.

Fixed header creation for header_only responses in HTTP/3.

MAX_DATA frame parser/handler.

Added parsing of STREAMS BLOCKED frames.

While there, added hex prefix for debug to avoid frame type confusion.

Implemented send_alert callback, CONNECTION_CLOSE writer.

The callback produces a CONNECTION_CLOSE frame, as per quic-tls-24#section-4.9.

Added copying addr_text to QUIC stream connections.

Now $remote_addr holds client address.

HTTP/3 $request_line variable.

Moved setting QUIC methods to runtime.

This allows listening to both https and http3 in the same server.
Also, the change eliminates the ssl_quic directive.

Added parsing of RESET_STREAM and STOP_SENDING frames

Fixed pointer increment while parsing HTTP/3 header.

Implemented creation of server unidirectional streams.

The ngx_quic_create_stream() function is a generic function extracted from
the ngx_quic_handle_stream_frame() function.

Fixed HTTP/3 server stream creation.

Removed comment.

Refactored HTTP/3 parser.

Style and handlers.

Cleanup in ngx_event_quic.c:
    + reorderded functions, structures
    + added missing prototypes
    + added separate handlers for each frame type
    + numerous indentation/comments/TODO fixes
    + removed non-implemented qc->state and corresponding enum;
        this requires deep thinking, stub was unused.
    + streams inside quic connection are now in own structure

Extracted transport part of the code into separate file.

All code dealing with serializing/deserializing
is moved int srv/event/ngx_event_quic_transport.c/h file.

All macros for dealing with data are internal to source file.

The header file exposes frame types and error codes.

The exported functions are currently packet header parsers and writers
and frames parser/writer.

The ngx_quic_header_t structure is updated with 'log' member. This avoids
passing extra argument to parsing functions that need to report errors.

Firefox fixes.

 + support for more than one initial packet
 + workaround for trailing zeroes in packet
 + ignore application data packet if no keys yet (issue in draft 27/ff nightly)
 + fixed PING frame parser
 + STREAM frames need to be acknowledged

The following HTTP configuration is used for firefox (v74):

http {

    ssl_certificate_key localhost.key;
    ssl_certificate localhost.crt;
    ssl_protocols TLSv1.2 TLSv1.3;

    server {
        listen 127.0.0.1:10368 reuseport http3;
        ssl_quic on;
        server_name  localhost;

        location / {
            return 200 "This-is-QUICK\n";
        }
    }
    server {
        listen 127.0.0.1:5555 ssl; # point the browser here
        server_name  localhost;
        location / {
            add_header Alt-Svc 'h3-24=":10368";ma=100';
            return 200 "ALT-SVC";
        }
    }
}

Fixed a typo with OpenSSL.

Split transport and crypto parts into separate files.

New files:
    src/event/ngx_event_quic_protection.h
    src/event/ngx_event_quic_protection.c

The protection.h header provides interface to the crypto part of the QUIC:

2 functions to initialize corresponding secrets:

ngx_quic_set_initial_secret()
ngx_quic_set_encryption_secret()

and 2 functions to deal with packet processing:

ngx_quic_encrypt()
ngx_quic_decrypt()

Also, structures representing secrets are defined there.

All functions require SSL connection and a pool, only crypto operations
inside, no access to nginx connections or events.

Currently pool->log is used for the logging (instead of original c->log).

Added processing of CONNECTION CLOSE frames.

Contents is parsed and debug is output. No actions are taken.

Temporary fix for header null-termination in HTTP/3.

Fixed header protection application with pn length > 1.

Fixed sanitizer errors.

Added check for initialized c->ssl before calling SSL shutdown.

HTTP/3.

Fixed infinite loop in ngx_quic_stream_send_chain().

Implemented tracking offset in STREAM frames.

Implemented ngx_quic_stream_send_chain() method.

 - just call send in a loop

Stream "connection" read/write methods.

Fix build.

Removed hardcoded CRYPTO and ACK frame sizes.

HTTP/QUIC interface reworked.

 - events handling moved into src/event/ngx_event_quic.c
 - http invokes once ngx_quic_run() and passes stream callback
 (diff to original http_request.c is now minimal)

 - streams are stored in rbtree using ID as a key
 - when a new stream is registered, appropriate callback is called

 - ngx_quic_stream_t type represents STREAM and stored in c->qs

Initial parsing of STREAM frames.

Added support of multiple QUIC packets in single datagram.

 - now NEW_CONNECTION_ID frames can be received and parsed

The packet structure is created in ngx_quic_input() and passed
to all handlers (initial, handshake and application data).

The UDP datagram buffer is saved as pkt->raw;
The QUIC packet is stored as pkt->data and pkt->len (instead of pkt->buf)
(pkt->len is adjusted after parsing headers to actual length)

The pkt->pos is removed, pkt->raw->pos is used instead.

Added more transport parameters.

Needed for client to start sending streams.

Compatibility with BoringSSL revised QUIC encryption secret APIs.

See for details: https://boringssl.googlesource.com/boringssl/+/1e85905%5E!/

Chacha20 header protection support with BoringSSL.

BoringSSL lacks EVP for Chacha20.  Here we use CRYPTO_chacha_20() instead.

ChaCha20 / Poly1305 initial support.

Using SSL cipher suite id to obtain cipher/digest, part 2.

Ciphers negotiation handling refactored into ngx_quic_ciphers().