Merge ~paelzer/ubuntu/+source/nginx:lp-1874831-nchan-bump-FOCAL into ubuntu/+source/nginx:ubuntu/focal-devel

[Christian Ehrhardt ]

[Christian Ehrhardt  (paelzer)]

PPA: https://launchpad.net/~ci-train-ppa-service/+archive/ubuntu/4678

[Christian Ehrhardt  (paelzer)]

Fix is a cherry pick from Salsa of what went into Groovy.

SRU template once the rrporter confirms this is helpful.

[Christian Ehrhardt  (paelzer)]

I'll rework this to also fix http-lua

Unmerged commits

e1587cc... by Christian Ehrhardt  on 2021-10-07

changelog: nchan: Upgrade module to 1.2.7 (LP: #1874831)

Signed-off-by: Christian Ehrhardt <email address hidden>

c8c1511... by Ondřej Nový on 2020-05-28

nchan: Upgrade to 1.2.7

diff --git a/debian/changelog b/debian/changelog
index e91b482..79d22ef 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,10 @@
+nginx (1.18.0-0ubuntu1.3) focal; urgency=medium
+
+  * nchan: Upgrade module to 1.2.7 as former versions are incompatible
+    with 1.18 (LP: #1874831)
+
+ -- Christian Ehrhardt <[e-mail]>  Thu, 07 Oct 2021 13:59:10 +0200
+
 nginx (1.18.0-0ubuntu1.2) focal-security; urgency=medium
 
   * SECURITY UPDATE: DNS Resolver issues
diff --git a/debian/modules/nchan/README.md b/debian/modules/nchan/README.md
index ee43ac9..152396d 100644
--- a/debian/modules/nchan/README.md
+++ b/debian/modules/nchan/README.md
@@ -1,57 +1,56 @@
-<img class="logo" alt="NCHAN" src="https://nchan.slact.net/github-logo.png" />
+<img class="logo" alt="NCHAN" src="https://nchan.io/github-logo.png" />
 
-https://nchan.slact.net
+https://nchan.io
 
 Nchan is a scalable, flexible pub/sub server for the modern web, built as a module for the [Nginx](http://nginx.org) web server. It can be configured as a standalone server, or as a shim between your application and hundreds, thousands, or millions of live subscribers. It can buffer messages in memory, on-disk, or via [Redis](http://redis.io). All connections are handled asynchronously and distributed among any number of worker processes. It can also scale to many Nginx servers with [Redis](http://redis.io).
 
 Messages are [published](#publisher-endpoints) to channels with HTTP `POST` requests or Websocket, and [subscribed](#subscriber-endpoint) also through [Websocket](#websocket), [long-polling](#long-polling), [EventSource](#eventsource) (SSE), old-fashioned [interval polling](#interval-polling), [and](#http-chunked-transfer) [more](#http-multipart-mixed).
 
-In a web browser, you can use Websocket or EventSource directly, or the [NchanSubscriber.js](https://github.com/slact/nchan/blob/master/NchanSubscriber.js) wrapper library. It supports Long-Polling, EventSource, and resumable Websockets, and has a few other added convenience options.
+In a web browser, you can use Websocket or EventSource natively, or the [NchanSubscriber.js](https://github.com/slact/nchan.js) wrapper library. It supports Long-Polling, EventSource, and resumable Websockets, and has a few other added convenience options. It's also available on [NPM](https://www.npmjs.com/package/nchan).
 
 ## Features
- - RESTful, HTTP-native API.
- - Supports [Websocket](https://nchan.slact.net/#websocket), [EventSource (Server-Sent Events)](https://nchan.slact.net/#eventsource), [Long-Polling](https://nchan.slact.net/#long-polling) and other HTTP-based subscribers.
- - No-repeat, no-loss message delivery guarantees with per-channel configurable message buffers.
+ - RESTful, HTTP-native [API](#publishing-messages).
+ - Supports [Websocket](#websocket), [EventSource (Server-Sent Events)](#eventsource), [Long-Polling](#long-polling) and other HTTP-based subscribers.
+ - Per-channel configurable message buffers with no-repeat, no-loss message delivery guarantees.
  - Subscribe to [hundreds of channels](#channel-multiplexing) over a single subscriber connection.
- - HTTP request [callbacks and hooks](https://nchan.slact.net/details#application-callbacks) for easy integration.
- - Introspection with [channel events](https://nchan.slact.net/details#channel-events) and [url for monitoring performance statistics](https://nchan.slact.net/details#nchan_stub_status).
- - Fast ephemeral local message storage and optional, slower, persistent storage with [Redis](https://nchan.slact.net/details#connecting-to-a-redis-server).
- - Horizontally scalable (using [Redis](https://nchan.slact.net/details#connecting-to-a-redis-server)).
- - Highly Available with no single point of failure (using [Redis Cluster](https://nchan.slact.net/details#redis-cluster)).
- 
-<!-- toc -->
+ - HTTP request [callbacks and hooks](#hooks-and-callbacks) for easy integration.
+ - Introspection with [channel events](#channel-events) and [url for monitoring performance statistics](#nchan_stub_status-stats).
+ - Channel [group](#channel-groups) usage [accounting and limits](#limits-and-accounting).
+ - Fast, nonblocking [shared-memory local message storage](#memory-storage) and optional, slower, persistent storage with [Redis](#redis).
+ - Horizontally scalable (using [Redis](#redis)).
+ - Auto-failover and [high availability](#high-availability) with no single point of failure using [Redis Cluster](#redis-cluster).
 
 ## Status and History
 
-The latest Nchan release is v1.0.8 (November 28, 2016) ([changelog](https://nchan.slact.net/changelog)).
+The latest Nchan release is 1.2.7 (March 17, 2020) ([changelog](https://nchan.io/changelog)).
 
-The first iteration of Nchan was written in 2009-2010 as the [Nginx HTTP Push Module](https://pushmodule.slact.net), and was vastly refactored into its present state in 2014-2016. The present release is in the **testing** phase. The core features and old functionality are thoroughly tested and stable. Some of the new functionality, especially Redis Cluster may be a bit buggy.
+The first iteration of Nchan was written in 2009-2010 as the [Nginx HTTP Push Module](https://pushmodule.slact.net), and was vastly refactored into its present state in 2014-2016.
 
 #### Upgrade from Nginx HTTP Push Module
 
-Although Nchan is backwards-compatible with all Push Module configuration directives, some of the more unusual and rarely used settings have been disabled and will be ignored (with a warning). See the [upgrade page](https://nchan.slact.net/upgrade) for a detailed list of changes and improvements, as well as a full list of incompatibilities.
+Although Nchan is backwards-compatible with all Push Module configuration directives, some of the more unusual and rarely used settings have been disabled and will be ignored (with a warning). See the [upgrade page](https://nchan.io/upgrade) for a detailed list of changes and improvements, as well as a full list of incompatibilities.
 
 
 ## Does it scale?
 
-<img class="benchmark_graph" alt="benchmarking internal subscriber response times" src="https://nchan.slact.net/img/benchmark_internal_total.png" />
+<img class="benchmark_graph" alt="benchmarking internal subscriber response times" src="https://nchan.io/img/benchmark_internal_total.png" />
 
 Yes it does. Like Nginx, Nchan can easily handle as much traffic as you can throw at it. I've tried to benchmark it, but my benchmarking tools are much slower than Nchan. The data I've gathered is on how long Nchan itself takes to respond to every subscriber after publishing a message -- this excludes TCP handshake times and internal HTTP request parsing. Basically, it measures how Nchan scales assuming all other components are already tuned for scalability. The graphed data are averages of 5 runs with 50-byte messages.
 
-With a well-tuned OS and network stack on commodity server hardware, expect to handle upwards of 300K concurrent subscribers per second at minimal CPU load. Nchan can also be scaled out to multiple Nginx instances using the [Redis storage engine](#nchan_use_redis), and that too can be scaled up beyond a single-point-of-failure by using [Redis Cluster](https://nchan.slact.net/details#using-redis).
+With a well-tuned OS and network stack on commodity server hardware, expect to handle upwards of 300K concurrent subscribers per second at minimal CPU load. Nchan can also be scaled out to multiple Nginx instances using the [Redis storage engine](#nchan_use_redis), and that too can be scaled up beyond a single-point-of-failure by using [Redis Cluster](#redis-cluster).
 
-Currently, Nchan's main bottleneck is not CPU load but memory bandwidth. This can be improved significantly in future versions with fewer allocations and better use of contiguous memory pools. Please consider supporting Nchan to speed up the work of memory cache optimization.
 
 ## Install
 
 #### Download Packages
- - [Arch Linux](https://archlinux.org): [nginx-nchan](https://aur.archlinux.org/packages/nginx-nchan/) and [nginx-nchan-git](https://aur.archlinux.org/packages/nginx-nchan-git/) are available in the Arch User Repository.  
- - Mac OS X: a [homebrew](http://brew.sh) package is available. `brew tap homebrew/nginx; brew install nginx-full --with-nchan-module`
- - [Debian](https://www.debian.org/): A dynamic module build for is available in the Debian package repository: [libnginx-mod-nchan](https://packages.debian.org/sid/libnginx-mod-nchan).  
- Additionally, you can use the pre-built static module packages [nginx-common.deb](https://nchan.slact.net/download/nginx-common.deb) and [nginx-extras.deb](https://nchan.slact.net/download/nginx-extras.deb). Download both and install them with `dpkg -i`, followed by `sudo apt-get -f install`.
- - [Ubuntu](http://www.ubuntu.com/):  [nginx-common.ubuntu.deb](https://nchan.slact.net/download/nginx-common.ubuntu.deb) and [nginx-extras.ubuntu.deb](https://nchan.slact.net/download/nginx-extras.ubuntu.deb). Download both and install them with `dpkg -i`, followed by `sudo apt-get -f install`. Who knows when Ubuntu will add them to their repository?...
- - [Fedora](https://fedoraproject.org): Dynamic module builds for Nginx > 1.10.0 are available: [nginx-mod-nchan.x86_64.rpm](https://nchan.slact.net/download/nginx-mod-nchan.x86-64.rpm), [nginx-mod-nchan.src.rpm](https://nchan.slact.net/download/nginx-mod-nchan.src.rpm). 
- - A statically compiled binary and associated linux nginx installation files are also [available as a tarball](https://nchan.slact.net/download/nginx-nchan-latest.tar.gz).
+ - [Arch Linux](https://archlinux.org): [nginx-mod-nchan](https://aur.archlinux.org/packages/nginx-mod-nchan/) and [nginx-mainline-mod-nchan](https://aur.archlinux.org/packages/nginx-mainline-mod-nchan/) are available in the Arch User Repository.
+ - Mac OS X: a [homebrew](http://brew.sh) package is available. `brew tap denji/nginx; brew install nginx-full --with-nchan-module`
+ - [Debian](https://www.debian.org/): A dynamic module build is available in the Debian package repository: [libnginx-mod-nchan](https://packages.debian.org/sid/libnginx-mod-nchan).  
+ Additionally, you can use the pre-built static module packages [nginx-common.deb](https://nchan.io/download/nginx-common.deb) and [nginx-extras.deb](https://nchan.io/download/nginx-extras.deb). Download both and install them with `dpkg -i`, followed by `sudo apt-get -f install`.
+ - [Ubuntu](http://www.ubuntu.com/):  [nginx-common.ubuntu.deb](https://nchan.io/download/nginx-common.ubuntu.deb) and [nginx-extras.ubuntu.deb](https://nchan.io/download/nginx-extras.ubuntu.deb). Download both and install them with `dpkg -i`, followed by `sudo apt-get -f install`. Who knows when Ubuntu will add Nchan to their repository?...
+ - [Fedora](https://fedoraproject.org): Dynamic module builds for Nginx > 1.10.0 are available: [nginx-mod-nchan.x86_64.rpm](https://nchan.io/download/nginx-mod-nchan.x86-64.rpm), [nginx-mod-nchan.src.rpm](https://nchan.io/download/nginx-mod-nchan.src.rpm). 
+ - [Heroku](https://heroku.com): A buildpack for compiling Nchan into Nginx is available: [nchan-buildpack](https://github.com/andjosh/nchan-buildpack). A one-click, readily-deployable app is also available: [nchan-heroku](https://github.com/andjosh/nchan-heroku).
+ - A statically compiled binary and associated linux nginx installation files are also [available as a tarball](https://nchan.io/download/nginx-nchan-latest.tar.gz).
 
 
 #### Build From Source
@@ -62,7 +61,7 @@ Grab the latest copy of Nginx from [nginx.org](http://nginx.org). Grab the lates
 
 If you're using Nginx  > 1.9.11, you can build Nchan as a [dynamic module](https://www.nginx.com/blog/dynamic-modules-nginx-1-9-11/) with `--add-dynamic-module=path/to/nchan`
 
-Run `make`, `make install`, and enjoy. (Caution, contents may be hot.)
+Run `make`, then `make install`.
 
 ## Getting Started
 
@@ -87,11 +86,11 @@ http {
 }
 ```
 
-You can now publish messages to channels by `POST`ing data to `/sub?id=channel_id` , and subscribe by pointing Websocket, EventSource, or [NchanSubscriber.js](https://github.com/slact/nchan/blob/master/NchanSubscriber.js) to `sub/?id=channel_id`. It's that simple.
+You can now publish messages to channels by `POST`ing data to `/pub?id=channel_id` , and subscribe by pointing Websocket, EventSource, or [NchanSubscriber.js](https://github.com/slact/nchan.js) to `sub/?id=channel_id`. It's that simple.
 
 But Nchan is very flexible and highly configurable. So, of course, it can get a lot more complicated...
 
-## Conceptual Overview
+### Conceptual Overview
 
 The basic unit of most pub/sub solutions is the messaging *channel*. Nchan is no different. Publishers send messages to channels with a certain *channel id*, and subscribers subscribed to those channels receive them. Some number of messages may be buffered for a time in a channel's message buffer before they are deleted. Pretty simple, right? 
 
@@ -121,15 +120,26 @@ http {
 The above maps requests to the URI `/sub` onto the channel `foobar`'s *subscriber endpoint* , and similarly `/pub` onto channel `foobar`'s *publisher endpoint*.
 
 
-#### Publisher Endpoints
+## Publisher Endpoints
 
 Publisher endpoints are Nginx config *locations* with the [*`nchan_publisher`*](#nchan_publisher) directive.
 
 Messages can be published to a channel by sending HTTP **POST** requests with the message contents to the *publisher endpoint* locations. You can also publish messages through a **Websocket** connection to the same location.
 
+```nginx
+  location /pub {
+    #example publisher location
+    nchan_publisher;
+    nchan_channel_id foo;
+    nchan_channel_group test;
+    nchan_message_buffer_length 50;
+    nchan_message_timeout 5m;
+  }
+```
+
 <!-- tag:publisher -->
 
-##### Publishing Messages
+### Publishing Messages
 
 Requests and websocket messages are responded to with information about the channel at time of message publication. Here's an example from publishing with `curl`:
 
@@ -147,7 +157,7 @@ The response can be in plaintext (as above), JSON, or XML, based on the request'
 ```console
 > curl --request POST --data "test message" -H "Accept: text/json" http://127.0.0.2:80/pub
 
- {"messages": 6, "requested": 55, "subscribers": 0, "last_message_id": "1450755317:0" }
+ {"messages": 5, "requested": 18, "subscribers": 0, "last_message_id": "1450755280:0" }
 ```
 
 Websocket publishers also receive the same responses when publishing, with the encoding determined by the *`Accept`* header present during the handshake.
@@ -156,7 +166,7 @@ The response code for an HTTP request is *`202` Accepted* if no subscribers are 
 
 Metadata can be added to a message when using an HTTP POST request for publishing. A `Content-Type` header will be associated as the message's content type (and output to Long-Poll, Interval-Poll, and multipart/mixed subscribers). A `X-EventSource-Event` header can also be used to associate an EventSource `event:` line value with a message.
 
-##### Other Publisher Endpoint Actions
+### Other Publisher Endpoint Actions
 
 **HTTP `GET`** requests return channel information without publishing a message. The response code is `200` if the channel exists, and `404` otherwise:  
 ```console
@@ -171,15 +181,32 @@ Metadata can be added to a message when using an HTTP POST request for publishin
 
 **HTTP `DELETE`** requests delete a channel and end all subscriber connections. Like the `GET` requests, this returns a `200` status response with channel info if the channel existed, and a `404` otherwise.
 
-For an in-depth explanation of how settings are applied to channels from publisher locations, see the [details page](https://nchan.slact.net/details#publisher-endpoint-configs).
+### How Channel Settings Work
+
+*A channel's configuration is set to the that of its last-used publishing location.*
+So, if you want a channel to behave consistently, and want to publish to it from multiple locations, *make sure those locations have the same configuration*.
 
-#### Subscriber Endpoints
+You can also can use differently-configured publisher locations to dynamically update a channel's message buffer settings. This can be used to erase messages or to scale an existing channel's message buffer as desired.
+
+## Subscriber Endpoints
 
 Subscriber endpoints are Nginx config *locations* with the [*`nchan_subscriber`*](#nchan_subscriber) directive.
 
 Nchan supports several different kinds of subscribers for receiving messages: [*Websocket*](#websocket), [*EventSource*](#eventsource) (Server Sent Events),  [*Long-Poll*](#long-polling), [*Interval-Poll*](#interval-polling). [*HTTP chunked transfer*](#http-chunked-transfer), and [*HTTP multipart/mixed*](#http-multipart-mixed).
 
-- ##### Long-Polling
+```nginx
+  location /sub {
+    #example subscriber location
+    nchan_subscriber;
+    nchan_channel_id foo;
+    nchan_channel_group test;
+    nchan_subscriber_first_message oldest;
+  }
+```
+
+<!-- tag:subscriber -->
+
+- ### Long-Polling
   The tried-and-true server-push method supported by every browser out there.  
   Initiated by sending an HTTP `GET` request to a channel subscriber endpoint.  
   The long-polling subscriber walks through a channel's message queue via the built-in cache mechanism of HTTP clients, namely with the "`Last-Modified`" and "`Etag`" headers. Explicitly, to receive the next message for given a long-poll subscriber response, send a request with the "`If-Modified-Since`" header set to the previous response's "`Last-Modified`" header, and "`If-None-Match`" likewise set to the previous response's "`Etag`" header.  
@@ -187,15 +214,16 @@ Nchan supports several different kinds of subscribers for receiving messages: [*
   A message's associated content type, if present, will be sent to this subscriber with the `Content-Type` header.
   <!-- tag:subscriber-longpoll -->
   
-- ##### Interval-Polling
+- ### Interval-Polling
   Works just like long-polling, except if the requested message is not yet available, immediately responds with a `304 Not Modified`.
-  There is no way to differentiate between long-poll and interval-poll subscriber requests, so long-polling must be disabled for a subscriber location if you wish to use interval-polling.
+  Nchan cannot automatically distinguish between long-poll and interval-poll subscriber requests, so long-polling must be disabled for a subscriber location if you wish to use interval-polling.
 
-- ##### Websocket
+- ### Websocket
   Bidirectional communication for web browsers. Part of the [HTML5 spec](http://www.w3.org/TR/2014/REC-html5-20141028/single-page.html). Nchan supports the latest protocol version 13 ([RFC 6455](https://tools.ietf.org/html/rfc6455)).  
   Initiated by sending a websocket handshake to the desired subscriber endpoint location.  
-  If the websocket connection is closed by the server, the `close` frame will contain the HTTP response code and status line describing the reason for closing the connection. Server-initiated keep-alive pings can be configured with the [`nchan_websocket_ping_interval`](#nchan_websocket_ping_interval) config directive. Websocket extensions are not yet supported.  
-  Messages published through a websocket connection can be forwarded to an upstream application with the [`nchan_publisher_upstream_request`](#nchan_publisher_upstream_request) config directive.   
+  If the websocket connection is closed by the server, the `close` frame will contain the HTTP response code and status line describing the reason for closing the connection. Server-initiated keep-alive pings can be configured with the [`nchan_websocket_ping_interval`](#nchan_websocket_ping_interval) config directive.
+  Messages are delivered to subscribers in `text` websocket frames, except if a message's `content-type` is "`application/octet-stream`" -- then it is delivered in a `binary` frame.
+  <br />
   Websocket subscribers can use the custom `ws+meta.nchan` subprotocol to receive message metadata with messages, making websocket connections resumable. Messages received with this subprotocol are of the form
   <pre>
   id: message_id
@@ -204,9 +232,24 @@ Nchan supports several different kinds of subscribers for receiving messages: [*
   message_data
   </pre>   
   The `content-type:` line may be omitted.
+  <br />
+  #### Websocket Publisher
+  Messages published through a websocket connection can be forwarded to an upstream application with the [`nchan_publisher_upstream_request`](#nchan_publisher_upstream_request) config directive.   
+  Messages published in a binary frame are automatically given the `content-type` "`application/octet-stream`".
+  #### Permessage-deflate
+  Nchan version 1.1.8 and above supports the [permessage-deflate protocol extension](https://tools.ietf.org/html/rfc7692). Messages are deflated once when they are published, and then can be broadcast to any number of compatible websocket subscribers. Message deflation is enabled by setting the [`nchan_deflate_message_for_websocket on;`](#nchan_deflate_message_for_websocket) directive in a publisher location.
+  <br />
+  The deflated data is stored alongside the original message in memory, or, if large enough, on disk. This means more [shared memory](#nchan_shared_memory_size) is necessary when using `nchan_deflate_message_for_websocket`.
+  <br />
+  Deflation parameters (speed, memory use, strategy, etc.), can be tweaked using the [`nchan_permessage_deflate_compression_window`](#nchan_permessage_deflate_compression_window), [`nchan_permessage_deflate_compression_level`](#nchan_permessage_deflate_compression_level),
+  [`nchan_permessage_deflate_compression_strategy`](#nchan_permessage_deflate_compression_strategy), and 
+  [`nchan_permessage_deflate_compression_window`](#nchan_permessage_deflate_compression_window) settings.
+  <br />
+  Nchan also supports the (deprecated) [perframe-deflate extension](https://tools.ietf.org/html/draft-tyoshino-hybi-websocket-perframe-deflate-06) still in use by Safari as `x-webkit-perframe-deflate`.
+  <br />
   <!-- tag:subscriber-websocket -->
   
-- ##### EventSource
+- ### EventSource
   Also known as [Server-Sent Events](https://en.wikipedia.org/wiki/Server-sent_events) or SSE, it predates Websockets in the [HTML5 spec](http://www.w3.org/TR/2014/REC-html5-20141028/single-page.html), and is a [very simple protocol](http://www.w3.org/TR/eventsource/#event-stream-interpretation).  
   Initiated by sending an HTTP `GET` request to a channel subscriber endpoint with the "`Accept: text/event-stream`" header.    
   Each message `data: ` segment will be prefaced by the message `id: `.  
@@ -217,7 +260,7 @@ Nchan supports several different kinds of subscribers for receiving messages: [*
   A message's associated `event` type, if present, will be sent to this subscriber with the `event:` line.  
   <!-- tag:subscriber-eventsource -->
   
-- ##### HTTP [multipart/mixed](http://www.w3.org/Protocols/rfc1341/7_2_Multipart.html#z0)
+- ### HTTP [multipart/mixed](http://www.w3.org/Protocols/rfc1341/7_2_Multipart.html#z0)
   The `multipart/mixed` MIMEtype was conceived for emails, but hey, why not use it for HTTP? It's easy to parse and includes metadata with each message.  
   Initiated by including an `Accept: multipart/mixed` header.  
   The response headers and the unused "preamble" portion of the response body are sent right away, with the boundary string generated randomly for each subscriber.  Each subsequent message will be sent as one part of the multipart message, and will include the message time and tag (`Last-Modified` and `Etag`) as well as the optional `Content-Type` headers.  
@@ -225,11 +268,11 @@ Nchan supports several different kinds of subscribers for receiving messages: [*
   A message's associated content type, if present, will be sent to this subscriber with the `Content-Type` header.
   <!-- tag:subscriber-multipart -->
   
-- ##### HTTP Raw Stream
+- ### HTTP Raw Stream
   A simple subscription method similar to the [streaming subscriber](https://github.com/wandenberg/nginx-push-stream-module/blob/master/docs/directives/subscribers.textile#push_stream_subscriber) of the [Nginx HTTP Push Stream Module](https://github.com/wandenberg/nginx-push-stream-module). Messages are appended to the response body, separated by a newline or configurable by `nchan_subscriber_http_raw_stream_separator`.
   <!-- tag:subscriber-rawstream -->
 
-- ##### HTTP [Chunked Transfer](http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6.1)
+- ### HTTP [Chunked Transfer](http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6.1)
   This subscription method uses the `chunked` `Transfer-Encoding` to receive messages.   
   Initiated by explicitly including `chunked` in the [`TE` header](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.39):  
   `TE: chunked` (or `TE: chunked;q=??` where the qval > 0)  
@@ -237,9 +280,7 @@ Nchan supports several different kinds of subscribers for receiving messages: [*
   Unlike the other subscriber types, the `chunked` subscriber cannot be used with http/2 because it dissallows chunked encoding.
   <!-- tag:subscriber-chunked -->
 
-<!-- tag:subscriber -->
-
-#### PubSub Endpoint  
+## PubSub Endpoint  
 
 PubSub endpoints are Nginx config *locations* with the [*`nchan_pubsub`*](#nchan_pubsub) directive.
 
@@ -249,17 +290,19 @@ requests as subscribers, and all HTTP `POST` as publishers. One simple use case 
 ```nginx
   location = /pubsub {
     nchan_pubsub;
-    nchan_channel_id foobar;
+    nchan_channel_id foo;
+    nchan_channel_group test;
   }
 ```
 
-A more applicable setup may set different publisher and subscriber channel ids:
+A more interesting setup may set different publisher and subscriber channel ids:
 
 ```nginx
   location = /pubsub {
     nchan_pubsub;
     nchan_publisher_channel_id foo;
     nchan_subscriber_channel_id bar;
+    nchan_channel_group test;
   }
 ```
 
@@ -267,9 +310,9 @@ Here, subscribers will listen for messages on channel `foo`, and publishers will
 
 <!-- tag:pubsub -->
 
-### The Channel ID
+## The Channel ID
 
-So far the examples have used static channel ids, which is not very useful in practice. It can be set to any nginx *variable*, such as a querystring argument, a header value, or a part of the location url:
+So far the examples have used static channel ids, which is not very useful. In practice, the channel id can be set to any nginx *variable*, such as a querystring argument, a header value, or a part of the location url:
 
 ```nginx
   location = /sub_by_ip {
@@ -294,9 +337,11 @@ So far the examples have used static channel ids, which is not very useful in pr
   }
 ```
 
+I recommend using the last option, a channel id derived from the request URL via a regular expression. It makes things nice and RESTful.
+
 <!-- tag:channel-id -->
 
-#### Channel Multiplexing
+### Channel Multiplexing
 
 With channel multiplexing, subscribers can subscribe to up to 255 channels per connection. Messages published to all the specified channels will be delivered in-order to the subscriber. There are two ways to enable multiplexing:
 
@@ -325,68 +370,626 @@ For more than 7 channels, `nchan_channel_id_split_delimiter` can be used to spli
   }
 ```
 
-Publishing to multiple channels with a single request is also possible, with similar configuration:
+It is also possible to publish to multiple channels with a single request as well as delete multiple channels with a single request, with similar configuration:
 
 ```nginx
   location ~ /multipub/(\w+)/(\w+)$ {
     nchan_publisher;
     nchan_channel_id "$1" "$2" "another_channel";
+    #POST /multipub/foo/bar will publish to:
+    # channels 'foo', 'bar', 'another_channel'
+    #DELETE /multipub/foo/bar will delete:
+    # channels 'foo', 'bar', 'another_channel'
   }
 ```
 
-`DELETE` requests to a multiplexed channel broadcast the deletion to each of the channels it multiplexes, deletes all their messages and kicks out all clients subscribed to any of the channel ids.
+When a channel is deleted, all of its messages are deleted, and all of its subscribers' connection are closed -- including ones subscribing through a multiplexed location. For example, suppose a subscriber is subscribed to channels "foo" and "bar" via a single multiplexed connection. If "foo" is deleted, the connection is closed, and the subscriber therefore loses the "bar" subscription as well.
 
-See the [details page](https://nchan.slact.net/details#securing-channels) for more information about using good IDs and keeping channels secure.
+See the [Channel Security](#securing-channels) section about using good IDs and keeping private channels secure.
 
 <!-- tag:channel-multiplexing -->
 
+### Channel Groups
+
+Channels can be associated with groups to avoid channel ID conflicts:
+
+```nginx
+  location /test_pubsub {
+    nchan_pubsub;
+    nchan_channel_group "test";
+    nchan_channel_id "foo";
+  }
+  
+  location /pubsub {
+    nchan_pubsub;
+    nchan_channel_group "production";
+    nchan_channel_id "foo";
+    #same channel id, different channel group. Thus, different channel.
+  }
+  
+  location /flexgroup_pubsub {
+    nchan_pubsub;
+    nchan_channel_group $arg_group;
+    nchan_channel_id "foo";
+    #group can be set with request variables too
+  }
+```
+
+#### Limits and Accounting
+
+Groups can be used to track aggregate channel usage, as well as set limits on the number of channels, subscribers, stored messages, memory use, etc:
+
+```nginx
+  #enable group accounting
+  nchan_channel_group_accounting on;
+  
+  location ~ /pubsub/(\w+)$ {
+    nchan_pubsub;
+    nchan_channel_group "limited";
+    nchan_channel_id $1;
+  }
+  
+  location ~ /prelimited_pubsub/(\w+)$ {
+    nchan_pubsub;
+    nchan_channel_group "limited";
+    nchan_channel_id $1;
+    nchan_group_max_subscribers 100;
+    nchan_group_max_messages_memory 50M;
+  }
+  
+  location /group {
+    nchan_channel_group limited;
+    nchan_group_location;
+    nchan_group_max_channels $arg_max_channels;
+    nchan_group_max_messages $arg_max_messages;
+    nchan_group_max_messages_memory $arg_max_messages_mem;
+    nchan_group_max_messages_disk $arg_max_messages_disk;
+    nchan_group_max_subscribers $arg_max_subs;
+  }
+```
+
+Here, `/group` is an `nchan_group_location`, which is used for accessing and modifying group data. To get group data, send a `GET` request to a `nchan_group_location`:
+
+```sh
+>  curl http://localhost/group
+
+channels: 10
+subscribers: 0
+messages: 219
+shared memory used by messages: 42362 bytes
+disk space used by messages: 0 bytes
+limits:
+  max channels: 0
+  max subscribers: 0
+  max messages: 0
+  max messages shared memory: 0
+  max messages disk space: 0  
+```
+
+By default, the data is returned in human-readable plaintext, but can also be formatted as JSON, XML, or YAML:
+
+```sh
+>  curl -H "Accept: text/json" http://localhost/group
+
+{
+  "channels": 21,
+  "subscribers": 40,
+  "messages": 53,
+  "messages_memory": 19941,
+  "messages_disk": 0,
+  "limits": {
+    "channels": 0,
+    "subscribers": 0,
+    "messages": 0,
+    "messages_memory": 0,
+    "messages_disk": 0
+  }
+}
+```
+
+The data in the response are for the single Nchan instance only, regardless of whether Redis is used. A limit of 0 means 'unlimited'.
+
+Limits can be set per-location, as with the above `/prelimited_pubsub/...` location, or with a POST request to the `nchan_group_location`:
+```sh
+>  curl -X POST "http://localhost/group?max_channels=15&max_subs=1000&max_messages_disk=0.5G"
+
+channels: 0
+subscribers: 0
+messages: 0
+shared memory used by messages: 0 bytes
+disk space used by messages: 0 bytes
+limits:
+  max channels: 15
+  max subscribers: 1000
+  max messages: 0
+  max messages shared memory: 0
+  max messages disk space: 536870912
+
+```
+
+Limits are only applied locally, regardless of whether Redis is enabled. 
+If a publisher or subscriber request exceeds a group limit, Nchan will respond to it with a `403 Forbidden` response.
+
+<!-- tag:group -->
+
+## Hooks and Callbacks
+
+<!-- tag:hook -->
+  
+### Request Authorization
+
+This feature, configured with [`nchan_authorize_request`](#nchan_authorize_request), behaves just like the Nginx [http_auth_request module](http://nginx.org/en/docs/http/ngx_http_auth_request_module.html#auth_request_set).
+
+Consider the configuration:
+```nginx
+  upstream my_app {
+    server 127.0.0.1:8080;
+  }
+  location = /auth {
+    proxy_pass http://my_app/pubsub_authorize;
+    proxy_pass_request_body off;
+    proxy_set_header Content-Length "";
+    proxy_set_header X-Subscriber-Type $nchan_subscriber_type;
+    proxy_set_header X-Publisher-Type $nchan_publisher_type;
+    proxy_set_header X-Prev-Message-Id $nchan_prev_message_id;
+    proxy_set_header X-Channel-Id $nchan_channel_id;
+    proxy_set_header X-Original-URI $request_uri;
+    proxy_set_header X-Forwarded-For $remote_addr;
+  }
+  
+  location ~ /pubsub/auth/(\w+)$ {
+    nchan_channel_id $1;
+    nchan_authorize_request /auth;
+    nchan_pubsub;
+    nchan_channel_group test;
+  }
+```
+
+Here, any request to the location `/pubsub/auth/<...>` will need to be authorized by your application (`my_app`). Nginx will generate a `GET /pubsub_authorize` request to the application, with additional headers set by the `proxy_set_header` directives. Note that Nchan-specific variables are available for this authorization request. Once your application receives this request, it should decide whether or not to authorize the subscriber. This can be done based on a forwarded session cookie, IP address, or any set of parameters of your choosing. If authorized, it should respond with an empty `200 OK` response.  
+All non-`2xx` response codes (such as `403 Forbidden`) are intepreted as authorization failures. In this case, the failing response is proxied to the client. 
+
+Note that Websocket and EventSource clients will only try to authorize during the initial handshake request, whereas Long-Poll and Interval-Poll subscribers will need to be authorized each time they request the next message, which may flood your application with too many authorization requests.
+
+<!-- commands: nchan_authorize_request -->
+
+### Subscriber Presence
+
+Subscribers can notify an application when they have subscribed and unsubscribed to a channel using the [`nchan_subscribe_request`](#nchan_subscribe_request)
+and [`nchan_unsubscribe_request`](#nchan_unsubscribe_request) settings. 
+These should point to Nginx locations configured to forward requests to an upstream proxy (your application):
+
+```nginx
+  location ~ /sub/(\w+)$ {
+    nchan_channel_id $1;
+    nchan_subscribe_request /upstream/sub;
+    nchan_unsubscribe_request /upstream/unsub;
+    nchan_subscriber;
+    nchan_channel_group test;
+  }
+
+  location = /upstream/unsub {
+    proxy_pass http://127.0.0.1:9292/unsub;
+    proxy_ignore_client_abort on;  #!!!important!!!!
+    proxy_set_header X-Subscriber-Type $nchan_subscriber_type;
+    proxy_set_header X-Channel-Id $nchan_channel_id;
+    proxy_set_header X-Original-URI $request_uri;
+  } 
+  location = /upstream/sub {
+    proxy_pass http://127.0.0.1:9292/sub;
+    proxy_set_header X-Subscriber-Type $nchan_subscriber_type;
+    proxy_set_header X-Message-Id $nchan_message_id;
+    proxy_set_header X-Channel-Id $nchan_channel_id;
+    proxy_set_header X-Original-URI $request_uri;
+  } 
+```
+
+In order for `nchan_unsubscribe_request` to work correctly, the location it points to must have `proxy_ignore_client_abort on;`. Otherwise, suddenly aborted subscribers may not trigger an unsubscribe request.
+
+Note that the subscribe/unsubscribe hooks are **disabled for long-poll and interval-poll clients**, because they would trigger these hooks each time they receive a message.
+
+<!-- commands: nchan_subscribe_request nchan_unsubscribe_request -->
+
+### Message Forwarding
+
+Messages can be forwarded to an upstream application before being published using the `nchan_publisher_upstream_request` setting:
+
+```nginx
+  location ~ /pub/(\w+)$ {
+    #publisher endpoint
+    nchan_channel_id $1;
+    nchan_pubsub;
+    nchan_publisher_upstream_request /upstream_pub;
+  }
+  
+  location = /upstream_pub {
+    proxy_pass http://127.0.0.1:9292/pub;
+    proxy_set_header X-Publisher-Type $nchan_publisher_type;
+    proxy_set_header X-Prev-Message-Id $nchan_prev_message_id;
+    proxy_set_header X-Channel-Id $nchan_channel_id;
+    proxy_set_header X-Original-URI $request_uri;
+  } 
+```
+With this configuration, incoming messages are first `POST`ed to `http://127.0.0.1:9292/pub`.
+The upstream response code determines how publishing will proceed:
+  - `304 Not Modified` publishes the message as received, without modifification.
+  - `204 No Content` discards the message
+  - `200 OK` is used for modifying the message. Instead of the original incoming message, the message contained in this HTTP response is published.
+
+There are two main use cases for `nchan_publisher_upstream_request`: forwarding incoming data from Websocket publishers to an application, and mutating incoming messages.
+
+<!-- commands: nchan_publisher_upstream_request -->
+
 ## Storage
 
 Nchan can stores messages in memory, on disk, or via Redis. Memory storage is much faster, whereas Redis has additional overhead as is considerably slower for publishing messages, but offers near unlimited scalability for broadcast use cases with far more subscribers than publishers.
 
-<!-- tag:storage -->
-
 ### Memory Storage
 
-This storage method uses a segment of shared memory to store messages and channel data. Large messages as determined by Nginx's caching layer are stored on-disk. The size of the memory segment is configured with `nchan_max_reserved_memory`. Data stored here is not persistent, and is lost if Nginx is restarted or reloaded.
+This default storage method uses a segment of shared memory to store messages and channel data. Large messages as determined by Nginx's caching layer are stored on-disk. The size of the memory segment is configured with `nchan_shared_memory_size`. Data stored here is not persistent, and is lost if Nginx is restarted or reloaded.
 
 <!-- tag:memstore -->
 
 ### Redis
 
-Nchan can also store messages and channels on a Redis server, or in a Redis cluster. To use a Redis server, set `nchan_use_redis on;` and set the server url with `nchan_redis_url`. These two settings are inheritable by nested locations, so it is enough to set them within an `http { }` block to enable Redis for all Nchan locations in that block. Different locations can also use different Redis servers.
+[Redis](http://redis.io) can be used to add **data persistence** and **horizontal scalability**, **failover** and **high availability** to your Nchan setup. 
+
+<!-- tag:redis -->
 
-To use a Redis Cluster, the Redis servers acting as cluster nodes need to be configured in an `upstream { }` block:
+#### Connecting to a Redis Server
+To connect to a single Redis master server, use an `upstream` with `nchan_redis_server` and `nchan_redis_pass` settings:
 
 ```nginx
+http {
+  upstream my_redis_server {
+    nchan_redis_server 127.0.0.1;
+  }
+  server {
+    listen 80;
+    
+    location ~ /redis_sub/(\w+)$ {
+      nchan_subscriber;
+      nchan_channel_id $1;
+      nchan_redis_pass my_redis_server;
+    }
+    location ~ /redis_pub/(\w+)$ {
+      nchan_redis_pass my_redis_server;
+      nchan_publisher;
+      nchan_channel_id $1;
+    }
+  }
+} 
+```
+
+All servers with the above configuration connecting to the same redis server share channel and message data.
+
+Channels that don't use Redis can be configured side-by-side with Redis-backed channels, provided the endpoints never overlap. (This can be ensured, as above, by setting separate `nchan_channel_group`s.). Different locations can also connect to different Redis servers.
+
+Nchan can work with a single Redis master. It can also auto-discover and use Redis slaves to balance PUBSUB traffic.
+
+<!-- commands: nchan_redis_server nchan_redis_pass -->
+
+#### Redis Cluster
+Nchan also supports using Redis Cluster, which adds scalability via sharding channels among cluster nodes. Redis cluster also provides **automatic failover**, **high availability**, and eliminates the single point of failure of one shared Redis server. It is configred and used like so:
+
+```nginx
+http {
   upstream redis_cluster {
     nchan_redis_server redis://127.0.0.1:7000;
     nchan_redis_server redis://127.0.0.1:7001;
     nchan_redis_server redis://127.0.0.1:7002;
+    # you don't need to specify all the nodes, they will be autodiscovered
+    # however, it's recommended that you do specify at least a few master nodes.
   }
+  server {
+    listen 80;
+    
+    location ~ /sub/(\w+)$ {
+      nchan_subscriber;
+      nchan_channel_id $1;
+      nchan_redis_pass redis_cluster;
+    }
+    location ~ /pub/(\w+)$ {
+      nchan_publisher;
+      nchan_channel_id $1;
+      nchan_redis_pass redis_cluster;
+    }
+  }
+} 
 ```
 
-It is best to specify all master cluster nodes, but this is not required -- as long as Nchan can connect to at least 1 node, it will discover and connect to the whole cluster.
+<!-- commands: nchan_redis_server nchan_redis_pass -->
+
+##### High Availability
+Redis Cluster connections are designed to be resilient and try to recover from errors. Interrupted connections will have their commands queued until reconnection, and Nchan will publish any messages it successfully received while disconnected. Nchan is also adaptive to cluster modifications. It will add new nodes and remove them as needed.
+
+All Nchan servers sharing a Redis server or cluster should have their times synchronized (via ntpd or your favorite ntp daemon). Failure to do so may result in missed or duplicate messages.
+
+#### Tweaks and Optimizations
+
+As of version 1.2.0, Nchan uses Redis slaves to load-balance PUBSUB traffic. By default, there is an equal chance that a channel's PUBSUB subscription will go to any master or slave. The [`nchan_redis_subscribe_weights`](#nchan_redis_subscribe_weights) setting is available to fine-tune this load-balancing.
+
+Also from 1.2.0 onward, [`nchan_redis_optimize_target`](#nchan_redis_optimize_target) can be used to prefer optimizing Redis slaves for CPU or bandwidth. For heavy publishing loads, the tradeoff is very roughly 35% replication bandwidth per slave to 30% CPU load on slaves.
+
+## Introspection
+
+There are several ways to see what's happening inside Nchan. These are useful for debugging application integration and for measuring performance.
 
-To use Redis Cluster in an Nchan location, use the `nchan_redis_pass` setting:
+### Channel Events
+
+Channel events are messages automatically published by Nchan when certain events occur in a channel. These are very useful for debugging the use of channels. However, they carry a significant performance overhead and should be used during development, and not in production.
+
+Channel events are published to special 'meta' channels associated with normal channels. Here's how to configure them:
 
 ```nginx
-  location ~ /pubsub/(\w+)$ {
+location ~ /pubsub/(.+)$ {
+  nchan_pubsub;
+  nchan_channel_id $1;
+  nchan_channel_events_channel_id $1; #enables channel events for this location
+}
+
+location ~ /channel_events/(.+) {
+  #channel events subscriber location
+  nchan_subscriber;
+  nchan_channel_group meta; #"meta" is a SPECIAL channel group
+  nchan_channel_id $1;
+}
+```
+
+Note the `/channel_events/...` location has a *special* `nchan_channel_group`, `meta`. This group is reserved for accessing "channel events channels", or"metachannels".
+
+Now, say I subscribe to `/channel_events/foo` I will refer to this as the channel events subscriber.
+
+Let's see what this channel events subscriber receives when I publish messages to 
+
+Subscribing to `/pubsub/foo` produces the channel event
+```
+subscriber_enqueue foo
+```
+
+Publishing a message to `/pubsub/foo`:
+```
+channel_publish foo
+```
+
+Unsubscribing from `/pubsub/foo`:
+```
+subscriber_dequeue foo
+```
+
+Deleting `/pubsub/foo` (with HTTP `DELETE /pubsub/foo`):
+```
+channel_delete foo
+```
+
+The event string itself is configirable with [nchan_channel_event_string](#nchan_channel_event_string). By default, it is set to `$nchan_channel_event $nchan_channel_id`. 
+This string can use any Nginx and [Nchan variables](/#variables).
+
+
+### nchan_stub_status Stats
+
+Like Nginx's [stub_status](https://nginx.org/en/docs/http/ngx_http_stub_status_module.html),
+`nchan_stub_status` is used to get performance metrics.
+
+```nginx
+  location /nchan_stub_status {
+    nchan_stub_status;
+  }
+```
+
+Sending a GET request to this location produces the response:
+
+```text
+total published messages: 1906
+stored messages: 1249
+shared memory used: 1824K
+channels: 80
+subscribers: 90
+redis pending commands: 0
+redis connected servers: 0
+total interprocess alerts received: 1059634
+interprocess alerts in transit: 0
+interprocess queued alerts: 0
+total interprocess send delay: 0
+total interprocess receive delay: 0
+nchan version: 1.1.5
+```
+
+Here's what each line means, and how to interpret it:
+  - `total published messages`: Number of messages published to all channels through this Nchan server.
+  - `stored messages`: Number of messages currently buffered in memory
+  - `shared memory used`: Total shared memory used for buffering messages, storing channel information, and other purposes. This value should be comfortably below `nchan_shared_memory_size`.
+  - `channels`: Number of channels present on this Nchan server.
+  - `subscribers`: Number of subscribers to all channels on this Nchan server.
+  - `redis pending commands`: Number of commands sent to Redis that are awaiting a reply. May spike during high load, especially if the Redis server is overloaded. Should tend towards 0.
+  - `redis connected servers`: Number of redis servers to which Nchan is currently connected.
+  - `total interprocess alerts received`: Number of interprocess communication packets transmitted between Nginx workers processes for Nchan. Can grow at 100-10000 per second at high load.
+  - `interprocess alerts in transit`: Number of interprocess communication packets in transit between Nginx workers. May be nonzero during high load, but should always tend toward 0 over time.
+  - `interprocess queued alerts`: Number of interprocess communication packets waiting to be sent. May be nonzero during high load, but should always tend toward 0 over time.
+  - `total interprocess send delay`: Total amount of time interprocess communication packets spend being queued if delayed. May increase during high load.
+  - `total interprocess receive delay`: Total amount of time interprocess communication packets spend in transit if delayed. May increase during high load.
+  - `nchan_version`: current version of Nchan. Available for version 1.1.5 and above.
+
+Additionally, when there is at least one `nchan_stub_status` location, the following Nginx variables are available:
+  - `$nchan_stub_status_total_published_messages`  
+  - `$nchan_stub_status_stored_messages`  
+  - `$nchan_stub_status_shared_memory_used`  
+  - `$nchan_stub_status_channels`  
+  - `$nchan_stub_status_subscribers`  
+  - `$nchan_stub_status_redis_pending_commands`  
+  - `$nchan_stub_status_redis_connected_servers`  
+  - `$nchan_stub_status_total_ipc_alerts_received`  
+  - `$nchan_stub_status_ipc_queued_alerts`  
+  - `$nchan_stub_status_total_ipc_send_delay`  
+  - `$nchan_stub_status_total_ipc_receive_delay`  
+
+  
+## Securing Channels
+
+### Securing Publisher Endpoints
+Consider the use case of an application where authenticated users each use a private, dedicated channel for live updates. The configuration might look like this:
+
+```nginx
+http {
+  server {
+    #available only on localhost
+    listen  127.0.0.1:8080;
+    location ~ /pub/(\w+)$ {
+      nchan_publisher;
+      nchan_channel_group my_app_group;
+      nchan_channel_id $1;
+    }
+  }
+  
+  server {
+    #available to the world
+    listen 80;
+    
+    location ~ /sub/(\w+)$ {
+      nchan_subscriber;
+      nchan_channel_group my_app_group;
+      nchan_channel_id $1;
+    }
+  }
+}
+
+```
+
+Here, the subscriber endpoint is available on a public-facing port 80, and the publisher endpoint is only available on localhost, so can be accessed only by applications residing on that machine. Another way to limit access to the publisher endpoint is by using the allow/deny settings:
+
+```nginx
+
+  server {
+    #available to the world
+    listen 80; 
+    location ~ /pub/(\w+)$ {
+      allow 127.0.0.1;
+      deny all;
+      nchan_publisher;
+      nchan_channel_group my_app_group;
+      nchan_channel_id $1;
+    }
+```
+
+Here, only the local IP 127.0.0.1 is allowed to use the publisher location, even though it is defined in a non-localhost server block.
+
+### Keeping a Channel Private
+
+A Channel ID that is meant to be private should be treated with the same care as a session ID token. Considering the above use case of one-channel-per-user, how can we ensure that only the authenticated user, and no one else, is able to access his channel? 
+
+First, if you intend on securing the channel contents, you must use TLS/SSL:
+
+```nginx 
+http {
+  server {
+    #available only on localhost
+    listen  127.0.0.1:8080;
+    #...publisher endpoint config
+  }
+  server {
+    #available to the world
+    listen 443 ssl;
+    #SSL config goes here
+    location ~ /sub/(\w+)$ {
+      nchan_subscriber;
+      nchan_channel_group my_app_group;
+      nchan_channel_id $1;
+    }
+  }
+}
+```
+
+Now that you have a secure connection between the subscriber client and the server, you don't need to worry about the channel ID or messages being passively intercepted. This is a minimum requirement for secure message delivery, but it is not sufficient. 
+
+You must also take care to do at least one of the following:
+  - [Generate good, high-entropy Channel IDs](#good-ids).
+  - [Authorize all subscribers with the `nchan_authorize_request` config directive](#request-authorization).
+  - [Authorize subscribers and hide channel IDs with the "`X-Accel-Redirect`" mechanism](#x-accel-redirect).
+  
+#### Good IDs
+
+An ID that can be guessed is an ID that can be hijacked. If you are not authenticating subscribers (as described below), a channel ID should be impossible to guess. Use at least 128 bits of entropy to generate a random token, associate it with the authenticated user, and share it only with the user's client. Do not reuse tokens, just as you would not reuse session IDs.
+
+#### X-Accel-Redirect
+
+This feature uses the [X-Accel feature](https://www.nginx.com/resources/wiki/start/topics/examples/x-accel) of Nginx upstream proxies to perform an internal request to a subscriber endpoint.
+It allows a subscriber client to be authenticated by your application, and then redirected by nginx internally to a location chosen by your appplication (such as a publisher or subscriber endpoint). This makes it possible to have securely authenticated clients that are unaware of the channel id they are subscribed to.
+
+Consider the following configuration:
+```nginx 
+upstream upstream_app {
+  server 127.0.0.1:8080;
+}
+
+server {
+  listen 80; 
+  
+  location = /sub_upstream {
+    proxy_pass http://upstream_app/subscriber_x_accel_redirect;
+    proxy_set_header X-Forwarded-For $remote_addr;
+  }
+  
+  location ~ /sub/internal/(\w+)$ {
+    internal; #this location only accessible for internal nginx redirects
+    nchan_subscriber;
     nchan_channel_id $1;
-    nchan_pubsub;
-    nchan_redis_pass redis_cluster;
+    nchan_channel_group test;
   }
+}
+```
 
+As commented, `/sub/internal/` is inaccessible from the outside:
+```console
+> curl  -v  http://127.0.0.1/sub/internal/foo
+  
+  < HTTP/1.1 404 Not Found
+  < Server: nginx/1.9.5
+  <
+  <html>
+  <head><title>404 Not Found</title></head>
+  <body bgcolor="white">
+  <center><h1>404 Not Found</h1></center>
+  <hr><center>nginx/1.9.5</center>
+  </body>
+  </html>
 ```
 
-Note that `nchan_redis_pass` implies `nchan_use_redis on;`, and that this setting is *not* inherited by nested locations.
+But if a request is made to `/sub_upstream`, it gets forwarded to your application (`my_app`) on port 8080 with the url `/subscriber_x_accel_redirect`.
+Note that you can set any forwarded headers here like any [`proxy_pass`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_pass) Nginx location, 
+but unlike the case with `nchan_authorize_request`, Nchan-specific variables are not available.
 
-When connecting several Nchan servers to the same Redis server (or cluster), the servers **must have their times synced up**. Failure to do so may result in missing and duplicated messages.
+Now, your application must be set up to handle the request to `/subscriber_x_accel_redirect`. You should make sure the client is properly authenticated (maybe using a session cookie), and generate an associated channel id. If authentication fails, respond with a normal `403 Forbidden` response. You can also pass extra information about the failure in the response body and headers.
 
-See the [details page](https://nchan.slact.net/details#using-redis) for more information on using Redis.
+If your application successfully authenticates the subscriber request, you now need to instruct Nginx to issue an internal redirect to `/sub/internal/my_channel_id`.
+This is accomplished by responding with an empty `200 OK` response that includes two headers:
+- `X-Accel-Redirect: /sub/internal/my_channel_id`
+- `X-Accel-Buffering: no`
 
-<!-- tag:redis -->
+In the presence of these headers, Nginx will not forward your app's response to the client, and instead will *internally* redirect to `/sub/internal/my_channel_id`. 
+This will behave as if the client had requested the subscriber endpoint location directly.
+
+Thus using X-Accel-Redirect it is possible to both authenticate all subscribers *and* keep channel IDs completely hidden from subscribers.
+
+This method is especially useful for EventSource and Websocket subscribers. Long-Polling subscribers will need to be re-authenticated for every new message, which may flood your application with too many authentication requests.
+
+### Revoking Channel Authorization
+
+In some cases, you may want to revoke a particular subscriber's authorization for a given channel (e.g., if the user's permissions are changed). If the channel is unique to the subscriber, this is simply accomplished by deleting the channel. The same can be achieved for shared channels by subscribing each subscriber to both the shared channel and a subscriber-specific channel via a multiplexed connection. Deleting the subscriber-specific channel will terminate the subscriber''s connection, thereby also terminating their subscription to the shared channel. Consider the following configuration:
+
+```nginx
+location ~ /sub/(\w+) {
+  nchan_subscriber;
+  nchan_channel_id shared_$1 user_$arg_userid;
+  nchan_authorize_request /authorize;
+}
 
+location /pub/user {
+  nchan_publisher;
+  nchan_channel_id user_$arg_userid;
+}
+```
+
+A request to `/sub/foo?userid=1234` will subscribe to channels "shared_foo" and "user_1234" via a multiplexed connection. If you later send a `DELETE` request to `/pub/user?userid=1234`, this subscriber will be disconnected and therefore unsubscribed from both "user_1234" and "shared_foo".
+  
 ## Variables
 
 Nchan makes several variables usabled in the config file:
@@ -401,13 +1004,16 @@ Nchan makes several variables usabled in the config file:
   For subscriber locations, this variable is set to the subscriber type (websocket, longpoll, etc.).
 
 - `$nchan_publisher_type`  
-  For subscriber locations, this variable is set to the subscriber type (http or websocket).
+  For publisher locations, this variable is set to the subscriber type (http or websocket).
   
 - `$nchan_prev_message_id`, `$nchan_message_id`
   The current and previous (if applicable) message id for publisher request or subscriber response.
 
 - `$nchan_channel_event`
   For channel events, this is the event name. Useful when configuring `nchan_channel_event_string`.
+
+- `$nchan_version`
+  Current Nchan version. Available since 1.1.5.
   
 Additionally, `nchan_stub_status` data is also exposed as variables. These are available only when `nchan_stub_status` is enabled on at least one location:
 
@@ -440,18 +1046,72 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   > Split the channel id into several ids for multiplexing using the delimiter string provided.    
   [more details](#channel-multiplexing)  
 
+- **nchan_deflate_message_for_websocket** `[ on | off ]`  
+  arguments: 1  
+  default: `off`  
+  context: server, location  
+  > Store a compressed (deflated) copy of the message along with the original to be sent to websocket clients supporting the permessage-deflate protocol extension    
+
 - **nchan_eventsource_event**  
   arguments: 1  
   default: `(none)`  
   context: server, location, if  
   > Set the EventSource `event:` line to this value. When used in a publisher location, overrides the published message's `X-EventSource-Event` header and associates the message with the given value. When used in a subscriber location, overrides all messages' associated `event:` string with the given value.    
 
+- **nchan_eventsource_ping_comment**  
+  arguments: 1  
+  default: `(empty)`  
+  context: server, location, if  
+  > Set the EventSource comment `: ...` line for periodic pings from server to client. Newlines are not allowed. If empty, no comment is sent with the ping.    
+
+- **nchan_eventsource_ping_data**  
+  arguments: 1  
+  default: `(empty)`  
+  context: server, location, if  
+  > Set the EventSource `data:` line for periodic pings from server to client. Newlines are not allowed. If empty, no data is sent with the ping.    
+
+- **nchan_eventsource_ping_event**  
+  arguments: 1  
+  default: `ping`  
+  context: server, location, if  
+  > Set the EventSource `event:` line for periodic pings from server to client. Newlines are not allowed. If empty, no event type is sent with the ping.    
+
+- **nchan_eventsource_ping_interval** `<number> (seconds)`  
+  arguments: 1  
+  default: `0 (none)`  
+  context: server, location, if  
+  > Interval for sending ping messages to EventSource subscribers. Disabled by default.    
+
 - **nchan_longpoll_multipart_response** `[ off | on | raw ]`  
   arguments: 1  
   default: `off`  
   context: server, location, if  
   > when set to 'on', enable sending multiple messages in a single longpoll response, separated using the multipart/mixed content-type scheme. If there is only one available message in response to a long-poll request, it is sent unmodified. This is useful for high-latency long-polling connections as a way to minimize round-trips to the server. When set to 'raw', sends multiple messages using the http-raw-stream message separator.    
 
+- **nchan_permessage_deflate_compression_level** `[ 0-9 ]`  
+  arguments: 1  
+  default: `6`  
+  context: http  
+  > Compression level for the `deflate` algorithm used in websocket's permessage-deflate extension. 0: no compression, 1: fastest, worst, 9: slowest, best    
+
+- **nchan_permessage_deflate_compression_memlevel** `[ 1-9 ]`  
+  arguments: 1  
+  default: `8`  
+  context: http  
+  > Memory level for the `deflate` algorithm used in websocket's permessage-deflate extension. How much memory should be allocated for the internal compression state. 1 - minimum memory, slow and reduces compression ratio; 9 - maximum memory for optimal speed    
+
+- **nchan_permessage_deflate_compression_strategy** `[ default | filtered | huffman-only | rle | fixed ]`  
+  arguments: 1  
+  default: `default`  
+  context: http  
+  > Compression strategy for the `deflate` algorithm used in websocket's permessage-deflate extension. Use 'default' for normal data, For details see [zlib's section on copression strategies](http://zlib.net/manual.html#Advanced)    
+
+- **nchan_permessage_deflate_compression_window** `[ 9-15 ]`  
+  arguments: 1  
+  default: `10`  
+  context: http  
+  > Compression window for the `deflate` algorithm used in websocket's permessage-deflate extension. The base two logarithm of the window size (the size of the history buffer). The bigger the window, the better the compression, but the more memory used by the compressor.    
+
 - **nchan_publisher** `[ http | websocket ]`  
   arguments: 0 - 2  
   default: `http websocket`  
@@ -471,7 +1131,7 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   context: server, location, if  
   > Send POST request to internal location (which may proxy to an upstream server) with published message in the request body. Useful for bridging websocket publishers with HTTP applications, or for transforming message via upstream application before publishing to a channel.    
   > The upstream response code determines how publishing will proceed. A `200 OK` will publish the message from the upstream response's body. A `304 Not Modified` will publish the message as it was received from the publisher. A `204 No Content` will result in the message not being published.    
-  [more details](https://nchan.slact.net/details#message-publishing-callbacks)  
+  [more details](#message-forwarding)  
 
 - **nchan_pubsub** `[ http | websocket | eventsource | longpoll | intervalpoll | chunked | multipart-mixed | http-raw-stream ]`  
   arguments: 0 - 6  
@@ -480,6 +1140,12 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   > Defines a server or location as a pubsub endpoint. For long-polling, GETs subscribe. and POSTs publish. For Websockets, publishing data on a connection does not yield a channel metadata response. Without additional configuration, this turns a location into an echo server.    
   [more details](#pubsub-endpoint)  
 
+- **nchan_subscribe_request** `<url>`  
+  arguments: 1  
+  context: server, location, if  
+  > Send GET request to internal location (which may proxy to an upstream server) after subscribing. Disabled for longpoll and interval-polling subscribers.    
+  [more details](#subscriber-presence)  
+
 - **nchan_subscriber** `[ websocket | eventsource | longpoll | intervalpoll | chunked | multipart-mixed | http-raw-stream ]`  
   arguments: 0 - 5  
   default: `websocket eventsource longpoll chunked multipart-mixed`  
@@ -535,37 +1201,111 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   legacy name: push_subscriber_timeout  
   > Maximum time a subscriber may wait for a message before being disconnected. If you don't want a subscriber's connection to timeout, set this to 0. When possible, the subscriber will get a response with a `408 Request Timeout` status; otherwise the subscriber will simply be disconnected.    
 
+- **nchan_unsubscribe_request** `<url>`  
+  arguments: 1  
+  context: server, location, if  
+  > Send GET request to internal location (which may proxy to an upstream server) after unsubscribing. Disabled for longpoll and interval-polling subscribers.    
+  [more details](#subscriber-presence)  
+
+- **nchan_websocket_client_heartbeat** `<heartbeat_in> <heartbeat_out>`  
+  arguments: 2  
+  default: `none (disabled)`  
+  context: server, location, if  
+  > Most browser Websocket clients do not allow manually sending PINGs to the server. To overcome this limitation, this setting can be used to set up a PING/PONG message/response connection heartbeat. When the client sends the server message *heartbeat_in* (PING), the server automatically responds with *heartbeat_out* (PONG).    
+
 - **nchan_websocket_ping_interval** `<number> (seconds)`  
   arguments: 1  
   default: `0 (none)`  
   context: server, location, if  
   > Interval for sending websocket ping frames. Disabled by default.    
 
+- **nchan_access_control_allow_credentials**  
+  arguments: 1  
+  default: `on`  
+  context: http, server, location, if  
+  > When enabled, sets the [Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) `Access-Control-Allow-Credentials` header to `true`.    
+
+- **nchan_access_control_allow_origin** `<string>`  
+  arguments: 1  
+  default: `$http_origin`  
+  context: http, server, location, if  
+  > Set the [Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) `Access-Control-Allow-Origin` header to this value. If the incoming request's `Origin` header does not match this value, respond with a `403 Forbidden`. Multiple origins can be provided in a single argument separated with a space.    
+
 - **nchan_authorize_request** `<url>`  
   arguments: 1  
   context: server, location, if  
   > Send GET request to internal location (which may proxy to an upstream server) for authorization of a publisher or subscriber request. A 200 response authorizes the request, a 403 response forbids it.    
-  [more details](https://nchan.slact.net/details#request-authorization)  
+  [more details](#request-authorization)  
 
-- **nchan_subscribe_request** `<url>`  
+- **nchan_channel_group** `<string>`  
   arguments: 1  
+  default: `(none)`  
   context: server, location, if  
-  > Send GET request to internal location (which may proxy to an upstream server) after subscribing. Disabled for longpoll and interval-polling subscribers.    
-  [more details](https://nchan.slact.net/details#subsribe-and-unsubscribe-callbacks)  
+  legacy name: push_channel_group  
+  > The accounting and security group a channel belongs to. Works like a prefix string to the channel id. Can be set with nginx variables.    
 
-- **nchan_unsubscribe_request** `<url>`  
+- **nchan_channel_group_accounting**  
   arguments: 1  
-  context: server, location, if  
-  > Send GET request to internal location (which may proxy to an upstream server) after unsubscribing. Disabled for longpoll and interval-polling subscribers.    
-  [more details](https://nchan.slact.net/details#subsribe-and-unsubscribe-callbacks)  
+  default: `off`  
+  context: server, location  
+  > Enable tracking channel, subscriber, and message information on a per-channel-group basis. Can be used to place upper limits on channel groups.    
+
+- **nchan_group_location** `[ get | set | delete | off ]`  
+  arguments: 0 - 3  
+  default: `get set delete`  
+  context: location  
+  > Group information and configuration location. GET request for group info, POST to set limits, DELETE to delete all channels in group.    
 
-- **nchan_max_reserved_memory** `<size>`  
+- **nchan_group_max_channels** `<number>`  
   arguments: 1  
-  default: `32M`  
-  context: http  
-  legacy name: push_max_reserved_memory  
-  > The size of the shared memory chunk this module will use for message queuing and buffering.    
-  [more details](#memory-storage)  
+  default: `0 (unlimited)`  
+  context: location  
+  > Maximum number of channels allowed in the group.    
+
+- **nchan_group_max_messages** `<number>`  
+  arguments: 1  
+  default: `0 (unlimited)`  
+  context: location  
+  > Maximum number of messages allowed for all the channels in the group.    
+
+- **nchan_group_max_messages_disk** `<number>`  
+  arguments: 1  
+  default: `0 (unlimited)`  
+  context: location  
+  > Maximum amount of disk space allowed for the messages of all the channels in the group.    
+
+- **nchan_group_max_messages_memory** `<number>`  
+  arguments: 1  
+  default: `0 (unlimited)`  
+  context: location  
+  > Maximum amount of shared memory allowed for the messages of all the channels in the group.    
+
+- **nchan_group_max_subscribers** `<number>`  
+  arguments: 1  
+  default: `0 (unlimited)`  
+  context: location  
+  > Maximum number of subscribers allowed for the messages of all the channels in the group.    
+
+- **nchan_max_channel_id_length** `<number>`  
+  arguments: 1  
+  default: `1024`  
+  context: http, server, location  
+  legacy name: push_max_channel_id_length  
+  > Maximum permissible channel id length (number of characters). This settings applies to ids before they may be split by the `nchan_channel_id_split_delimiter` Requests with a channel id that is too long will receive a `403 Forbidden` response.    
+
+- **nchan_max_channel_subscribers** `<number>`  
+  arguments: 1  
+  default: `0 (unlimited)`  
+  context: http, server, location  
+  legacy name: push_max_channel_subscribers  
+  > Maximum concurrent subscribers to the channel on this Nchan server. Does not include subscribers on other Nchan instances when using a shared Redis server.    
+
+- **nchan_subscribe_existing_channels_only** `[ on | off ]`  
+  arguments: 1  
+  default: `off`  
+  context: http, server, location  
+  legacy name: push_authorized_channels_only  
+  > Whether or not a subscriber may create a channel by sending a request to a subscriber location. If set to on, a publisher must send a POST or PUT request before a subscriber can request messages on the channel. Otherwise, all subscriber requests to nonexistent channels will get a 403 Forbidden response.    
 
 - **nchan_message_buffer_length** `[ <number> | <variable> ]`  
   arguments: 1  
@@ -574,6 +1314,12 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   legacy names: push_max_message_buffer_length, push_message_buffer_length  
   > Publisher configuration setting the maximum number of messages to store per channel. A channel's message buffer will retain a maximum of this many most recent messages. An Nginx variable can also be used to set the buffer length dynamically.    
 
+- **nchan_message_temp_path** `<path>`  
+  arguments: 1  
+  default: `<client_body_temp_path>`  
+  context: http  
+  > Large messages are stored in temporary files in the `client_body_temp_path` or the `nchan_message_temp_path` if the former is unavailable. Default is the built-in default `client_body_temp_path`    
+
 - **nchan_message_timeout** `[ <time> | <variable> ]`  
   arguments: 1  
   default: `1h`  
@@ -581,36 +1327,83 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   legacy name: push_message_timeout  
   > Publisher configuration setting the length of time a message may be queued before it is considered expired. If you do not want messages to expire, set this to 0. Note that messages always expire from oldest to newest, so an older message may prevent a newer one with a shorter timeout from expiring. An Nginx variable can also be used to set the timeout dynamically.    
 
+- **nchan_redis_connect_timeout**  
+  arguments: 1  
+  default: `600ms`  
+  context: upstream  
+  > Redis server connection timeout.    
+
 - **nchan_redis_idle_channel_cache_timeout** `<time>`  
   arguments: 1  
   default: `30s`  
   context: http, server, location  
   > A Redis-stored channel and its messages are removed from memory (local cache) after this timeout, provided there are no local subscribers.    
 
-- **nchan_redis_pass**  
+- **nchan_redis_namespace** `<string>`  
+  arguments: 1  
+  context: http, server, upstream, location  
+  > Prefix all Redis keys with this string. All Nchan-related keys in redis will be of the form "nchan_redis_namespace:*" . Default is empty.    
+
+- **nchan_redis_nostore_fastpublish** `[ on | off ]`  
+  arguments: 1  
+  default: `off`  
+  context: http, server, upstream  
+  > Increases publishing capacity by 2-3x for Redis nostore mode at the expense of inaccurate subscriber counts in the publisher response.    
+
+- **nchan_redis_optimize_target** `[ cpu | bandwidth ]`  
+  arguments: 1  
+  default: `cpu`  
+  context: upstream  
+  > This tweaks whether [effect replication](https://redis.io/commands/eval#replicating-commands-instead-of-scripts) is enabled. Optimizing for CPU usage enables effect replication, costing additional bandwidth (between 1.2 and 2 times more) between all master->slave links. Optimizing for bandwidth increases CPU load on slaves, but keeps outgoing bandwidth used for replication the same as the incoming bandwidth on Master.    
+
+- **nchan_redis_pass** `<upstream-name>`  
   arguments: 1  
   context: http, server, location  
   > Use an upstream config block for Redis servers.    
-  [more details](https://nchan.slact.net/details#using-redis)  
+  [more details](#connecting-to-a-redis-server)  
 
 - **nchan_redis_ping_interval**  
   arguments: 1  
   default: `4m`  
-  context: http, server, location  
+  context: http, server, upstream, location  
   > Send a keepalive command to redis to keep the Nchan redis clients from disconnecting. Set to 0 to disable.    
 
-- **nchan_redis_server**  
+- **nchan_redis_server** `<redis-url>`  
+  arguments: 1  
+  context: upstream  
+  > Used in upstream { } blocks to set redis servers. Redis url is in the form 'redis://:password@hostname:6379/0'. Shorthands 'host:port' or 'host' are permitted.    
+  [more details](#connecting-to-a-redis-server)  
+
+- **nchan_redis_storage_mode** `[ distributed | backup | nostore ]`  
   arguments: 1  
+  default: `distributed`  
+  context: http, server, upstream  
+  > The mode of operation of the Redis server. In `distributed` mode, messages are published directly to Redis, and retrieved in real-time. Any number of Nchan servers in distributed mode can share the Redis server (or cluster). Useful for horizontal scalability, but suffers the latency penalty of all message publishing going through Redis first.  
+  >   
+  > In `backup` mode, messages are published locally first, then later forwarded to Redis, and are retrieved only upon chanel initialization. Only one Nchan server should use a Redis server (or cluster) in this mode. Useful for data persistence without sacrificing response times to the latency of a round-trip to Redis.  
+  >   
+  > In `nostore` mode, messages are published as in `distributed` mode, but are not stored. Thus Redis is used to broadcast messages to many Nchan instances with no delivery guarantees during connection failure, and only local in-memory storage. This means that there are also no message delivery guarantees for subscribers switching from one Nchan instance to another connected to the same Redis server or cluster. Nostore mode increases Redis publishing capacity by an order of magnitude.    
+
+- **nchan_redis_subscribe_weights** `master=<integer> slave=<integer>`  
+  arguments: 1 - 2  
+  default: `master=1 slave=1`  
   context: upstream  
-  > Used in upstream { } blocks to set redis servers.    
-  [more details](https://nchan.slact.net/details#using-redis)  
+  > Determines how subscriptions to Redis PUBSUB channels are distributed between master and slave nodes. The higher the number, the more likely that each node of that type will be chosen for each new channel. The weights for slave nodes are cumulative, so an equal 1:1 master:slave weight ratio with two slaves would have a 1/3 chance of picking a master, and 2/3 chance of picking one of the slaves. The weight must be a non-negative integer.    
 
-- **nchan_redis_url**  
+- **nchan_redis_url** `<redis-url>`  
   arguments: 1  
   default: `127.0.0.1:6379`  
   context: http, server, location  
-  > The path to a redis server, of the form 'redis://:password@hostname:6379/0'. Shorthand of the form 'host:port' or just 'host' is also accepted.    
-  [more details](https://nchan.slact.net/details#using-redis)  
+  > Use of this command is discouraged in favor of upstreams blocks with (`nchan_redis_server`)[#nchan_redis_server]. The path to a redis server, of the form 'redis://:password@hostname:6379/0'. Shorthand of the form 'host:port' or just 'host' is also accepted.    
+  [more details](#connecting-to-a-redis-server)  
+
+- **nchan_shared_memory_size** `<size>`  
+  arguments: 1  
+  default: `128M`  
+  context: http  
+  legacy names: push_max_reserved_memory, nchan_max_reserved_memory  
+  > Shared memory slab pre-allocated for Nchan. Used for channel statistics, message storage, and interprocess communication.    
+  [more details](#memory-storage)  
 
 - **nchan_store_messages** `[ on | off ]`  
   arguments: 1  
@@ -623,28 +1416,8 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   arguments: 1  
   default: `off`  
   context: http, server, location  
-  > Use redis for message storage at this location.    
-  [more details](https://nchan.slact.net/details#using-redis)  
-
-- **nchan_access_control_allow_origin** `<string>`  
-  arguments: 1  
-  default: `*`  
-  context: http, server, location  
-  > Set the [Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) `Access-Control-Allow-Origin` header to this value. If the publisher or subscriber request's `Origin` header does not match this value, respond with a `403 Forbidden`.    
-
-- **nchan_channel_group** `<string>`  
-  arguments: 1  
-  default: `(none)`  
-  context: server, location, if  
-  legacy name: push_channel_group  
-  > Because settings are bound to locations and not individual channels, it is useful to be able to have channels that can be reached only from some locations and never others. That's where this setting comes in. Think of it as a prefix string for the channel id.    
-
-- **nchan_subscribe_existing_channels_only** `[ on | off ]`  
-  arguments: 1  
-  default: `off`  
-  context: http, server, location  
-  legacy name: push_authorized_channels_only  
-  > Whether or not a subscriber may create a channel by sending a request to a subscriber location. If set to on, a publisher must send a POST or PUT request before a subscriber can request messages on the channel. Otherwise, all subscriber requests to nonexistent channels will get a 403 Forbidden response.    
+  > Use of this command is discouraged in favor of (`nchan_redis_pass`)[#nchan_redis_pass]. Use Redis for message storage at this location.    
+  [more details](#connecting-to-a-redis-server)  
 
 - **nchan_channel_event_string** `<string>`  
   arguments: 1  
@@ -656,27 +1429,13 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   arguments: 1  
   context: server, location, if  
   > Channel id where `nchan_channel_id`'s events should be sent. Events like subscriber enqueue/dequeue, publishing messages, etc. Useful for application debugging. The channel event message is configurable via nchan_channel_event_string. The channel group for events is hardcoded to 'meta'.    
-  [more details](https://nchan.slact.net/details#channel-events)  
+  [more details](#channel-events)  
 
 - **nchan_stub_status**  
   arguments: 0  
   context: location  
   > Similar to Nginx's stub_status directive, requests to an `nchan_stub_status` location get a response with some vital Nchan statistics. This data does not account for information from other Nchan instances, and monitors only local connections, published messages, etc.    
-  [more details](https://nchan.slact.net/details#nchan_stub_status)  
-
-- **nchan_max_channel_id_length** `<number>`  
-  arguments: 1  
-  default: `512`  
-  context: http, server, location  
-  legacy name: push_max_channel_id_length  
-  > Maximum permissible channel id length (number of characters). Longer ids will be truncated.    
-
-- **nchan_max_channel_subscribers** `<number>`  
-  arguments: 1  
-  default: `0 (unlimited)`  
-  context: http, server, location  
-  legacy name: push_max_channel_subscribers  
-  > Maximum concurrent subscribers to the channel on this Nchan server. Does not include subscribers on other Nchan instances when using a shared Redis server.    
+  [more details](#nchan_stub_status)  
 
 - **nchan_channel_timeout**  
   arguments: 1  
@@ -690,5 +1449,9 @@ Additionally, `nchan_stub_status` data is also exposed as variables. These are a
   context: http, server, location  
   > Development directive to completely replace default storage engine. Don't use unless you are an Nchan developer.    
 
+- **nchan_redis_wait_after_connecting**  
+  arguments: 1  
+  context: http, server, location  
+
 ## Contribute
-Please support this project with a donation to keep me warm through the winter. I accept bitcoin at 15dLBzRS4HLRwCCVjx4emYkxXcyAPmGxM3 . Other donation methods can be found at https://nchan.slact.net
+Please support this project with a donation to keep me warm through the winter. I accept bitcoin at 15dLBzRS4HLRwCCVjx4emYkxXcyAPmGxM3 . Other donation methods can be found at https://nchan.io
diff --git a/debian/modules/nchan/changelog.txt b/debian/modules/nchan/changelog.txt
index 8eba621..88f481e 100644
--- a/debian/modules/nchan/changelog.txt
+++ b/debian/modules/nchan/changelog.txt
@@ -1,3 +1,208 @@
+1.2.7 (Mar. 17 2020)
+ fix: unidirectional subscribers have their connection terminated if they send any data to the server
+      after the initial request handshake. This applies to all subscribers except Websocket
+ feature: periodic pings for EventSource subscribers
+ fix: Redis pending commands count may be incorrect in nchan's stub status page
+ fix: channel deletion fails to propagate to Redis slaves
+ fix: possible stack overflow when using websocket subscribers
+1.2.6 (Jun. 18 2019)
+ fix: when using Redis, a channel can stop receiving new messages if 
+      they are published faster than they can be sent to subscribers and the 
+      message buffer is sufficiently small
+ fix: websocket PONG response did not contain PING frame data
+ fix: multiplexed channels may stop receiving messages
+ fix (security): specially crafted websocket publisher requests when using Redis
+      may result in use-after-free memory access
+ fix: Nginx config reload may result in crash when using Redis cluster
+1.2.5 (Mar. 20 2019)
+ fix: using multiplexed channels with Redis in backup mode may result in worker crash
+ fix: nchan_publisher_channel_id could not be set exclusively in a publisher location
+ fix: Google pagespeed module compatibility
+ fix: nchan prevents nginx from starting if no http {} block is configured
+1.2.4 (Feb. 25 2019)
+ fix: Redis cluster info with zero-length hostname may result in worker crash
+ fix: build problems with included hiredis lib in FreeBSD
+ feature: nchan_redis_namespace and nchan_redis_ping_interval now work in upstream blocks
+ fix: websocket publisher did not publishing channel events
+ fix: Redis namespace was limited to 8 bytes
+1.2.3 (Oct. 15 2018)
+ fix: possible invalid memory access when the initial connection to a Redis cluster node times out
+1.2.2 (Oct. 9 2018)
+ fix (security): using an unresponsive, overloaded Redis server may result in invalid memory access
+ fix: incorrect logging of discovered Redis cluster nodes
+ fix: better handling of connection loss when Redis server is unresponsive
+ fix: presence of Redis cluster nodes with no known address ("noaddr") nodes could result in worker crash
+ fix (security): subscriber may erroneously receive a 400 Bad Request or crash a worker 
+      based on data from a previous subscriber
+ feature: built-in backend benchmark
+ feature: add optimized fastpublish option to Redis nostore mode for maximum
+      message publishing thoroughput via Redis
+ feature: add no-store Redis mode that uses Redis for broadcasting messages, not storage
+ fix: connecting to load-balancing Redis proxy resulted in crash
+ fix: using longpoll-multipart in "raw" mode cound result in worker crash
+ fix: channel events used with Redis resulted in segfault
+1.2.1 (Aug. 2 2018)
+ fix: channel last_requested was set to 0 instead of -1 on channel creation
+ fix: authentication failure body not forwarded for Nginx > 1.13.10
+ fix: possible invalid memory access for websocket unsubscribe requests
+ fix: building Nchan could interfere with building other modules
+1.2.0 (Jul. 23 2018)
+ feature: configurable support for CORS Access-Control-Allow-Credentials header
+ fix: better compliance with RFC7692  Websocket permessage-deflate parameter negotiation
+ fix (security): possible busy-loop denial-of-service for specially crafted 
+      handshakes from Websocket subscribers using permessage-deflate
+      (Thanks, Benjamin Michéle)
+ fix: nchan_permessage_deflate_compression_memlevel was not applied when set
+ refactor: all publisher and subscriber upstream requests are now more memory-efficient
+ fix: Using websocket publisher upstream requests may result in invalid memory access
+ fix: publishing Redis-backed messages with 1-second expiration may fail after
+      cluster restart
+ change: nchan_redis_wait_after_connecting directive is now obsolete, and is ignored
+ feature: nchan_redis_optimize_target for "cpu" or "bandwidth". Trades off CPU
+      load on Redis slaves for syncronization bandwidth.
+ feature: configurable Redis master/slave channel subscribe weights with
+      nchan_redis_subscribe_weights
+ fix: Compilation issues on OS X and systems lacking non-POSIX memrchr()
+ fix: nchan_pubsub CORS Allowed headers did not include headers used by subscribers
+ fix: Redis-backed channel buffer length could exceed nchan_message_buffer_length
+ fix: Publisher upstream compatibility for Nginx > 1.13.10
+ feature: nchan_redis_connect_timeout to configure maximum connection time 
+      to Redis servers
+ feature: Offload Redis SUBSCRIBE traffic to slaves 
+      (one SUBSCRIBE per channel per worker)
+ fix: Redis cluster and master/slave failover and reconnection issues
+ refactor: Redis connection handling rewritten from scratch
+ fix: subscribers may not receive new messages after reconnecting to Redis
+ fix: publishing to an unavailable Redis-backed channel may result in a 
+      following 400 Bad Request
+ change: Old Redis-backed channel messages are now delivered after the message
+      buffer is fully loaded into memory. Previously they were delivered
+      incrementally while the buffer loaded.
+ fix: multiplexed Redis-backed channels may not deliver messages if one or
+      more channels' messages all expire
+ fix: possible crash when catching up to reconnected Redis channel with
+      subscribers waiting for consecutive messages
+ fix: possible crash from rapidly creating and deleting channels
+1.1.15 (Apr. 27 2018)
+ fix: A disconnect from a Redis cluster node can result in a segfault
+ fix: Using Redis-backed multiplexed channels can result in a segfault
+1.1.14 (Jan. 10 2018)
+ feature: added nchan_redis_wait_after_connecting setting
+ fix: compatibility with Redis >= 4.0 cluster
+1.1.13 (Dec. 4 2017)
+ fix: added Redis backwards compatibility with Nchan 1.1.7 and below
+      for online upgrades with mixed-version Nchan cluster
+1.1.12 (Dec. 1 2017)
+ fix: possible "Unexpected spool == nuspool" worker crash
+ fix: subscriber messages delivered during active nchan_subscribe subrequest
+      may be garbled
+1.1.11 (Nov. 29 2017)
+ fix: Redis backup-mode not working (since 1.1.9)
+ fix: incorrect handling of Redis permessage-deflated messages results in
+      missing first char of eventsource event type
+ fix: worker crash when unable to create temp file for large websocket
+      permessage-deflate message
+ fix: CPU-bound overloaded Nginx may result in worker crashes
+      (may occur with large Openresty Lua load)
+ change: default nchan_shared_memory_size is now 128M
+ fix: some channel info from publisher GET requests may be incorrect with Redis
+ fix: file descriptor leak when reconnecting to Redis
+1.1.10 (Nov. 13 2017)
+ feature: nchan_authorize_request failure response forwarded back to subscriber
+      Sponsored by Symless (https://symless.com/)
+ fix: allow nchan_access_control_allow_origin in if blocks
+ fix: longpoll-multipart may read uninitialized memory when receiving 
+      zero-length message
+ fix (security): invalid memory access for aborted websocket subscriber 
+      after channel existence check via Redis
+ fix: websocket handhshake failure handled incorrectly when messages 
+      are available
+ fix (security): websocket subscriber disconnecting before handshake may
+      result in invalid memory access
+ fix (security): possible invalid memory access for disappearing longpoll sub
+ feature: add "shared memory limit" to nchan_stub_status output
+1.1.9 (Oct. 30 2017)
+ fix: more proper websocket extension negotiation with more 
+      informative failure messages
+ fix: websocket handshake failure response included superfluous CLOSE frame
+ feature: websocket deflate-frame and x-webkit-deflate-frame support
+1.1.8 (Oct. 26 2017)
+ feature: websocket permessage-deflate support
+      Sponsored by HYFN (https://hyfn.com/)
+ fix (security): websocket publisher may crash worker when publishing with
+      channel group accounting on to a new group
+ fix: messages published to Nchan via websocket binary frames 
+      should have content-type set to "application/octet-stream"
+ fix: accept websocket publisher binary frames (thanks @rponczkowski)
+ fix: multiplexing over exactly 255 channels results in worker crash
+ fix (security): Specially crafted invalid subscriber msgid may crash worker
+ fix: nchan_subscriber_first_message <= 0 (newest) with existing Redis data
+      incorrectly treated as "oldest" for initial subscribers
+ fix: 0-length channel name may crash worker
+ fix: subscribe/unsubscribe callback requests do not work when used with
+      authorization callback request
+ fix (security): Messages published with Redis through websocket publisher 
+      may result in worker crash (bug introduced in 1.1.5)
+ fix: nchan_pubsub setting may not be parsed correctly
+1.1.7 (Jul. 3 2017)
+ fix: possible read-after-free after redis disconnect
+ fix: publishing to redis cluster before it is connected results in worker crash
+ fix: possible use-after-free for suddenly disconnected longpoll-multipart subscriber
+ fix: possible use-after-free when using nchan_authorize_request for slow subscribers and slow upstream
+ fix: nchan_stub_status "stored messages" value could be incorrect when using Redis
+1.1.6 (May 9 2017)
+ fix: messages published through Redis may crash worker (introduced in 1.1.5)
+ fix (security): urlencoded message id in url parsed incorrectly can result in worker crash
+1.1.5 (May 3 2017)
+ feature: get current Nchan version through $nchan_version variable 
+      and nchan_stub_status
+ fix (security): invalid memory access for multiplexed channel subscribers 
+      with buffered output (Thanks Casey Forbes (@caseyf) for debugging.)
+ fix: "redis pending commands" nchan_stub_status stat could be wrong after 
+      deleting channels
+ fix: invalid memory access when using Redis under high load
+ fix: possible "message from the past" errors under high publishing load
+ fix: graceful publisher/subscriber notifications when out of shared memory
+      (via HTTP 507 Insufficient Storage status code)
+ fix: compatibility with limit_except directive
+1.1.4 (Apr. 25 2017)
+ fix (security): possible memory corruption using multiplexed channels 
+      at high load (Thanks Giovanni Caporaletti (@TrustNoOne) for debugging.)
+ fix: possible crash when reconnecting to Redis cluster (introduced in 1.1.3)
+1.1.3 (Mar. 25 2017)
+ fix (security): incorrect handling of WS optimization could trigger SIGABRT
+ fix: Redis cluster reconnect readiness verification
+1.1.2 (Mar. 1 2017)
+ change: "interprocess alert X delayed by Y sec" log messages downgraded 
+      from ERROR to NOTICE
+ fix: "group info string too short" error
+ fix: Incorrect handling of connections to Redis cluster nodes with round-robin
+      DNS hostnames (Thanks to ring.com for sponsoring this fix!)
+1.1.1 (Feb. 8 2017)
+ fix: incorrect stats for nchan_stub_status after reload.
+      (Stats are no longer reset after reload)
+ fix: websocket subscriber may receive two CLOSE frames
+ fix: websocket with ws+meta.nchan subprotocol did not receive empty messages
+ feature: websocket client heartbeats with nchan_websocket_client_heartbeat
+ fix: websocket now echoes code and reason when connection close initiated from client
+1.1.0 (Jan. 4 2017)
+ feature: websocket subscribers now receive "application/octet-stream" messages
+      in binary frame rather than text
+ fix: publisher request variables not always passed to nchan_publisher_upstream_request
+ feature: Redis storage 'backup' mode strictly for data persistence
+ fix: possible lingering subscriber if connection is closed just before subscribing
+ fix: possible memory leak when using multiplexed channels
+ security fix: subscribing with If-Modified-Since and without If-None-Match headers
+      crashed the Nginx worker (thanks @supertong)
+ security fix: sending an empty message to multipart/mixed subscriber crashed Nginx worker
+ fix: publisher & subscriber response codes were logged incorrectly
+ fix: websocket subscriber memory leak on upstream authentication failure
+ fix: possible crash after reloading when using several instances of Nchan with Redis
+ feature: nchan_access_control_allow_origin can accept nginx variables
+ feature: Redis key namespaces
+ feature: all size configurations can now parse decimal values
+ fix: off-by-one subscriber count when using multiplexed channels
+ feature: accounting and dynamic limits for channel groups
 1.0.8 (Nov. 28 2016)
  fix: possible crash under severely heavy load, introduced in 1.0.7 with stack-overflow fix
 1.0.7 (Nov. 27 2016)
diff --git a/debian/modules/nchan/cloc-exclude.txt b/debian/modules/nchan/cloc-exclude.txt
index c72f372..fdf0e34 100644
--- a/debian/modules/nchan/cloc-exclude.txt
+++ b/debian/modules/nchan/cloc-exclude.txt
@@ -1,17 +1,16 @@
 src/uthash.h
 src/hiredis
-src/store/redis/cmp.*
+src/util/ngx_nchan_hacked_slab.c
+src/util/hdr_histogram.c
+src/util/hdr_histogram.h
+src/store/redis/cmp.c
+src/store/redis/cmp.h
+src/store/redis/redis_lua_commands.h
 src/nginx-source
-dev/package
-dev/nginx-nchan/*.patch
-dev/nginx-nchan/pkg
-dev/nginx-nchan/src
-dev/nginx-nchan/*.txt
-dev/nginx-nchan/nginx.conf
-dev/nginx-nchan/nginx.logrotate
-dev/nginx-nchan/*.tar
-dev/nginx-nchan/*.gz
+src/nchan_config_commands.c
+dev/bench
+dev/nginx-pkg
 dev/clang-analyzer
 dev/package
 dev/src
-
+dev/redis-trib.rb
diff --git a/debian/modules/nchan/config b/debian/modules/nchan/config
index 5776d29..324deef 100644
--- a/debian/modules/nchan/config
+++ b/debian/modules/nchan/config
@@ -1,25 +1,68 @@
 ngx_addon_name=ngx_nchan_module
 
+nchan_libs=""
 #do we have hiredis on the platform?
-ngx_feature="hiredis"
+# it's currently no longer possible to link the platform's hiredis lib, 
+# because we now use a hacked connect function
+# maybe it can be brought back at some later time...
+ngx_feature="hiredis with stored sockaddr"
+ngx_feature_name="NCHAN_HAVE_HIREDIS_WITH_SOCKADDR"
 ngx_feature_run=yes
-ngx_feature_incs="#include <hiredis/hiredis.h>"
-ngx_feature_test="if(HIREDIS_SONAME < 0.13) { return 1; }"
+ngx_feature_path=
+ngx_feature_incs=" \
+  #include <hiredis/hiredis.h>
+  #include <sys/socket.h>
+"
 ngx_feature_libs="-lhiredis"
+ngx_feature_test=" \
+  redisContext c; \
+  if(HIREDIS_SONAME < 0.13) { return 1; } \
+  if(sizeof(c.sockaddr) != sizeof(struct sockaddr)) { return 1;} \
+"
 . auto/feature
 if [ $ngx_found = no ]; then
   _NCHAN_HIREDIS_SRCS="\
-    ${ngx_addon_dir}/src/hiredis/hiredis.c \
-    ${ngx_addon_dir}/src/hiredis/read.c \
-    ${ngx_addon_dir}/src/hiredis/async.c \
-    ${ngx_addon_dir}/src/hiredis/sds.c \
-    ${ngx_addon_dir}/src/hiredis/net.c \
+    ${ngx_addon_dir}/src/store/redis/hiredis/hiredis.c \
+    ${ngx_addon_dir}/src/store/redis/hiredis/read.c \
+    ${ngx_addon_dir}/src/store/redis/hiredis/async.c \
+    ${ngx_addon_dir}/src/store/redis/hiredis/sds.c \
+    ${ngx_addon_dir}/src/store/redis/hiredis/net.c \
   "
   ngx_feature_libs=""
 else
+  nchan_libs="$nchan_libs $ngx_feature_libs"
   _NCHAN_HIREDIS_SRCS=""
 fi
 
+ngx_feature="math lib"
+ngx_feature_name="NCHAN_HAVE_MATH"
+ngx_feature_run=yes
+ngx_feature_path=
+ngx_feature_incs="#include <math.h>"
+ngx_feature_libs="-lm"
+ngx_feature_test="sqrt(20);"
+. auto/feature
+if [ $ngx_found = yes ]; then
+  nchan_libs="$nchan_libs $ngx_feature_libs"
+fi
+
+#do we have memrchr() on the platform?
+ngx_feature="memrchr()"
+ngx_feature_name="NCHAN_HAVE_MEMRCHR"
+ngx_feature_run=yes
+ngx_feature_path=
+ngx_feature_libs=
+ngx_feature_incs=" \
+  #include <string.h> 
+  #include <stddef.h> 
+"
+ngx_feature_test=" \
+  const char *str = \"aboobar\"; \
+  const void *place = &str[4]; \
+  const void *found = memrchr(str, 'b', strlen(str)); \
+  if(place != found) { return 1; } \
+"
+. auto/feature
 
 _NCHAN_SUBSCRIBERS_SRCS="\
   ${ngx_addon_dir}/src/subscribers/common.c \
@@ -35,24 +78,31 @@ _NCHAN_SUBSCRIBERS_SRCS="\
   ${ngx_addon_dir}/src/subscribers/memstore_ipc.c \
   ${ngx_addon_dir}/src/subscribers/memstore_multi.c \
   ${ngx_addon_dir}/src/subscribers/memstore_redis.c \
+  ${ngx_addon_dir}/src/subscribers/getmsg_proxy.c \
+  ${ngx_addon_dir}/src/subscribers/benchmark.c \
 "
 
 _NCHAN_REDIS_STORE_SRCS="\
   ${_NCHAN_HIREDIS_SRCS} \
   ${ngx_addon_dir}/src/store/redis/cmp.c \
-  ${ngx_addon_dir}/src/store/redis/cluster.c \
+  ${ngx_addon_dir}/src/store/redis/redis_lua_commands.c \
+  ${ngx_addon_dir}/src/store/redis/redis_nodeset_parser.c \
+  ${ngx_addon_dir}/src/store/redis/redis_nodeset.c \
   ${ngx_addon_dir}/src/store/redis/rdsstore.c \
   ${ngx_addon_dir}/src/store/redis/redis_nginx_adapter.c \
 "
 _NCHAN_MEMORY_STORE_SRCS="\
   ${ngx_addon_dir}/src/store/memory/ipc.c \
   ${ngx_addon_dir}/src/store/memory/ipc-handlers.c \
+  ${ngx_addon_dir}/src/store/memory/groups.c \
   ${ngx_addon_dir}/src/store/memory/memstore.c \
 "
 
 _nchan_util_dir="${ngx_addon_dir}/src/util"
 _NCHAN_UTIL_SRCS=" \
+  $_nchan_util_dir/nchan_debug.c \
   $_nchan_util_dir/nchan_list.c \
+  $_nchan_util_dir/nchan_slist.c \
   $_nchan_util_dir/ngx_nchan_hacked_slab.c \
   $_nchan_util_dir/shmem.c \
   $_nchan_util_dir/nchan_rbtree.c \
@@ -62,31 +112,32 @@ _NCHAN_UTIL_SRCS=" \
   $_nchan_util_dir/nchan_fake_request.c \
   $_nchan_util_dir/nchan_bufchainpool.c \
   $_nchan_util_dir/nchan_channel_id.c \
-  $_nchan_util_dir/nchan_channel_info.c \
-  $_nchan_util_dir/nchan_msgid.c \
+  $_nchan_util_dir/nchan_output_info.c \
+  $_nchan_util_dir/nchan_msg.c \
   $_nchan_util_dir/nchan_thingcache.c \
   $_nchan_util_dir/nchan_reaper.c \
   $_nchan_util_dir/nchan_subrequest.c \
+  $_nchan_util_dir/nchan_benchmark.c \
+  $_nchan_util_dir/hdr_histogram.c \
 "
 
 _NCHAN_STORE_SRCS="\
   ${ngx_addon_dir}/src/store/spool.c \
   ${ngx_addon_dir}/src/store/ngx_rwlock.c \
   ${ngx_addon_dir}/src/store/store_common.c \
-  $_NCHAN_REDIS_STORE_SRCS \
   $_NCHAN_MEMORY_STORE_SRCS \
+  $_NCHAN_REDIS_STORE_SRCS \
 "
 
 _NCHAN_SRCS="\
-  $_NCHAN_UTIL_SRCS \
-  $_NCHAN_SUBSCRIBERS_SRCS \
-  $_NCHAN_STORE_SRCS \
   ${ngx_addon_dir}/src/nchan_defs.c \
   ${ngx_addon_dir}/src/nchan_variables.c \
   ${ngx_addon_dir}/src/nchan_module.c \
+  $_NCHAN_UTIL_SRCS \
+  $_NCHAN_SUBSCRIBERS_SRCS \
+  $_NCHAN_STORE_SRCS \
 "
 
-
 ngx_module_incs=$ngx_addon_dir/src
 
 have=NGX_HTTP_HEADERS . auto/have
@@ -95,11 +146,11 @@ if test -n "$ngx_module_link"; then
   ngx_module_type=HTTP
   ngx_module_name=$ngx_addon_name
   ngx_module_srcs="$_NCHAN_SRCS"
-  ngx_module_libs=$ngx_feature_libs
+  ngx_module_libs=$nchan_libs
   . auto/module
 else
   NGX_ADDON_SRCS="$NGX_ADDON_SRCS $_NCHAN_SRCS"
-  CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
+  CORE_LIBS="$CORE_LIBS $nchan_libs"
   CORE_INCS="$CORE_INCS $ngx_module_incs"
   HTTP_MODULES="$HTTP_MODULES $ngx_addon_name"
 fi
diff --git a/debian/modules/nchan/src/nchan_commands.rb b/debian/modules/nchan/src/nchan_commands.rb
index 12a88f1..eae0ea9 100644
--- a/debian/modules/nchan/src/nchan_commands.rb
+++ b/debian/modules/nchan/src/nchan_commands.rb
@@ -30,13 +30,24 @@ CfCmd.new do
       group: "pubsub",
       tags: [ 'publisher', 'hook' ],
       value: "<url>",
-      uri: "/details#message-publishing-callbacks",
+      uri: "#message-forwarding",
       info: <<-EOS.gsub(/^ {8}/, '')
         Send POST request to internal location (which may proxy to an upstream server) with published message in the request body. Useful for bridging websocket publishers with HTTP applications, or for transforming message via upstream application before publishing to a channel.  
         The upstream response code determines how publishing will proceed. A `200 OK` will publish the message from the upstream response's body. A `304 Not Modified` will publish the message as it was received from the publisher. A `204 No Content` will result in the message not being published.
       EOS
-      
   
+      
+  nchan_deflate_message_for_websocket [:srv, :loc],
+      :nchan_set_message_compression_slot,
+      :loc_conf,
+      args: 1,
+      
+      group: "pubsub",
+      tags: ["publisher", 'subscriber-websocket'],
+      value: ['on', 'off'],
+      default: "off",
+      info: "Store a compressed (deflated) copy of the message along with the original to be sent to websocket clients supporting the permessage-deflate protocol extension"
+      
   nchan_channel_id_split_delimiter [:srv, :loc, :if],
       :ngx_conf_set_str_slot,
       [:loc_conf, :channel_id_split_delimiter],
@@ -62,6 +73,7 @@ CfCmd.new do
       :nchan_pubsub_directive,
       :loc_conf,
       args: 0..6,
+      alt: ["nchan_pubsub_location"],
       
       group: "pubsub",
       tags: [ 'publisher', 'subscriber', 'pubsub' ],
@@ -91,13 +103,53 @@ CfCmd.new do
       tags: ['subscriber-eventsource'],
       default: "(none)",
       info: "Set the EventSource `event:` line to this value. When used in a publisher location, overrides the published message's `X-EventSource-Event` header and associates the message with the given value. When used in a subscriber location, overrides all messages' associated `event:` string with the given value."
+  
+  nchan_eventsource_ping_comment [:srv, :loc, :if],
+      :ngx_conf_set_str_slot_no_newlines,
+      [:loc_conf, :"eventsource_ping.comment"],
+      args: 1,
+      
+      group: "pubsub",
+      tags: ['subscriber-eventsource'],
+      default: "(empty)",
+      info: "Set the EventSource comment `: ...` line for periodic pings from server to client. Newlines are not allowed. If empty, no comment is sent with the ping."
+  
+  nchan_eventsource_ping_event [:srv, :loc, :if],
+      :ngx_conf_set_str_slot_no_newlines,
+      [:loc_conf, :"eventsource_ping.event"],
+      args: 1,
+      
+      group: "pubsub",
+      tags: ['subscriber-eventsource'],
+      default: "ping",
+      info: "Set the EventSource `event:` line for periodic pings from server to client. Newlines are not allowed. If empty, no event type is sent with the ping."
+  
+  nchan_eventsource_ping_data [:srv, :loc, :if],
+      :ngx_conf_set_str_slot_no_newlines,
+      [:loc_conf, :"eventsource_ping.data"],
+      args: 1,
+      
+      group: "pubsub",
+      tags: ['subscriber-eventsource'],
+      default: "(empty)",
+      info: "Set the EventSource `data:` line for periodic pings from server to client. Newlines are not allowed. If empty, no data is sent with the ping."
+  
+    nchan_eventsource_ping_interval [:srv, :loc, :if],
+      :ngx_conf_set_sec_slot,
+      [:loc_conf, :"eventsource_ping.interval"],
       
+      group: "pubsub",
+      tags: ['subscriber-eventsource'],
+      value: "<number> (seconds)",
+      default: "0 (none)",
+      info: "Interval for sending ping messages to EventSource subscribers. Disabled by default."
   
   nchan_subscriber [:srv, :loc, :if],
       :nchan_subscriber_directive,
       :loc_conf,
       args: 0..5,
       legacy: "push_subscriber",
+      alt: ["nchan_subscriber_location"],
       
       group: "pubsub",
       tags: ['subscriber'],
@@ -188,11 +240,23 @@ CfCmd.new do
       default: "0 (none)",
       info: "Interval for sending websocket ping frames. Disabled by default."
   
+  nchan_websocket_client_heartbeat [:srv, :loc, :if],
+      :nchan_websocket_heartbeat_directive,
+      [:loc_conf, :websocket_heartbeat],
+      args: 2,
+      
+      group: "pubsub",
+      tags:['subscriber-websocket'],
+      value: "<heartbeat_in> <heartbeat_out>",
+      default: "none (disabled)",
+      info: "Most browser Websocket clients do not allow manually sending PINGs to the server. To overcome this limitation, this setting can be used to set up a PING/PONG message/response connection heartbeat. When the client sends the server message *heartbeat_in* (PING), the server automatically responds with *heartbeat_out* (PONG)."
+  
   nchan_publisher [:srv, :loc, :if],
       :nchan_publisher_directive,
       :loc_conf,
       args: 0..2,
       legacy: "push_publisher",
+      alt: ["nchan_publisher_location"],
       
       group: "pubsub",
       tags: ['publisher'],
@@ -221,7 +285,7 @@ CfCmd.new do
       tags: ['publisher', 'subscriber', 'hook'],
       value: "<url>",
       info: "Send GET request to internal location (which may proxy to an upstream server) for authorization of a publisher or subscriber request. A 200 response authorizes the request, a 403 response forbids it.",
-      uri: "/details#request-authorization"
+      uri: "#request-authorization"
   
   nchan_subscribe_request [:srv, :loc, :if], 
       :ngx_http_set_complex_value_slot,
@@ -231,7 +295,7 @@ CfCmd.new do
       tags: ['subscriber', 'hook'],
       value: "<url>",
       info: "Send GET request to internal location (which may proxy to an upstream server) after subscribing. Disabled for longpoll and interval-polling subscribers.",
-      uri: "/details#subsribe-and-unsubscribe-callbacks"
+      uri: "#subscriber-presence"
   
   nchan_unsubscribe_request [:srv, :loc, :if], 
       :ngx_http_set_unsubscribe_request_url,
@@ -241,7 +305,18 @@ CfCmd.new do
       tags: ['subscriber', 'hook'],
       value: "<url>",
       info: "Send GET request to internal location (which may proxy to an upstream server) after unsubscribing. Disabled for longpoll and interval-polling subscribers.",
-      uri: "/details#subsribe-and-unsubscribe-callbacks"
+      uri: "#subscriber-presence"
+  
+  nchan_message_temp_path [:main],
+      :ngx_conf_set_path_slot,
+      [:main_conf, :message_temp_path],
+      
+      group: "storage",
+      tags: ["memstore"],
+      value: "<path>",
+      default: "<client_body_temp_path>",
+      info: "Large messages are stored in temporary files in the `client_body_temp_path` or the `nchan_message_temp_path` if the former is unavailable. Default is the built-in default `client_body_temp_path`"
+      
   
   nchan_store_messages [:main, :srv, :loc, :if],
       :nchan_store_messages_directive,
@@ -254,27 +329,68 @@ CfCmd.new do
       default: :on,
       info: "Publisher configuration. \"`off`\" is equivalent to setting `nchan_message_buffer_length 0`, which disables the buffering of old messages. Using this setting is not recommended when publishing very quickly, as it may result in missed messages."
     
-  nchan_max_reserved_memory [:main],
-      :ngx_conf_set_size_slot,
+  nchan_shared_memory_size [:main],
+      :nchan_conf_set_size_slot,
       [:main_conf, :shm_size],
-      legacy: "push_max_reserved_memory",
+      legacy: ["push_max_reserved_memory", "nchan_max_reserved_memory"],
       
       group: "storage",
       tags: ['memstore'],
       value: "<size>",
-      default: "32M",
-      info: "The size of the shared memory chunk this module will use for message queuing and buffering.",
+      default: "128M",
+      info: "Shared memory slab pre-allocated for Nchan. Used for channel statistics, message storage, and interprocess communication.",
       uri: "#memory-storage"
-    
+  
+  nchan_permessage_deflate_compression_level [:main],
+      :nchan_conf_deflate_compression_level_directive,
+      :main_conf,
+      
+      group: "pubsub",
+      tags: ['subscriber-websocket'],
+      value: ["0-9"],
+      default: "6",
+      info: "Compression level for the `deflate` algorithm used in websocket's permessage-deflate extension. 0: no compression, 1: fastest, worst, 9: slowest, best"
+  
+  nchan_permessage_deflate_compression_strategy [:main],
+      :nchan_conf_deflate_compression_strategy_directive,
+      :main_conf,
+      
+      group: "pubsub",
+      tags: ['subscriber-websocket'],
+      value: ["default", "filtered", "huffman-only", "rle", "fixed"],
+      default: "default",
+      info: "Compression strategy for the `deflate` algorithm used in websocket's permessage-deflate extension. Use 'default' for normal data, For details see [zlib's section on copression strategies](http://zlib.net/manual.html#Advanced)"
+  
+  nchan_permessage_deflate_compression_window [:main],
+      :nchan_conf_deflate_compression_window_directive,
+      :main_conf,
+      
+      group: "pubsub",
+      tags: ['subscriber-websocket'],
+      value: ["9-15"],
+      default: "10",
+      info: "Compression window for the `deflate` algorithm used in websocket's permessage-deflate extension. The base two logarithm of the window size (the size of the history buffer). The bigger the window, the better the compression, but the more memory used by the compressor."
+  
+  nchan_permessage_deflate_compression_memlevel [:main],
+      :nchan_conf_deflate_compression_memlevel_directive,
+      :main_conf,
+      
+      group: "pubsub",
+      tags: ['subscriber-websocket'],
+      value: ["1-9"],
+      default: "8",
+      info: "Memory level for the `deflate` algorithm used in websocket's permessage-deflate extension. How much memory should be allocated for the internal compression state. 1 - minimum memory, slow and reduces compression ratio; 9 - maximum memory for optimal speed"
+  
   nchan_redis_url [:main, :srv, :loc],
       :ngx_conf_set_redis_url,
       [:loc_conf, :"redis.url"],
       
       group: "storage",
       tags: ['redis'],
+      value: "<redis-url>",
       default: "127.0.0.1:6379",
-      info: "The path to a redis server, of the form 'redis://:password@hostname:6379/0'. Shorthand of the form 'host:port' or just 'host' is also accepted.",
-      uri: "/details#using-redis"
+      info: "Use of this command is discouraged in favor of upstreams blocks with (`nchan_redis_server`)[#nchan_redis_server]. The path to a redis server, of the form 'redis://:password@hostname:6379/0'. Shorthand of the form 'host:port' or just 'host' is also accepted.",
+      uri: "#connecting-to-a-redis-server"
   
   nchan_redis_pass [:main, :srv, :loc],
       :ngx_conf_set_redis_upstream_pass,
@@ -282,8 +398,9 @@ CfCmd.new do
       
       group: "storage",
       tags: ['publisher', 'subscriber', 'redis'],
+      value: "<upstream-name>",
       info: "Use an upstream config block for Redis servers.",
-      uri: "/details#using-redis"
+      uri: "#connecting-to-a-redis-server"
   
   nchan_redis_pass_inheritable [:main, :srv, :loc],
       :ngx_conf_set_flag_slot,
@@ -303,8 +420,36 @@ CfCmd.new do
       :loc_conf,
       group: "storage",
       tags: ['redis'],
-      info: "Used in upstream { } blocks to set redis servers.",
-      uri: "/details#using-redis"
+      value: "<redis-url>",
+      info: "Used in upstream { } blocks to set redis servers. Redis url is in the form 'redis://:password@hostname:6379/0'. Shorthands 'host:port' or 'host' are permitted.",
+      uri: "#connecting-to-a-redis-server"
+  
+  nchan_redis_storage_mode [:main, :srv, :upstream], 
+      :ngx_conf_set_redis_storage_mode_slot,
+      [:loc_conf, :"redis.storage_mode"],
+      
+      group: "storage",
+      tags: ['redis'],
+      value: ["distributed", "backup", "nostore"],
+      default: "distributed",
+      info: <<-EOS.gsub(/^ {8}/, '')
+        The mode of operation of the Redis server. In `distributed` mode, messages are published directly to Redis, and retrieved in real-time. Any number of Nchan servers in distributed mode can share the Redis server (or cluster). Useful for horizontal scalability, but suffers the latency penalty of all message publishing going through Redis first.
+        
+        In `backup` mode, messages are published locally first, then later forwarded to Redis, and are retrieved only upon chanel initialization. Only one Nchan server should use a Redis server (or cluster) in this mode. Useful for data persistence without sacrificing response times to the latency of a round-trip to Redis.
+        
+        In `nostore` mode, messages are published as in `distributed` mode, but are not stored. Thus Redis is used to broadcast messages to many Nchan instances with no delivery guarantees during connection failure, and only local in-memory storage. This means that there are also no message delivery guarantees for subscribers switching from one Nchan instance to another connected to the same Redis server or cluster. Nostore mode increases Redis publishing capacity by an order of magnitude.
+      EOS
+  
+  nchan_redis_nostore_fastpublish [:main, :srv, :upstream],
+      :ngx_conf_set_flag_slot,
+      [:loc_conf, :"redis.nostore_fastpublish"],
+      
+      group: "storage",
+      tags: ['redis', 'publisher'],
+      value: [:on, :off],
+      default: :off,
+      info: "Increases publishing capacity by 2-3x for Redis nostore mode at the expense of inaccurate subscriber counts in the publisher response."
+  
   
   nchan_use_redis [:main, :srv, :loc],
       :ngx_conf_enable_redis,
@@ -314,10 +459,10 @@ CfCmd.new do
       tags: ['redis', 'publisher', 'subscriber'],
       value: [ :on, :off ],
       default: :off,
-      info: "Use redis for message storage at this location.", 
-      uri: "/details#using-redis"
+      info: "Use of this command is discouraged in favor of (`nchan_redis_pass`)[#nchan_redis_pass]. Use Redis for message storage at this location.",
+      uri: "#connecting-to-a-redis-server"
   
-  nchan_redis_ping_interval [:main, :srv, :loc],
+  nchan_redis_ping_interval [:main, :srv, :upstream, :loc],
       :ngx_conf_set_sec_slot,
       [:loc_conf, :"redis.ping_interval"],
       
@@ -326,6 +471,55 @@ CfCmd.new do
       default: "4m",
       info: "Send a keepalive command to redis to keep the Nchan redis clients from disconnecting. Set to 0 to disable."
   
+  nchan_redis_wait_after_connecting [:main, :srv, :loc],
+      :nchan_ignore_obsolete_setting,
+      :loc_conf,
+      
+      group: "obsolete",
+      tags: ['redis'],
+      uncocumented: true
+  
+  nchan_redis_connect_timeout [:upstream],
+      :ngx_conf_set_msec_slot,
+      [:srv_conf, :"redis.connect_timeout"],
+      
+      group: "storage",
+      tags: ['redis'],
+      default: "600ms",
+      info: "Redis server connection timeout."
+  
+  nchan_redis_subscribe_weights [:upstream],
+      :ngx_conf_set_redis_subscribe_weights,
+      :srv_conf,
+      args: 1..2,
+      
+      group: "storage",
+      tags: ['redis'],
+      value: "master=<integer> slave=<integer>",
+      default: "master=1 slave=1",
+      info: "Determines how subscriptions to Redis PUBSUB channels are distributed between master and slave nodes. The higher the number, the more likely that each node of that type will be chosen for each new channel. The weights for slave nodes are cumulative, so an equal 1:1 master:slave weight ratio with two slaves would have a 1/3 chance of picking a master, and 2/3 chance of picking one of the slaves. The weight must be a non-negative integer."
+  
+  nchan_redis_optimize_target [:upstream],
+      :ngx_conf_set_redis_optimize_target,
+      :srv_conf,
+      
+      group: "storage",
+      tags: ['redis'],
+      value: [:cpu, :bandwidth],
+      default: "cpu",
+      info: "This tweaks whether [effect replication](https://redis.io/commands/eval#replicating-commands-instead-of-scripts) is enabled. Optimizing for CPU usage enables effect replication, costing additional bandwidth (between 1.2 and 2 times more) between all master->slave links. Optimizing for bandwidth increases CPU load on slaves, but keeps outgoing bandwidth used for replication the same as the incoming bandwidth on Master."
+  
+  nchan_redis_namespace [:main, :srv, :upstream, :loc], 
+      :ngx_conf_set_str_slot,
+      [:loc_conf, :"redis.namespace"],
+      args: 1,
+      post_handler: "ngx_conf_process_redis_namespace_slot",
+      
+      group: "storage",
+      value: "<string>",
+      tags: ['redis'],
+      info: "Prefix all Redis keys with this string. All Nchan-related keys in redis will be of the form \"nchan_redis_namespace:*\" . Default is empty."
+  
   nchan_redis_fakesub_timer_interval [:main],
       :ngx_conf_set_msec_slot,
       [:main_conf, :redis_fakesub_timer_interval],
@@ -378,27 +572,108 @@ CfCmd.new do
       default: :off,
       info: "Whether or not a subscriber may create a channel by sending a request to a subscriber location. If set to on, a publisher must send a POST or PUT request before a subscriber can request messages on the channel. Otherwise, all subscriber requests to nonexistent channels will get a 403 Forbidden response."
   
-  nchan_access_control_allow_origin [:main, :srv, :loc], 
-      :ngx_conf_set_str_slot,
+  nchan_access_control_allow_origin [:main, :srv, :loc, :if], 
+      :ngx_http_set_complex_value_slot,
       [:loc_conf, :allow_origin],
       args: 1,
       
       group: "security",
       value: "<string>",
       tags: ['publisher', 'subscriber'],
-      default: "*",
-      info: "Set the [Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) `Access-Control-Allow-Origin` header to this value. If the publisher or subscriber request's `Origin` header does not match this value, respond with a `403 Forbidden`."
+      default: "$http_origin",
+      info: "Set the [Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) `Access-Control-Allow-Origin` header to this value. If the incoming request's `Origin` header does not match this value, respond with a `403 Forbidden`. Multiple origins can be provided in a single argument separated with a space."
+
+  nchan_access_control_allow_credentials [:main, :srv, :loc, :if], 
+      :ngx_conf_set_flag_slot,
+      [:loc_conf, :allow_credentials],
+      args: 1,
+      
+      group: "security",
+      tags: ['publisher', 'subscriber'],
+      default: "on",
+      info: "When enabled, sets the [Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) `Access-Control-Allow-Credentials` header to `true`."
+  
   
   nchan_channel_group [:srv, :loc, :if], 
-      :ngx_conf_set_str_slot, 
+      :ngx_http_set_complex_value_slot, 
       [:loc_conf, :channel_group],
       legacy: "push_channel_group",
       
       group: "security",
-      tags: ['publisher', 'subscriber', 'channel-events'],
+      tags: ['publisher', 'subscriber', 'channel-events', 'group'],
       value: "<string>",
       default: "(none)",
-      info: "Because settings are bound to locations and not individual channels, it is useful to be able to have channels that can be reached only from some locations and never others. That's where this setting comes in. Think of it as a prefix string for the channel id."
+      info: "The accounting and security group a channel belongs to. Works like a prefix string to the channel id. Can be set with nginx variables."
+  
+  nchan_channel_group_accounting [:srv, :loc], 
+      :ngx_conf_set_flag_slot,
+      [:loc_conf, "group.enable_accounting"],
+      
+      group: "security",
+      tags: ['group', 'security'],
+      default: "off",
+      info: "Enable tracking channel, subscriber, and message information on a per-channel-group basis. Can be used to place upper limits on channel groups."
+  
+  nchan_group_location [:loc], 
+      :nchan_group_directive, 
+      [:loc_conf],
+      args: 0..3,
+      
+      group: "security",
+      tags: ['group'],
+      value: ["get", "set", "delete", "off"],
+      default: ["get", "set", "delete"],
+      info: "Group information and configuration location. GET request for group info, POST to set limits, DELETE to delete all channels in group."
+  
+  nchan_group_max_channels [:loc], 
+      :ngx_http_set_complex_value_slot, 
+      [:loc_conf, "group.max_channels"],
+      
+      group: "security",
+      tags: ['group', 'security'],
+      value: "<number>",
+      default: "0 (unlimited)",
+      info: "Maximum number of channels allowed in the group."
+  
+  nchan_group_max_messages [:loc], 
+      :ngx_http_set_complex_value_slot, 
+      [:loc_conf, "group.max_messages"],
+      
+      group: "security",
+      tags: ['group', 'security'],
+      value: "<number>",
+      default: "0 (unlimited)",
+      info: "Maximum number of messages allowed for all the channels in the group."
+  
+  nchan_group_max_messages_memory [:loc], 
+      :ngx_http_set_complex_value_slot, 
+      [:loc_conf, "group.max_messages_shm_bytes"],
+      
+      group: "security",
+      tags: ['group', 'security'],
+      value: "<number>",
+      default: "0 (unlimited)",
+      info: "Maximum amount of shared memory allowed for the messages of all the channels in the group."
+  
+  nchan_group_max_messages_disk [:loc], 
+      :ngx_http_set_complex_value_slot, 
+      [:loc_conf, "group.max_messages_file_bytes"],
+      
+      group: "security",
+      tags: ['group', 'security'],
+      value: "<number>",
+      default: "0 (unlimited)",
+      info: "Maximum amount of disk space allowed for the messages of all the channels in the group."
+  
+  nchan_group_max_subscribers [:loc], 
+      :ngx_http_set_complex_value_slot, 
+      [:loc_conf, "group.max_subscribers"],
+      
+      group: "security",
+      tags: ['group', 'security'],
+      value: "<number>",
+      default: "0 (unlimited)",
+      info: "Maximum number of subscribers allowed for the messages of all the channels in the group."
   
   nchan_channel_events_channel_id [:srv, :loc, :if],
       :nchan_set_channel_events_channel_id,
@@ -406,8 +681,8 @@ CfCmd.new do
       args: 1,
       
       group: "meta",
-      tags: ['publisher', 'subscriber', 'channel-events'],
-      uri: "/details#channel-events",
+      tags: ['publisher', 'subscriber', 'channel-events', 'introspection'],
+      uri: "#channel-events",
       info: "Channel id where `nchan_channel_id`'s events should be sent. Events like subscriber enqueue/dequeue, publishing messages, etc. Useful for application debugging. The channel event message is configurable via nchan_channel_event_string. The channel group for events is hardcoded to 'meta'."
   
   nchan_stub_status [:loc],
@@ -416,15 +691,16 @@ CfCmd.new do
       args: 0,
       
       group: "meta",
+      tags: ['introspection'],
       info: "Similar to Nginx's stub_status directive, requests to an `nchan_stub_status` location get a response with some vital Nchan statistics. This data does not account for information from other Nchan instances, and monitors only local connections, published messages, etc.",
-      uri: "/details#nchan_stub_status"
+      uri: "#nchan_stub_status"
   
   nchan_channel_event_string [:srv, :loc, :if], 
       :ngx_http_set_complex_value_slot,
       [:loc_conf, :channel_event_string],
       
       group: "meta",
-      tags: ['publisher', 'subscriber', 'channel-events'],
+      tags: ['publisher', 'subscriber', 'channel-events', 'introspection'],
       value: "<string>",
       default: "\"$nchan_channel_event $nchan_channel_id\"",
       info: "Contents of channel event message"
@@ -437,8 +713,8 @@ CfCmd.new do
       group: "security",
       tags: ['publisher', 'subscriber', 'channel-id' ],
       value: "<number>",
-      default: 512,
-      info: "Maximum permissible channel id length (number of characters). Longer ids will be truncated."
+      default: 1024,
+      info: "Maximum permissible channel id length (number of characters). This settings applies to ids before they may be split by the `nchan_channel_id_split_delimiter` Requests with a channel id that is too long will receive a `403 Forbidden` response."
   
   nchan_max_channel_subscribers [:main, :srv, :loc],
       :ngx_conf_set_num_slot,
@@ -468,6 +744,49 @@ CfCmd.new do
       default: "memory",
       info: "Development directive to completely replace default storage engine. Don't use unless you are an Nchan developer."
   
+  nchan_benchmark [:loc],
+      :nchan_benchmark_directive,
+      [:loc_conf],
+      group: "development",
+      undocumented: true,
+      args: 0
+  nchan_benchmark_time [:loc],
+      :ngx_conf_set_sec_slot,
+      [:loc_conf, "benchmark.time"],
+      group: "development",
+      undocumented: true
+  nchan_benchmark_messages_per_channel_per_minute [:loc],
+      :ngx_conf_set_num_slot,
+      [:loc_conf, "benchmark.msgs_per_minute"],
+      group: "development",
+      undocumented: true
+  nchan_benchmark_message_padding_bytes [:loc],
+      :ngx_conf_set_num_slot,
+      [:loc_conf, "benchmark.msg_padding"],
+      group: "development",
+      undocumented: true
+  nchan_benchmark_channels [:loc],
+      :ngx_conf_set_num_slot,
+      [:loc_conf, "benchmark.channels"],
+      group: "development",
+      undocumented: true
+  nchan_benchmark_subscribers_per_channel [:loc],
+      :ngx_conf_set_num_slot,
+      [:loc_conf, "benchmark.subscribers_per_channel"],
+      group: "development",
+      undocumented: true
+    nchan_benchmark_subscriber_distribution [:loc],
+      :nchan_benchmark_subscriber_distribution_directive,
+      [:loc_conf, "benchmark.subscriber_distribution"],
+      group: "development",
+      undocumented: true
+    nchan_benchmark_publisher_distribution [:loc],
+      :nchan_benchmark_publisher_distribution_directive,
+      [:loc_conf, "benchmark.publisher_distribution"],
+      group: "development",
+      undocumented: true
+
+  
   push_min_message_buffer_length [:srv, :loc, :if],
       :nchan_ignore_obsolete_setting,
       :loc_conf,
diff --git a/debian/modules/nchan/src/nchan_config_commands.c b/debian/modules/nchan/src/nchan_config_commands.c
index 3051f09..4cbde2a 100644
--- a/debian/modules/nchan/src/nchan_config_commands.c
+++ b/debian/modules/nchan/src/nchan_config_commands.c
@@ -1,4 +1,8 @@
 //AUTOGENERATED, do not edit! see nchan_commands.rb
+static ngx_conf_post_t nchan_redis_namespace__post_handler = {
+  ngx_conf_process_redis_namespace_slot
+};
+
 static ngx_command_t  nchan_commands[] = {
     { ngx_string("nchan_channel_id"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1|NGX_CONF_TAKE2|NGX_CONF_TAKE3|NGX_CONF_TAKE4|NGX_CONF_TAKE5|NGX_CONF_TAKE6|NGX_CONF_TAKE7,
@@ -33,6 +37,13 @@ static ngx_command_t  nchan_commands[] = {
     offsetof(nchan_loc_conf_t, publisher_upstream_request_url),
     NULL } ,
 
+  { ngx_string("nchan_deflate_message_for_websocket"),
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    nchan_set_message_compression_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    0,
+    NULL } ,
+
   { ngx_string("nchan_channel_id_split_delimiter"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
     ngx_conf_set_str_slot,
@@ -59,6 +70,12 @@ static ngx_command_t  nchan_commands[] = {
     NGX_HTTP_LOC_CONF_OFFSET,
     0,
     NULL } ,
+  { ngx_string("nchan_pubsub_location"), //alt for nchan_pubsub
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_NOARGS|NGX_CONF_TAKE1|NGX_CONF_TAKE2|NGX_CONF_TAKE3|NGX_CONF_TAKE4|NGX_CONF_TAKE5|NGX_CONF_TAKE6,
+    nchan_pubsub_directive,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    0,
+    NULL } ,
 
   { ngx_string("nchan_longpoll_multipart_response"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
@@ -74,6 +91,34 @@ static ngx_command_t  nchan_commands[] = {
     offsetof(nchan_loc_conf_t, eventsource_event),
     NULL } ,
 
+  { ngx_string("nchan_eventsource_ping_comment"),
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_str_slot_no_newlines,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, eventsource_ping.comment),
+    NULL } ,
+
+  { ngx_string("nchan_eventsource_ping_event"),
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_str_slot_no_newlines,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, eventsource_ping.event),
+    NULL } ,
+
+  { ngx_string("nchan_eventsource_ping_data"),
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_str_slot_no_newlines,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, eventsource_ping.data),
+    NULL } ,
+
+  { ngx_string("nchan_eventsource_ping_interval"),
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_sec_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, eventsource_ping.interval),
+    NULL } ,
+
   { ngx_string("nchan_subscriber"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_NOARGS|NGX_CONF_TAKE1|NGX_CONF_TAKE2|NGX_CONF_TAKE3|NGX_CONF_TAKE4|NGX_CONF_TAKE5,
     nchan_subscriber_directive,
@@ -86,6 +131,12 @@ static ngx_command_t  nchan_commands[] = {
     NGX_HTTP_LOC_CONF_OFFSET,
     0,
     NULL } ,
+  { ngx_string("nchan_subscriber_location"), //alt for nchan_subscriber
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_NOARGS|NGX_CONF_TAKE1|NGX_CONF_TAKE2|NGX_CONF_TAKE3|NGX_CONF_TAKE4|NGX_CONF_TAKE5,
+    nchan_subscriber_directive,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    0,
+    NULL } ,
 
   { ngx_string("nchan_subscriber_compound_etag_message_id"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
@@ -129,6 +180,13 @@ static ngx_command_t  nchan_commands[] = {
     offsetof(nchan_loc_conf_t, websocket_ping_interval),
     NULL } ,
 
+  { ngx_string("nchan_websocket_client_heartbeat"),
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE2,
+    nchan_websocket_heartbeat_directive,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, websocket_heartbeat),
+    NULL } ,
+
   { ngx_string("nchan_publisher"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_NOARGS|NGX_CONF_TAKE1|NGX_CONF_TAKE2,
     nchan_publisher_directive,
@@ -141,6 +199,12 @@ static ngx_command_t  nchan_commands[] = {
     NGX_HTTP_LOC_CONF_OFFSET,
     0,
     NULL } ,
+  { ngx_string("nchan_publisher_location"), //alt for nchan_publisher
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_NOARGS|NGX_CONF_TAKE1|NGX_CONF_TAKE2,
+    nchan_publisher_directive,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    0,
+    NULL } ,
 
   { ngx_string("nchan_subscriber_timeout"),
     NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
@@ -176,6 +240,13 @@ static ngx_command_t  nchan_commands[] = {
     offsetof(nchan_loc_conf_t, unsubscribe_request_url),
     NULL } ,
 
+  { ngx_string("nchan_message_temp_path"),
+    NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_path_slot,
+    NGX_HTTP_MAIN_CONF_OFFSET,
+    offsetof(nchan_main_conf_t, message_temp_path),
+    NULL } ,
+
   { ngx_string("nchan_store_messages"),
     NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
     nchan_store_messages_directive,
@@ -189,18 +260,52 @@ static ngx_command_t  nchan_commands[] = {
     0,
     NULL } ,
 
-  { ngx_string("nchan_max_reserved_memory"),
+  { ngx_string("nchan_shared_memory_size"),
     NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
-    ngx_conf_set_size_slot,
+    nchan_conf_set_size_slot,
     NGX_HTTP_MAIN_CONF_OFFSET,
     offsetof(nchan_main_conf_t, shm_size),
     NULL } ,
-  { ngx_string("push_max_reserved_memory"), //legacy for nchan_max_reserved_memory
+  { ngx_string("push_max_reserved_memory"), //legacy for nchan_shared_memory_size
     NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
-    ngx_conf_set_size_slot,
+    nchan_conf_set_size_slot,
     NGX_HTTP_MAIN_CONF_OFFSET,
     offsetof(nchan_main_conf_t, shm_size),
     NULL } ,
+  { ngx_string("nchan_max_reserved_memory"), //legacy for nchan_shared_memory_size
+    NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
+    nchan_conf_set_size_slot,
+    NGX_HTTP_MAIN_CONF_OFFSET,
+    offsetof(nchan_main_conf_t, shm_size),
+    NULL } ,
+
+  { ngx_string("nchan_permessage_deflate_compression_level"),
+    NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
+    nchan_conf_deflate_compression_level_directive,
+    NGX_HTTP_MAIN_CONF_OFFSET,
+    0,
+    NULL } ,
+
+  { ngx_string("nchan_permessage_deflate_compression_strategy"),
+    NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
+    nchan_conf_deflate_compression_strategy_directive,
+    NGX_HTTP_MAIN_CONF_OFFSET,
+    0,
+    NULL } ,
+
+  { ngx_string("nchan_permessage_deflate_compression_window"),
+    NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
+    nchan_conf_deflate_compression_window_directive,
+    NGX_HTTP_MAIN_CONF_OFFSET,
+    0,
+    NULL } ,
+
+  { ngx_string("nchan_permessage_deflate_compression_memlevel"),
+    NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
+    nchan_conf_deflate_compression_memlevel_directive,
+    NGX_HTTP_MAIN_CONF_OFFSET,
+    0,
+    NULL } ,
 
   { ngx_string("nchan_redis_url"),
     NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
@@ -237,6 +342,20 @@ static ngx_command_t  nchan_commands[] = {
     0,
     NULL } ,
 
+  { ngx_string("nchan_redis_storage_mode"),
+    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_redis_storage_mode_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, redis.storage_mode),
+    NULL } ,
+
+  { ngx_string("nchan_redis_nostore_fastpublish"),
+    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_flag_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, redis.nostore_fastpublish),
+    NULL } ,
+
   { ngx_string("nchan_use_redis"),
     NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
     ngx_conf_enable_redis,
@@ -245,12 +364,47 @@ static ngx_command_t  nchan_commands[] = {
     NULL } ,
 
   { ngx_string("nchan_redis_ping_interval"),
-    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_UPS_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
     ngx_conf_set_sec_slot,
     NGX_HTTP_LOC_CONF_OFFSET,
     offsetof(nchan_loc_conf_t, redis.ping_interval),
     NULL } ,
 
+  { ngx_string("nchan_redis_wait_after_connecting"),
+    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    nchan_ignore_obsolete_setting,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    0,
+    NULL } ,
+
+  { ngx_string("nchan_redis_connect_timeout"),
+    NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_msec_slot,
+    NGX_HTTP_SRV_CONF_OFFSET,
+    offsetof(nchan_srv_conf_t, redis.connect_timeout),
+    NULL } ,
+
+  { ngx_string("nchan_redis_subscribe_weights"),
+    NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1|NGX_CONF_TAKE2,
+    ngx_conf_set_redis_subscribe_weights,
+    NGX_HTTP_SRV_CONF_OFFSET,
+    0,
+    NULL } ,
+
+  { ngx_string("nchan_redis_optimize_target"),
+    NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_redis_optimize_target,
+    NGX_HTTP_SRV_CONF_OFFSET,
+    0,
+    NULL } ,
+
+  { ngx_string("nchan_redis_namespace"),
+    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_UPS_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_str_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, redis.namespace),
+    &nchan_redis_namespace__post_handler } ,
+
   { ngx_string("nchan_redis_fakesub_timer_interval"),
     NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
     ngx_conf_set_msec_slot,
@@ -317,25 +471,81 @@ static ngx_command_t  nchan_commands[] = {
     NULL } ,
 
   { ngx_string("nchan_access_control_allow_origin"),
-    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
-    ngx_conf_set_str_slot,
+    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
+    ngx_http_set_complex_value_slot,
     NGX_HTTP_LOC_CONF_OFFSET,
     offsetof(nchan_loc_conf_t, allow_origin),
     NULL } ,
 
+  { ngx_string("nchan_access_control_allow_credentials"),
+    NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_flag_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, allow_credentials),
+    NULL } ,
+
   { ngx_string("nchan_channel_group"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
-    ngx_conf_set_str_slot,
+    ngx_http_set_complex_value_slot,
     NGX_HTTP_LOC_CONF_OFFSET,
     offsetof(nchan_loc_conf_t, channel_group),
     NULL } ,
   { ngx_string("push_channel_group"), //legacy for nchan_channel_group
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
-    ngx_conf_set_str_slot,
+    ngx_http_set_complex_value_slot,
     NGX_HTTP_LOC_CONF_OFFSET,
     offsetof(nchan_loc_conf_t, channel_group),
     NULL } ,
 
+  { ngx_string("nchan_channel_group_accounting"),
+    NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_flag_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, group.enable_accounting),
+    NULL } ,
+
+  { ngx_string("nchan_group_location"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_NOARGS|NGX_CONF_TAKE1|NGX_CONF_TAKE2|NGX_CONF_TAKE3,
+    nchan_group_directive,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    0,
+    NULL } ,
+
+  { ngx_string("nchan_group_max_channels"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_http_set_complex_value_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, group.max_channels),
+    NULL } ,
+
+  { ngx_string("nchan_group_max_messages"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_http_set_complex_value_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, group.max_messages),
+    NULL } ,
+
+  { ngx_string("nchan_group_max_messages_memory"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_http_set_complex_value_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, group.max_messages_shm_bytes),
+    NULL } ,
+
+  { ngx_string("nchan_group_max_messages_disk"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_http_set_complex_value_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, group.max_messages_file_bytes),
+    NULL } ,
+
+  { ngx_string("nchan_group_max_subscribers"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_http_set_complex_value_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, group.max_subscribers),
+    NULL } ,
+
   { ngx_string("nchan_channel_events_channel_id"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
     nchan_set_channel_events_channel_id,
@@ -403,6 +613,62 @@ static ngx_command_t  nchan_commands[] = {
     offsetof(nchan_loc_conf_t, storage_engine),
     NULL } ,
 
+  { ngx_string("nchan_benchmark"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_NOARGS,
+    nchan_benchmark_directive,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    0,
+    NULL } ,
+
+  { ngx_string("nchan_benchmark_time"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_sec_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, benchmark.time),
+    NULL } ,
+
+  { ngx_string("nchan_benchmark_messages_per_channel_per_minute"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_num_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, benchmark.msgs_per_minute),
+    NULL } ,
+
+  { ngx_string("nchan_benchmark_message_padding_bytes"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_num_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, benchmark.msg_padding),
+    NULL } ,
+
+  { ngx_string("nchan_benchmark_channels"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_num_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, benchmark.channels),
+    NULL } ,
+
+  { ngx_string("nchan_benchmark_subscribers_per_channel"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    ngx_conf_set_num_slot,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, benchmark.subscribers_per_channel),
+    NULL } ,
+
+  { ngx_string("nchan_benchmark_subscriber_distribution"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    nchan_benchmark_subscriber_distribution_directive,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, benchmark.subscriber_distribution),
+    NULL } ,
+
+  { ngx_string("nchan_benchmark_publisher_distribution"),
+    NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
+    nchan_benchmark_publisher_distribution_directive,
+    NGX_HTTP_LOC_CONF_OFFSET,
+    offsetof(nchan_loc_conf_t, benchmark.publisher_distribution),
+    NULL } ,
+
   { ngx_string("push_min_message_buffer_length"),
     NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
     nchan_ignore_obsolete_setting,
diff --git a/debian/modules/nchan/src/nchan_defs.c b/debian/modules/nchan/src/nchan_defs.c
index c9e07e1..8dbd49c 100644
--- a/debian/modules/nchan/src/nchan_defs.c
+++ b/debian/modules/nchan/src/nchan_defs.c
@@ -15,6 +15,7 @@ const  ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_ALLOW_HEADERS = ngx_string("Access-
 const  ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_ALLOW_METHODS = ngx_string("Access-Control-Allow-Methods");
 const  ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN = ngx_string("Access-Control-Allow-Origin");
 const  ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS = ngx_string("Access-Control-Expose-Headers");
+const  ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS = ngx_string("Access-Control-Allow-Credentials");
 
 const  ngx_str_t NCHAN_HEADER_EVENTSOURCE_EVENT = ngx_string("X-EventSource-Event");
 
@@ -26,6 +27,7 @@ const ngx_str_t NCHAN_HEADER_SEC_WEBSOCKET_KEY = ngx_string("Sec-WebSocket-Key")
 const ngx_str_t NCHAN_HEADER_SEC_WEBSOCKET_ACCEPT = ngx_string("Sec-WebSocket-Accept");
 const ngx_str_t NCHAN_HEADER_SEC_WEBSOCKET_VERSION = ngx_string("Sec-WebSocket-Version");
 const ngx_str_t NCHAN_HEADERS_SEC_WEBSOCKET_PROTOCOL = ngx_string("Sec-WebSocket-Protocol");
+const ngx_str_t NCHAN_HEADER_SEC_WEBSOCKET_EXTENSIONS = ngx_string("Sec-WebSocket-Extensions");
 
 //and some wobsockety values
 const ngx_str_t NCHAN_UPGRADE = ngx_string("Upgrade");
@@ -39,6 +41,7 @@ const  ngx_str_t NCHAN_CACHE_CONTROL_VALUE = ngx_string("no-cache");
 const  ngx_str_t NCHAN_HTTP_STATUS_101 = ngx_string("101 Switching Protocols");
 const  ngx_str_t NCHAN_HTTP_STATUS_204 = ngx_string("204 No Content");
 const  ngx_str_t NCHAN_HTTP_STATUS_304 = ngx_string("304 Not Modified");
+const  ngx_str_t NCHAN_HTTP_STATUS_400 = ngx_string("400 Bad Request");
 const  ngx_str_t NCHAN_HTTP_STATUS_408 = ngx_string("408 Request Timeout");
 const  ngx_str_t NCHAN_HTTP_STATUS_409 = ngx_string("409 Conflict");
 const  ngx_str_t NCHAN_HTTP_STATUS_410 = ngx_string("410 Gone");
@@ -46,10 +49,14 @@ const  ngx_str_t NCHAN_HTTP_STATUS_410 = ngx_string("410 Gone");
 //other stuff
 const  ngx_str_t NCHAN_SUBSCRIBER_TIMEOUT= ngx_string("Subscriber Timeout");
 const  ngx_str_t NCHAN_ANYSTRING= ngx_string("*");
+const  ngx_str_t NCHAN_ACCESS_CONTROL_ALLOWED_GROUP_HEADERS = ngx_string("Accept, Content-Type");
 const  ngx_str_t NCHAN_ACCESS_CONTROL_ALLOWED_PUBLISHER_HEADERS = ngx_string("Content-Type");
 const  ngx_str_t NCHAN_ACCESS_CONTROL_ALLOWED_SUBSCRIBER_HEADERS = ngx_string("If-None-Match, If-Modified-Since, Content-Type, Cache-Control, X-EventSource-Event");
+const  ngx_str_t NCHAN_ACCESS_CONTROL_ALLOWED_PUBSUB_HEADERS = ngx_string("If-None-Match, If-Modified-Since, Content-Type, Cache-Control, X-EventSource-Event");
 const  ngx_str_t NCHAN_ALLOW_GET_POST_PUT_DELETE= ngx_string("GET, POST, PUT, DELETE");
 const  ngx_str_t NCHAN_ALLOW_GET= ngx_string("GET");
+const  ngx_str_t NCHAN_ALLOW_GET_POST_DELETE= ngx_string("GET, POST, DELETE");
+
 
 const  ngx_str_t NCHAN_VARY_HEADER_VALUE = ngx_string("If-None-Match, If-Modified-Since");
 const  ngx_str_t NCHAN_MSG_RESPONSE_ALLOWED_HEADERS = ngx_string("Last-Modified, Etag, Content-Type");
@@ -86,6 +93,6 @@ const ngx_str_t NCHAN_CHANNEL_INFO_YAML = ngx_string(
   "messages: %ui" CRLF
   "requested: %d" CRLF
   "subscribers: %ui" CRLF
-  "last_message_id: %V" CRLF
+  "last_message_id: \"%V\"" CRLF
   CRLF
   "\0");
diff --git a/debian/modules/nchan/src/nchan_defs.h b/debian/modules/nchan/src/nchan_defs.h
index 8e1af05..0809080 100644
--- a/debian/modules/nchan/src/nchan_defs.h
+++ b/debian/modules/nchan/src/nchan_defs.h
@@ -1,12 +1,13 @@
 #ifndef NCHAN_DEFS_H
 #define NCHAN_DEFS_H
 
-#define NCHAN_DEFAULT_SHM_SIZE 33554432 //32 megs
+#define NCHAN_DEFAULT_SHM_SIZE 134217728 //128 megs
 #define NCHAN_DEFAULT_MESSAGE_TIMEOUT 3600
 #define NCHAN_DEFAULT_REDIS_IDLE_CHANNEL_CACHE_TIMEOUT 30
 #define NCHAN_DEFAULT_SUBSCRIBER_TIMEOUT 0  //default: never timeout
+#define NCHAN_DEFAULT_REDIS_NODE_CONNECT_TIMEOUT_MSEC 600
 //(liucougar: this is a bit confusing, but it is what's the default behavior before this option is introducecd)
-#define NCHAN_DEFAULT_WEBSOCKET_PING_INTERVAL 0
+#define NCHAN_DEFAULT_SUBSCRIBER_PING_INTERVAL 0
 
 #define NCHAN_DEFAULT_CHANNEL_TIMEOUT 5 //default: timeout in 5 seconds
 
@@ -62,6 +63,7 @@ extern const ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_ALLOW_HEADERS;
 extern const ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_ALLOW_METHODS;
 extern const ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN;
 extern const ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS;
+extern const ngx_str_t NCHAN_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS;
 
 extern const ngx_str_t NCHAN_HEADER_EVENTSOURCE_EVENT;
 
@@ -71,6 +73,7 @@ extern const ngx_str_t NCHAN_HEADER_SEC_WEBSOCKET_KEY;
 extern const ngx_str_t NCHAN_HEADER_SEC_WEBSOCKET_ACCEPT;
 extern const ngx_str_t NCHAN_HEADER_SEC_WEBSOCKET_VERSION;
 extern const ngx_str_t NCHAN_HEADERS_SEC_WEBSOCKET_PROTOCOL;
+extern const ngx_str_t NCHAN_HEADER_SEC_WEBSOCKET_EXTENSIONS;
 
 //header values
 extern const  ngx_str_t NCHAN_CACHE_CONTROL_VALUE;
@@ -79,6 +82,7 @@ extern const  ngx_str_t NCHAN_CACHE_CONTROL_VALUE;
 extern const  ngx_str_t NCHAN_HTTP_STATUS_101;
 extern const  ngx_str_t NCHAN_HTTP_STATUS_204;
 extern const  ngx_str_t NCHAN_HTTP_STATUS_304;
+extern const  ngx_str_t NCHAN_HTTP_STATUS_400;
 extern const  ngx_str_t NCHAN_HTTP_STATUS_408;
 extern const  ngx_str_t NCHAN_HTTP_STATUS_409;
 extern const  ngx_str_t NCHAN_HTTP_STATUS_410;
@@ -91,7 +95,10 @@ extern const ngx_str_t NCHAN_WEBSOCKET;
 extern const ngx_str_t NCHAN_ANYSTRING;
 extern const ngx_str_t NCHAN_ACCESS_CONTROL_ALLOWED_PUBLISHER_HEADERS;
 extern const ngx_str_t NCHAN_ACCESS_CONTROL_ALLOWED_SUBSCRIBER_HEADERS;
+extern const ngx_str_t NCHAN_ACCESS_CONTROL_ALLOWED_PUBSUB_HEADERS;
+extern const ngx_str_t NCHAN_ACCESS_CONTROL_ALLOWED_GROUP_HEADERS;
 extern const ngx_str_t NCHAN_ALLOW_GET_POST_PUT_DELETE;
+extern const ngx_str_t NCHAN_ALLOW_GET_POST_DELETE;
 extern const ngx_str_t NCHAN_ALLOW_GET;
 extern const ngx_str_t NCHAN_VARY_HEADER_VALUE;
 extern const ngx_str_t NCHAN_MSG_RESPONSE_ALLOWED_HEADERS;
diff --git a/debian/modules/nchan/src/nchan_module.c b/debian/modules/nchan/src/nchan_module.c
old mode 100755
new mode 100644
index ff97852..4555c5d
--- a/debian/modules/nchan/src/nchan_module.c
+++ b/debian/modules/nchan/src/nchan_module.c
@@ -13,11 +13,17 @@
 #include <subscribers/http-multipart-mixed.h>
 #include <subscribers/http-raw-stream.h>
 #include <subscribers/websocket.h>
+#include <subscribers/benchmark.h>
 #include <store/memory/store.h>
 #include <store/redis/store.h>
 
 #include <nchan_setup.c>
 
+#if (NGX_ZLIB)
+#include <zlib.h>
+#endif
+
+
 #if FAKESHARD
 #include <store/memory/ipc.h>
 #include <store/memory/shmem.h>
@@ -30,6 +36,9 @@ ngx_int_t           nchan_worker_processes;
 int                 nchan_stub_status_enabled = 0;
 
 
+static void nchan_publisher_body_handler(ngx_http_request_t *r);
+static void nchan_publisher_unavailable_body_handler(ngx_http_request_t *r);
+
 //#define DEBUG_LEVEL NGX_LOG_WARN
 //#define DEBUG_LEVEL NGX_LOG_DEBUG
 
@@ -55,8 +64,6 @@ ngx_int_t nchan_maybe_send_channel_event_message(ngx_http_request_t *r, channel_
   static ngx_str_t evt_chan_publish= ngx_string("channel_publish");
   static ngx_str_t evt_chan_delete = ngx_string("channel_delete");
 
-  struct timeval             tv;
-  
   nchan_loc_conf_t          *cf = ngx_http_get_module_loc_conf(r, ngx_nchan_module);
   ngx_http_complex_value_t  *cv = cf->channel_events_channel_id;
   if(cv==NULL) {
@@ -70,7 +77,6 @@ ngx_int_t nchan_maybe_send_channel_event_message(ngx_http_request_t *r, channel_
   ngx_str_t                 *id;
   u_char                    *cur;
   ngx_str_t                  evstr;
-  ngx_buf_t                  buf;
   nchan_msg_t                msg;
   
   switch(event_type) {
@@ -113,21 +119,22 @@ ngx_int_t nchan_maybe_send_channel_event_message(ngx_http_request_t *r, channel_
   
   //the event message
   ngx_http_complex_value(r, cf->channel_event_string, &evstr);
-  ngx_memzero(&buf, sizeof(buf)); //do we really need this?...
-  buf.temporary = 1;
-  buf.memory = 1;
-  buf.last_buf = 1;
-  buf.pos = evstr.data;
-  buf.last = evstr.data + evstr.len;
-  buf.start = buf.pos;
-  buf.end = buf.last;
   
   ngx_memzero(&msg, sizeof(msg));
-  ngx_gettimeofday(&tv);
-  msg.id.time = tv.tv_sec;
-  msg.id.tagcount = 1;
-  msg.buf = &buf;
   
+  msg.buf.temporary = 1;
+  msg.buf.memory = 1;
+  msg.buf.last_buf = 1;
+  msg.buf.pos = evstr.data;
+  msg.buf.last = evstr.data + evstr.len;
+  msg.buf.start = msg.buf.pos;
+  msg.buf.end = msg.buf.last;
+  
+  msg.id.time = 0;
+  msg.id.tag.fixed[0] = 0;
+  msg.id.tagactive = 0;
+  msg.id.tagcount = 1;
+  msg.storage = NCHAN_MSG_STACK;
   
   if(evcf == NULL) {
     evcf = &evcf_data;
@@ -201,9 +208,7 @@ ngx_int_t nchan_loc_conf_max_messages(nchan_loc_conf_t *cf) {
   return num;
 }
 
-static void nchan_publisher_body_handler(ngx_http_request_t *r);
-
-static ngx_int_t nchan_http_publisher_handler(ngx_http_request_t * r) {
+static ngx_int_t nchan_http_publisher_handler(ngx_http_request_t * r, void (*body_handler)(ngx_http_request_t *r)) {
   ngx_int_t                       rc;
   nchan_request_ctx_t            *ctx = ngx_http_get_module_ctx(r, ngx_nchan_module);
   
@@ -211,7 +216,7 @@ static ngx_int_t nchan_http_publisher_handler(ngx_http_request_t * r) {
   
   if(ctx) ctx->publisher_type = &publisher_name;
   
-  /* Instruct ngx_http_read_subscriber_request_body to store the request
+  /* Instruct ngx_http_read_client_request_body to store the request
      body entirely in a memory buffer or in a file */
   r->request_body_in_single_buf = 1;
   r->request_body_in_persistent_file = 1;
@@ -221,7 +226,7 @@ static ngx_int_t nchan_http_publisher_handler(ngx_http_request_t * r) {
   //don't buffer the request body --send it right on through
   //r->request_body_no_buffering = 1;
 
-  rc = ngx_http_read_client_request_body(r, nchan_publisher_body_handler);
+  rc = ngx_http_read_client_request_body(r, body_handler);
   if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
     return rc;
   }
@@ -233,11 +238,14 @@ ngx_int_t nchan_stub_status_handler(ngx_http_request_t *r) {
   ngx_chain_t          out;
   nchan_stub_status_t *stats;
   
-  float                shmem_used;
+  nchan_main_conf_t   *mcf = ngx_http_get_module_main_conf(r, ngx_nchan_module);
+  
+  float                shmem_used, shmem_max;
   
   char     *buf_fmt = "total published messages: %ui\n"
                       "stored messages: %ui\n"
                       "shared memory used: %fK\n"
+                      "shared memory limit: %fK\n"
                       "channels: %ui\n"
                       "subscribers: %ui\n"
                       "redis pending commands: %ui\n"
@@ -246,7 +254,8 @@ ngx_int_t nchan_stub_status_handler(ngx_http_request_t *r) {
                       "interprocess alerts in transit: %ui\n"
                       "interprocess queued alerts: %ui\n"
                       "total interprocess send delay: %ui\n"
-                      "total interprocess receive delay: %ui\n";
+                      "total interprocess receive delay: %ui\n"
+                      "nchan version: %s\n";
   
   if ((b = ngx_pcalloc(r->pool, sizeof(*b) + 800)) == NULL) {
     nchan_log_request_error(r, "Failed to allocate response buffer for nchan_stub_status.");
@@ -254,13 +263,14 @@ ngx_int_t nchan_stub_status_handler(ngx_http_request_t *r) {
   }
   
   shmem_used = (float )((float )nchan_get_used_shmem() / 1024.0);
+  shmem_max = (float )((float )mcf->shm_size / 1024.0);
   
   stats = nchan_get_stub_status_stats();
   
   b->start = (u_char *)&b[1];
   b->pos = b->start;
   
-  b->end = ngx_snprintf(b->start, 800, buf_fmt, stats->total_published_messages, stats->messages, shmem_used, stats->channels, stats->subscribers, stats->redis_pending_commands, stats->redis_connected_servers, stats->ipc_total_alerts_received, stats->ipc_total_alerts_sent - stats->ipc_total_alerts_received, stats->ipc_queue_size, stats->ipc_total_send_delay, stats->ipc_total_receive_delay);
+  b->end = ngx_snprintf(b->start, 800, buf_fmt, stats->total_published_messages, stats->messages, shmem_used, shmem_max, stats->channels, stats->subscribers, stats->redis_pending_commands, stats->redis_connected_servers, stats->ipc_total_alerts_received, stats->ipc_total_alerts_sent - stats->ipc_total_alerts_received, stats->ipc_queue_size, stats->ipc_total_send_delay, stats->ipc_total_receive_delay, NCHAN_VERSION);
   b->last = b->end;
 
   b->memory = 1;
@@ -336,6 +346,133 @@ int nchan_parse_message_buffer_config(ngx_http_request_t *r, nchan_loc_conf_t *c
   return 1;
 }
 
+static ngx_int_t group_handler_callback(ngx_int_t status, nchan_group_t *group, ngx_http_request_t *r) {
+  nchan_request_ctx_t    *ctx = ngx_http_get_module_ctx(r, ngx_nchan_module);
+  
+  if(!group) {
+    group = ngx_pcalloc(r->pool, sizeof(*group));
+  }
+  
+  if(!ctx->request_ran_content_handler) {
+    r->main->count--;
+    nchan_group_info(r, group);
+  }
+  else {
+    nchan_http_finalize_request(r, nchan_group_info(r, group));
+  }
+  
+  
+  
+  return NGX_OK;
+}
+
+
+static ngx_int_t parse_size_limit(u_char *data, size_t len) {
+  ngx_str_t  str;
+  str.data = data;
+  str.len = len;
+  return nchan_parse_size(&str);
+}
+
+static ngx_int_t set_group_num_limit(ngx_http_request_t *r, ngx_http_complex_value_t *cv, ngx_atomic_int_t *dst, ngx_int_t (*parsefunc)(u_char *, size_t), char *errstr) {
+  ngx_str_t               tmp;
+  ngx_int_t               num;
+  if(cv) {
+    ngx_http_complex_value(r, cv, &tmp);
+    if(tmp.len == 0) {
+      *dst = -1;
+      return 1;
+    }
+    else if((num = parsefunc(tmp.data, tmp.len)) == NGX_ERROR || num < 0) {
+      nchan_respond_cstring(r, NGX_HTTP_FORBIDDEN, &NCHAN_CONTENT_TYPE_TEXT_PLAIN, errstr, 0);
+      return 0;
+    }
+    *dst = num;
+  }
+  else {
+    *dst = -1;
+  }
+  return 1;
+}
+
+static ngx_int_t parse_group_limits(ngx_http_request_t *r, nchan_loc_conf_t *cf, nchan_group_limits_t *limits) {
+  set_group_num_limit(r, cf->group.max_channels, &limits->channels, ngx_atoi, "invalid nchan_group_max_channels value");
+  set_group_num_limit(r, cf->group.max_subscribers, &limits->subscribers, ngx_atoi, "invalid nchan_group_max_subscribers value");
+  set_group_num_limit(r, cf->group.max_messages, &limits->messages, ngx_atoi, "invalid nchan_group_max_messages value");
+  set_group_num_limit(r, cf->group.max_messages_shm_bytes, &limits->messages_shmem_bytes, parse_size_limit, "invalid nchan_group_max_messages_memory value");
+  set_group_num_limit(r, cf->group.max_messages_file_bytes, &limits->messages_file_bytes, parse_size_limit, "invalid nchan_group_max_messages_disk value");
+  
+  return r->headers_out.status != NGX_HTTP_FORBIDDEN ? NGX_OK : NGX_ERROR;
+}
+
+ngx_int_t nchan_group_handler(ngx_http_request_t *r) {
+  nchan_loc_conf_t       *cf = ngx_http_get_module_loc_conf(r, ngx_nchan_module);
+  nchan_request_ctx_t    *ctx;
+  ngx_int_t               rc = NGX_DONE;
+  ngx_str_t              *group;
+  
+  if((ctx = ngx_pcalloc(r->pool, sizeof(nchan_request_ctx_t))) == NULL) {
+    return NGX_HTTP_INTERNAL_SERVER_ERROR;
+  }
+  ngx_http_set_ctx(r, ctx, ngx_nchan_module);
+  
+  if(r->connection && (r->connection->read->eof || r->connection->read->pending_eof)) {
+    ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
+    return NGX_ERROR;
+  }
+  
+  if(!cf->group.enable_accounting) {
+    nchan_respond_cstring(r, NGX_HTTP_FORBIDDEN, &NCHAN_CONTENT_TYPE_TEXT_PLAIN, "Channel group accounting is disabled.", 0);
+    return NGX_OK;
+  }
+  
+  group = nchan_get_group_name(r, cf, ctx);
+  if(group == NULL) {
+    nchan_respond_cstring(r, NGX_HTTP_BAD_REQUEST, &NCHAN_CONTENT_TYPE_TEXT_PLAIN, "No group specified", 0);
+    return NGX_OK;
+  }
+  
+  switch(r->method) {
+    case NGX_HTTP_GET:
+      if(!cf->group.get) {
+        rc = nchan_respond_status(r, NGX_HTTP_FORBIDDEN, NULL, NULL, 0);
+      }
+      r->main->count++;
+      cf->storage_engine->get_group(group, cf, (callback_pt )group_handler_callback, r);
+      
+      break;
+      
+    case NGX_HTTP_POST:
+      if(!cf->group.set) {
+        rc = nchan_respond_status(r, NGX_HTTP_FORBIDDEN, NULL, NULL, 0);
+      }
+      
+      nchan_group_limits_t     limits;
+      
+      if(parse_group_limits(r, cf, &limits) != NGX_OK) {
+        return NGX_OK;
+      }
+      
+      r->main->count++;
+      cf->storage_engine->set_group_limits(group, cf, &limits, (callback_pt )group_handler_callback, r);
+      break;
+      
+    case NGX_HTTP_DELETE:
+      if(!cf->group.delete) {
+        rc = nchan_respond_status(r, NGX_HTTP_FORBIDDEN, NULL, NULL, 0);
+      }
+      r->main->count++;
+      cf->storage_engine->delete_group(group, cf, (callback_pt )group_handler_callback, r);
+      break;
+      
+    case NGX_HTTP_OPTIONS:
+        rc= nchan_OPTIONS_respond(r, &NCHAN_ACCESS_CONTROL_ALLOWED_GROUP_HEADERS, &NCHAN_ALLOW_GET_POST_DELETE);
+      break;
+  }
+  ctx->request_ran_content_handler = 1;
+  return rc;
+}
+
 ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r) {
   nchan_loc_conf_t       *cf = ngx_http_get_module_loc_conf(r, ngx_nchan_module);
   ngx_str_t              *channel_id;
@@ -343,47 +480,55 @@ ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r) {
   nchan_msg_id_t         *msg_id;
   ngx_int_t               rc = NGX_DONE;
   nchan_request_ctx_t    *ctx;
-  ngx_str_t              *origin_header;
+  nchan_group_limits_t    group_limits;
   
-#if NCHAN_BENCHMARK
-  struct timeval          tv;
-  ngx_gettimeofday(&tv);
-#endif
+  if(r->connection && (r->connection->read->eof || r->connection->read->pending_eof)) {
+    ngx_http_finalize_request(r, NGX_HTTP_CLIENT_CLOSED_REQUEST);
+    return NGX_ERROR;
+  }  
   
   if((ctx = ngx_pcalloc(r->pool, sizeof(nchan_request_ctx_t))) == NULL) {
     return NGX_HTTP_INTERNAL_SERVER_ERROR;
   }
   ngx_http_set_ctx(r, ctx, ngx_nchan_module);
 
-#if NCHAN_BENCHMARK
-  ctx->start_tv = tv;
-#endif
-  
   //X-Accel-Redirected requests get their method mangled to GET. De-mangle it if necessary
   if(r->upstream && r->upstream->headers_in.x_accel_redirect) {
     //yep, we got x-accel-redirected. what was the original method?...
     nchan_recover_x_accel_redirected_request_method(r);
   }
   
-  if((origin_header = nchan_get_header_value(r, NCHAN_HEADER_ORIGIN)) != NULL) {
-    ctx->request_origin_header = *origin_header;
-    if(!(cf->allow_origin.len == 1 && cf->allow_origin.data[0] == '*')) {
-      if(!(origin_header->len == cf->allow_origin.len && ngx_strnstr(origin_header->data, (char *)cf->allow_origin.data, origin_header->len) != NULL)) {
-        //CORS origin match failed! return a 403 forbidden
-        goto forbidden;
-      }
-    }
+  if(!nchan_match_origin_header(r, cf, ctx)) {
+    goto forbidden;
+  }
+  
+  if((msg_id = nchan_subscriber_get_msg_id(r)) == NULL) {
+    goto bad_msgid;
+  }
+  
+  if(parse_group_limits(r, cf, &group_limits) == NGX_OK) {
+    // unless the group already exists, these limits may only be set after this incoming request.
+    // TODO: fix this, although that will lead to even gnarlier control flow.
+    cf->storage_engine->set_group_limits(nchan_get_group_name(r, cf, ctx), cf, &group_limits, NULL, NULL);
   }
   else {
-    ctx->request_origin_header.len=0;
-    ctx->request_origin_header.data=NULL;
+    // there waas an error parsing group limit strings, and it has already been sent in the response. 
+    // just quit.
+    return NGX_OK;
   }
   
-  if((channel_id = nchan_get_channel_id(r, SUB, 1)) == NULL) {
-    //just get the subscriber_channel_id for now. the publisher one is handled elsewhere
-    return r->headers_out.status ? NGX_OK : NGX_HTTP_INTERNAL_SERVER_ERROR;
+  if(cf->redis.enabled && !nchan_store_redis_ready(cf)) {
+    //using redis, and it's not ready yet
+    if(r->method == NGX_HTTP_POST || r->method == NGX_HTTP_PUT) {
+      //discard request body before responding
+      nchan_http_publisher_handler(r, nchan_publisher_unavailable_body_handler);
+    }
+    else {
+      nchan_respond_status(r, NGX_HTTP_SERVICE_UNAVAILABLE, NULL, NULL, 0);
+    }
+    return NGX_OK;
   }
-
+  
   if(cf->pub.websocket || cf->pub.http) {
     char *err;
     if(!nchan_parse_message_buffer_config(r, cf, &err)) {
@@ -392,7 +537,7 @@ ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r) {
         return NGX_OK;
       }
       else {
-        nchan_respond_status(r, NGX_HTTP_INTERNAL_SERVER_ERROR, NULL, 0);
+        nchan_respond_status(r, NGX_HTTP_INTERNAL_SERVER_ERROR, NULL, NULL, 0);
         return NGX_OK;
       }
     }
@@ -402,6 +547,10 @@ ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r) {
     //want websocket?
     if(cf->sub.websocket) {
       //we prefer to subscribe
+      if((channel_id = nchan_get_channel_id(r, SUB, 1)) == NULL) {
+        return r->headers_out.status ? NGX_OK : NGX_HTTP_INTERNAL_SERVER_ERROR;
+      }
+      
 #if FAKESHARD
       memstore_sub_debug_start();
 #endif
@@ -412,7 +561,9 @@ ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r) {
         nchan_log_request_error(r, "unable to create websocket subscriber");
         return NGX_HTTP_INTERNAL_SERVER_ERROR;
       }
-      sub->fn->subscribe(sub, channel_id);
+      if(sub->fn->subscribe(sub, channel_id) != NGX_OK) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+      }
 #if FAKESHARD      
       memstore_sub_debug_end();
 #endif
@@ -448,25 +599,31 @@ ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r) {
           sub_create = longpoll_subscriber_create;
         }
         else if(cf->pub.http) {
-          nchan_http_publisher_handler(r);
+          nchan_http_publisher_handler(r, nchan_publisher_body_handler);
         }
         else {
           goto forbidden;
         }
         
         if(sub_create) {
+          if((channel_id = nchan_get_channel_id(r, SUB, 1)) == NULL) {
+            return r->headers_out.status ? NGX_OK : NGX_HTTP_INTERNAL_SERVER_ERROR;
+          }
 #if FAKESHARD
           memstore_sub_debug_start();
 #endif
           if((msg_id = nchan_subscriber_get_msg_id(r)) == NULL) {
             goto bad_msgid;
           }
+          
           if((sub = sub_create(r, msg_id)) == NULL) {
             nchan_log_request_error(r, "unable to create subscriber");
             return NGX_HTTP_INTERNAL_SERVER_ERROR;
           }
           
-          sub->fn->subscribe(sub, channel_id);
+          if(sub->fn->subscribe(sub, channel_id) != NGX_OK) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+          }
 #if FAKESHARD
           memstore_sub_debug_end();
 #endif
@@ -477,24 +634,27 @@ ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r) {
       case NGX_HTTP_POST:
       case NGX_HTTP_PUT:
         if(cf->pub.http) {
-          nchan_http_publisher_handler(r);
+          nchan_http_publisher_handler(r, nchan_publisher_body_handler);
         }
         else goto forbidden;
         break;
       
       case NGX_HTTP_DELETE:
         if(cf->pub.http) {
-          nchan_http_publisher_handler(r);
+          nchan_http_publisher_handler(r, nchan_publisher_body_handler);
         }
         else goto forbidden;
         break;
       
       case NGX_HTTP_OPTIONS:
-        if(cf->pub.http) {
-          nchan_OPTIONS_respond(r, &cf->allow_origin, &NCHAN_ACCESS_CONTROL_ALLOWED_PUBLISHER_HEADERS, &NCHAN_ALLOW_GET_POST_PUT_DELETE);
+        if(cf->pub.http && (cf->sub.poll || cf->sub.longpoll || cf->sub.eventsource || cf->sub.websocket)) {
+          nchan_OPTIONS_respond(r, &NCHAN_ACCESS_CONTROL_ALLOWED_PUBSUB_HEADERS, &NCHAN_ALLOW_GET_POST_PUT_DELETE);
+        }
+        else if(cf->pub.http) {
+          nchan_OPTIONS_respond(r, &NCHAN_ACCESS_CONTROL_ALLOWED_PUBLISHER_HEADERS, &NCHAN_ALLOW_GET_POST_PUT_DELETE);
         }
         else if(cf->sub.poll || cf->sub.longpoll || cf->sub.eventsource || cf->sub.websocket) {
-          nchan_OPTIONS_respond(r, &cf->allow_origin, &NCHAN_ACCESS_CONTROL_ALLOWED_SUBSCRIBER_HEADERS, &NCHAN_ALLOW_GET);
+          nchan_OPTIONS_respond(r, &NCHAN_ACCESS_CONTROL_ALLOWED_SUBSCRIBER_HEADERS, &NCHAN_ALLOW_GET);
         }
         else goto forbidden;
         break;
@@ -504,7 +664,7 @@ ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r) {
   return rc;
   
 forbidden:
-  nchan_respond_status(r, NGX_HTTP_FORBIDDEN, NULL, 0);
+  nchan_respond_status(r, NGX_HTTP_FORBIDDEN, NULL, NULL, 0);
   ctx->request_ran_content_handler = 1;
   return NGX_OK;
 
@@ -520,7 +680,12 @@ static ngx_int_t channel_info_callback(ngx_int_t status, void *rptr, void *pd) {
   if(r == NULL) {
     return NGX_ERROR;
   }
-  nchan_http_finalize_request(r, nchan_response_channel_ptr_info( (nchan_channel_t *)rptr, r, 0));
+  if(status>=500 && status <= 599) {
+    nchan_http_finalize_request(r, status);
+  }
+  else {
+    nchan_http_finalize_request(r, nchan_response_channel_ptr_info( (nchan_channel_t *)rptr, r, 0));
+  }
   return NGX_OK;
 }
 
@@ -567,9 +732,10 @@ static ngx_http_request_t *nchan_get_safe_request_ptr(safe_request_ptr_t *d) {
 }
 
 
-static ngx_int_t publish_callback(ngx_int_t status, nchan_channel_t *ch, safe_request_ptr_t *pd) {
+static ngx_int_t publish_callback(ngx_int_t status, void *data, safe_request_ptr_t *pd) {
   nchan_request_ctx_t   *ctx;
   static nchan_msg_id_t  empty_msgid = NCHAN_ZERO_MSGID;
+  nchan_channel_t       *ch = data;
   
   ngx_http_request_t    *r = nchan_get_safe_request_ptr(pd);
   
@@ -599,19 +765,34 @@ static ngx_int_t publish_callback(ngx_int_t status, nchan_channel_t *ch, safe_re
       return NGX_OK;
       
     case NGX_ERROR:
+      status = NGX_HTTP_INTERNAL_SERVER_ERROR;
+      /*fallthrough*/
+    case NGX_HTTP_INSUFFICIENT_STORAGE:
     case NGX_HTTP_INTERNAL_SERVER_ERROR:
+    case NGX_HTTP_SERVICE_UNAVAILABLE:
       //WTF?
-      nchan_log_request_error(r, "error publishing message");
-      ctx->prev_msg_id = empty_msgid;;
+      nchan_log_request_error(r, "error publishing message (HTTP status code %i)", status);
+      ctx->prev_msg_id = empty_msgid;
       ctx->msg_id = empty_msgid;
-      nchan_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
+      nchan_http_finalize_request(r, status);
       return NGX_ERROR;
       
+    case NGX_HTTP_FORBIDDEN:
+      ctx->prev_msg_id = empty_msgid;
+      ctx->msg_id = empty_msgid;
+      if(data) {
+        nchan_respond_cstring(r, NGX_HTTP_FORBIDDEN, &NCHAN_CONTENT_TYPE_TEXT_PLAIN, (char *)data, 1);
+      }
+      else {
+        nchan_http_finalize_request(r, NGX_HTTP_FORBIDDEN);
+      }
+      return NGX_OK;
+      
     default:
       //for debugging, mostly. I don't expect this branch to behit during regular operation
       ctx->prev_msg_id = empty_msgid;;
       ctx->msg_id = empty_msgid;
-      nchan_log_request_error(r, "TOTALLY UNEXPECTED error publishing message, status code %i", status);
+      nchan_log_request_error(r, "TOTALLY UNEXPECTED error publishing message (HTTP status code %i)", status);
       nchan_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
       return NGX_ERROR;
   }
@@ -619,7 +800,6 @@ static ngx_int_t publish_callback(ngx_int_t status, nchan_channel_t *ch, safe_re
 
 static void nchan_publisher_post_request(ngx_http_request_t *r, ngx_str_t *content_type, size_t content_length, ngx_chain_t *request_body_chain, ngx_str_t *channel_id, nchan_loc_conf_t *cf) {
   ngx_buf_t                      *buf;
-  struct timeval                  tv;
   nchan_msg_t                    *msg;
   ngx_str_t                      *eventsource_event;
   
@@ -633,19 +813,19 @@ static void nchan_publisher_post_request(ngx_http_request_t *r, ngx_str_t *conte
     nchan_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
     return; 
   }
-  msg->shared = 0;
+  msg->storage = NCHAN_MSG_POOL;
   
   
   if(cf->eventsource_event.len > 0) {
-    msg->eventsource_event = cf->eventsource_event;
+    msg->eventsource_event = &cf->eventsource_event;
   }
   else if((eventsource_event = nchan_get_header_value(r, NCHAN_HEADER_EVENTSOURCE_EVENT)) != NULL) {
-    msg->eventsource_event = *eventsource_event;
+    msg->eventsource_event = eventsource_event;
   }
   
   //content type
   if(content_type) {
-    msg->content_type = *content_type;
+    msg->content_type = content_type;
   }
   
   if(content_length == 0) {
@@ -660,22 +840,16 @@ static void nchan_publisher_post_request(ngx_http_request_t *r, ngx_str_t *conte
     return;
   }
   
-  ngx_gettimeofday(&tv);
-  msg->id.time = tv.tv_sec;
+  msg->id.time = 0;
   msg->id.tag.fixed[0] = 0;
   msg->id.tagactive = 0;
   msg->id.tagcount = 1;
   
-  msg->buf = buf;
+  msg->buf = *buf;
 #if NCHAN_MSG_LEAK_DEBUG
   msg->lbl = r->uri;
 #endif
-#if NCHAN_BENCHMARK
-  nchan_request_ctx_t            *ctx = ngx_http_get_module_ctx(r, ngx_nchan_module);
-  msg->start_tv = ctx->start_tv;
-#endif
-  
-  
+  nchan_deflate_message_if_needed(msg, cf, r, r->pool);
   if((pd = nchan_set_safe_request_ptr(r)) == NULL) {
     return;
   }
@@ -715,7 +889,11 @@ static ngx_int_t nchan_publisher_upstream_handler(ngx_http_request_t *sr, void *
         if(sr->upstream) {
           content_type = (sr->upstream->headers_in.content_type ? &sr->upstream->headers_in.content_type->value : NULL);
           content_length = nchan_subrequest_content_length(sr);
+#if nginx_version >= 1013010
+          request_chain = sr->out;
+#else
           request_chain = sr->upstream->out_bufs;
+#endif
         }
         else {
           content_type = NULL;
@@ -793,7 +971,8 @@ static void nchan_publisher_body_handler_continued(ngx_http_request_t *r, ngx_st
         psrd->ch_id = channel_id;
         
         ngx_http_subrequest(r, &publisher_upstream_request_url, NULL, &sr, psr, NGX_HTTP_SUBREQUEST_IN_MEMORY);
-        nchan_adjust_subrequest(sr, NGX_HTTP_POST, &POST_REQUEST_STRING, r->request_body, r->headers_in.content_length_n, NULL);
+        nchan_adjust_subrequest(sr, NGX_HTTP_POST, &POST_REQUEST_STRING, r->request_body, r->headers_in.content_length_n);
+        sr->args = r->args;
       }
       break;
       
@@ -806,7 +985,7 @@ static void nchan_publisher_body_handler_continued(ngx_http_request_t *r, ngx_st
       break;
       
     default: 
-      nchan_respond_status(r, NGX_HTTP_FORBIDDEN, NULL, 0);
+      nchan_respond_status(r, NGX_HTTP_FORBIDDEN, NULL, NULL, 0);
   }
   
 }
@@ -841,6 +1020,11 @@ static ngx_int_t nchan_publisher_body_authorize_handler(ngx_http_request_t *r, v
   return NGX_OK;
 }
 
+static void nchan_publisher_unavailable_body_handler(ngx_http_request_t *r) {
+  nchan_http_finalize_request(r, NGX_HTTP_SERVICE_UNAVAILABLE);
+  return;
+}
+
 static void nchan_publisher_body_handler(ngx_http_request_t *r) {
   ngx_str_t                      *channel_id;
   nchan_loc_conf_t               *cf = ngx_http_get_module_loc_conf(r, ngx_nchan_module);
@@ -902,72 +1086,22 @@ static void nchan_publisher_body_handler(ngx_http_request_t *r) {
   }
 }
 
-#if NCHAN_BENCHMARK
-int nchan_timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y) {
-  /* Perform the carry for the later subtraction by updating y. */
-  if (x->tv_usec < y->tv_usec) {
-    int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
-    y->tv_usec -= 1000000 * nsec;
-    y->tv_sec += nsec;
-  }
-  if (x->tv_usec - y->tv_usec > 1000000) {
-    int nsec = (x->tv_usec - y->tv_usec) / 1000000;
-    y->tv_usec += 1000000 * nsec;
-    y->tv_sec -= nsec;
-  }
-
-  /* Compute the time remaining to wait.
-     tv_usec is certainly positive. */
-  result->tv_sec = x->tv_sec - y->tv_sec;
-  result->tv_usec = x->tv_usec - y->tv_usec;
-
-  /* Return 1 if result is negative. */
-  return x->tv_sec < y->tv_sec;
-}
-#endif
-
-
-#if NCHAN_SUBSCRIBER_LEAK_DEBUG
-
-subscriber_t *subdebug_head = NULL;
-
-void subscriber_debug_add(subscriber_t *sub) {
-  if(subdebug_head == NULL) {
-    sub->dbg_next = NULL;
-    sub->dbg_prev = NULL;
-  }
-  else {
-    sub->dbg_next = subdebug_head;
-    sub->dbg_prev = NULL;
-    assert(subdebug_head->dbg_prev == NULL);
-    subdebug_head->dbg_prev = sub;
-  }
-  subdebug_head = sub;
-}
-void subscriber_debug_remove(subscriber_t *sub) {
-  subscriber_t *prev, *next;
-  prev = sub->dbg_prev;
-  next = sub->dbg_next;
-  if(subdebug_head == sub) {
-    assert(sub->dbg_prev == NULL);
-    if(next) {
-      next->dbg_prev = NULL;
-    }
-    subdebug_head = next;
+ngx_int_t nchan_benchmark_handler(ngx_http_request_t *r) {
+  nchan_request_ctx_t    *ctx;
+  
+  if(r->connection && (r->connection->read->eof || r->connection->read->pending_eof)) {
+    return NGX_HTTP_INTERNAL_SERVER_ERROR;
   }
-  else {
-    if(prev) {
-      prev->dbg_next = next;
-    }
-    if(next) {
-      next->dbg_prev = prev;
-    }
+  if((ctx = ngx_pcalloc(r->pool, sizeof(nchan_request_ctx_t))) == NULL) {
+    return NGX_HTTP_INTERNAL_SERVER_ERROR;
   }
+  ngx_http_set_ctx(r, ctx, ngx_nchan_module);
   
-  sub->dbg_next = NULL;
-  sub->dbg_prev = NULL;
-}
-void subscriber_debug_assert_isempty(void) {
-  assert(subdebug_head == NULL);
+  return nchan_benchmark_ws_initialize(r);
+  
+  /*
+  ctx->bcp = ngx_palloc(r->pool, sizeof(nchan_bufchain_pool_t));
+  nchan_bufchain_pool_init(ctx->bcp, r->pool);
+  return nchan_benchmark_initialize(r);
+  */
 }
-#endif
diff --git a/debian/modules/nchan/src/nchan_module.h b/debian/modules/nchan/src/nchan_module.h
index 8c1aafb..b337e54 100644
--- a/debian/modules/nchan/src/nchan_module.h
+++ b/debian/modules/nchan/src/nchan_module.h
@@ -3,17 +3,17 @@
 //#define NCHAN_SUBSCRIBER_LEAK_DEBUG 1
 //#define NCHAN_MSG_RESERVE_DEBUG 1
 //#define NCHAN_MSG_LEAK_DEBUG 1
-//#define NCHAN_BENCHMARK 1
 
 //debugging config
 //#define FAKESHARD 1
+//#define FAKE_SHMEM 1
 #if FAKESHARD
 //#define PUB_FAKE_WORKER 0
 //#define SUB_FAKE_WORKER 1
 //#define ONE_FAKE_CHANNEL_OWNER 2
 #define MAX_FAKE_WORKERS 5
 #endif
-
+#include <nchan_version.h>
 #include <ngx_http.h>
 
 //building for old versions
@@ -30,9 +30,10 @@
 #include <nchan_defs.h>
 #include <util/nchan_util.h>
 #include <util/nchan_channel_id.h>
-#include <util/nchan_channel_info.h>
-#include <util/nchan_msgid.h>
+#include <util/nchan_output_info.h>
+#include <util/nchan_msg.h>
 #include <util/nchan_output.h>
+#include <util/nchan_debug.h>
 
 extern ngx_pool_t *nchan_pool;
 extern ngx_int_t nchan_worker_processes;
@@ -43,7 +44,8 @@ extern int nchan_stub_status_enabled;
 
 ngx_int_t nchan_stub_status_handler(ngx_http_request_t *r);
 ngx_int_t nchan_pubsub_handler(ngx_http_request_t *r);
-ngx_buf_t *nchan_channel_info_buf(ngx_str_t *accept_header, ngx_uint_t messages, ngx_uint_t subscribers, time_t last_seen, nchan_msg_id_t *last_msgid, ngx_str_t **generated_content_type);
+ngx_int_t nchan_group_handler(ngx_http_request_t *r);
+ngx_int_t nchan_benchmark_handler(ngx_http_request_t *r);
 
 time_t nchan_loc_conf_message_timeout(nchan_loc_conf_t *cf);
 ngx_int_t nchan_loc_conf_max_messages(nchan_loc_conf_t *cf);
@@ -55,23 +57,13 @@ void __memstore_update_stub_status(off_t offset, int count);
 nchan_stub_status_t *nchan_get_stub_status_stats(void);
 size_t nchan_get_used_shmem(void);
 
-#if NCHAN_SUBSCRIBER_LEAK_DEBUG
-void subscriber_debug_add(subscriber_t *);
-void subscriber_debug_remove(subscriber_t *);
-void subscriber_debug_assert_isempty(void);
-#endif
-
-#if NCHAN_BENCHMARK
-int nchan_timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y);
-#endif
-
-#define nchan_log_notice(fmt, args...)  ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0, "nchan: " fmt, ##args)
-#define nchan_log_warning(fmt, args...) ngx_log_error(NGX_LOG_WARN,   ngx_cycle->log, 0, "nchan: " fmt, ##args)
-#define nchan_log_error(fmt, args...)   ngx_log_error(NGX_LOG_ERR,    ngx_cycle->log, 0, "nchan: " fmt, ##args)
-#define nchan_log_request_warning(request, fmt, args...) ngx_log_error(NGX_LOG_WARN, (request)->connection->log, 0, "nchan: " fmt, ##args)
-#define nchan_log_request_error(request, fmt, args...)    ngx_log_error(NGX_LOG_ERR, (request)->connection->log, 0, "nchan: " fmt, ##args)
-
 #define nchan_log(level, log, errno, fmt, args...) ngx_log_error(level, log, errno, "nchan: " fmt, ##args)
+#define nchan_log_notice(fmt, args...) nchan_log(NGX_LOG_NOTICE, ngx_cycle->log, 0, fmt, ##args)
+#define nchan_log_warning(fmt, args...) nchan_log(NGX_LOG_WARN, ngx_cycle->log, 0, fmt, ##args)
+#define nchan_log_error(fmt, args...) nchan_log(NGX_LOG_ERR, ngx_cycle->log, 0, fmt, ##args)
+#define nchan_log_ooshm_error(fmt, args...) nchan_log(NGX_LOG_ERR, ngx_cycle->log, 0, "Out of shared memory while " fmt ". Increase nchan_max_reserved_memory.", ##args)
 
+#define nchan_log_request_warning(request, fmt, args...) ngx_log_error(NGX_LOG_WARN, (request)->connection->log, 0, "nchan: " fmt, ##args)
+#define nchan_log_request_error(request, fmt, args...)    ngx_log_error(NGX_LOG_ERR, ((request) ? (request)->connection->log : ngx_cycle->log), 0, "nchan: " fmt, ##args)
 
 #endif /*NCHAN_MODULE_H*/
diff --git a/debian/modules/nchan/src/nchan_setup.c b/debian/modules/nchan/src/nchan_setup.c
index e083e31..8d416a0 100644
--- a/debian/modules/nchan/src/nchan_setup.c
+++ b/debian/modules/nchan/src/nchan_setup.c
@@ -4,20 +4,46 @@
 #include <nchan_variables.h>
 #include <store/memory/store.h>
 #include <store/redis/store.h>
+#if (NGX_ZLIB)
+#include <zlib.h>
+#endif
 
 static ngx_str_t      DEFAULT_CHANNEL_EVENT_STRING = ngx_string("$nchan_channel_event $nchan_channel_id");
 
 nchan_store_t   *default_storage_engine = &nchan_store_memory;
+ngx_flag_t       global_nchan_enabled = 0;
 ngx_flag_t       global_redis_enabled = 0;
+ngx_flag_t       global_zstream_needed = 0;
+ngx_flag_t       global_benchmark_enabled = 0;
+void            *global_owner_cycle = NULL;
+
+#define MERGE_UNSET_CONF(conf, prev, unset, default)         \
+if (conf == unset) {                                         \
+  conf = (prev == unset) ? default : prev;                   \
+}
 
 #define MERGE_CONF(cf, prev_cf, name) if((cf)->name == NULL) { (cf)->name = (prev_cf)->name; }
 
 static ngx_int_t nchan_init_module(ngx_cycle_t *cycle) {
-  ngx_core_conf_t                *ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
+  if(global_owner_cycle && global_owner_cycle != ngx_cycle) {
+    global_nchan_enabled = 0;
+    global_redis_enabled = 0;
+    global_zstream_needed = 0;
+    global_benchmark_enabled = 0;
+  }
+  global_owner_cycle = (void *)ngx_cycle;
+  
+  if(!global_nchan_enabled) {
+    return NGX_OK;
+  }
+  ngx_core_conf_t         *ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
   nchan_worker_processes = ccf->worker_processes;
   
   //initialize storage engines
   nchan_store_memory.init_module(cycle);
+  if(global_benchmark_enabled) {
+    nchan_benchmark_init_module(cycle);
+  }
   if(global_redis_enabled) {
     nchan_store_redis.init_module(cycle);
   }
@@ -25,6 +51,9 @@ static ngx_int_t nchan_init_module(ngx_cycle_t *cycle) {
 }
 
 static ngx_int_t nchan_init_worker(ngx_cycle_t *cycle) {
+  if(!global_nchan_enabled) {
+    return NGX_OK;
+  }
   if (ngx_process != NGX_PROCESS_WORKER && ngx_process != NGX_PROCESS_SINGLE) {
     //not a worker, stop initializing stuff.
     return NGX_OK;
@@ -33,6 +62,9 @@ static ngx_int_t nchan_init_worker(ngx_cycle_t *cycle) {
   if(nchan_store_memory.init_worker(cycle)!=NGX_OK) {
     return NGX_ERROR;
   }
+  if(global_benchmark_enabled) {
+    nchan_benchmark_init_worker(cycle);
+  }
   
   if(global_redis_enabled && nchan_store_redis.init_worker(cycle)!=NGX_OK) {
     return NGX_ERROR;
@@ -44,13 +76,30 @@ static ngx_int_t nchan_init_worker(ngx_cycle_t *cycle) {
   return NGX_OK;
 }
 
+static ngx_int_t nchan_preconfig(ngx_conf_t *cf) {
+  global_owner_cycle = (void *)ngx_cycle;
+  global_nchan_enabled = 0;
+  return nchan_add_variables(cf);
+}
+
 static ngx_int_t nchan_postconfig(ngx_conf_t *cf) {
+  global_owner_cycle = (void *)ngx_cycle;
   if(nchan_store_memory.init_postconfig(cf)!=NGX_OK) {
     return NGX_ERROR;
   }
   if(global_redis_enabled && nchan_store_redis.init_postconfig(cf)!=NGX_OK) {
     return NGX_ERROR;
   }
+  
+#if (NGX_ZLIB)
+  if(global_zstream_needed) {
+    nchan_main_conf_t  *mcf = ngx_http_conf_get_module_main_conf(cf, ngx_nchan_module);
+    nchan_common_deflate_init(mcf);
+  }
+#endif
+  
+  global_nchan_enabled = 1;
+  
   return NGX_OK;
 }
 
@@ -60,12 +109,45 @@ static void * nchan_create_main_conf(ngx_conf_t *cf) {
   if(mcf == NULL) {
     return NGX_CONF_ERROR;
   }
+  
+  static ngx_path_init_t nchan_temp_path = { ngx_string(NGX_HTTP_CLIENT_TEMP_PATH), { 0, 0, 0 } };
+  ngx_conf_merge_path_value(cf, &mcf->message_temp_path, NULL, &nchan_temp_path);
+  
   nchan_store_memory.create_main_conf(cf, mcf);
   nchan_store_redis.create_main_conf(cf, mcf);
   
+#if (NGX_ZLIB)
+  mcf->zlib_params.level = Z_DEFAULT_COMPRESSION;
+  mcf->zlib_params.windowBits = 10;
+  mcf->zlib_params.memLevel = 8;
+  mcf->zlib_params.strategy = Z_DEFAULT_STRATEGY;
+#endif
+  
   return mcf;
 }
 
+static void *nchan_create_srv_conf(ngx_conf_t *cf) {
+  nchan_srv_conf_t       *scf = ngx_pcalloc(cf->pool, sizeof(*scf));
+  if(scf == NULL) {
+    return NGX_CONF_ERROR;
+  }
+  scf->redis.connect_timeout = NGX_CONF_UNSET_MSEC;
+  scf->redis.optimize_target = NCHAN_REDIS_OPTIMIZE_UNSET;
+  scf->redis.master_weight = NGX_CONF_UNSET;
+  scf->redis.slave_weight = NGX_CONF_UNSET;
+  scf->upstream_nchan_loc_conf = NULL;
+  return scf;
+}
+
+static char *nchan_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child) {
+  nchan_srv_conf_t       *prev = parent, *conf = child;
+  ngx_conf_merge_msec_value(conf->redis.connect_timeout, prev->redis.connect_timeout, NCHAN_DEFAULT_REDIS_NODE_CONNECT_TIMEOUT_MSEC);
+  MERGE_UNSET_CONF(conf->redis.optimize_target, prev->redis.optimize_target, NCHAN_REDIS_OPTIMIZE_UNSET, NCHAN_REDIS_OPTIMIZE_CPU);
+  ngx_conf_merge_value(conf->redis.master_weight, prev->redis.master_weight, 1);
+  ngx_conf_merge_value(conf->redis.slave_weight, prev->redis.slave_weight, 1);
+  return NGX_CONF_OK;
+}
+
 //location config stuff
 static void *nchan_create_loc_conf(ngx_conf_t *cf) {
   nchan_loc_conf_t       *lcf = ngx_pcalloc(cf->pool, sizeof(*lcf));
@@ -82,12 +164,16 @@ static void *nchan_create_loc_conf(ngx_conf_t *cf) {
   lcf->sub.websocket=0;
   lcf->sub.http_chunked=0;
   
+  // lcf->group is already zeroed
+  lcf->group.enable_accounting = NGX_CONF_UNSET;
+  
   lcf->shared_data_index=NGX_CONF_UNSET;
   
   lcf->authorize_request_url = NULL;
   lcf->publisher_upstream_request_url = NULL;
   lcf->unsubscribe_request_url = NULL;
   lcf->subscribe_request_url = NULL;
+  lcf->channel_group = NULL;
   
   lcf->message_timeout=NGX_CONF_UNSET;
   lcf->max_messages=NGX_CONF_UNSET;
@@ -107,11 +193,19 @@ static void *nchan_create_loc_conf(ngx_conf_t *cf) {
   
   lcf->websocket_ping_interval=NGX_CONF_UNSET;
   
+  lcf->eventsource_ping.interval=NGX_CONF_UNSET;
+  
   lcf->msg_in_etag_only = NGX_CONF_UNSET;
   
+  lcf->allow_origin = NULL;
+  lcf->allow_credentials = NGX_CONF_UNSET;
+  
   lcf->channel_events_channel_id = NULL;
   lcf->channel_event_string = NULL;
   
+  lcf->websocket_heartbeat.enabled=NGX_CONF_UNSET;
+  
+  lcf->message_compression = NCHAN_MSG_COMPRESSION_INVALID;
   
   lcf->longpoll_multimsg=NGX_CONF_UNSET;
   lcf->longpoll_multimsg_use_raw_stream_separator=NGX_CONF_UNSET;
@@ -125,7 +219,20 @@ static void *nchan_create_loc_conf(ngx_conf_t *cf) {
   lcf->redis.url_enabled=NGX_CONF_UNSET;
   lcf->redis.ping_interval = NGX_CONF_UNSET;
   lcf->redis.upstream_inheritable=NGX_CONF_UNSET;
-  
+  lcf->redis.storage_mode = REDIS_MODE_CONF_UNSET;
+  lcf->redis.nostore_fastpublish = NGX_CONF_UNSET;
+  lcf->redis.privdata = NULL;
+  lcf->redis.nodeset = NULL;
+  
+  lcf->request_handler = NULL;
+  
+  lcf->benchmark.time = NGX_CONF_UNSET;
+  lcf->benchmark.msgs_per_minute = NGX_CONF_UNSET;
+  lcf->benchmark.msg_padding = NGX_CONF_UNSET;
+  lcf->benchmark.channels = NGX_CONF_UNSET;
+  lcf->benchmark.subscribers_per_channel = NGX_CONF_UNSET;
+  lcf->benchmark.subscriber_distribution = NCHAN_BENCHMARK_SUBSCRIBER_DISTRIBUTION_UNSET;
+  lcf->benchmark.publisher_distribution = NCHAN_BENCHMARK_PUBLISHER_DISTRIBUTION_UNSET;
   return lcf;
 }
 
@@ -153,6 +260,36 @@ static char * create_complex_value_from_ngx_str(ngx_conf_t *cf, ngx_http_complex
   return NGX_CONF_OK;
 }
 
+static int is_pub_location(nchan_loc_conf_t *lcf) {
+  return lcf->pub.http || lcf->pub.websocket;
+}
+static int is_sub_location(nchan_loc_conf_t *lcf) {
+  nchan_conf_subscriber_types_t s = lcf->sub;
+  return s.poll || s.http_raw_stream || s.longpoll || s.http_chunked || s.http_multipart || s.eventsource || s.websocket;
+}
+static int is_group_location(nchan_loc_conf_t *lcf) {
+  return lcf->group.get || lcf->group.set || lcf->group.delete;
+}
+
+static int is_valid_location(ngx_conf_t *cf, nchan_loc_conf_t *lcf) {
+  
+  if(is_group_location(lcf)) {
+    if(is_pub_location(lcf) && is_sub_location(lcf)) {
+      ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "Can't have a publisher and subscriber location and also be a group access location (nchan_group + nchan_publisher, nchan_subscriber or nchan_pubsub)");
+      return 0;
+    }
+    else if(is_pub_location(lcf)) {
+      ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "Can't have a publisher location and also be a group access location (nchan_group + nchan_publisher)");
+      return 0;
+    }
+    else if(is_sub_location(lcf)) {
+      ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "Can't have a subscriber location and also be a group access location (nchan_group + nchan_subscriber)");
+      return 0;
+    }
+  }
+  return 1;
+}
+
 static char *ngx_conf_set_redis_upstream(ngx_conf_t *cf, ngx_str_t *url, void *conf) {  
   ngx_url_t             upstream_url;
   nchan_loc_conf_t     *lcf = conf;
@@ -170,14 +307,43 @@ static char *ngx_conf_set_redis_upstream(ngx_conf_t *cf, ngx_str_t *url, void *c
   
   lcf->redis.enabled = 1;
   global_redis_enabled = 1;
-  nchan_store_redis_add_server_conf(cf, &lcf->redis, lcf);
+  nchan_store_redis_add_active_loc_conf(cf, lcf);
+  
+  return NGX_CONF_OK;
+}
+
+static char *nchan_setup_handler(ngx_conf_t *cf, ngx_int_t (*handler)(ngx_http_request_t *)) {
+  ngx_http_core_loc_conf_t       *clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+  //nchan_loc_conf_t               *plcf = conf;
+  clcf->handler = handler;
+  clcf->if_modified_since = NGX_HTTP_IMS_OFF;
   
   return NGX_CONF_OK;
 }
 
+static nchan_loc_conf_t *nchan_loc_conf_get_upstream_lcf(nchan_loc_conf_t *conf, nchan_loc_conf_t *prev) {
+  nchan_redis_conf_t *rcf = &conf->redis, *prev_rcf = &prev->redis;
+  if(rcf->upstream == prev_rcf->upstream || rcf->upstream == NULL) {
+    //same or no upstream, so don't bother
+    return NULL;
+  }
+  else {
+    assert(rcf->upstream);
+    nchan_srv_conf_t      *upstream_scf = ngx_http_conf_upstream_srv_conf(rcf->upstream, ngx_nchan_module);
+    if(upstream_scf && upstream_scf->upstream_nchan_loc_conf) {
+      return upstream_scf->upstream_nchan_loc_conf;
+    }
+    else {
+      //ngx_conf_log_error(NGX_LOG_WARN, cf, 0, "nchan upstream srv_conf loc_conf ptr is null");
+      return NULL;
+    }
+  }
+}
+
+
 static char * nchan_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) {
   nchan_loc_conf_t       *prev = parent, *conf = child;
-  
+  nchan_loc_conf_t       *up = nchan_loc_conf_get_upstream_lcf(conf, prev);
   //publisher types
   ngx_conf_merge_bitmask_value(conf->pub.http, prev->pub.http, 0);
   ngx_conf_merge_bitmask_value(conf->pub.websocket, prev->pub.websocket, 0);
@@ -189,6 +355,20 @@ static char * nchan_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) {
   ngx_conf_merge_bitmask_value(conf->sub.http_chunked, prev->sub.http_chunked, 0);
   ngx_conf_merge_bitmask_value(conf->sub.websocket, prev->sub.websocket, 0);
   
+  //group request types
+  ngx_conf_merge_bitmask_value(conf->group.get, prev->group.get, 0);
+  ngx_conf_merge_bitmask_value(conf->group.set, prev->group.set, 0);
+  ngx_conf_merge_bitmask_value(conf->group.delete, prev->group.delete, 0);
+  
+  ngx_conf_merge_value(conf->group.enable_accounting, prev->group.enable_accounting, 0);
+  
+  //validate location
+  if(!is_valid_location(cf, conf)) {
+    return NGX_CONF_ERROR;
+  }
+  
+  MERGE_UNSET_CONF(conf->message_compression, prev->message_compression, NCHAN_MSG_COMPRESSION_INVALID, NCHAN_MSG_NO_COMPRESSION);
+  
   ngx_conf_merge_sec_value(conf->message_timeout, prev->message_timeout, NCHAN_DEFAULT_MESSAGE_TIMEOUT);
   ngx_conf_merge_value(conf->max_messages, prev->max_messages, NCHAN_DEFAULT_MAX_MESSAGES);
   
@@ -199,7 +379,12 @@ static char * nchan_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) {
     conf->subscriber_first_message = (prev->subscriber_first_message == NCHAN_SUBSCRIBER_FIRST_MESSAGE_UNSET) ? NCHAN_SUBSCRIBER_DEFAULT_FIRST_MESSAGE : prev->subscriber_first_message;
   }
   
-  ngx_conf_merge_sec_value(conf->websocket_ping_interval, prev->websocket_ping_interval, NCHAN_DEFAULT_WEBSOCKET_PING_INTERVAL);
+  ngx_conf_merge_sec_value(conf->websocket_ping_interval, prev->websocket_ping_interval, NCHAN_DEFAULT_SUBSCRIBER_PING_INTERVAL);
+  
+  ngx_conf_merge_sec_value(conf->eventsource_ping.interval, prev->eventsource_ping.interval, NCHAN_DEFAULT_SUBSCRIBER_PING_INTERVAL);
+  ngx_conf_merge_str_value(conf->eventsource_ping.data, prev->eventsource_ping.comment, "");
+  ngx_conf_merge_str_value(conf->eventsource_ping.event, prev->eventsource_ping.event, "ping");
+  ngx_conf_merge_str_value(conf->eventsource_ping.data, prev->eventsource_ping.data, "");
   
   ngx_conf_merge_sec_value(conf->subscriber_timeout, prev->subscriber_timeout, NCHAN_DEFAULT_SUBSCRIBER_TIMEOUT);
   ngx_conf_merge_sec_value(conf->redis_idle_channel_cache_timeout, prev->redis_idle_channel_cache_timeout, NCHAN_DEFAULT_REDIS_IDLE_CHANNEL_CACHE_TIMEOUT);
@@ -212,13 +397,18 @@ static char * nchan_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) {
   ngx_conf_merge_str_value(conf->subscriber_http_raw_stream_separator, prev->subscriber_http_raw_stream_separator, "\n");
   
   ngx_conf_merge_str_value(conf->channel_id_split_delimiter, prev->channel_id_split_delimiter, "");
-  ngx_conf_merge_str_value(conf->channel_group, prev->channel_group, "");
-  ngx_conf_merge_str_value(conf->allow_origin, prev->allow_origin, "*");
+  MERGE_CONF(conf, prev, allow_origin);
+  ngx_conf_merge_value(conf->allow_credentials, prev->allow_credentials, 1);
   ngx_conf_merge_str_value(conf->eventsource_event, prev->eventsource_event, "");
   ngx_conf_merge_str_value(conf->custom_msgtag_header, prev->custom_msgtag_header, "");
   ngx_conf_merge_value(conf->msg_in_etag_only, prev->msg_in_etag_only, 0);
   ngx_conf_merge_value(conf->longpoll_multimsg, prev->longpoll_multimsg, 0);
   ngx_conf_merge_value(conf->longpoll_multimsg_use_raw_stream_separator, prev->longpoll_multimsg_use_raw_stream_separator, 0);
+  
+  ngx_conf_merge_value(conf->websocket_heartbeat.enabled, prev->websocket_heartbeat.enabled, 0);
+  MERGE_CONF(conf, prev, websocket_heartbeat.in);
+  MERGE_CONF(conf, prev, websocket_heartbeat.out);
+  
   MERGE_CONF(conf, prev, channel_events_channel_id);
   MERGE_CONF(conf, prev, channel_event_string);
   
@@ -236,6 +426,13 @@ static char * nchan_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) {
   MERGE_CONF(conf, prev, publisher_upstream_request_url);
   MERGE_CONF(conf, prev, unsubscribe_request_url);
   MERGE_CONF(conf, prev, subscribe_request_url);
+  MERGE_CONF(conf, prev, channel_group);
+  
+  MERGE_CONF(conf, prev, group.max_channels);
+  MERGE_CONF(conf, prev, group.max_subscribers);
+  MERGE_CONF(conf, prev, group.max_messages);
+  MERGE_CONF(conf, prev, group.max_messages_shm_bytes);
+  MERGE_CONF(conf, prev, group.max_messages_file_bytes);
   
   if(conf->pub_chid.n == 0) {
     conf->pub_chid = prev->pub_chid;
@@ -261,30 +458,54 @@ static char * nchan_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) {
     }
     conf->last_message_id.n = 2;
   }
-  
+    
   ngx_conf_merge_value(conf->redis.url_enabled, prev->redis.url_enabled, 0);
+  
   ngx_conf_merge_value(conf->redis.upstream_inheritable, prev->redis.upstream_inheritable, 0);
   ngx_conf_merge_str_value(conf->redis.url, prev->redis.url, NCHAN_REDIS_DEFAULT_URL);
+  
+  if(up && up->redis.namespace.len > 0) { //upstream has a namespace set
+    ngx_conf_merge_str_value(conf->redis.namespace, up->redis.namespace, ""); 
+  }
+  else {
+    ngx_conf_merge_str_value(conf->redis.namespace, prev->redis.namespace, "");
+  }
+  
+  if(up)
+    ngx_conf_merge_value(conf->redis.ping_interval, up->redis.ping_interval, NGX_CONF_UNSET);
   ngx_conf_merge_value(conf->redis.ping_interval, prev->redis.ping_interval, NCHAN_REDIS_DEFAULT_PING_INTERVAL_TIME);
+  
+  if(up)
+    ngx_conf_merge_value(conf->redis.nostore_fastpublish, up->redis.nostore_fastpublish, NGX_CONF_UNSET);
+  ngx_conf_merge_value(conf->redis.nostore_fastpublish, prev->redis.nostore_fastpublish, 0);
+  
   if(conf->redis.url_enabled) {
     conf->redis.enabled = 1;
-    nchan_store_redis_add_server_conf(cf, &conf->redis, conf);
+    nchan_store_redis_add_active_loc_conf(cf, conf);
   }
   if(conf->redis.upstream_inheritable && !conf->redis.upstream && prev->redis.upstream && prev->redis.upstream_url.len > 0) {
     conf->redis.upstream_url = prev->redis.upstream_url;
     ngx_conf_set_redis_upstream(cf, &conf->redis.upstream_url, conf);
   }
   
-  return NGX_CONF_OK;
-}
-
- //channel id variable
-//publisher and subscriber handlers now.
-static char *nchan_setup_handler(ngx_conf_t *cf, void * conf, ngx_int_t (*handler)(ngx_http_request_t *)) {
-  ngx_http_core_loc_conf_t       *clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
-  //nchan_loc_conf_t               *plcf = conf;
-  clcf->handler = handler;
-  clcf->if_modified_since = NGX_HTTP_IMS_OFF;
+  if(up)
+    MERGE_UNSET_CONF(conf->redis.storage_mode, up->redis.storage_mode, REDIS_MODE_CONF_UNSET, REDIS_MODE_CONF_UNSET);
+  MERGE_UNSET_CONF(conf->redis.storage_mode, prev->redis.storage_mode, REDIS_MODE_CONF_UNSET, REDIS_MODE_DISTRIBUTED);
+  
+  if(prev->request_handler != NULL && conf->request_handler == NULL) {
+    conf->request_handler = prev->request_handler;
+  }
+  if(conf->request_handler != NULL) {
+    nchan_setup_handler(cf, conf->request_handler);
+  }
+  
+  ngx_conf_merge_value(conf->benchmark.time, prev->benchmark.time, 10);
+  ngx_conf_merge_value(conf->benchmark.msgs_per_minute, prev->benchmark.msgs_per_minute, 120);
+  ngx_conf_merge_value(conf->benchmark.msg_padding, prev->benchmark.msg_padding, 0);
+  ngx_conf_merge_value(conf->benchmark.channels, prev->benchmark.channels, 1000);
+  ngx_conf_merge_value(conf->benchmark.subscribers_per_channel, prev->benchmark.subscribers_per_channel, 100);
+  MERGE_UNSET_CONF(conf->benchmark.subscriber_distribution, prev->benchmark.subscriber_distribution, NCHAN_BENCHMARK_SUBSCRIBER_DISTRIBUTION_UNSET, NCHAN_BENCHMARK_SUBSCRIBER_DISTRIBUTION_RANDOM);
+  MERGE_UNSET_CONF(conf->benchmark.publisher_distribution, prev->benchmark.publisher_distribution, NCHAN_BENCHMARK_PUBLISHER_DISTRIBUTION_UNSET, NCHAN_BENCHMARK_PUBLISHER_DISTRIBUTION_RANDOM);
   
   return NGX_CONF_OK;
 }
@@ -332,12 +553,12 @@ static char *nchan_set_storage_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *
 #define DISABLED_STRINGS "none", "off", "disabled"
 #define DISABLED_STRINGS_N 3
 
-
 static char *nchan_publisher_directive_parse(ngx_conf_t *cf, ngx_command_t *cmd, void *conf, ngx_int_t fail) {
   nchan_loc_conf_t     *lcf = conf;
   ngx_str_t            *val;
   ngx_uint_t            i;
   
+  
   nchan_conf_publisher_types_t *pubt = &lcf->pub;
   
   if(cf->args->nelts == 1){ //no arguments
@@ -362,7 +583,11 @@ static char *nchan_publisher_directive_parse(ngx_conf_t *cf, ngx_command_t *cmd,
     }
   }
   
-  return nchan_setup_handler(cf, conf, &nchan_pubsub_handler);
+  if(!is_valid_location(cf, lcf)) {
+    return NGX_CONF_ERROR;
+  }
+  lcf->request_handler = &nchan_pubsub_handler;
+  return NGX_CONF_OK;
 }
 
 static char *nchan_publisher_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
@@ -425,7 +650,12 @@ static char *nchan_subscriber_directive_parse(ngx_conf_t *cf, ngx_command_t *cmd
       }
     }
   }
-  return nchan_setup_handler(cf, conf, &nchan_pubsub_handler);
+  
+  if(!is_valid_location(cf, lcf)) {
+    return NGX_CONF_ERROR;
+  }
+  lcf->request_handler = &nchan_pubsub_handler;
+  return NGX_CONF_OK;
 }
 
 static char *nchan_subscriber_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
@@ -435,18 +665,147 @@ static char *nchan_subscriber_directive(ngx_conf_t *cf, ngx_command_t *cmd, void
 static char *nchan_pubsub_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
   ngx_str_t            *val;
   ngx_uint_t            i;
+  nchan_loc_conf_t     *lcf = conf;
   nchan_publisher_directive_parse(cf, cmd, conf, 0);
   nchan_subscriber_directive_parse(cf, cmd, conf, 0);
   for(i=1; i < cf->args->nelts; i++) {
     val = &((ngx_str_t *) cf->args->elts)[i];
     if(! nchan_strmatch(val, 
-      WEBSOCKET_STRINGS_N + EVENTSOURCE_STRINGS_N + HTTP_CHUNKED_STRINGS_N + HTTP_MULTIPART_STRINGS_N + LONGPOLL_STRINGS_N + INTERVALPOLL_STRINGS_N + DISABLED_STRINGS_N,
-      WEBSOCKET_STRINGS, EVENTSOURCE_STRINGS, HTTP_CHUNKED_STRINGS, HTTP_MULTIPART_STRINGS, LONGPOLL_STRINGS_N, INTERVALPOLL_STRINGS_N, DISABLED_STRINGS_N)) {
+      WEBSOCKET_STRINGS_N + EVENTSOURCE_STRINGS_N + HTTP_CHUNKED_STRINGS_N + HTTP_MULTIPART_STRINGS_N + LONGPOLL_STRINGS_N + INTERVALPOLL_STRINGS_N + HTTP_RAW_STREAM_STRINGS_N + DISABLED_STRINGS_N,
+      WEBSOCKET_STRINGS, EVENTSOURCE_STRINGS, HTTP_CHUNKED_STRINGS, HTTP_MULTIPART_STRINGS, LONGPOLL_STRINGS, INTERVALPOLL_STRINGS, HTTP_RAW_STREAM_STRINGS, DISABLED_STRINGS)) {
       ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "invalid %V value: %V", &cmd->name, val);
       return NGX_CONF_ERROR;
     }
   }
-  return nchan_setup_handler(cf, conf, &nchan_pubsub_handler);
+  
+  if(!is_valid_location(cf, lcf)) {
+    return NGX_CONF_ERROR;
+  }
+  
+  return NGX_CONF_OK;
+}
+
+static char *nchan_group_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  nchan_loc_conf_t     *lcf = conf;
+  ngx_str_t            *val;
+  ngx_uint_t            i;
+  nchan_conf_group_t   *group = &lcf->group;
+  
+  if(cf->args->nelts == 1){ //no arguments
+    group->get=1;
+    group->set=1;
+    group->delete=1;
+  }
+  else {
+    for(i=1; i < cf->args->nelts; i++) {
+      val = &((ngx_str_t *) cf->args->elts)[i];
+      if(nchan_strmatch(val, 1, "get")) {
+        group->get=1;
+      }
+      else if(nchan_strmatch(val, 1, "set")) {
+        group->set=1;
+      }
+      else if(nchan_strmatch(val, 1, "delete")) {
+        group->delete=1;
+      }
+      else if(nchan_strmatch(val, 1, "off")) {
+        group->get=0;
+        group->set=0;
+        group->delete=0;
+      }
+      else {
+        ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "invalid %V value: %V", &cmd->name, val);
+        return NGX_CONF_ERROR;
+      }
+    }
+  }
+  
+  if(!is_valid_location(cf, lcf)) {
+    return NGX_CONF_ERROR;
+  }
+  lcf->request_handler = &nchan_group_handler;
+  return NGX_CONF_OK;
+}
+
+static ngx_int_t set_complex_value(ngx_conf_t *cf, ngx_http_complex_value_t **cv, char *val) {
+  ngx_http_compile_complex_value_t    ccv;
+  ngx_str_t                          *value = ngx_palloc(cf->pool, sizeof(ngx_str_t));;
+  if(value == NULL) {
+    return NGX_ERROR;
+  }
+  value->data = (u_char *)val;
+  value->len = strlen(val);
+  *cv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
+  if (*cv == NULL) {
+    return NGX_ERROR;
+  } 
+  ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
+  ccv.cf = cf;
+  ccv.value = value;
+  ccv.complex_value = *cv;
+  if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
+    return NGX_ERROR;
+  }
+  
+  return NGX_OK;
+}
+
+static ngx_int_t set_complex_value_array_size1(ngx_conf_t *cf, nchan_complex_value_arr_t *chid, char *val) {
+  chid->n = 1;
+  return set_complex_value(cf, &chid->cv[0], val);
+}
+
+static char *nchan_benchmark_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  nchan_loc_conf_t     *lcf = conf;
+  global_benchmark_enabled = 1;
+  lcf->request_handler = &nchan_benchmark_handler;
+  
+  
+  //set group
+  if(set_complex_value(cf, &lcf->channel_group, "benchmark") != NGX_OK) {
+    return "error setting benchmark channel group";
+  }
+  //set pub and sub channel ids
+  if(set_complex_value_array_size1(cf, &lcf->pub_chid, "control") != NGX_OK) {
+    return "error setting benchmark control channel";
+  }
+  if(set_complex_value_array_size1(cf, &lcf->sub_chid, "data") != NGX_OK) {
+    return "error setting benchmark data channel";
+  }
+  
+  lcf->sub.websocket = 1;
+  lcf->pub.websocket = 1;
+  
+  return NGX_CONF_OK;
+}
+
+static char *nchan_benchmark_subscriber_distribution_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  ngx_str_t          *val = &((ngx_str_t *) cf->args->elts)[1];
+  nchan_loc_conf_t   *lcf = conf;
+  if(nchan_strmatch(val, 1, "random")) {
+    lcf->benchmark.subscriber_distribution = NCHAN_BENCHMARK_SUBSCRIBER_DISTRIBUTION_RANDOM;
+  }
+  else if(nchan_strmatch(val, 2, "optimal", "best")) {
+    lcf->benchmark.subscriber_distribution = NCHAN_BENCHMARK_SUBSCRIBER_DISTRIBUTION_OPTIMAL;
+  }
+  else {
+    return "invalid value, must be \"random\" or \"optimal\"";
+  }
+  return NGX_CONF_OK;
+}
+static char *nchan_benchmark_publisher_distribution_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  ngx_str_t          *val = &((ngx_str_t *) cf->args->elts)[1];
+  nchan_loc_conf_t   *lcf = conf;
+  if(nchan_strmatch(val, 1, "random")) {
+    lcf->benchmark.publisher_distribution = NCHAN_BENCHMARK_PUBLISHER_DISTRIBUTION_RANDOM;
+  }
+  else if(nchan_strmatch(val, 2, "optimal", "best")) {
+    lcf->benchmark.publisher_distribution = NCHAN_BENCHMARK_PUBLISHER_DISTRIBUTION_OPTIMAL;
+  }
+  else {
+    return "invalid value, must be \"random\" or \"optimal\"";
+  }
+  return NGX_CONF_OK;
 }
 
 static char *nchan_subscriber_first_message_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
@@ -482,7 +841,113 @@ static char *nchan_subscriber_first_message_directive(ngx_conf_t *cf, ngx_comman
   return NGX_CONF_OK;
 }
 
+static char *nchan_websocket_heartbeat_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  nchan_loc_conf_t   *lcf = (nchan_loc_conf_t *)conf;
+  ngx_str_t          *heartbeat_in = &((ngx_str_t *) cf->args->elts)[1];
+  ngx_str_t          *heartbeat_out = &((ngx_str_t *) cf->args->elts)[2];
+  ngx_str_t          *in, *out;
+  lcf->websocket_heartbeat.enabled = 1;
+  
+  in = ngx_pcalloc(cf->pool, sizeof(ngx_str_t) + heartbeat_in->len);
+  in->data = (u_char *)&in[1];
+  in->len = heartbeat_in->len;
+  ngx_memcpy(in->data, heartbeat_in->data, heartbeat_in->len);
+  lcf->websocket_heartbeat.in = in;
+  
+  out = ngx_pcalloc(cf->pool, sizeof(ngx_str_t) + heartbeat_out->len);
+  out->data = (u_char *)&out[1];
+  out->len = heartbeat_out->len;
+  ngx_memcpy(out->data, heartbeat_out->data, heartbeat_out->len);
+  lcf->websocket_heartbeat.out = out;
+  
+  return NGX_CONF_OK;
+}
+
+static char *nchan_conf_deflate_compression_level_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+#if (NGX_ZLIB)
+  nchan_main_conf_t  *mcf = (nchan_main_conf_t *)conf;
+  ngx_int_t           np;
+  ngx_str_t           *value = cf->args->elts;
+  np = ngx_atoi(value[1].data, value[1].len);
+  if (np == NGX_ERROR) {
+    return "invalid number";
+  }
+  if(np < 0 || np > 9) {
+    return "must be between 0 and 9";
+  }
+  
+  mcf->zlib_params.level = np;
+#endif
+  return NGX_CONF_OK;
+}
+
+static char *nchan_conf_deflate_compression_strategy_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+#if (NGX_ZLIB)
+  nchan_main_conf_t   *mcf = (nchan_main_conf_t *)conf;
+  ngx_str_t           *val = cf->args->elts;
+  if(nchan_strmatch(val, 1, "default")) {
+    mcf->zlib_params.strategy = Z_DEFAULT_STRATEGY;
+  }
+  else if(nchan_strmatch(val, 1, "filtered")) {
+    mcf->zlib_params.strategy = Z_FILTERED;
+  }
+  else if(nchan_strmatch(val, 1, "huffman-only")) {
+    mcf->zlib_params.strategy = Z_HUFFMAN_ONLY;
+  }
+  else if(nchan_strmatch(val, 1, "rle")) {
+    mcf->zlib_params.strategy = Z_RLE;
+  }
+  else if(nchan_strmatch(val, 1, "fixed")) {
+    mcf->zlib_params.strategy = Z_FIXED;
+  }
+  else {
+    return "invalid compression strategy";
+  }
+#endif
+  return NGX_CONF_OK;
+}
+
+static char *nchan_conf_deflate_compression_window_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+#if (NGX_ZLIB)
+  nchan_main_conf_t  *mcf = (nchan_main_conf_t *)conf;
+  ngx_int_t           np;
+  ngx_str_t           *value = cf->args->elts;
+  np = ngx_atoi(value[1].data, value[1].len);
+  if (np == NGX_ERROR) {
+    return "invalid number";
+  }
+  if(np < 9 || np > 15) {
+    return "must be between 9 and 15";
+  }
+  
+  mcf->zlib_params.windowBits = np;
+#endif
+  return NGX_CONF_OK;
+}
+
+static char *nchan_conf_deflate_compression_memlevel_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+#if (NGX_ZLIB)
+  nchan_main_conf_t  *mcf = (nchan_main_conf_t *)conf;
+  ngx_int_t           np;
+  ngx_str_t           *value = cf->args->elts;
+  np = ngx_atoi(value[1].data, value[1].len);
+  if (np == NGX_ERROR) {
+    return "invalid number";
+  }
+  if(np < 1 || np > 9) {
+    return "must be between 1 and 9";
+  }
+  
+  mcf->zlib_params.memLevel = np;
+#endif
+  return NGX_CONF_OK;
+}
+
+
 static void nchan_exit_worker(ngx_cycle_t *cycle) {
+  if(!global_nchan_enabled) {
+    return;
+  }
   if(global_redis_enabled) {
     redis_store_prepare_to_exit_worker();
   }
@@ -491,16 +956,32 @@ static void nchan_exit_worker(ngx_cycle_t *cycle) {
     nchan_store_redis.exit_worker(cycle);
   }
   nchan_output_shutdown();
+#if (NGX_ZLIB)
+  if(global_zstream_needed) {
+    nchan_common_deflate_shutdown();
+  }
+#endif
 #if NCHAN_SUBSCRIBER_LEAK_DEBUG
   subscriber_debug_assert_isempty();
 #endif
 }
 
 static void nchan_exit_master(ngx_cycle_t *cycle) {
+  if(!global_nchan_enabled) {
+    return;
+  }
+  if(global_benchmark_enabled) {
+    nchan_benchmark_exit_master(cycle);
+  }
   nchan_store_memory.exit_master(cycle);
   if(global_redis_enabled) {
     nchan_store_redis.exit_master(cycle);
   }
+#if (NGX_ZLIB)
+  if(global_zstream_needed) {
+    nchan_common_deflate_shutdown();
+  }
+#endif
 }
 
 static char *nchan_set_complex_value_array(ngx_conf_t *cf, ngx_command_t *cmd, void *conf, nchan_complex_value_arr_t *chid) {
@@ -668,6 +1149,26 @@ static char *nchan_set_raw_subscriber_separator(ngx_conf_t *cf, ngx_command_t *c
   return NGX_CONF_OK;
 }
 
+static char *nchan_set_message_compression_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  ngx_str_t          *val = &((ngx_str_t *) cf->args->elts)[1];
+  nchan_loc_conf_t   *lcf = conf;
+#if (NGX_ZLIB)
+  if(nchan_strmatch(val, 1, "on")) {
+    lcf->message_compression = 1;
+    global_zstream_needed = 1;
+  }
+  else if(nchan_strmatch(val, 1, "off")) {
+    lcf->message_compression = 0;
+  }
+  else {
+    return "invalid value: must be 'on' or 'off'";
+  }
+  return NGX_CONF_OK;
+#else
+  return "cannot use compression, Nginx was built without zlib";
+#endif
+}
+
 static char *nchan_set_longpoll_multipart(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
   ngx_str_t          *val = &((ngx_str_t *) cf->args->elts)[1];
   nchan_loc_conf_t   *lcf = conf;
@@ -688,11 +1189,59 @@ static char *nchan_set_longpoll_multipart(ngx_conf_t *cf, ngx_command_t *cmd, vo
   return NGX_CONF_OK;
 }
 
+static char *ngx_conf_set_redis_subscribe_weights(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  ngx_int_t  master = NGX_CONF_UNSET;
+  ngx_int_t  slave = NGX_CONF_UNSET;
+  ngx_str_t *val = cf->args->elts;
+  ngx_str_t *cur;
+  unsigned   i;
+  nchan_srv_conf_t *scf = conf;
+  for(i=1; i < cf->args->nelts; i++) {
+    cur = &val[i];
+    if(nchan_str_after(&cur, "master=")) {
+      if((master = ngx_atoi(cur->data, cur->len)) == NGX_ERROR) {
+        return "has invalid weight for master";
+      }
+    }
+    else if(nchan_str_after(&cur, "slave=")) {
+      if((slave = ngx_atoi(cur->data, cur->len)) == NGX_ERROR) {
+        return "has invalid weight for slave";
+      }
+    }
+  }
+  
+  if(master != NGX_CONF_UNSET) {
+    scf->redis.master_weight = master;
+  }
+  if(slave != NGX_CONF_UNSET) {
+    scf->redis.slave_weight = slave;
+  }
+  
+  return NGX_CONF_OK;
+}
+
+static char *ngx_conf_set_redis_optimize_target(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  ngx_str_t          *val = &((ngx_str_t *) cf->args->elts)[1];
+  nchan_srv_conf_t   *scf = conf;
+  if(nchan_strmatch(val, 2, "bandwidth", "bw")) {
+    scf->redis.optimize_target = NCHAN_REDIS_OPTIMIZE_BANDWIDTH;
+  }
+  else if(nchan_strmatch(val, 2, "cpu", "CPU")) {
+    scf->redis.optimize_target = NCHAN_REDIS_OPTIMIZE_CPU;
+  }
+  else {
+    return "invalid value, must be \"bandwidth\" or \"cpu\"";
+  }
+  return NGX_CONF_OK;
+}
+
 static char *ngx_conf_enable_redis(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
   char                *rc;
   ngx_flag_t          *fp;
   char                *p = conf;
-  nchan_loc_conf_t    *lcf = (nchan_loc_conf_t *)conf;
+  nchan_loc_conf_t    *lcf = conf;
+  
+  ngx_conf_log_error(NGX_LOG_WARN, cf, 0, "Use of %V is discouraged in favor of nchan_redis_pass.", &cmd->name);
   
   rc = ngx_conf_set_flag_slot(cf, cmd, conf);
   if(rc == NGX_CONF_ERROR) {
@@ -703,20 +1252,22 @@ static char *ngx_conf_enable_redis(ngx_conf_t *cf, ngx_command_t *cmd, void *con
   if(*fp) {
     if(!lcf->redis.enabled) {
       lcf->redis.enabled = 1;
-      nchan_store_redis_add_server_conf(cf, &lcf->redis, lcf);
+      nchan_store_redis_add_active_loc_conf(cf, lcf);
     }
     global_redis_enabled = 1;
   }
   else {
-    nchan_store_redis_remove_server_conf(cf, &lcf->redis);
+    nchan_store_redis_remove_active_loc_conf(cf, lcf);
   }
   
   return rc;
 }
 
 static char *nchan_stub_status_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  nchan_loc_conf_t    *lcf = conf;
   nchan_stub_status_enabled = 1;
-  return nchan_setup_handler(cf, conf, &nchan_stub_status_handler);
+  lcf->request_handler = &nchan_stub_status_handler;
+  return NGX_CONF_OK;
 }
 
 
@@ -728,8 +1279,18 @@ static char *ngx_conf_upstream_redis_server(ngx_conf_t *cf, ngx_command_t *cmd, 
   ngx_http_upstream_srv_conf_t        *uscf;
   ngx_str_t                           *value;
   ngx_http_upstream_server_t          *usrv;
-  
+  nchan_loc_conf_t                    *lcf = conf;
   uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);  
+  nchan_srv_conf_t                    *scf = NULL;
+  scf = ngx_http_conf_upstream_srv_conf(uscf, ngx_nchan_module);
+  if(scf->upstream_nchan_loc_conf) {
+    assert(scf->upstream_nchan_loc_conf == lcf);
+  }
+  else {
+    //is this even a safe technique? it might break in the future...
+    scf->upstream_nchan_loc_conf = lcf;
+  }
+  
   
   if(uscf->servers == NULL) {
         uscf->servers = ngx_array_create(cf->pool, 4, sizeof(ngx_http_upstream_server_t));
@@ -738,6 +1299,11 @@ static char *ngx_conf_upstream_redis_server(ngx_conf_t *cf, ngx_command_t *cmd, 
     return NGX_CONF_ERROR;
   }
   value = cf->args->elts;
+  
+  if(!nchan_store_redis_validate_url(&value[1])) {
+    return "url is invalid";
+  }
+  
   ngx_memzero(usrv, sizeof(*usrv));
 #if nginx_version >= 1007002
   usrv->name = value[1];
@@ -749,16 +1315,89 @@ static char *ngx_conf_upstream_redis_server(ngx_conf_t *cf, ngx_command_t *cmd, 
   return NGX_CONF_OK;
 }
 
+static char *ngx_conf_set_str_slot_no_newlines(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  ngx_str_t *val = cf->args->elts;
+  ngx_str_t *arg = &val[1];
+  
+  if(nchan_ngx_str_substr(arg, "\n")) {
+    return "can't contain any newline characters";
+  }
+  
+  return ngx_conf_set_str_slot(cf, cmd, conf);
+}
+
 static char *ngx_conf_set_redis_url(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
   nchan_loc_conf_t  *lcf = conf;
+  ngx_str_t *val = cf->args->elts;
+  ngx_str_t *arg = &val[1];
+  
+  ngx_conf_log_error(NGX_LOG_WARN, cf, 0, "Use of %V is discouraged in favor of an upstream { } block with nchan_redis_server %V;", &cmd->name, arg);
   
   if(lcf->redis.upstream) {
     return "can't be set here: already using nchan_redis_pass";
   }
+  if(!nchan_store_redis_validate_url(arg)) {
+    return "url is invalid";
+  }
   
   return ngx_conf_set_str_slot(cf, cmd, conf);
 }
 
+static char *ngx_conf_process_redis_namespace_slot(ngx_conf_t *cf, void *post, void *fld) {
+  ngx_str_t *arg = fld;
+
+  if(memchr(arg->data, '{', arg->len)) {
+    return "can't contain character '{'";
+  }
+  
+  if(memchr(arg->data, '}', arg->len)) {
+    return "can't contain character '}'";
+  }
+  
+  if(arg->len > 0 && arg->data[arg->len-1] != ':') {
+    u_char  *nns;
+    if((nns = ngx_palloc(cf->pool, arg->len + 2)) == NULL) {
+      return "couldn't allocate redis namespace data";
+    }
+    ngx_memcpy(nns, arg->data, arg->len);
+    nns[arg->len]=':';
+    nns[arg->len+1]='\0';
+    arg->len++;
+    arg->data=nns;
+  }
+  
+  return NGX_CONF_OK;
+}
+
+static char *ngx_conf_set_redis_storage_mode_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+  char                         *p = conf;
+  ngx_str_t                    *val = cf->args->elts;
+  ngx_str_t                    *arg = &val[1];
+  
+  nchan_redis_storage_mode_t   *field;
+
+  field = (nchan_redis_storage_mode_t *) (p + cmd->offset);
+  
+  if(*field != REDIS_MODE_CONF_UNSET) {
+    return "is duplicate";
+  }
+  
+  if(nchan_strmatch(arg, 1, "backup")) {
+    *field = REDIS_MODE_BACKUP;
+  }
+  else if(nchan_strmatch(arg, 1, "distributed")) {
+    *field = REDIS_MODE_DISTRIBUTED;
+  }
+  else if(nchan_strmatch(arg, 1, "nostore") ||  nchan_strmatch(arg, 1, "distributed-nostore")) {
+    *field = REDIS_MODE_DISTRIBUTED_NOSTORE;
+  }
+  else {
+    return "is invalid, must be one of 'distributed',  'backup' or 'nostore'";
+  }
+  
+  return NGX_CONF_OK;
+}
+
 static char *ngx_conf_set_redis_upstream_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
   nchan_loc_conf_t  *lcf = conf;
   ngx_str_t         *value = cf->args->elts;
@@ -771,12 +1410,12 @@ static char *ngx_conf_set_redis_upstream_pass(ngx_conf_t *cf, ngx_command_t *cmd
 #include "nchan_config_commands.c" //hideous but hey, it works
 
 static ngx_http_module_t  nchan_module_ctx = {
-    nchan_add_variables,           /* preconfiguration */
+    nchan_preconfig,               /* preconfiguration */
     nchan_postconfig,              /* postconfiguration */
     nchan_create_main_conf,        /* create main configuration */
     NULL,                          /* init main configuration */
-    NULL,                          /* create server configuration */
-    NULL,                          /* merge server configuration */
+    nchan_create_srv_conf,         /* create server configuration */
+    nchan_merge_srv_conf,          /* merge server configuration */
     nchan_create_loc_conf,         /* create location configuration */
     nchan_merge_loc_conf,          /* merge location configuration */
 };
diff --git a/debian/modules/nchan/src/nchan_types.h b/debian/modules/nchan/src/nchan_types.h
index 58b8ee1..d8733c0 100644
--- a/debian/modules/nchan/src/nchan_types.h
+++ b/debian/modules/nchan/src/nchan_types.h
@@ -5,8 +5,14 @@
 
 typedef ngx_int_t (*callback_pt)(ngx_int_t, void *, void *);
 
-typedef enum {MSG_CHANNEL_NOTREADY, MSG_NORESPONSE, MSG_INVALID, MSG_PENDING, MSG_NOTFOUND, MSG_FOUND, MSG_EXPECTED, MSG_EXPIRED} nchan_msg_status_t;
-typedef enum {INACTIVE, NOTREADY, WAITING, STUBBED, READY} chanhead_pubsub_status_t;
+#include <util/nchan_fake_request.h>
+
+typedef enum {MSG_ERROR, MSG_CHANNEL_NOTREADY, MSG_INVALID, MSG_PENDING, MSG_NOTFOUND, MSG_FOUND, MSG_EXPECTED, MSG_EXPIRED} nchan_msg_status_t;
+typedef enum {INACTIVE, NOTREADY, WAITING, STUBBED, READY, DELETED} chanhead_pubsub_status_t;
+
+typedef enum {NCHAN_CONTENT_TYPE_PLAIN, NCHAN_CONTENT_TYPE_JSON, NCHAN_CONTENT_TYPE_XML, NCHAN_CONTENT_TYPE_YAML, NCHAN_CONTENT_TYPE_HTML} nchan_content_type_t;
+
+typedef enum {REDIS_MODE_CONF_UNSET = NGX_CONF_UNSET, REDIS_MODE_BACKUP = 1, REDIS_MODE_DISTRIBUTED = 2, REDIS_MODE_DISTRIBUTED_NOSTORE = 3} nchan_redis_storage_mode_t;
 
 typedef enum {
   SUB_ENQUEUE, SUB_DEQUEUE, SUB_RECEIVE_MESSAGE, SUB_RECEIVE_STATUS, 
@@ -17,6 +23,15 @@ typedef struct {
   size_t                          shm_size;
   ngx_msec_t                      redis_fakesub_timer_interval;
   size_t                          redis_publish_message_msgkey_size;
+#if (NGX_ZLIB)
+  struct {
+                                    int level;
+                                    int windowBits;
+                                    int memLevel;
+                                    int strategy;
+  }                               zlib_params;
+#endif
+  ngx_path_t                     *message_temp_path;
 } nchan_main_conf_t;
 
 
@@ -24,10 +39,14 @@ typedef struct {
   ngx_str_t                     url;
   ngx_flag_t                    url_enabled;
   time_t                        ping_interval;
+  ngx_str_t                     namespace;
+  nchan_redis_storage_mode_t    storage_mode;
+  ngx_int_t                     nostore_fastpublish;
   ngx_str_t                     upstream_url;
   ngx_http_upstream_srv_conf_t *upstream;
   ngx_flag_t                    upstream_inheritable;
   unsigned                      enabled:1;
+  void                         *nodeset;
   void                         *privdata;
 } nchan_redis_conf_t;
 
@@ -57,8 +76,8 @@ union nchan_msg_multitag {
 typedef struct {
   time_t                          time; //tag message by time
   union nchan_msg_multitag        tag;
-  unsigned                        tagactive:16;
-  unsigned                        tagcount:16;
+  int16_t                         tagactive;
+  int16_t                         tagcount;
 } nchan_msg_id_t;
 
 typedef struct {
@@ -80,20 +99,35 @@ struct msg_rsv_dbg_s {
 typedef struct nchan_loc_conf_s nchan_loc_conf_t;
 typedef struct nchan_msg_s nchan_msg_t;
 
+typedef enum {NCHAN_MSG_SHARED, NCHAN_MSG_HEAP, NCHAN_MSG_POOL, NCHAN_MSG_STACK} nchan_msg_storage_t;
+
+typedef enum {
+  NCHAN_MSG_COMPRESSION_INVALID = -1,
+  NCHAN_MSG_NO_COMPRESSION = 0, 
+  NCHAN_MSG_COMPRESSION_WEBSOCKET_PERMESSAGE_DEFLATE
+} nchan_msg_compression_type_t;
+  
+typedef struct {
+  ngx_buf_t                       buf;
+  nchan_msg_compression_type_t    compression;
+} nchan_compressed_msg_t;
+
 struct nchan_msg_s {
   nchan_msg_id_t                  id;
   nchan_msg_id_t                  prev_id;
-  ngx_str_t                       content_type;
-  ngx_str_t                       eventsource_event;
+  ngx_str_t                      *content_type;
+  ngx_str_t                      *eventsource_event;
   //  ngx_str_t                   charset;
-  ngx_buf_t                      *buf;
+  ngx_buf_t                       buf;
   time_t                          expires;
+  
   ngx_atomic_int_t                refcount;
+  nchan_msg_t                    *parent;
+  nchan_compressed_msg_t         *compressed;
+  //struct nchan_msg_s             *reload_next;
   
-  struct nchan_msg_s             *reload_next;
+  nchan_msg_storage_t             storage;
   
-  unsigned                        shared:1; //for debugging
-  unsigned                        temp_allocd:1;
 #if NCHAN_MSG_RESERVE_DEBUG
   struct msg_rsv_dbg_s           *rsv;
 #endif
@@ -102,17 +136,9 @@ struct nchan_msg_s {
   struct nchan_msg_s             *dbg_prev;
   struct nchan_msg_s             *dbg_next;
 #endif
-#if NCHAN_BENCHMARK
-  struct timeval                  start_tv;
-#endif
 }; // nchan_msg_t
 
 typedef struct {
-  nchan_msg_t       copy;
-  nchan_msg_t      *original;
-} nchan_msg_copy_t;
-
-typedef struct {
   ngx_str_t                       id;
   ngx_int_t                       messages;
   ngx_int_t                       subscribers;
@@ -150,6 +176,26 @@ typedef struct {
 
 typedef struct subscriber_s subscriber_t;
 
+typedef struct {
+  //must be made entirely of ngx_atomic_int_t
+  ngx_atomic_int_t                channels;
+  ngx_atomic_int_t                subscribers;
+  ngx_atomic_int_t                messages;
+  ngx_atomic_int_t                messages_shmem_bytes;
+  ngx_atomic_int_t                messages_file_bytes;
+} nchan_group_limits_t;
+
+typedef struct {
+  ngx_atomic_int_t               channels;
+  ngx_atomic_int_t               multiplexed_channels;
+  ngx_atomic_int_t               subscribers;
+  ngx_atomic_int_t               messages;
+  ngx_atomic_int_t               messages_shmem_bytes;
+  ngx_atomic_int_t               messages_file_bytes;
+  nchan_group_limits_t           limit;
+  ngx_str_t                      name;
+} nchan_group_t;
+
 typedef struct{
   //init
   ngx_int_t (*init_module)(ngx_cycle_t *cycle);
@@ -166,16 +212,14 @@ typedef struct{
   ngx_int_t (*subscribe)   (ngx_str_t *, subscriber_t *);
   ngx_int_t (*publish)     (ngx_str_t *, nchan_msg_t *, nchan_loc_conf_t *, callback_pt, void *);
   
+    //channel actions
   ngx_int_t (*delete_channel)(ngx_str_t *, nchan_loc_conf_t *, callback_pt, void *);
-  
-  //channel actions
   ngx_int_t (*find_channel)(ngx_str_t *, nchan_loc_conf_t *, callback_pt, void*);
   
-  
-  
-  //message actions and properties
-  ngx_str_t * (*message_etag)(nchan_msg_t *msg, ngx_pool_t *pool);
-  ngx_str_t * (*message_content_type)(nchan_msg_t *msg, ngx_pool_t *pool);
+  //group actions
+  ngx_int_t (*get_group)(ngx_str_t *name, nchan_loc_conf_t *, callback_pt, void *);
+  ngx_int_t (*set_group_limits)(ngx_str_t *name, nchan_loc_conf_t *, nchan_group_limits_t *limits, callback_pt, void *);
+  ngx_int_t (*delete_group)(ngx_str_t *name, nchan_loc_conf_t *, callback_pt, void *);
 
 } nchan_store_t;
 
@@ -196,6 +240,20 @@ typedef struct {
   unsigned                        websocket:1;
 } nchan_conf_subscriber_types_t;
 
+typedef struct {
+  unsigned                        get:1;
+  unsigned                        set:1;
+  unsigned                        delete:1;
+  
+  ngx_int_t                       enable_accounting;
+  
+  ngx_http_complex_value_t       *max_channels;
+  ngx_http_complex_value_t       *max_subscribers;
+  ngx_http_complex_value_t       *max_messages;
+  ngx_http_complex_value_t       *max_messages_shm_bytes;
+  ngx_http_complex_value_t       *max_messages_file_bytes;
+} nchan_conf_group_t;
+
 #define NCHAN_COMPLEX_VALUE_ARRAY_MAX 8
 typedef struct {
   ngx_http_complex_value_t       *cv[NCHAN_COMPLEX_VALUE_ARRAY_MAX];
@@ -207,6 +265,40 @@ typedef struct {
  ngx_atomic_uint_t               max_messages;
 } nchan_loc_conf_shared_data_t;
 
+typedef enum {
+  NCHAN_REDIS_OPTIMIZE_UNSET = -1,
+  NCHAN_REDIS_OPTIMIZE_CPU = 1,
+  NCHAN_REDIS_OPTIMIZE_BANDWIDTH = 2
+} nchan_redis_optimize_t;
+
+typedef struct {
+  struct {
+      ngx_msec_t                    connect_timeout;
+      nchan_redis_optimize_t        optimize_target;
+      ngx_int_t                     master_weight;
+      ngx_int_t                     slave_weight;
+  }                               redis;
+  nchan_loc_conf_t                *upstream_nchan_loc_conf;
+} nchan_srv_conf_t;
+
+typedef struct {
+  time_t                          time;
+  ngx_int_t                       msgs_per_minute;
+  ngx_int_t                       msg_padding;
+  ngx_int_t                       channels;
+  ngx_int_t                       subscribers_per_channel;
+  enum {
+    NCHAN_BENCHMARK_SUBSCRIBER_DISTRIBUTION_UNSET = -1,
+    NCHAN_BENCHMARK_SUBSCRIBER_DISTRIBUTION_RANDOM = 1,
+    NCHAN_BENCHMARK_SUBSCRIBER_DISTRIBUTION_OPTIMAL = 2
+  }                               subscriber_distribution;
+  enum {
+    NCHAN_BENCHMARK_PUBLISHER_DISTRIBUTION_UNSET = -1,
+    NCHAN_BENCHMARK_PUBLISHER_DISTRIBUTION_RANDOM = 1,
+    NCHAN_BENCHMARK_PUBLISHER_DISTRIBUTION_OPTIMAL = 2
+  }                               publisher_distribution;
+} nchan_benchmark_conf_t;
+
 struct nchan_loc_conf_s { //nchan_loc_conf_t
   
   ngx_int_t                       shared_data_index;
@@ -226,12 +318,14 @@ struct nchan_loc_conf_s { //nchan_loc_conf_t
   nchan_complex_value_arr_t       pub_chid;
   nchan_complex_value_arr_t       sub_chid;
   nchan_complex_value_arr_t       pubsub_chid;
-  ngx_str_t                       channel_group;
+  ngx_http_complex_value_t       *channel_group;
+  
   ngx_str_t                       channel_id_split_delimiter;
   
   ngx_str_t                       subscriber_http_raw_stream_separator;
 
-  ngx_str_t                       allow_origin;
+  ngx_http_complex_value_t       *allow_origin;
+  ngx_int_t                       allow_credentials;
   
   nchan_complex_value_arr_t       last_message_id;
   ngx_str_t                       custom_msgtag_header;
@@ -239,7 +333,7 @@ struct nchan_loc_conf_s { //nchan_loc_conf_t
   
   nchan_conf_publisher_types_t    pub;
   nchan_conf_subscriber_types_t   sub; 
-  
+  nchan_conf_group_t              group;
   time_t                          subscriber_timeout;
   
   ngx_int_t                       longpoll_multimsg;
@@ -248,6 +342,20 @@ struct nchan_loc_conf_s { //nchan_loc_conf_t
   ngx_str_t                       eventsource_event;
   
   time_t                          websocket_ping_interval;
+  struct {
+    time_t                          interval;
+    ngx_str_t                       event;
+    ngx_str_t                       data;
+    ngx_str_t                       comment;
+  }                               eventsource_ping;
+  
+  struct {
+    ngx_int_t   enabled;
+    ngx_str_t  *in;
+    ngx_str_t  *out;
+  }                               websocket_heartbeat;
+  
+  nchan_msg_compression_type_t    message_compression;
   
   ngx_int_t                       subscriber_first_message;
   
@@ -263,14 +371,12 @@ struct nchan_loc_conf_s { //nchan_loc_conf_t
   ngx_int_t                       max_channel_subscribers;
   time_t                          channel_timeout;
   nchan_store_t                  *storage_engine;
+  
+  nchan_benchmark_conf_t          benchmark;
+  
+  ngx_int_t                     (*request_handler)(ngx_http_request_t *r);
 };// nchan_loc_conf_t;
 
-typedef struct {