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

Transport parameters stub, to complete handshake.

Introduced ngx_quic_secret_t.

QUIC handshake handler, draft 24 bump.

Fixed indentation.

PN-aware AEAD nonce, feeding proper CRYPTO length.

OpenSSL compatibility.

QUIC add_handshake_data callback, varint routines.

QUIC set_encryption_secrets callback.

Server Initial Keys.

Initial QUIC support in http.

HTTP UDP layer, QUIC support autotest.

Created the "quic" branch.

Added default overwrite in error_page 494.

We used to have default error_page overwrite for 495, 496, and 497, so
a configuration like

    error_page 495 /error;

will result in error 400, much like without any error_page configured.

The 494 status code was introduced later (in 3848:de59ad6bf557, nginx 0.9.4),
and relevant changes to ngx_http_core_error_page() were missed, resulting
in inconsistent behaviour of "error_page 494" - with error_page configured
it results in 494 being returned instead of 400.

Reported by Frank Liu,
http://mailman.nginx.org/pipermail/nginx/2020-February/058957.html.

Mp4: fixed possible chunk offset overflow.

In "co64" atom chunk start offset is a 64-bit unsigned integer.  When trimming
the "mdat" atom, chunk offsets are casted to off_t values which are typically
64-bit signed integers.  A specially crafted mp4 file with huge chunk offsets
may lead to off_t overflow and result in negative trim boundaries.

The consequences of the overflow are:
- Incorrect Content-Length header value in the response.
- Negative left boundary of the response file buffer holding the trimmed "mdat".
  This leads to pread()/sendfile() errors followed by closing the client
  connection.

On rare systems where off_t is a 32-bit integer, this scenario is also feasible
with the "stco" atom.

The fix is to add checks which make sure data chunks referenced by each track
are within the mp4 file boundaries.  Additionally a few more checks are added to
ensure mp4 file consistency and log errors.

Disabled connection reuse while in SSL handshake.

During SSL handshake, the connection could be reused in the OCSP stapling
callback, if configured, which subsequently leads to a segmentation fault.

Disabled duplicate "Host" headers (ticket #1724).

Duplicate "Host" headers were allowed in nginx 0.7.0 (revision b9de93d804ea)
as a workaround for some broken Motorola phones which used to generate
requests with two "Host" headers[1].  It is believed that this workaround
is no longer relevant.

[1] http://mailman.nginx.org/pipermail/nginx-ru/2008-May/017845.html

Removed "Transfer-Encoding: identity" support.

The "identity" transfer coding has been removed in RFC 7230.  It is
believed that it is not used in real life, and at the same time it
provides a potential attack vector.

Disabled multiple Transfer-Encoding headers.

We anyway do not support more than one transfer encoding, so accepting
requests with multiple Transfer-Encoding headers doesn't make sense.
Further, we do not handle multiple headers, and ignore anything but
the first header.

Reported by Filippo Valsorda.

Made ngx_http_get_forwarded_addr_internal() non-recursive.

HTTP/2: fixed socket leak with an incomplete HEADERS frame.

A connection could get stuck without timers if a client has partially sent
the HEADERS frame such that it was split on the individual header boundary.
In this case, it cannot be processed without the rest of the HEADERS frame.

The fix is to call ngx_http_v2_state_headers_save() in this case.  Normally,
it would be called from the ngx_http_v2_state_header_block() handler on the
next iteration, when there is not enough data to continue processing.  This
isn't the case if recv_buffer became empty and there's no more data to read.

Version bump.

release-1.17.8 tag

nginx-1.17.8-RELEASE

gRPC: variables support in the "grpc_pass" directive.

HTTP/2: removed ngx_debug_point() call.
    
With the recent change to prevent frames flood in d4448892a294,
nginx will finalize the connection with NGX_HTTP_V2_INTERNAL_ERROR
whenever flood is detected, causing nginx aborting or stopping if
the debug_points directive is used in nginx config.

SSL: reworked posted next events again.

Previous change 1ce3f01a4355 incorrectly introduced processing of the
ngx_posted_next_events queue at the end of operation, effectively making
posted next events a nop, since at the end of an event loop iteration
the queue is always empty.  Correct approach is to move events to the
ngx_posted_events queue at an iteration start, as it was done previously.

Further, in some cases the c->read event might be already in the
ngx_posted_events queue, and calling ngx_post_event() with the
ngx_posted_next_events queue won't do anything.  To make sure the event
will be correctly placed into the ngx_posted_next_events queue
we now check if it is already posted.

Trailing space removed.

Version bump.

release-1.17.7 tag

nginx-1.17.7-RELEASE

SSL: reworked posted next events.

Introduced in 9d2ad2fb4423 available bytes handling in SSL relied
on connection read handler being overwritten to set the ready flag
and the amount of available bytes.  This approach is, however, does
not work properly when connection read handler is changed, for example,
when switching to a next pipelined request, and can result in unexpected
connection timeouts, see here:

http://mailman.nginx.org/pipermail/nginx-devel/2019-December/012825.html

Fix is to introduce ngx_event_process_posted_next() instead, which
will set ready and available regardless of how event handler is set.

HTTP/2: introduced separate handler to retry stream close.

When ngx_http_v2_close_stream_handler() is used to retry stream close
after queued frames are sent, client timeouts on the stream can be
logged multiple times and/or in addition to already happened errors.
To resolve this, separate ngx_http_v2_retry_close_stream_handler()
was introduced, which does not try to log timeouts.

HTTP/2: fixed socket leak with queued frames (ticket #1689).

If a stream is closed with queued frames, it is possible that no further
write events will occur on the stream, leading to the socket leak.
To fix this, the stream's fake connection read handler is set to
ngx_http_v2_close_stream_handler(), to make sure that finalizing the
connection with ngx_http_v2_finalize_connection() will be able to
close the stream regardless of the current number of queued frames.

Additionally, the stream's fake connection fc->error flag is explicitly
set, so ngx_http_v2_handle_stream() will post a write event when queued
frames are finally sent even if stream flow control window is exhausted.

Dav: added checks for chunked to body presence conditions.

These checks were missed when chunked support was introduced.  And also
added an explicit error message to ngx_http_dav_copy_move_handler()
(it was missed for some reason, in contrast to DELETE and MKCOL handlers).

Update manpage, sort command line options.

Discard request body when redirecting to a URL via error_page.

Reported by Bert JW Regeer and Francisco Oca Gonzalez.

Rewrite: disallow empty replacements.

While empty replacements were caught at run-time, parsing code
of the "rewrite" directive expects that a minimum length of the
"replacement" argument is 1.

Tolerate '\0' in URI when mapping URI to path.

If a rewritten URI has the null character, only a part of URI was
copied to a memory buffer allocated for path.  In some setups this
could be exploited to expose uninitialized memory via the Location
header.