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().

Fixed nonce in short packet protection.

Generic payload handler for quic packets.

 - added basic parsing of ACK, PING and PADDING frames on input
 - added preliminary parsing of SHORT headers

The ngx_quic_output() is now called after processing of each input packet.
Frames are added into output queue according to their level: inital packets
go ahead of handshake and application data, so they can be merged properly.

The payload handler is called from both new, handshake and applicataion data
handlers (latter is a stub).

Fixed header protection with negotiated cipher suite.

Initial packets are protected with AEAD_AES_128_GCM.

Fixed write secret logging in set_encryption_secrets callback.

Fixed format specifiers.

Style.

Added functions to decrypt long packets.

Fixed ngx_quic_varint_len misuse in the previous change.

Macro for calculating size of varint.

Fixed packet "input" debug log message.

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

While here, log the negotiated cipher just once, - after handshake.

Using cached ssl_conn in ngx_quic_handshake_input(), NFC.

Adjusted transport parameters stub for active_connection_id_limit.

As was objserved with ngtcp2 client, Finished CRYPTO frame within Handshake
packet may not be sent for some reason if there's nothing to append on 1-RTT.
This results in unnecessary retransmit.  To avoid this edge case, a non-zero
active_connection_id_limit transport parameter is now used to append datagram
with NEW_CONNECTION_ID 1-RTT frames.

Implemented improved version of quic_output().

Now handshake generates frames, and they are queued in c->quic->frames.
The ngx_quic_output() is called from ngx_quic_flush_flight() or manually,
processes the queue and encrypts all frames according to required encryption
level.

QUIC handshake final bits.

Added handling of client Finished, both feeding and acknowledgement.
This includes sending NST in 1-RTT triggered by a handshake process.

Split frame and packet generation into separate steps.

While there, a number of QUIC constants from spec defined and magic numbers
were replaced.

Aded the "ngx_quic_hexdump" macro.

ngx_quic_hexdump0(log, format, buffer, buffer_size);
    - logs hexdump of buffer to specified error log

    ngx_quic_hexdump0(c->log, "this is foo:", foo.data, foo.len);

ngx_quic_hexdump(log, format, buffer, buffer_size, ...)
    - same as hexdump0, but more format/args possible:

    ngx_quic_hexdump(c->log, "a=%d b=%d, foo is:", foo.data, foo.len, a, b);

Moved all QUIC code into ngx_event_quic.c

Introduced ngx_quic_input() and ngx_quic_output() as interface between
nginx and protocol.  They are the only functions that are exported.

While there, added copyrights.

Introduced quic_version macro, uint16/uint32 routines ported.

Cleanup.

Generic function for HKDF expansion.

QUIC header protection routines, introduced ngx_quic_tls_hp().

AEAD routines, introduced ngx_quic_tls_open()/ngx_quic_tls_seal().