SSL: guard use of SSL_OP_MSIE_SSLV2_RSA_PADDING.

This option had no effect since 0.9.7h / 0.9.8b and it was removed
in recent OpenSSL.

Signed-off-by: Piotr Sikora <piotr@cloudflare.com>

Improved check for duplicate path names in ngx_add_path().

The same path names with different "data" context should not be allowed.

In particular it rejects configurations like this:

    proxy_cache_path /var/cache/ keys_zone=one:10m max_size=1g inactive=5m;
    proxy_cache_path /var/cache/ keys_zone=two:20m max_size=4m inactive=30s;

Removed surplus initializations from ngx_conf_set_path_slot().

An instance of ngx_path_t is already zeroed by ngx_pcalloc().

Use ngx_pcalloc() in ngx_conf_merge_path_value().

It initializes the "data" pointer of ngx_path_t that will be checked after
subsequent changes.

Use EPOLLRDHUP in ngx_http_test_reading() (ticket #320).

This allows to detect client connection close with pending data when
the ngx_http_test_reading() request event handler is set.

Upstream: use EPOLLRDHUP to check broken connections (ticket #320).

This allows to detect client connection close with pending data on Linux
while processing upstream.

Events: support for EPOLLRDHUP (ticket #320).

Since Linux 2.6.17, epoll is able to report about peer half-closed connection
using special EPOLLRDHUP flag on a read event.

Events: removed unused flags from the ngx_event_s structure.

They are not used since 708f8bb772ec (pre 0.0.1).

Fixed handling of the ready flag with kqueue.

There is nothing to do more when recv() has returned 0,
so we should drop the flag.

Return reason phrase for 414.

After 62be77b0608f nginx can return this code.

Upstream: fixed $upstream_response_time format specifiers.

Configure: TCP_KEEPIDLE test name simplified.

Configure: fixed building with Sun C if CFLAGS set (ticket #65).

SSL: clear error queue after SSL_CTX_load_verify_locations().

The SSL_CTX_load_verify_locations() may leave errors in the error queue
while returning success (e.g. if there are duplicate certificates in the file
specified), resulting in "ignoring stale global SSL error" alerts later
at runtime.

Fixed incorrect response line on "return 203".

Reported by Weibin Yao,
http://mailman.nginx.org/pipermail/nginx-devel/2013-April/003607.html.

Request cleanup code unified, no functional changes.

Additionally, detaching a cleanup chain from a request is a bit more resilent
to various bugs if any.

Handling of ngx_int_t != intptr_t case.

Casts between pointers and integers produce warnings on size mismatch.  To
silence them, cast to (u)intptr_t should be used.  Prevoiusly, casts to
ngx_(u)int_t were used in some cases, and several ngx_int_t expressions had
no casts.

As of now it's mostly style as ngx_int_t is defined as intptr_t.

Win32: $request_time fixed.

On win32, time_t is 64 bits wide by default, and passing an ngx_msec_int_t
argument for %T format specifier doesn't work.  This doesn't manifest itself
on other platforms as time_t and ngx_msec_int_t are usually of the same size.

Win32: MinGW GCC compatibility.

Several warnings silenced, notably (ngx_socket_t) -1 is now checked
on socket operations instead of -1, as ngx_socket_t is unsigned on win32
and gcc complains on comparison.

With this patch, it's now possible to compile nginx using mingw gcc,
with options we normally compile on win32.

Win32: Borland C compatibility fixes.

Several false positive warnings silenced, notably W8012 "Comparing
signed and unsigned" (due to u_short values promoted to int), and
W8072 "Suspicious pointer arithmetic" (due to large type values added
to pointers).

With this patch, it's now again possible to compile nginx using bcc32,
with options we normally compile on win32 minus ipv6 and ssl.

Win32: Open Watcom C compatibility fixes.

Precompiled headers are disabled as they lead to internal compiler errors
with long configure lines.  Couple of false positive warnings silenced.
Various win32 typedefs are adjusted to work with Open Watcom C 1.9 headers.

With this patch, it's now again possible to compile nginx using owc386,
with options we normally compile on win32 minus ipv6 and ssl.

Disable symlinks: removed recursive call of ngx_file_o_path_info().

It is surplus.

Disable symlinks: use O_PATH to open path components.

It was introduced in Linux 2.6.39, glibc 2.14 and allows to obtain
file descriptors without actually opening files.  Thus made it possible
to traverse path with openat() syscalls without the need to have read
permissions for path components.  It is effectively emulates O_SEARCH
which is missing on Linux.

O_PATH is used in combination with O_RDONLY.  The last one is ignored
if O_PATH is used, but it allows nginx to not fail when it was built on
modern system (i.e. glibc 2.14+) and run with a kernel older than 2.6.39.
Then O_PATH is unknown to the kernel and ignored, while O_RDONLY is used.

Sadly, fstat() is not working with O_PATH descriptors till Linux 3.6.
As a workaround we fallback to fstatat() with the AT_EMPTY_PATH flag
that was introduced at the same time as O_PATH.

Added the NGX_EBADF define.

Assume the HTTP/1.0 version by default.

It is believed to be better than fallback to HTTP/0.9, because most of
the clients at present time support HTTP/1.0.  It allows nginx to return
error response code for them in cases when it fail to parse request line,
and therefore fail to detect client protocol version.

Even if the client does not support HTTP/1.0, this assumption should not
cause any harm, since from the HTTP/0.9 point of view it still a valid
response.

Upstream: setting u->header_sent before ngx_http_upstream_upgrade().

Without u->header_sent set a special response might be generated following
an upgraded connection.  The problem appeared in 1ccdda1f37f3 (1.5.3).
Catched by "header already sent" alerts in 1.5.4 after upstream timeouts.

Referer: fixed hostname buffer overflow check.

Because of premature check the effective buffer size was 255 symbols
while the buffer is able to handle 256.

Referer: "server_names" parsing deferred to merge phase.

This allows to approach "server_name" values specified below the
"valid_referers" directive when used within the "server_names" parameter, e.g.:

    server_name  example.org;
    valid_referers server_names;
    server_name  example.com;

As a bonus, this fixes bogus error with "server_names" specified several times.

Referer: fixed server_name regex matching.

The server_name regexes are normally compiled for case-sensitive matching.
This violates case-insensitive obligations in the referer module.  To fix
this, the host string is converted to lower case before matching.

Previously server_name regex was executed against the whole referer string
after dropping the scheme part.  This could led to an improper matching, e.g.:

    server_name ~^localhost$;
    valid_referers server_names;

    Referer: http://localhost/index.html

It was changed to look only at the hostname part.

The server_name regexes are separated into another array to not clash with
regular regexes.

Referer: fixed error type usage inconsistency for ngx_http_add*().

Image filter: large image handling.

If Content-Length header is not set, and the image size is larger than the
buffer size, client will hang until a timeout occurs.

Now NGX_HTTP_UNSUPPORTED_MEDIA_TYPE is returned immediately.

diff -r d1403de41631 -r 4fae04f332b4
src/http/modules/ngx_http_image_filter_module.c

Typo fixed.

Version bump.

release-1.5.4 tag

nginx-1.5.4-RELEASE

Updated PCRE used for win32 builds.

As of PCRE 8.33, config.h.generic no longer contains boolean macros.  Two
of them (SUPPORT_PCRE8 and HAVE_MEMMOVE) were added to appropriate makefiles.
This allows PCRE 8.33 to compile and don't change anything for previous
versions.

Configure: pcre.lib dependencies fix.

Previously, an attempt to build pcre.lib on win32 before anything else
failed due to no pcre.h.

Cache: lock timeouts are now logged at info level.

Upstream: posted requests handling after ssl handshake errors.

Missing call to ngx_http_run_posted_request() resulted in a main request hang
if subrequest's ssl handshake with an upstream server failed for some reason.

Reported by Aviram Cohen.

Fixed try_files with empty argument (ticket #390).

MIME: eot MIME type updated to follow IANA (ticket #306).

MIME: added the most common OOXML MIME types (ticket #243).

MIME: added application/font-woff MIME type (ticket #292).

Added auth request to win32 builds.

Added safety belt for the case of sending header twice.

The aforementioned situation is abnormal per se and as such it now forces
request termination with appropriate error message.

Autoindex: improved ngx_de_info() error handling.

This allows to build a directory listing whenever a loop exists in symbolic
link resolution of the path argument.

Autoindex: return NGX_ERROR on error if headers were sent.

This prevents ngx_http_finalize_request() from issuing
ngx_http_special_response_handler() on a freed context.

Style improved after 12dd27b74117.

Backed out f1a91825730a and 7094bd12c1ff.

While ngx_get_full_name() might have a bit more descriptive arguments,
the ngx_conf_full_name() is generally easier to use when parsing
configuration and limits exposure of cycle->prefix / cycle->conf_prefix
details.

Auth request module import.

Minor ngx_http_parse_request_line() optimization.

Noted by Nils Kuhnhenn.

Format specifier fixes in error logging.

Whitespace fix.

SPDY: alert about activated fake events instead of deleting them.

They refer to the same socket descriptor as our real connection, and
deleting them will stop processing of the connection.

Events of fake connections must not be activated, and if it happened there
is nothing we can do.  The whole processing should be terminated as soon as
possible, but it is not obvious how to do this safely.

SPDY: do not reject headers with empty value (ticket #396).

A quote from SPDY draft 2 specification: "The length of each name and
value must be greater than zero.  A receiver of a zero-length name or
value must send a RST_STREAM with code PROTOCOL error."

But it appears that Chrome browser allows sending requests over SPDY/2
connection using JavaScript that contain headers with empty values.

For better compatibility across SPDY clients and to be compliant with
HTTP, such headers are no longer rejected.

Also, it is worth noting that in SPDY draft 3 the statement has been
changed so that it permits empty values for headers.

SPDY: fixed corruption of headers with names longer than 255.

It is a bad idea to put zero byte in position where the length of
the next header name can be stored before it was parsed.

Unbreak building on Linux without sendfile64() support.

It was broken in 8e446a2daf48 when the NGX_SENDFILE_LIMIT constant was added
to ngx_linux_sendfile_chain.c having the same name as already defined one in
ngx_linux_config.h.

The newer is needed to overcome a bug in old Linux kernels by limiting the
number of bytes to send per sendfile() syscall.  The older is used with
sendfile() on ancient kernels that works with 32-bit offsets only.

One of these renamed to NGX_SENDFILE_MAXSIZE.

Referer module: fixed regex matching against HTTPS referers.

When matching a compiled regex against value in the "Referer" header field,
the length was calculated incorrectly for strings that start from "https://".
This might cause matching to fail for regexes with end-of-line anchors.

Patch by Liangbin Li.

Don't lose pointer to first nonempty buf in ngx_*_sendfile_chain().

In ngx_*_sendfile_chain() when calculating pointer to a first
non-zero sized buf, use "in" as iterator.  This fixes processing
of zero sized buf(s) after EINTR.  Otherwise function can return
zero sized buf to caller, and later ngx_http_write_filter()
logs warning.

Fixed misleading example SSL config.

a) ssl as listen parameter is preferable.
b) ssl_protocols defaults are better because they do not forbid TLS versions
   1.1 and 1.2.
c) ssl_session_timeout has sense only with SSL cache.

API change: removed the ngx_conf_full_name() function.

The ngx_get_full_name() should be used instead.

Replaced ngx_conf_full_name() with ngx_get_full_name().

The ngx_get_full_name() function takes more readable arguments list.

Fixed memory leaks in the root and auth_basic_user_file directives.

If a relative path is set by variables, then the ngx_conf_full_name()
function was called while processing requests, which causes allocations
from the cycle pool.

A new function that takes pool as an argument was introduced.

Image filter: use "application/json" MIME type for JSON output.

As it is defined by RFC 4627, and allows for various browser tools like
JSONView to display JSON well-formatted.

Core: guard use of AI_ADDRCONFIG.

Some systems (notably NetBSD and OpenBSD) lack AI_ADDRCONFIG support.

Reported by Piotr Sikora.

Fixed build with signed socklen_t and unix sockets.

This seems to be the case at least under Cygwin, where build was broken
by 05ba5bce31e0 (1.5.3).

Reported by Kevin Worthington,
http://mailman.nginx.org/pipermail/nginx/2013-August/040028.html.

Core: only resolve address families configured on the local system.

This is done by passing AI_ADDRCONFIG to getaddrinfo().

On Linux, setting net.ipv6.conf.all.disable_ipv6 to 1 will now be
respected.

On FreeBSD, AI_ADDRCONFIG filtering is currently implemented by
attempting to create a datagram socket for the corresponding family,
which succeeds even if the system doesn't in fact have any addresses
of that family configured.  That is, if the system with IPv6 support
in the kernel doesn't have IPv6 addresses configured, AI_ADDRCONFIG
will filter out IPv6 only inside a jail without IPv6 addresses or
with IPv6 disabled.

MIME: use "application/javascript" for .js files.

Though there are several MIME types commonly used for JavaScript nowadays,
the most common being "text/javascript", "application/javascript", and
currently used by nginx "application/x-javascript", RFC 4329 prefers
"application/javascript".

The "charset_types" directive's default value was adjusted accordingly.

Version bump.

Configure: fixed autotest cleanup commands.

Previously, if configured with --with-cc="clang -g", the autotest.dSYM
directories were left unremoved.

release-1.5.3 tag

nginx-1.5.3-RELEASE

Perl: fixed syntax usage for C preprocessor directives.

As per perlxs, C preprocessor directives should be at the first
non-whitespace of a line to avoid interpreting them as comments.

#if and #endif are moved so that there are no blank lines before them
to retain them as part of the function body.

Upstream: reliably detect connection failures with SSL peers.

Upstream: no last buffer on errors.

Previously, after sending a header we always sent a last buffer and
finalized a request with code 0, even in case of errors.  In some cases
this resulted in a loss of ability to detect the response wasn't complete
(e.g. if Content-Length was removed from a response by gzip filter).

This change tries to propogate to a client information that a response
isn't complete in such cases.  In particular, with this change we no longer
pretend a returned response is complete if we wasn't able to create
a temporary file.

If an error code suggests the error wasn't fatal, we flush buffered data
and disable keepalive, then finalize request normally.  This allows to to
propogate information about a problem to a client, while still sending all
the data we've got from an upstream.

Upstream: request finalization rework.

No semantic changes expected, though some checks are done differently.
In particular, the r->cached flag is no longer explicitly checked.  Instead,
we relay on u->header_sent not being set if a response is sent from
a cache.

Upstream: NGX_HTTP_CLIENT_CLOSED_REQUEST no longer reset to 0.

The NGX_HTTP_CLIENT_CLOSED_REQUEST code is allowed to happen after we
started sending a response (much like NGX_HTTP_REQUEST_TIME_OUT), so there
is no need to reset response code to 0 in this case.

Upstream: added check if a response is complete.

Checks were added to both buffered and unbuffered code paths to detect
and complain if a response is incomplete.  Appropriate error codes are
now passed to ngx_http_upstream_finalize_request().

With this change in unbuffered mode we now use u->length set to -1 as an
indicator that EOF is allowed per protocol and used to indicate response
end (much like its with p->length in buffered mode).  Proxy module was
changed to set u->length to 1 (instead of previously used -1) in case of
chunked transfer encoding used to comply with the above.

Upstream: u->length now defaults to -1 (API change).

That is, by default we assume that response end is signalled by
a connection close.  This seems to be better default, and in line
with u->pipe->length behaviour.

Memcached module was modified accordingly.

Upstream: fixed store/cache of unfinished responses.

In case of upstream eof, only responses with u->pipe->length == -1
are now cached/stored.  This ensures that unfinished chunked responses
are not cached.

Note well - previously used checks for u->headers_in.content_length_n are
preserved.  This provides an additional level of protection if protol data
disagree with Content-Length header provided (e.g., a FastCGI response
is sent with wrong Content-Length, or an incomple SCGI or uwsgi response),
as well as protects from storing of responses to HEAD requests.  This should
be reconsidered if we'll consider caching of responses to HEAD requests.

Upstream: replaced u->pipe->temp_file with p->temp_file.

While here, redundant parentheses removed.  No functional changes.

Upstream: NGX_ERROR after pipe errors.

Upstream: NGX_HTTP_GATEWAY_TIME_OUT after upstream timeouts.

There is no real difference from previously used 0 as NGX_HTTP_* will
become 0 in ngx_http_upstream_finalize_request(), but the change
preserves information about a timeout a bit longer.  Previous use of
ETIMEDOUT in one place was just wrong.

Note well that with cacheable responses there will be a difference
(code in ngx_http_upstream_finalize_request() will store the error
in cache), though this change doesn't touch cacheable case.

Upstream: ngx_http_upstream_finalize_request(NGX_ERROR) on errors.

Previously, ngx_http_upstream_finalize_request(0) was used in most
cases after errors.  While with current code there is no difference,
use of NGX_ERROR allows to pass a bit more information into
ngx_http_upstream_finalize_request().

Upstream: consistent error handling after u->input_filter_init().

In all cases ngx_http_upstream_finalize_request() with NGX_ERROR now used.
Previously used NGX_HTTP_INTERNAL_SERVER_ERROR in the subrequest in memory
case don't cause any harm, but inconsistent with other uses.

Upstream: busy lock remnants removed.

Upstream: stale comments removed.

Gzip: clearing of c->buffered if all data are flushed.

This allows to finalize unfinished responses while still sending as
much data as available.

Event pipe: fixed writing cache header to a temp file.

With previous code the p->temp_file->offset wasn't adjusted if a temp
file was written by the code in ngx_event_pipe_write_to_downstream()
after an EOF, resulting in cache not being used with empty scgi and uwsgi
responses with Content-Length set to 0.

Fix it to call ngx_event_pipe_write_chain_to_temp_file() there instead
of calling ngx_write_chain_to_temp_file() directly.

Fixed ngx_http_test_reading() to finalize request properly.

Previous code called ngx_http_finalize_request() with rc = 0.  This is
ok if a response status was already set, but resulted in "000" being
logged if it wasn't.  In particular this happened with limit_req
if a connection was prematurely closed during limit_req delay.

Sub filter: fixed matching after a partial match.

After a failed partial match we now check if there is another partial
match in previously matched substring to fix cases like "aab" in "aaab".

The ctx->saved string is now always sent if it's present on return
from the ngx_http_sub_parse() function (and reset accordingly).  This
allows to release parts of previously matched data.

Sub filter: fixed incomplete last buffer on partial match.

If a pattern was partially matched at a response end, partially matched
string wasn't send.  E.g., a response "fo" was truncated to an empty response
if partially mathed by a pattern "foo".

Sub filter: flush buffers handling.

Sub filter: switched to ngx_chain_get_free_buf().

No functional changes.

Sub filter: stale comments removed.

On DragonFlyBSD, TCP_KEEPIDLE and TCP_KEEPINTVL are in msecs.

Based on a patch by Sepherosa Ziehau.

Style: reuse one int variable in ngx_configure_listening_sockets().

No functional changes.

SPDY: fixed segfault with "client_body_in_file_only" enabled.

It is possible to send FLAG_FIN in additional empty data frame, even if it is
known from the content-length header that request body is empty.  And Firefox
actually behaves like this (see ticket #357).

To simplify code we sacrificed our microoptimization that did not work right
due to missing check in the ngx_http_spdy_state_data() function for rb->buf
set to NULL.

Xslt: exsltRegisterAll() moved to preconfiguration.

The exsltRegisterAll() needs to be called before XSLT stylesheets
are compiled, else stylesheet compilation hooks will not work.  This
change fixes EXSLT Functions extension.

Events: honor NGX_USE_GREEDY_EVENT when kqueue support is enabled.

Currently this flag is needed for epoll and rtsig, and though these methods
usually present on different platforms than kqueue, nginx can be compiled to
support all of them.