nginx-1.9.11-RELEASE

Dynamic modules: NGX_STREAM define removed.

It's not used and contradicts the idea of dynamic loading.

Dynamic modules: added dlsym() to configure test.

It appears that AddressSanitizer in GCC 5 intercepts dlopen() and dlclose()
but not dlsym().

Dynamic modules: fixed a copy-n-paste error.

Dynamic modules.

The auto/module script is extended to understand ngx_module_link=DYNAMIC.
When set, it links the module as a shared object rather than statically
into nginx binary.  The module can later be loaded using the "load_module"
directive.

New auto/module parameter ngx_module_order allows to define module loading
order in complex cases.  By default the order is set based on ngx_module_type.

3rd party modules can be compiled dynamically using the --add-dynamic-module
configure option, which will preset ngx_module_link to "DYNAMIC" before
calling the module config script.

Win32 support is rudimentary, and only works when using MinGW gcc (which
is able to handle exports/imports automatically).

In collaboration with Ruslan Ermilov.

Dynamic modules: auto/module script.

This script simplifies configuration of additional modules,
including 3rd party ones.  The script is extensible, and
will be used to introduce dynamic linking of modules in upcoming
changes.

3rd party module config scripts are called with ngx_module_link
preset to "ADDON" - this allows config scripts to call auto/module
without ngx_module_link explicitly defined, as well as testing if
new interface is in place if compatibility with older nginx versions
is desired.

In collaboration with Ruslan Ermilov.

Dynamic modules: introduced HTTP_INIT_FILTER_MODULES.

Additionally, HTTP_HEADERS_FILTER_MODULE now added to HTTP_FILTER_MODULES.
This avoids explict use of modules at the later stages, now only module
lists are used.  This will be needed in later patches.

Dynamic modules: dlopen() support.

Dynamic modules: changed ngx_modules to cycle->modules.

Dynamic modules: moved module-related stuff to separate files.

