Upstream: times to obtain header/response are stored as ngx_msec_t.

Events: ngx_event_t size reduction by grouping bit fields.

Events: made a failure to create a notification channel non-fatal.

This may happen if eventfd() returns ENOSYS, notably seen on CentOS 5.4.
Such a failure will now just disable the notification mechanism and let
the callers cope with it, instead of failing to start worker processes.
If thread pools are not configured, this can safely be ignored.

Configure: handle deprecated options.

Removed the deprecated --without-http_limit_zone_module option.
Deprecated the --with-imap and --with-imap_ssl_module options.

Removed the deprecated "imap" directive.

Removed the deprecated "so_keepalive" directive.

Removed deprecated HTTP directives.

Removed the deprecated "connections" directive.

Fixed overflow detection in ngx_inet_addr().

Overflow detection of the last octet might not work.

Reported by Sergey Polovko.

Version bump.

release-1.9.0 tag

nginx-1.9.0-RELEASE

Added stream module to win32 builds.

Win32: shared memory base addresses and remapping.

Two mechanisms are implemented to make it possible to store pointers
in shared memory on Windows, in particular on Windows Vista and later
versions with ASLR:

- The ngx_shm_remap() function added to allow remapping of a shared memory
  zone to the address originally used for it in the master process.  While
  important, it doesn't solve the problem by itself as in many cases it's
  not possible to use the address because of conflicts with other
  allocations.

- We now create mappings at the same address in all processes by starting
  mappings at predefined addresses normally unused by newborn processes.

These two mechanisms combined allow to use shared memory on Windows
almost without problems, including reloads.

Based on the patch by Sergey Brester:
http://mailman.nginx.org/pipermail/nginx-devel/2015-April/006836.html

Win32: fixed shm.handle loss on reload.

Core: fixed nginx_shared_zone name.

Mail: error_log support.

Core: the ngx_set_connection_log() macro.

The http and stream versions of this macro were identical.

Merge proxy_protocol setting of listen directives.

It's now enough to specify proxy_protocol option in one listen directive to
enable it in all servers listening on the same address/port.  Previously,
the setting from the first directive was always used.

Removed the "worker_rlimit_sigpending" directive.

It was only needed by the just removed rtsig module.

Removed the obsolete rtsig module.

Removed the obsolete aio module.

Stream: prevent repeated event notifications after eof.

When client or upstream connection is closed, level-triggered read event
remained active until the end of the session leading to cpu hog.  Now the flag
NGX_CLOSE_EVENT is used to unschedule the event.

Upstream: allow multiple upstreams to use the same shared zone.

Memcached: enabled ranges.

Upstream: simplified ip_hash and hash peer selection code.

Now that peers are stored as a list, the weighted and unweighted
cases became nearly identical.

Fixed building --with-stream when precompiled headers are used.

Limit req: removed check for unknown limit_req_zone.

With 48b3d5ddfb03, it's possible to specify limit_req_zone after limit_req.

Core: allow shared memory size to be declared after a reference.

For example, this fixes the case when "proxy_cache_path" is specified
after "proxy_cache" that references it.

Stream: port from NGINX+.

Upstream: fixed unlocked access to peer->conns.

Replaced the remaining NGX_OLD_THREADS check with NGX_WIN32.

Removed NGX_OLD_THREADS from select and poll modules.

These modules can't be compiled on win32.

Removed "worker_threads" and "thread_stack_size" directives.

Removed unused thread-local-storage code.

Removed ngx_threaded and related code.

Upstream: get rid of questionable micro-optimization in ip_hash.

If a peer was initially skipped due to max_fails, there's no reason
not to try it again if enough time has passed, and the next_upstream
logic is in action.

This also reduces diffs with NGINX Plus.

Core: ensure that ngx_config.h is always included first.

This fixes compilation of various 3rd party modules when nginx is
configured with threads.

Version bump.

Upstream: the "zone" directive.

Upstreams with the "zone" directive are kept in shared memory,
with a consistent view of all worker processes.

Upstreams: locking.

Core: read/write locks.

Upstream: store peers as a linked list.

This is an API change.

Upstream: track the number of active connections to upstreams.

This also simplifies the implementation of the least_conn module.

Fixed build, broken by 8b7f062a3fe6.

Casting a "const char *" to "char *" doesn't work on older gcc versions.

Core: added OpenSSL version information to "nginx -V" output.

Version bump.

release-1.7.12 tag

nginx-1.7.12-RELEASE

Core: guard against spinlock usage without atomic ops.

The new thread pools code uses spinlocks.

Core: limited levels of subdirectory hierarchy used for temp files.