HTTP/2: fixed possible buffer overrun (ticket #893).

Due to greater priority of the unary plus operator over the ternary operator
the expression didn't work as expected.  That might result in one byte less
allocation than needed for the HEADERS frame buffer.

HTTP/2: fixed padding handling in HEADERS frame with CONTINUATION.

HTTP/2: fixed request length accounting.

Now it includes not only the received body size,
but the size of headers block as well.

HTTP/2: fixed excessive memory allocation for pool cleanup.

HTTP/2: removed unused field from ngx_http_v2_stream_t.

Resolver: style.

Use the original query name in error and debug messages when
processing PTR responses.

Resolver: improved PTR response processing.

The previous code only parsed the first answer, without checking its
type, and required a compressed RR name.

The new code checks the RR type, supports responses with multiple
answers, and doesn't require the RR name to be compressed.

This has a side effect in limited support of CNAME.  If a response
includes both CNAME and PTR RRs, like when recursion is enabled on
the server, PTR RR is handled.

Full CNAME support in PTR response is not implemented in this change.

Resolver: style.

Renamed argument in ngx_resolver_process_a() for consistency.

Resolver: free TCP buffers on resolver cleanup.

Resolver: fixed possible resource leak introduced in 5a16d40c63de.

Found by Coverity (CID 1351175).

Resolver: TCP support.

Resend DNS query over TCP once UDP response came truncated.

Resolver: per-request DNS server balancer.

Previously, a global server balancer was used to assign the next DNS server to
send a query to.  That could lead to a non-uniform distribution of servers per
request.  A request could be assigned to the same dead server several times in a
row and wait longer for a valid server or even time out without being processed.

Now each query is sent to all servers sequentially in a circle until a
response is received or timeout expires.  Initial server for each request is
still globally balanced.

Resolver: renamed UDP-specific structures, fields and variables.

They will be used for TCP connections as well.

Resolver: removed unused field from ngx_resolver_ctx_t.

Version bump.

release-1.9.10 tag

nginx-1.9.10-RELEASE

Resolver: limited CNAME recursion.

Previously, the recursion was only limited for cached responses.

Resolver: fixed use-after-free memory accesses with CNAME.

When several requests were waiting for a response, then after getting
a CNAME response only the last request's context had the name updated.
Contexts of other requests had the wrong name.  This name was used by
ngx_resolve_name_done() to find the node to remove the request context
from.  When the name was wrong, the request could not be properly
cancelled, its context was freed but stayed linked to the node's waiting
list.  This happened e.g. when the first request was aborted or timed
out before the resolving completed.  When it completed, this triggered
a use-after-free memory access by calling ctx->handler of already freed
request context.  The bug manifests itself by
"could not cancel <name> resolving" alerts in error_log.

When a request was responded with a CNAME, the request context kept
the pointer to the original node's rn->u.cname.  If the original node
expired before the resolving timed out or completed with an error,
this would trigger a use-after-free memory access via ctx->name in
ctx->handler().

The fix is to keep ctx->name unmodified.  The name from context
is no longer used by ngx_resolve_name_done().  Instead, we now keep
the pointer to resolver node to which this request is linked.
Keeping the original name intact also improves logging.

Resolver: changed the ngx_resolver_create_*_query() arguments.

No functional changes.

This is needed by the following change.

Resolver: fixed CNAME processing for several requests.

When several requests were waiting for a response, then after getting
a CNAME response only the last request was properly processed, while
others were left waiting.

Resolver: fixed crashes in timeout handler.

If one or more requests were waiting for a response, then after
getting a CNAME response, the timeout event on the first request
remained active, pointing to the wrong node with an empty
rn->waiting list, and that could cause either null pointer
dereference or use-after-free memory access if this timeout
expired.

If several requests were waiting for a response, and the first
request terminated (e.g., due to client closing a connection),
other requests were left without a timeout and could potentially
wait indefinitely.

This is fixed by introducing per-request independent timeouts.
This change also reverts 954867a2f0a6 and 5004210e8c78.

Resolver: fixed possible segmentation fault on DNS format error.

Request body: removed surplus assigment, no functional changes.

Setting rb->bufs to NULL is surplus after ngx_http_write_request_body()
has returned NGX_OK.

Core: worker_cpu_affinity auto.

If enabled, workers are bound to available CPUs, each worker to once CPU
in order.  If there are more workers than available CPUs, remaining are
bound in a loop, starting again from the first available CPU.

The optional mask parameter defines which CPUs are available for automatic
binding.

In collaboration with Vladimir Homutov.

Upstream: fixed changing method on X-Accel-Redirect.

Previously, only r->method was changed, resulting in handling of a request
as GET within nginx itself, but not in requests to proxied servers.

See http://mailman.nginx.org/pipermail/nginx/2015-December/049518.html.

Year 2016.

Upstream: don't keep connections on early responses (ticket #669).

Fixed PROXY protocol on IPv6 sockets (ticket #858).

Version bump.

Fixed a typo.

release-1.9.9 tag

nginx-1.9.9-RELEASE

Fixed fastcgi_pass with UNIX socket and variables (ticket #855).

This was broken in a93345ee8f52 (1.9.8).

Version bump.

release-1.9.8 tag

nginx-1.9.8-RELEASE

Slice filter: terminate first slice with last_in_chain flag.

This flag makes sub filter flush buffered data and optimizes allocation in copy
filter.

Slice filter: never run subrequests when main request is buffered.

With main request buffered, it's possible, that a slice subrequest will send
output before it.  For example, while main request is waiting for aio read to
complete, a slice subrequest can start an aio operation as well.  The order
in which aio callbacks are called is undetermined.

SSL: fixed possible segfault on renegotiation (ticket #845).

Skip SSL_CTX_set_tlsext_servername_callback in case of renegotiation.
Do nothing in SNI callback as in this case it will be supplied with
request in c->data which isn't expected and doesn't work this way.

This was broken by b40af2fd1c16 (1.9.6) with OpenSSL master branch and LibreSSL.

Updated OpenSSL and PCRE used for win32 builds.

Added slice module to win32 builds.

Slice filter.

Splits a request into subrequests, each providing a specific range of response.
The variable "$slice_range" must be used to set subrequest range and proper
cache key.  The directive "slice" sets slice size.

The following example splits requests into 1-megabyte cacheable subrequests.

server {
    listen 8000;

    location / {
        slice 1m;

        proxy_cache cache;
        proxy_cache_key $uri$is_args$args$slice_range;
        proxy_set_header Range $slice_range;
        proxy_cache_valid 200 206 1h;
        proxy_pass http://127.0.0.1:9000;
    }
}

Upstream: fill r->headers_out.content_range from upstream response.

Core: fix typo in error message.

Signed-off-by: Piotr Sikora <piotrsikora@google.com>

Style: NGX_PTR_SIZE replaced with sizeof(void *).

The NGX_PTR_SIZE macro is only needed in preprocessor directives where
it's not possible to use sizeof().

Style.

Stop emulating a space character after r->method_name.

This is an API change.

The proxy module was modified to not depend on this in 44122bddd9a1.
No known third-party modules seem to depend on this.

Proxy: improved code readability.

Do not assume that space character follows the method name, just pass it
explicitly.

The fuss around it has already proved to be unsafe, see bbdb172f0927 and
http://mailman.nginx.org/pipermail/nginx-ru/2013-January/049692.html for
details.

Reduced the number of GET method constants.

Increased the default "connection_pool_size" on 64-bit platforms.

The previous default of 256 bytes isn't enough and results in two
allocations on each accepted connection, which is suboptimal.

Configure: improved workaround for system perl on OS X.

The workaround from baf2816d556d stopped to work because the order of
"-arch x86_64" and "-arch i386" has changed.

Configure: removed comment obsolete in 3b763d36e055.

Style: unified request method checks.

Core: enabled "include" inside http upstreams (ticket #635).

The directive already works inside stream upstream blocks.

Configure: fixed using OpenSSL include paths.

Upstream: fixed "no port" detection in evaluated upstreams.

If an upstream with variables evaluated to address without a port,
then instead of a "no port in upstream" error an attempt was made
to connect() which failed with EADDRNOTAVAIL.

Missing "variable" word added.

Used the pwritev() syscall for writing files where possible.

It is more effective, because it doesn't require a separate lseek().

Moved file writev() handling code to a separate function.

No functional changes.

Handled EINTR from write() and pwrite() syscalls.

This is in addition to 6fce16b1fc10.

Adjusted file->sys_offset after the write() syscall.

This fixes suboptimal behavior caused by surplus lseek() for sequential writes
on systems without pwrite().  A consecutive read after write might result in an
error on systems without pread() and pwrite().

Fortunately, at the moment there are no widely used systems without these
syscalls.

Version bump.

release-1.9.7 tag

nginx-1.9.7-RELEASE

Realip: the $realip_remote_addr variable.

HTTP/2: reused HEADERS and CONTINUATION frames buffers.

HTTP/2: fixed handling of output HEADERS frames.

The HEADERS frame is always represented by more than one buffer since
b930e598a199, but the handling code hasn't been adjusted.

Only the first buffer of HEADERS frame was checked and if it had been
sent while others had not, the rest of the frame was dropped, resulting
in broken connection.

Before b930e598a199, the problem could only be seen in case of HEADERS
frame with CONTINUATION.

HTTP/2: fixed invalid headers handling (ticket #831).

The r->invalid_header flag wasn't reset once an invalid header appeared in a
request, resulting in all subsequent headers in the request were also marked
as invalid.

Upstream: proxy_cache_convert_head directive.

The directive toggles conversion of HEAD to GET for cacheable proxy requests.
When disabled, $request_method must be added to cache key for consistency.
By default, HEAD is converted to GET as before.

SSL: only select HTTP/2 using NPN if "http2" is enabled.

OpenSSL doesn't check if the negotiated protocol has been announced.
As a result, the client might force using HTTP/2 even if it wasn't
enabled in configuration.

HTTP/2: backed out 16905ecbb49e (ticket #822).

It caused inconsistency between setting "in_closed" flag and the moment when
the last DATA frame was actually read.  As a result, the body buffer might not
be initialized properly in ngx_http_v2_init_request_body(), which led to a
segmentation fault in ngx_http_v2_state_read_data().  Also it might cause
start processing of incomplete body.

This issue could be triggered when the processing of a request was delayed,
e.g. in the limit_req or auth_request modules.

Fixed ngx_parse_time() out of bounds access (ticket #821).

The code failed to ensure that "s" is within the buffer passed for
parsing when checking for "ms", and this resulted in unexpected errors when
parsing non-null-terminated strings with trailing "m".  The bug manifested
itself when the expires directive was used with variables.

Found by Roman Arutyunyan.

Syslog: added "nohostname" option.

The option disables sending hostname in the syslog message header.  This is
useful with syslog daemons that do not expect it (tickets #677 and #783).

HTTP/2: changed behavior of the "http2_max_field_size" directive.

Now it limits only the maximum length of literal string (either raw or
compressed) in HPACK request header fields.  It's easier to understand
and to describe in the documentation.

HTTP/2: fixed spelling.

Version bump.

release-1.9.6 tag

nginx-1.9.6-RELEASE

HTTP/2: simplified checking the END_STREAM flag.

No functional changes.

HTTP/2: improved the ngx_http_v2_integer_octets(v) macro.

Previously, it didn't work well for 0, 127, and 128, returning less than needed.

HTTP/2: fixed the NGX_HTTP_V2_MAX_FIELD macro.

HTTP/2: fixed splitting of response headers on CONTINUATION frames.

Previous code has been based on assumption that the header block can only be
splitted at the borders of individual headers.  That wasn't the case and might
result in emitting frames bigger than the frame size limit.

The current approach is to split header blocks by the frame size limit.

HTTP/2: introduced NGX_HTTP_V2_ENCODE_* macros.

No functional changes.

HTTP/2: simplified producing of the Last-Modified header.

HTTP/2: fixed header block size calculation.

HTTP/2: fix handling of connection errors.

Previously, nginx worker would crash because of a double free
if client disconnected or timed out before sending all headers.

Found with afl-fuzz.

Signed-off-by: Piotr Sikora <piotrsikora@google.com>

HTTP/2: fix indirect reprioritization.

Previously, streams that were indirectly reprioritized (either because of
a new exclusive dependency on their parent or because of removal of their
parent from the dependency tree), didn't have their pointer to the parent
node updated.

This broke detection of circular dependencies and, as a result, nginx
worker would crash due to stack overflow whenever such dependency was
introduced.

Found with afl-fuzz.

Signed-off-by: Piotr Sikora <piotrsikora@google.com>

HTTP/2: reject self-dependent streams.

Per RFC7540, a stream cannot depend on itself.

Previously, this requirement was enforced on PRIORITY frames, but not on
HEADERS frames and due to the implementation details nginx worker would
crash (stack overflow) while opening self-dependent stream.

Found with afl-fuzz.

Signed-off-by: Piotr Sikora <piotrsikora@google.com>

Core: read/write locks are also required by the Stream module.

Signed-off-by: Piotr Sikora <piotrsikora@google.com>