Similar to ngx_http_file_cache_set_slot(), the last component of file->name
with a fixed length of 10 bytes, as generated in ngx_create_temp_path(), is
used as a source for the names of intermediate subdirectories with each one
taking its own part.  Ensure that the sum of specified levels with slashes
fits into the length (ticket #731).

Core: removed excessive initialization in ngx_conf_set_path_slot().

Level hierarchy is pre-zeroed in ngx_pcalloc() of the surrounding ngx_path_t.

Core: fixed error handling on ngx_conf_full_name() failure.

Upstream: abbreviated SSL handshake may interact badly with Nagle.

Request body: always flush buffers if request buffering is off.

This fixes unbuffered proxying to SSL backends, since it prevents
ngx_ssl_send_chain() from accumulation of request body in the SSL
buffer.

Used the correct type for the AIO preload handler return value.

Configure: style.

OCSP stapling: missing free calls.

Missing call to X509_STORE_CTX_free when X509_STORE_CTX_init fails.
Missing call to OCSP_CERTID_free when OCSP_request_add0_id fails.
Possible leaks in vary particular scenariis of memory shortage.

Cache: added support for reading of the header in thread pools.

Fixed invalid access to complex value defined as an empty string.

Found by Valgrind.

Events: fixed possible crash on start or reload.

The main thread could wake up and start processing the notify event
before the handler was set.

Events: made posted events macros safe.

SPDY: always push pending data.

This helps to avoid suboptimal behavior when a client waits for a control
frame or more data to increase window size, but the frames have been delayed
in the socket buffer.

The delays can be caused by bad interaction between Nagle's algorithm on
nginx side and delayed ACK on the client side or by TCP_CORK/TCP_NOPUSH
if SPDY was working without SSL and sendfile() was used.

The pushing code is now very similar to ngx_http_set_keepalive().

SPDY: fixed error handling in ngx_http_spdy_send_output_queue().

Version bump.

Proxy: fixed proxy_request_buffering and chunked with preread body.

If any preread body bytes were sent in the first chain, chunk size was
incorrectly added before the whole chain, including header, resulting in
an invalid request sent to upstream.  Fixed to properly add chunk size
after the header.

release-1.7.11 tag

nginx-1.7.11-RELEASE

Upstream: uwsgi_request_buffering, scgi_request_buffering.

FastCGI: fastcgi_request_buffering.

Proxy: proxy_request_buffering chunked support.

Request body: unbuffered reading.

The r->request_body_no_buffering flag was introduced.  It instructs
client request body reading code to avoid reading the whole body, and
to call post_handler early instead.  The caller should use the
ngx_http_read_unbuffered_request_body() function to read remaining
parts of the body.

Upstream module is now able to use this mode, if configured with
the proxy_request_buffering directive.

Request body: filters support.

Request body: moved request body writing to save filter.

Request body: free chain links in ngx_http_write_request_body().

Output chain: free chain links in ngx_chain_writer().

Output chain: zero size buf alerts in ngx_chain_writer().

Now we log a "zero size buf in chain writer" alert if we encounter a zero
sized buffer in ngx_chain_writer(), and skip the buffer.

Format specifier fixed for file size of buffers.

Proxy: fixed proxy_set_body with proxy_cache.

If the last header evaluation resulted in an empty header, the e.skip flag
was set and was not reset when we've switched to evaluation of body_values.
This incorrectly resulted in body values being skipped instead of producing
some correct body as set by proxy_set_body.  Fix is to properly reset
the e.skip flag.

As the problem only appeared if the last potentially non-empty header
happened to be empty, it only manifested itself if proxy_set_body was used
with proxy_cache.

Thread pools: implemented graceful exiting of threads.

Thread pools: removed unused pointer to memory pool.

No functional changes.

Thread pools: keep waiting tasks mutex in ngx_thread_pool_t.

It's not needed for completed tasks queue since the previous change.

No functional changes.

Thread pools: replaced completed tasks queue mutex with spinlock.

Removed stub implementation of win32 mutexes.

Updated OpenSSL used for win32 builds.

SSL: use of SSL_MODE_NO_AUTO_CHAIN.

The SSL_MODE_NO_AUTO_CHAIN mode prevents OpenSSL from automatically
building a certificate chain on the fly if there is no certificate chain
explicitly provided.  Before this change, certificates provided via the
ssl_client_certificate and ssl_trusted_certificate directives were
used by OpenSSL to automatically build certificate chains, resulting
in unexpected (and in some cases unneeded) chains being sent to clients.

SSL: avoid SSL_CTX_set_tmp_rsa_callback() call with LibreSSL.

LibreSSL removed support for export ciphers and a call to
SSL_CTX_set_tmp_rsa_callback() results in an error left in the error
queue.  This caused alerts "ignoring stale global SSL error (...called
a function you should not call) while SSL handshaking" on a first connection
in each worker process.

SSL: clear protocol options.

LibreSSL 2.1.1+ started to set SSL_OP_NO_SSLv3 option by default on
new contexts.  This makes sure to clear it to make it possible to use SSLv3
with LibreSSL if enabled in nginx config.

Prodded by Kuramoto Eiji.

Core: added cyclic memory buffer support for error_log.

Example of usage:

  error_log memory:16m debug;

This allows to configure debug logging with minimum impact on performance.
It's especially useful when rare crashes are experienced under high load.

The log can be extracted from a coredump using the following gdb script:

  set $log = ngx_cycle->log

  while $log->writer != ngx_log_memory_writer
      set $log = $log->next
  end

  set $buf = (ngx_log_memory_buf_t *) $log->wdata
  dump binary memory debug_log.txt $buf->start $buf->end

Removed busy locks.

Removed ngx_connection_t.lock.

Removed unix ngx_threaded and related ngx_process_changes.

Removed old pthread implementation.

Removed old FreeBSD rfork() thread implementation.

Thread pools: silence warning on process exit.

Work around pthread_cond_destroy() and pthread_mutex_destroy() returning
EBUSY.  A proper solution would be to ensure all threads are terminated.

Thread pools: fixed the waiting tasks accounting.

Behave like POSIX semaphores.  If N worker threads are waiting for tasks,
at least that number of tasks should be allowed to be put into the queue.

Thread pools: keep waiting tasks counter in ngx_thread_pool_t.

It's not needed for completed tasks queue.

No functional changes.

SPDY: fixed format specifier in logging.

Added support for offloading Linux sendfile() in thread pools.

Added support for offloading read() in thread pools.